/**
 * @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 {?}
 */
var passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true });
/**
 * Options that can be used to bind an active event listener.
 * @type {?}
 */
var 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 {?}
 */
var 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
 */
var /**
 * @ignore
 * Reference to a draggable item. Used to manipulate or dispose of the item.
 * \@docs-private
 * @template T
 */
DragRef = /** @class */ (function () {
    function DragRef(element, _config, _document, _ngZone, _viewportRuler, _dragDropRegistry) {
        var _this = this;
        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 {?}
         */
        function (observer) {
            /** @type {?} */
            var subscription = _this._moveEvents.subscribe(observer);
            _this._moveEventSubscriptions++;
            return (/**
             * @return {?}
             */
            function () {
                subscription.unsubscribe();
                _this._moveEventSubscriptions--;
            });
        }));
        /**
         * Handler for the `mousedown`/`touchstart` events.
         */
        this._pointerDown = (/**
         * @param {?} event
         * @return {?}
         */
        function (event) {
            _this.beforeStarted.next();
            // Delegate the event based on whether it started from a handle or the element itself.
            if (_this._handles.length) {
                /** @type {?} */
                var targetHandle = _this._handles.find((/**
                 * @param {?} handle
                 * @return {?}
                 */
                function (handle) {
                    /** @type {?} */
                    var 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 {?}
         */
        function (event) {
            if (!_this._hasStartedDragging) {
                /** @type {?} */
                var pointerPosition = _this._getPointerPositionOnPage(event);
                /** @type {?} */
                var distanceX = Math.abs(pointerPosition.x - _this._pickupPositionOnPage.x);
                /** @type {?} */
                var 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 {?}
                     */
                    function () { 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 {?} */
            var constrainedPointerPosition = _this._getConstrainedPointerPosition(event);
            _this._hasMoved = true;
            event.preventDefault();
            _this._updatePointerDirectionDelta(constrainedPointerPosition);
            if (_this._dropContainer) {
                _this._updateActiveDropContainer(constrainedPointerPosition);
            }
            else {
                /** @type {?} */
                var activeTransform = _this._activeTransform;
                activeTransform.x =
                    constrainedPointerPosition.x - _this._pickupPositionOnPage.x + _this._passiveTransform.x;
                activeTransform.y =
                    constrainedPointerPosition.y - _this._pickupPositionOnPage.y + _this._passiveTransform.y;
                /** @type {?} */
                var 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 {?} */
                    var 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 {?}
                 */
                function () {
                    _this._moveEvents.next({
                        source: _this,
                        pointerPosition: constrainedPointerPosition,
                        event: event,
                        delta: _this._pointerDirectionDelta
                    });
                }));
            }
        });
        /**
         * Handler that is invoked when the user lifts their pointer up, after initiating a drag.
         */
        this._pointerUp = (/**
         * @param {?} event
         * @return {?}
         */
        function (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 {?}
                 */
                function () { return _this.ended.next({ source: _this }); }));
                _this._dragDropRegistry.stopDragging(_this);
                return;
            }
            _this._animatePreviewToPlaceholder().then((/**
             * @return {?}
             */
            function () {
                _this._cleanupDragArtifacts(event);
                _this._dragDropRegistry.stopDragging(_this);
            }));
        });
        this.withRootElement(element);
        _dragDropRegistry.registerDragItem(this);
    }
    Object.defineProperty(DragRef.prototype, "disabled", {
        /** Whether starting to drag this element is disabled. */
        get: /**
         * Whether starting to drag this element is disabled.
         * @return {?}
         */
        function () {
            return this._disabled || !!(this._dropContainer && this._dropContainer.disabled);
        },
        set: /**
         * @param {?} value
         * @return {?}
         */
        function (value) {
            /** @type {?} */
            var newValue = coerceBooleanProperty(value);
            if (newValue !== this._disabled) {
                this._disabled = newValue;
                this._toggleNativeDragInteractions();
            }
        },
        enumerable: true,
        configurable: true
    });
    /**
     * Returns the element that is being used as a placeholder
     * while the current element is being dragged.
     */
    /**
     * Returns the element that is being used as a placeholder
     * while the current element is being dragged.
     * @return {?}
     */
    DragRef.prototype.getPlaceholderElement = /**
     * Returns the element that is being used as a placeholder
     * while the current element is being dragged.
     * @return {?}
     */
    function () {
        return this._placeholder;
    };
    /** Returns the root draggable element. */
    /**
     * Returns the root draggable element.
     * @return {?}
     */
    DragRef.prototype.getRootElement = /**
     * Returns the root draggable element.
     * @return {?}
     */
    function () {
        return this._rootElement;
    };
    /** Registers the handles that can be used to drag the element. */
    /**
     * Registers the handles that can be used to drag the element.
     * @template THIS
     * @this {THIS}
     * @param {?} handles
     * @return {THIS}
     */
    DragRef.prototype.withHandles = /**
     * Registers the handles that can be used to drag the element.
     * @template THIS
     * @this {THIS}
     * @param {?} handles
     * @return {THIS}
     */
    function (handles) {
        (/** @type {?} */ (this))._handles = handles.map((/**
         * @param {?} handle
         * @return {?}
         */
        function (handle) { return coerceElement(handle); }));
        (/** @type {?} */ (this))._handles.forEach((/**
         * @param {?} handle
         * @return {?}
         */
        function (handle) { return toggleNativeDragInteractions(handle, false); }));
        (/** @type {?} */ (this))._toggleNativeDragInteractions();
        return (/** @type {?} */ (this));
    };
    /**
     * Registers the template that should be used for the drag preview.
     * @param template Template that from which to stamp out the preview.
     */
    /**
     * 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}
     */
    DragRef.prototype.withPreviewTemplate = /**
     * 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}
     */
    function (template) {
        (/** @type {?} */ (this))._previewTemplate = template;
        return (/** @type {?} */ (this));
    };
    /**
     * Registers the template that should be used for the drag placeholder.
     * @param template Template that from which to stamp out the placeholder.
     */
    /**
     * 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}
     */
    DragRef.prototype.withPlaceholderTemplate = /**
     * 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}
     */
    function (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.
     */
    /**
     * 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}
     */
    DragRef.prototype.withRootElement = /**
     * 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}
     */
    function (rootElement) {
        /** @type {?} */
        var 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.
     */
    /**
     * Element to which the draggable's position will be constrained.
     * @template THIS
     * @this {THIS}
     * @param {?} boundaryElement
     * @return {THIS}
     */
    DragRef.prototype.withBoundaryElement = /**
     * Element to which the draggable's position will be constrained.
     * @template THIS
     * @this {THIS}
     * @param {?} boundaryElement
     * @return {THIS}
     */
    function (boundaryElement) {
        (/** @type {?} */ (this))._boundaryElement = boundaryElement ? coerceElement(boundaryElement) : null;
        return (/** @type {?} */ (this));
    };
    /** Removes the dragging functionality from the DOM element. */
    /**
     * Removes the dragging functionality from the DOM element.
     * @return {?}
     */
    DragRef.prototype.dispose = /**
     * Removes the dragging functionality from the DOM element.
     * @return {?}
     */
    function () {
        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. */
    /**
     * Checks whether the element is currently being dragged.
     * @return {?}
     */
    DragRef.prototype.isDragging = /**
     * Checks whether the element is currently being dragged.
     * @return {?}
     */
    function () {
        return this._hasStartedDragging && this._dragDropRegistry.isDragging(this);
    };
    /** Resets a standalone drag item to its initial position. */
    /**
     * Resets a standalone drag item to its initial position.
     * @return {?}
     */
    DragRef.prototype.reset = /**
     * Resets a standalone drag item to its initial position.
     * @return {?}
     */
    function () {
        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.
     */
    /**
     * 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 {?}
     */
    DragRef.prototype.disableHandle = /**
     * 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 {?}
     */
    function (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.
     */
    /**
     * Enables a handle, if it has been disabled.
     * @param {?} handle Handle element to be enabled.
     * @return {?}
     */
    DragRef.prototype.enableHandle = /**
     * Enables a handle, if it has been disabled.
     * @param {?} handle Handle element to be enabled.
     * @return {?}
     */
    function (handle) {
        this._disabledHandles.delete(handle);
    };
    /** Sets the layout direction of the draggable item. */
    /**
     * Sets the layout direction of the draggable item.
     * @template THIS
     * @this {THIS}
     * @param {?} direction
     * @return {THIS}
     */
    DragRef.prototype.withDirection = /**
     * Sets the layout direction of the draggable item.
     * @template THIS
     * @this {THIS}
     * @param {?} direction
     * @return {THIS}
     */
    function (direction) {
        (/** @type {?} */ (this))._direction = direction;
        return (/** @type {?} */ (this));
    };
    /** Sets the container that the item is part of. */
    /**
     * Sets the container that the item is part of.
     * @param {?} container
     * @return {?}
     */
    DragRef.prototype._withDropContainer = /**
     * Sets the container that the item is part of.
     * @param {?} container
     * @return {?}
     */
    function (container) {
        this._dropContainer = container;
    };
    /** Unsubscribes from the global subscriptions. */
    /**
     * Unsubscribes from the global subscriptions.
     * @private
     * @return {?}
     */
    DragRef.prototype._removeSubscriptions = /**
     * Unsubscribes from the global subscriptions.
     * @private
     * @return {?}
     */
    function () {
        this._pointerMoveSubscription.unsubscribe();
        this._pointerUpSubscription.unsubscribe();
    };
    /** Destroys the preview element and its ViewRef. */
    /**
     * Destroys the preview element and its ViewRef.
     * @private
     * @return {?}
     */
    DragRef.prototype._destroyPreview = /**
     * Destroys the preview element and its ViewRef.
     * @private
     * @return {?}
     */
    function () {
        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. */
    /**
     * Destroys the placeholder element and its ViewRef.
     * @private
     * @return {?}
     */
    DragRef.prototype._destroyPlaceholder = /**
     * Destroys the placeholder element and its ViewRef.
     * @private
     * @return {?}
     */
    function () {
        if (this._placeholder) {
            removeElement(this._placeholder);
        }
        if (this._placeholderRef) {
            this._placeholderRef.destroy();
        }
        this._placeholder = this._placeholderRef = (/** @type {?} */ (null));
    };
    /** Starts the dragging sequence. */
    /**
     * Starts the dragging sequence.
     * @private
     * @param {?} event
     * @return {?}
     */
    DragRef.prototype._startDragSequence = /**
     * Starts the dragging sequence.
     * @private
     * @param {?} event
     * @return {?}
     */
    function (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 {?} */
            var 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 {?} */
            var preview = this._preview = this._createPreviewElement();
            /** @type {?} */
            var 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.
     * @param referenceElement Element that started the drag sequence.
     * @param event Browser event object that started the sequence.
     */
    /**
     * 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 {?}
     */
    DragRef.prototype._initializeDragSequence = /**
     * 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 {?}
     */
    function (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 {?} */
        var isDragging = this.isDragging();
        /** @type {?} */
        var isTouchSequence = isTouchEvent(event);
        /** @type {?} */
        var isAuxiliaryMouseButton = !isTouchSequence && ((/** @type {?} */ (event))).button !== 0;
        /** @type {?} */
        var rootElement = this._rootElement;
        /** @type {?} */
        var 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 {?} */
        var 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. */
    /**
     * Cleans up the DOM artifacts that were added to fanpitate the element being dragged.
     * @private
     * @param {?} event
     * @return {?}
     */
    DragRef.prototype._cleanupDragArtifacts = /**
     * Cleans up the DOM artifacts that were added to fanpitate the element being dragged.
     * @private
     * @param {?} event
     * @return {?}
     */
    function (event) {
        var _this = this;
        // 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 {?}
         */
        function () {
            /** @type {?} */
            var container = (/** @type {?} */ (_this._dropContainer));
            /** @type {?} */
            var currentIndex = container.getItemIndex(_this);
            var _a = _this._getPointerPositionOnPage(event), x = _a.x, y = _a.y;
            /** @type {?} */
            var isPointerOverContainer = container._isOverContainer(x, y);
            _this.ended.next({ source: _this });
            _this.dropped.next({
                item: _this,
                currentIndex: currentIndex,
                previousIndex: _this._initialContainer.getItemIndex(_this),
                container: container,
                previousContainer: _this._initialContainer,
                isPointerOverContainer: 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.
     */
    /**
     * 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 {?}
     */
    DragRef.prototype._updateActiveDropContainer = /**
     * 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 {?}
     */
    function (_a) {
        var _this = this;
        var x = _a.x, y = _a.y;
        // Drop container that draggable has been moved into.
        /** @type {?} */
        var 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 {?}
             */
            function () {
                // 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.
     */
    /**
     * 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 {?}
     */
    DragRef.prototype._createPreviewElement = /**
     * 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 {?}
     */
    function () {
        /** @type {?} */
        var previewConfig = this._previewTemplate;
        /** @type {?} */
        var previewTemplate = previewConfig ? previewConfig.template : null;
        /** @type {?} */
        var preview;
        if (previewTemplate) {
            /** @type {?} */
            var 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 {?} */
            var element = this._rootElement;
            /** @type {?} */
            var 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.
     * @returns Promise that resolves when the animation completes.
     */
    /**
     * Animates the preview element from its current position to the location of the drop placeholder.
     * @private
     * @return {?} Promise that resolves when the animation completes.
     */
    DragRef.prototype._animatePreviewToPlaceholder = /**
     * Animates the preview element from its current position to the location of the drop placeholder.
     * @private
     * @return {?} Promise that resolves when the animation completes.
     */
    function () {
        var _this = this;
        // If the user hasn't moved yet, the transitionend event won't fire.
        if (!this._hasMoved) {
            return Promise.resolve();
        }
        /** @type {?} */
        var 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 {?} */
        var duration = getTransformTransitionDurationInMs(this._preview);
        if (duration === 0) {
            return Promise.resolve();
        }
        return this._ngZone.runOutsideAngular((/**
         * @return {?}
         */
        function () {
            return new Promise((/**
             * @param {?} resolve
             * @return {?}
             */
            function (resolve) {
                /** @type {?} */
                var handler = (/** @type {?} */ (((/**
                 * @param {?} event
                 * @return {?}
                 */
                function (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 {?} */
                var 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. */
    /**
     * Creates an element that will be shown instead of the current element while dragging.
     * @private
     * @return {?}
     */
    DragRef.prototype._createPlaceholderElement = /**
     * Creates an element that will be shown instead of the current element while dragging.
     * @private
     * @return {?}
     */
    function () {
        /** @type {?} */
        var placeholderConfig = this._placeholderTemplate;
        /** @type {?} */
        var placeholderTemplate = placeholderConfig ? placeholderConfig.template : null;
        /** @type {?} */
        var 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.
     * @param referenceElement Element that initiated the dragging.
     * @param event Event that initiated the dragging.
     */
    /**
     * 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 {?}
     */
    DragRef.prototype._getPointerPositionInElement = /**
     * 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 {?}
     */
    function (referenceElement, event) {
        /** @type {?} */
        var elementRect = this._rootElement.getBoundingClientRect();
        /** @type {?} */
        var handleElement = referenceElement === this._rootElement ? null : referenceElement;
        /** @type {?} */
        var referenceRect = handleElement ? handleElement.getBoundingClientRect() : elementRect;
        /** @type {?} */
        var point = isTouchEvent(event) ? event.targetTouches[0] : event;
        /** @type {?} */
        var x = point.pageX - referenceRect.left - this._scrollPosition.left;
        /** @type {?} */
        var 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. */
    /**
     * Determines the point of the page that was touched by the user.
     * @private
     * @param {?} event
     * @return {?}
     */
    DragRef.prototype._getPointerPositionOnPage = /**
     * Determines the point of the page that was touched by the user.
     * @private
     * @param {?} event
     * @return {?}
     */
    function (event) {
        // `touches` will be empty for start/end events so we have to fall back to `changedTouches`.
        /** @type {?} */
        var 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. */
    /**
     * Gets the pointer position on the page, accounting for any position constraints.
     * @private
     * @param {?} event
     * @return {?}
     */
    DragRef.prototype._getConstrainedPointerPosition = /**
     * Gets the pointer position on the page, accounting for any position constraints.
     * @private
     * @param {?} event
     * @return {?}
     */
    function (event) {
        /** @type {?} */
        var point = this._getPointerPositionOnPage(event);
        /** @type {?} */
        var 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) {
            var _a = this._pickupPositionInElement, pickupX = _a.x, pickupY = _a.y;
            /** @type {?} */
            var boundaryRect = this._boundaryRect;
            /** @type {?} */
            var previewRect = (/** @type {?} */ (this._previewRect));
            /** @type {?} */
            var minY = boundaryRect.top + pickupY;
            /** @type {?} */
            var maxY = boundaryRect.bottom - (previewRect.height - pickupY);
            /** @type {?} */
            var minX = boundaryRect.left + pickupX;
            /** @type {?} */
            var 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. */
    /**
     * Updates the current drag delta, based on the user's current pointer position on the page.
     * @private
     * @param {?} pointerPositionOnPage
     * @return {?}
     */
    DragRef.prototype._updatePointerDirectionDelta = /**
     * Updates the current drag delta, based on the user's current pointer position on the page.
     * @private
     * @param {?} pointerPositionOnPage
     * @return {?}
     */
    function (pointerPositionOnPage) {
        var x = pointerPositionOnPage.x, y = pointerPositionOnPage.y;
        /** @type {?} */
        var delta = this._pointerDirectionDelta;
        /** @type {?} */
        var positionSinceLastChange = this._pointerPositionAtLastDirectionChange;
        // Amount of pixels the user has dragged since the last time the direction changed.
        /** @type {?} */
        var changeX = Math.abs(x - positionSinceLastChange.x);
        /** @type {?} */
        var 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. */
    /**
     * Toggles the native drag interactions, based on how many handles are registered.
     * @private
     * @return {?}
     */
    DragRef.prototype._toggleNativeDragInteractions = /**
     * Toggles the native drag interactions, based on how many handles are registered.
     * @private
     * @return {?}
     */
    function () {
        if (!this._rootElement || !this._handles) {
            return;
        }
        /** @type {?} */
        var 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. */
    /**
     * Removes the manually-added event listeners from the root element.
     * @private
     * @param {?} element
     * @return {?}
     */
    DragRef.prototype._removeRootElementListeners = /**
     * Removes the manually-added event listeners from the root element.
     * @private
     * @param {?} element
     * @return {?}
     */
    function (element) {
        element.removeEventListener('mousedown', this._pointerDown, activeEventListenerOptions);
        element.removeEventListener('touchstart', this._pointerDown, passiveEventListenerOptions);
    };
    return DragRef;
}());
/**
 * @ignore
 * Reference to a draggable item. Used to manipulate or dispose of the item.
 * \@docs-private
 * @template T
 */
export { DragRef };
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 {?} */
    var 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"]}