@angular/cdk 7.2.2 → 7.3.0

package/esm2015/drag-drop.js

@@ -5,13 +5,13 @@
  * 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 { InjectionToken, Injectable, NgZone, Inject, NgModule, ContentChildren, ElementRef, EventEmitter, forwardRef, Input, Output, Optional, Directive, ChangeDetectorRef, SkipSelf, ContentChild, ViewContainerRef, TemplateRef, defineInjectable, inject } from '@angular/core';
-import { DOCUMENT } from '@angular/common';
 import { normalizePassiveListenerOptions } from '@angular/cdk/platform';
-import { Subject, Subscription, Observable, merge } from 'rxjs';
 import { coerceBooleanProperty, coerceElement, coerceArray } from '@angular/cdk/coercion';
-import { Directionality } from '@angular/cdk/bidi';
+import { Subscription, Subject, Observable, merge } from 'rxjs';
+import { ElementRef, Injectable, NgZone, Inject, InjectionToken, NgModule, ContentChildren, EventEmitter, forwardRef, Input, Output, Optional, Directive, ChangeDetectorRef, SkipSelf, ContentChild, ViewContainerRef, TemplateRef, defineInjectable, inject } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
 import { ViewportRuler } from '@angular/cdk/scrolling';
+import { Directionality } from '@angular/cdk/bidi';
 import { startWith, take, map, takeUntil, switchMap, tap } from 'rxjs/operators';
 
 /**
@@ -19,24 +19,40 @@ import { startWith, take, map, takeUntil, switchMap, tap } from 'rxjs/operators'
  * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
- * Injection token that is used to provide a CdkDropList instance to CdkDrag.
- * Used for avoiding circular imports.
- * @type {?}
- */
-const CDK_DROP_LIST = new InjectionToken('CDK_DROP_LIST');
-/**
- * Injection token that is used to provide a CdkDropList instance to CdkDrag.
- * Used for avoiding circular imports.
- * @deprecated Use `CDK_DROP_LIST` instead.
- * \@breaking-change 8.0.0
- * @type {?}
+ * Shallow-extends a stylesheet object with another stylesheet object.
+ * \@docs-private
+ * @param {?} dest
+ * @param {?} source
+ * @return {?}
  */
-const CDK_DROP_LIST_CONTAINER = CDK_DROP_LIST;
-
+function extendStyles(dest, source) {
+    for (let key in source) {
+        if (source.hasOwnProperty(key)) {
+            dest[(/** @type {?} */ (key))] = source[(/** @type {?} */ (key))];
+        }
+    }
+    return dest;
+}
 /**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Toggles whether the native drag interactions should be enabled for an element.
+ * \@docs-private
+ * @param {?} element Element on which to toggle the drag interactions.
+ * @param {?} enable Whether the drag interactions should be enabled.
+ * @return {?}
  */
+function toggleNativeDragInteractions(element, enable) {
+    /** @type {?} */
+    const userSelect = enable ? '' : 'none';
+    extendStyles(element.style, {
+        touchAction: enable ? '' : 'none',
+        webkitUserDrag: enable ? '' : 'none',
+        webkitTapHighlightColor: enable ? '' : 'transparent',
+        userSelect: userSelect,
+        msUserSelect: userSelect,
+        webkitUserSelect: userSelect,
+        MozUserSelect: userSelect
+    });
+}
 
 /**
  * @fileoverview added by tsickle
@@ -44,74 +60,53 @@ const CDK_DROP_LIST_CONTAINER = CDK_DROP_LIST;
  */
 
 /**
- * Moves an item one index in an array to another.
- * @template T
- * @param {?} array Array in which to move the item.
- * @param {?} fromIndex Starting index of the item.
- * @param {?} toIndex Index to which the item should be moved.
+ * Parses a CSS time value to milliseconds.
+ * @param {?} value
  * @return {?}
  */
-function moveItemInArray(array, fromIndex, toIndex) {
-    /** @type {?} */
-    const from = clamp(fromIndex, array.length - 1);
-    /** @type {?} */
-    const to = clamp(toIndex, array.length - 1);
-    if (from === to) {
-        return;
-    }
-    /** @type {?} */
-    const target = array[from];
+function parseCssTimeUnitsToMs(value) {
+    // Some browsers will return it in seconds, whereas others will return milliseconds.
     /** @type {?} */
-    const delta = to < from ? -1 : 1;
-    for (let i = from; i !== to; i += delta) {
-        array[i] = array[i + delta];
-    }
-    array[to] = target;
+    const multiplier = value.toLowerCase().indexOf('ms') > -1 ? 1 : 1000;
+    return parseFloat(value) * multiplier;
 }
 /**
- * Moves an item from one array to another.
- * @template T
- * @param {?} currentArray Array from which to transfer the item.
- * @param {?} targetArray Array into which to put the item.
- * @param {?} currentIndex Index of the item in its current array.
- * @param {?} targetIndex Index at which to insert the item.
+ * Gets the transform transition duration, including the delay, of an element in milliseconds.
+ * @param {?} element
  * @return {?}
  */
-function transferArrayItem(currentArray, targetArray, currentIndex, targetIndex) {
+function getTransformTransitionDurationInMs(element) {
     /** @type {?} */
-    const from = clamp(currentIndex, currentArray.length - 1);
+    const computedStyle = getComputedStyle(element);
     /** @type {?} */
-    const to = clamp(targetIndex, targetArray.length);
-    if (currentArray.length) {
-        targetArray.splice(to, 0, currentArray.splice(from, 1)[0]);
-    }
-}
-/**
- * Copies an item from one array to another, leaving it in its
- * original position in current array.
- * @template T
- * @param {?} currentArray Array from which to copy the item.
- * @param {?} targetArray Array into which is copy the item.
- * @param {?} currentIndex Index of the item in its current array.
- * @param {?} targetIndex Index at which to insert the item.
- *
- * @return {?}
- */
-function copyArrayItem(currentArray, targetArray, currentIndex, targetIndex) {
+    const transitionedProperties = parseCssPropertyValue(computedStyle, 'transition-property');
     /** @type {?} */
-    const to = clamp(targetIndex, targetArray.length);
-    if (currentArray.length) {
-        targetArray.splice(to, 0, currentArray[currentIndex]);
+    const property = transitionedProperties.find(prop => prop === 'transform' || prop === 'all');
+    // If there's no transition for `all` or `transform`, we shouldn't do anything.
+    if (!property) {
+        return 0;
     }
+    // Get the index of the property that we're interested in and match
+    // it up to the same index in `transition-delay` and `transition-duration`.
+    /** @type {?} */
+    const propertyIndex = transitionedProperties.indexOf(property);
+    /** @type {?} */
+    const rawDurations = parseCssPropertyValue(computedStyle, 'transition-duration');
+    /** @type {?} */
+    const rawDelays = parseCssPropertyValue(computedStyle, 'transition-delay');
+    return parseCssTimeUnitsToMs(rawDurations[propertyIndex]) +
+        parseCssTimeUnitsToMs(rawDelays[propertyIndex]);
 }
 /**
- * Clamps a number between zero and a maximum.
- * @param {?} value
- * @param {?} max
+ * Parses out multiple values from a computed style into an array.
+ * @param {?} computedStyle
+ * @param {?} name
  * @return {?}
  */
-function clamp(value, max) {
-    return Math.max(0, Math.min(max, value));
+function parseCssPropertyValue(computedStyle, name) {
+    /** @type {?} */
+    const value = computedStyle.getPropertyValue(name);
+    return value.split(',').map(part => part.trim());
 }
 
 /**
@@ -119,1395 +114,1667 @@ function clamp(value, max) {
  * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
- * Event options that can be used to bind an active, capturing event.
+ * Options that can be used to bind a passive event listener.
  * @type {?}
  */
-const activeCapturingEventOptions = normalizePassiveListenerOptions({
-    passive: false,
-    capture: true
-});
+const passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true });
 /**
- * Service that keeps track of all the drag item and drop container
- * instances, and manages global event listeners on the `document`.
+ * Options that can be used to bind an active event listener.
+ * @type {?}
+ */
+const activeEventListenerOptions = normalizePassiveListenerOptions({ passive: false });
+/**
+ * Time in milliseconds for which to ignore mouse events, after
+ * receiving a touch event. Used to avoid doing double work for
+ * touch devices where the browser fires fake mouse events, in
+ * addition to touch events.
+ * @type {?}
+ */
+const MOUSE_EVENT_IGNORE_TIME = 800;
+/**
+ * Reference to a draggable item. Used to manipulate or dispose of the item.
  * \@docs-private
- * @template I, C
+ * @template T
  */
-// Note: this class is generic, rather than referencing CdkDrag and CdkDropList directly, in order
-// to avoid circular imports. If we were to reference them here, importing the registry into the
-// classes that are registering themselves will introduce a circular import.
-class DragDropRegistry {
+class DragRef {
     /**
-     * @param {?} _ngZone
+     * @param {?} element
+     * @param {?} _config
      * @param {?} _document
+     * @param {?} _ngZone
+     * @param {?} _viewportRuler
+     * @param {?} _dragDropRegistry
      */
-    constructor(_ngZone, _document) {
+    constructor(element, _config, _document, _ngZone, _viewportRuler, _dragDropRegistry) {
+        this._config = _config;
+        this._document = _document;
         this._ngZone = _ngZone;
+        this._viewportRuler = _viewportRuler;
+        this._dragDropRegistry = _dragDropRegistry;
         /**
-         * Registered drop container instances.
+         * 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._dropInstances = new Set();
+        this._passiveTransform = { x: 0, y: 0 };
         /**
-         * Registered drag item instances.
+         * CSS `transform` that is applied to the element while it's being dragged.
          */
-        this._dragInstances = new Set();
+        this._activeTransform = { x: 0, y: 0 };
         /**
-         * Drag item instances that are currently being dragged.
+         * Emits when the item is being moved.
          */
-        this._activeDragInstances = new Set();
+        this._moveEvents = new Subject();
         /**
-         * Keeps track of the event listeners that we've bound to the `document`.
+         * Amount of subscriptions to the move event. Used to avoid
+         * hitting the zone if the consumer didn't subscribe to it.
          */
-        this._globalListeners = new Map();
+        this._moveEventSubscriptions = 0;
         /**
-         * Emits the `touchmove` or `mousemove` events that are dispatched
-         * while the user is dragging a drag item instance.
+         * Subscription to pointer movement events.
          */
-        this.pointerMove = new Subject();
+        this._pointerMoveSubscription = Subscription.EMPTY;
         /**
-         * Emits the `touchend` or `mouseup` events that are dispatched
-         * while the user is dragging a drag item instance.
+         * Subscription to the event that is dispatched when the user lifts their pointer.
          */
-        this.pointerUp = new Subject();
+        this._pointerUpSubscription = Subscription.EMPTY;
         /**
-         * Event listener that will prevent the default browser action while the user is dragging.
-         * @param event Event whose default action should be prevented.
+         * Cached reference to the boundary element.
          */
-        this._preventDefaultWhileDragging = (event) => {
-            if (this._activeDragInstances.size) {
-                event.preventDefault();
-            }
-        };
-        this._document = _document;
-    }
-    /**
-     * Adds a drop container to the registry.
-     * @param {?} drop
-     * @return {?}
-     */
-    registerDropContainer(drop) {
-        if (!this._dropInstances.has(drop)) {
-            if (this.getDropContainer(drop.id)) {
-                throw Error(`Drop instance with id "${drop.id}" has already been registered.`);
-            }
-            this._dropInstances.add(drop);
-        }
-    }
-    /**
-     * Adds a drag item instance to the registry.
-     * @param {?} drag
-     * @return {?}
-     */
-    registerDragItem(drag) {
-        this._dragInstances.add(drag);
-        // The `touchmove` event gets bound once, ahead of time, because WebKit
-        // won't preventDefault on a dynamically-added `touchmove` listener.
-        // See https://bugs.webkit.org/show_bug.cgi?id=184250.
-        if (this._dragInstances.size === 1) {
-            this._ngZone.runOutsideAngular(() => {
-                // The event handler has to be explicitly active,
-                // because newer browsers make it passive by default.
-                this._document.addEventListener('touchmove', this._preventDefaultWhileDragging, activeCapturingEventOptions);
-            });
-        }
-    }
-    /**
-     * Removes a drop container from the registry.
-     * @param {?} drop
-     * @return {?}
-     */
-    removeDropContainer(drop) {
-        this._dropInstances.delete(drop);
-    }
-    /**
-     * Removes a drag item instance from the registry.
-     * @param {?} drag
-     * @return {?}
-     */
-    removeDragItem(drag) {
-        this._dragInstances.delete(drag);
-        this.stopDragging(drag);
-        if (this._dragInstances.size === 0) {
-            this._document.removeEventListener('touchmove', this._preventDefaultWhileDragging, activeCapturingEventOptions);
-        }
-    }
-    /**
-     * Starts the dragging sequence for a drag instance.
-     * @param {?} drag Drag instance which is being dragged.
-     * @param {?} event Event that initiated the dragging.
-     * @return {?}
-     */
-    startDragging(drag, event) {
-        this._activeDragInstances.add(drag);
-        if (this._activeDragInstances.size === 1) {
-            /** @type {?} */
-            const isTouchEvent = event.type.startsWith('touch');
-            /** @type {?} */
-            const moveEvent = isTouchEvent ? 'touchmove' : 'mousemove';
+        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((observer) => {
             /** @type {?} */
-            const upEvent = isTouchEvent ? 'touchend' : 'mouseup';
-            // We explicitly bind __active__ listeners here, because newer browsers will default to
-            // passive ones for `mousemove` and `touchmove`. The events need to be active, because we
-            // use `preventDefault` to prevent the page from scrolling while the user is dragging.
-            this._globalListeners
-                .set(moveEvent, {
-                handler: (e) => this.pointerMove.next((/** @type {?} */ (e))),
-                options: activeCapturingEventOptions
-            })
-                .set(upEvent, {
-                handler: (e) => this.pointerUp.next((/** @type {?} */ (e))),
-                options: true
-            })
-                // Preventing the default action on `mousemove` isn't enough to disable text selection
-                // on Safari so we need to prevent the selection event as well. Alternatively this can
-                // be done by setting `user-select: none` on the `body`, however it has causes a style
-                // recalculation which can be expensive on pages with a lot of elements.
-                .set('selectstart', {
-                handler: this._preventDefaultWhileDragging,
-                options: activeCapturingEventOptions
-            });
-            // TODO(crisbeto): prevent mouse wheel scrolling while
-            // dragging until we've set up proper scroll handling.
-            if (!isTouchEvent) {
-                this._globalListeners.set('wheel', {
-                    handler: this._preventDefaultWhileDragging,
-                    options: activeCapturingEventOptions
+            const subscription = this._moveEvents.subscribe(observer);
+            this._moveEventSubscriptions++;
+            return () => {
+                subscription.unsubscribe();
+                this._moveEventSubscriptions--;
+            };
+        });
+        /**
+         * Handler for the `mousedown`/`touchstart` events.
+         */
+        this._pointerDown = (event) => {
+            this.beforeStarted.next();
+            // Delegate the event based on whether it started from a handle or the element itself.
+            if (this._handles.length) {
+                /** @type {?} */
+                const targetHandle = this._handles.find(handle => {
+                    /** @type {?} */
+                    const target = event.target;
+                    return !!target && (target === handle || handle.contains((/** @type {?} */ (target))));
                 });
+                if (targetHandle && !this._disabledHandles.has(targetHandle) && !this.disabled) {
+                    this._initializeDragSequence(targetHandle, event);
+                }
             }
-            this._ngZone.runOutsideAngular(() => {
-                this._globalListeners.forEach((config, name) => {
-                    this._document.addEventListener(name, config.handler, config.options);
+            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 = (event) => {
+            if (!this._hasStartedDragging) {
+                /** @type {?} */
+                const pointerPosition = this._getPointerPositionOnPage(event);
+                /** @type {?} */
+                const distanceX = Math.abs(pointerPosition.x - this._pickupPositionOnPage.x);
+                /** @type {?} */
+                const distanceY = Math.abs(pointerPosition.y - this._pickupPositionOnPage.y);
+                // Only start dragging after the user has moved more than the minimum distance in either
+                // direction. Note that this is preferrable over doing something like `skip(minimumDistance)`
+                // in the `pointerMove` subscription, because we're not guaranteed to have one move event
+                // per pixel of movement (e.g. if the user moves their pointer quickly).
+                if (distanceX + distanceY >= this._config.dragStartThreshold) {
+                    this._hasStartedDragging = true;
+                    this._ngZone.run(() => this._startDragSequence(event));
+                }
+                return;
+            }
+            // We only need the preview dimensions if we have a boundary element.
+            if (this._boundaryElement) {
+                // Cache the preview element rect if we haven't cached it already or if
+                // we cached it too early before the element dimensions were computed.
+                if (!this._previewRect || (!this._previewRect.width && !this._previewRect.height)) {
+                    this._previewRect = (this._preview || this._rootElement).getBoundingClientRect();
+                }
+            }
+            /** @type {?} */
+            const constrainedPointerPosition = this._getConstrainedPointerPosition(event);
+            this._hasMoved = true;
+            event.preventDefault();
+            this._updatePointerDirectionDelta(constrainedPointerPosition);
+            if (this._dropContainer) {
+                this._updateActiveDropContainer(constrainedPointerPosition);
+            }
+            else {
+                /** @type {?} */
+                const activeTransform = this._activeTransform;
+                activeTransform.x =
+                    constrainedPointerPosition.x - this._pickupPositionOnPage.x + this._passiveTransform.x;
+                activeTransform.y =
+                    constrainedPointerPosition.y - this._pickupPositionOnPage.y + this._passiveTransform.y;
+                /** @type {?} */
+                const transform = getTransform(activeTransform.x, activeTransform.y);
+                // Preserve the previous `transform` value, if there was one. Note that we apply our own
+                // transform before the user's, because things like rotation can affect which direction
+                // the element will be translated towards.
+                this._rootElement.style.transform = this._initialTransform ?
+                    transform + ' ' + this._initialTransform : transform;
+                // Apply transform as attribute if dragging and svg element to work for IE
+                if (typeof SVGElement !== 'undefined' && this._rootElement instanceof SVGElement) {
+                    /** @type {?} */
+                    const appliedTransform = `translate(${activeTransform.x} ${activeTransform.y})`;
+                    this._rootElement.setAttribute('transform', appliedTransform);
+                }
+            }
+            // Since this event gets fired for every pixel while dragging, we only
+            // want to fire it if the consumer opted into it. Also we have to
+            // re-enter the zone because we run all of the events on the outside.
+            if (this._moveEventSubscriptions > 0) {
+                this._ngZone.run(() => {
+                    this._moveEvents.next({
+                        source: this,
+                        pointerPosition: constrainedPointerPosition,
+                        event,
+                        delta: this._pointerDirectionDelta
+                    });
                 });
+            }
+        };
+        /**
+         * Handler that is invoked when the user lifts their pointer up, after initiating a drag.
+         */
+        this._pointerUp = (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(() => this.ended.next({ source: this }));
+                this._dragDropRegistry.stopDragging(this);
+                return;
+            }
+            this._animatePreviewToPlaceholder().then(() => {
+                this._cleanupDragArtifacts(event);
+                this._dragDropRegistry.stopDragging(this);
             });
-        }
+        };
+        this.withRootElement(element);
+        _dragDropRegistry.registerDragItem(this);
     }
     /**
-     * Stops dragging a drag item instance.
-     * @param {?} drag
+     * Whether starting to drag this element is disabled.
      * @return {?}
      */
-    stopDragging(drag) {
-        this._activeDragInstances.delete(drag);
-        if (this._activeDragInstances.size === 0) {
-            this._clearGlobalListeners();
-        }
+    get disabled() {
+        return this._disabled || !!(this._dropContainer && this._dropContainer.disabled);
     }
     /**
-     * Gets whether a drag item instance is currently being dragged.
-     * @param {?} drag
+     * @param {?} value
      * @return {?}
      */
-    isDragging(drag) {
-        return this._activeDragInstances.has(drag);
+    set disabled(value) {
+        /** @type {?} */
+        const newValue = coerceBooleanProperty(value);
+        if (newValue !== this._disabled) {
+            this._disabled = newValue;
+            this._toggleNativeDragInteractions();
+        }
     }
     /**
-     * Gets a drop container by its id.
-     * @deprecated No longer being used. To be removed.
-     * \@breaking-change 8.0.0
-     * @param {?} id
+     * Returns the element that is being used as a placeholder
+     * while the current element is being dragged.
      * @return {?}
      */
-    getDropContainer(id) {
-        return Array.from(this._dropInstances).find(instance => instance.id === id);
+    getPlaceholderElement() {
+        return this._placeholder;
     }
     /**
+     * Returns the root draggable element.
      * @return {?}
      */
-    ngOnDestroy() {
-        this._dragInstances.forEach(instance => this.removeDragItem(instance));
-        this._dropInstances.forEach(instance => this.removeDropContainer(instance));
-        this._clearGlobalListeners();
-        this.pointerMove.complete();
-        this.pointerUp.complete();
+    getRootElement() {
+        return this._rootElement;
     }
     /**
-     * Clears out the global event listeners from the `document`.
-     * @private
-     * @return {?}
+     * Registers the handles that can be used to drag the element.
+     * @template THIS
+     * @this {THIS}
+     * @param {?} handles
+     * @return {THIS}
      */
-    _clearGlobalListeners() {
-        this._globalListeners.forEach((config, name) => {
-            this._document.removeEventListener(name, config.handler, config.options);
-        });
-        this._globalListeners.clear();
+    withHandles(handles) {
+        (/** @type {?} */ (this))._handles = handles.map(handle => coerceElement(handle));
+        (/** @type {?} */ (this))._handles.forEach(handle => toggleNativeDragInteractions(handle, false));
+        (/** @type {?} */ (this))._toggleNativeDragInteractions();
+        return (/** @type {?} */ (this));
     }
-}
-DragDropRegistry.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] },
-];
-/** @nocollapse */
-DragDropRegistry.ctorParameters = () => [
-    { type: NgZone },
-    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-];
-/** @nocollapse */ DragDropRegistry.ngInjectableDef = defineInjectable({ factory: function DragDropRegistry_Factory() { return new DragDropRegistry(inject(NgZone), inject(DOCUMENT)); }, token: DragDropRegistry, providedIn: "root" });
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Injection token that can be used for a `CdkDrag` to provide itself as a parent to the
- * drag-specific child directive (`CdkDragHandle`, `CdkDragPreview` etc.). Used primarily
- * to avoid circular imports.
- * \@docs-private
- * @type {?}
- */
-const CDK_DRAG_PARENT = new InjectionToken('CDK_DRAG_PARENT');
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Shallow-extends a stylesheet object with another stylesheet object.
- * \@docs-private
- * @param {?} dest
- * @param {?} source
- * @return {?}
- */
-function extendStyles(dest, source) {
-    for (let key in source) {
-        if (source.hasOwnProperty(key)) {
-            dest[(/** @type {?} */ (key))] = source[(/** @type {?} */ (key))];
+    /**
+     * Registers the template that should be used for the drag preview.
+     * @template THIS
+     * @this {THIS}
+     * @param {?} template Template that from which to stamp out the preview.
+     * @return {THIS}
+     */
+    withPreviewTemplate(template) {
+        (/** @type {?} */ (this))._previewTemplate = template;
+        return (/** @type {?} */ (this));
+    }
+    /**
+     * Registers the template that should be used for the drag placeholder.
+     * @template THIS
+     * @this {THIS}
+     * @param {?} template Template that from which to stamp out the placeholder.
+     * @return {THIS}
+     */
+    withPlaceholderTemplate(template) {
+        (/** @type {?} */ (this))._placeholderTemplate = template;
+        return (/** @type {?} */ (this));
+    }
+    /**
+     * Sets an alternate drag root element. The root element is the element that will be moved as
+     * the user is dragging. Passing an alternate root element is useful when trying to enable
+     * dragging on an element that you might not have access to.
+     * @template THIS
+     * @this {THIS}
+     * @param {?} rootElement
+     * @return {THIS}
+     */
+    withRootElement(rootElement) {
+        /** @type {?} */
+        const element = coerceElement(rootElement);
+        if (element !== (/** @type {?} */ (this))._rootElement) {
+            if ((/** @type {?} */ (this))._rootElement) {
+                (/** @type {?} */ (this))._removeRootElementListeners((/** @type {?} */ (this))._rootElement);
+            }
+            element.addEventListener('mousedown', (/** @type {?} */ (this))._pointerDown, activeEventListenerOptions);
+            element.addEventListener('touchstart', (/** @type {?} */ (this))._pointerDown, passiveEventListenerOptions);
+            (/** @type {?} */ (this))._initialTransform = undefined;
+            (/** @type {?} */ (this))._rootElement = element;
         }
+        return (/** @type {?} */ (this));
     }
-    return dest;
-}
-/**
- * Toggles whether the native drag interactions should be enabled for an element.
- * \@docs-private
- * @param {?} element Element on which to toggle the drag interactions.
- * @param {?} enable Whether the drag interactions should be enabled.
- * @return {?}
- */
-function toggleNativeDragInteractions(element, enable) {
-    /** @type {?} */
-    const userSelect = enable ? '' : 'none';
-    extendStyles(element.style, {
-        touchAction: enable ? '' : 'none',
-        webkitUserDrag: enable ? '' : 'none',
-        webkitTapHighlightColor: enable ? '' : 'transparent',
-        userSelect: userSelect,
-        msUserSelect: userSelect,
-        webkitUserSelect: userSelect,
-        MozUserSelect: userSelect
-    });
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Handle that can be used to drag and CdkDrag instance.
- */
-class CdkDragHandle {
     /**
-     * @param {?} element
-     * @param {?=} parentDrag
+     * Element to which the draggable's position will be constrained.
+     * @template THIS
+     * @this {THIS}
+     * @param {?} boundaryElement
+     * @return {THIS}
      */
-    constructor(element, parentDrag) {
-        this.element = element;
-        /**
-         * Emits when the state of the handle has changed.
-         */
-        this._stateChanges = new Subject();
-        this._disabled = false;
-        this._parentDrag = parentDrag;
-        toggleNativeDragInteractions(element.nativeElement, false);
+    withBoundaryElement(boundaryElement) {
+        (/** @type {?} */ (this))._boundaryElement = boundaryElement ? coerceElement(boundaryElement) : null;
+        return (/** @type {?} */ (this));
     }
     /**
-     * Whether starting to drag through this handle is disabled.
+     * Removes the dragging functionality from the DOM element.
      * @return {?}
      */
-    get disabled() { return this._disabled; }
+    dispose() {
+        this._removeRootElementListeners(this._rootElement);
+        // Do this check before removing from the registry since it'll
+        // stop being considered as dragged once it is removed.
+        if (this.isDragging()) {
+            // Since we move out the element to the end of the body while it's being
+            // dragged, we have to make sure that it's removed if it gets destroyed.
+            removeElement(this._rootElement);
+        }
+        this._destroyPreview();
+        this._destroyPlaceholder();
+        this._dragDropRegistry.removeDragItem(this);
+        this._removeSubscriptions();
+        this.beforeStarted.complete();
+        this.started.complete();
+        this.released.complete();
+        this.ended.complete();
+        this.entered.complete();
+        this.exited.complete();
+        this.dropped.complete();
+        this._moveEvents.complete();
+        this._handles = [];
+        this._disabledHandles.clear();
+        this._dropContainer = undefined;
+        this._boundaryElement = this._rootElement = this._placeholderTemplate =
+            this._previewTemplate = this._nextSibling = (/** @type {?} */ (null));
+    }
     /**
-     * @param {?} value
+     * Checks whether the element is currently being dragged.
      * @return {?}
      */
-    set disabled(value) {
-        this._disabled = coerceBooleanProperty(value);
-        this._stateChanges.next(this);
+    isDragging() {
+        return this._hasStartedDragging && this._dragDropRegistry.isDragging(this);
     }
     /**
+     * Resets a standalone drag item to its initial position.
      * @return {?}
      */
-    ngOnDestroy() {
-        this._stateChanges.complete();
+    reset() {
+        this._rootElement.style.transform = this._initialTransform || '';
+        this._activeTransform = { x: 0, y: 0 };
+        this._passiveTransform = { x: 0, y: 0 };
     }
-}
-CdkDragHandle.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkDragHandle]',
-                host: {
-                    'class': 'cdk-drag-handle'
-                }
-            },] },
-];
-/** @nocollapse */
-CdkDragHandle.ctorParameters = () => [
-    { type: ElementRef },
-    { type: undefined, decorators: [{ type: Inject, args: [CDK_DRAG_PARENT,] }, { type: Optional }] }
-];
-CdkDragHandle.propDecorators = {
-    disabled: [{ type: Input, args: ['cdkDragHandleDisabled',] }]
-};
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Element that will be used as a template for the placeholder of a CdkDrag when
- * it is being dragged. The placeholder is displayed in place of the element being dragged.
- * @template T
- */
-class CdkDragPlaceholder {
     /**
-     * @param {?} templateRef
+     * 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 {?}
      */
-    constructor(templateRef) {
-        this.templateRef = templateRef;
+    disableHandle(handle) {
+        if (this._handles.indexOf(handle) > -1) {
+            this._disabledHandles.add(handle);
+        }
     }
-}
-CdkDragPlaceholder.decorators = [
-    { type: Directive, args: [{
-                selector: 'ng-template[cdkDragPlaceholder]'
-            },] },
-];
-/** @nocollapse */
-CdkDragPlaceholder.ctorParameters = () => [
-    { type: TemplateRef }
-];
-CdkDragPlaceholder.propDecorators = {
-    data: [{ type: Input }]
-};
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Element that will be used as a template for the preview
- * of a CdkDrag when it is being dragged.
- * @template T
- */
-class CdkDragPreview {
     /**
-     * @param {?} templateRef
+     * Enables a handle, if it has been disabled.
+     * @param {?} handle Handle element to be enabled.
+     * @return {?}
      */
-    constructor(templateRef) {
-        this.templateRef = templateRef;
+    enableHandle(handle) {
+        this._disabledHandles.delete(handle);
     }
-}
-CdkDragPreview.decorators = [
-    { type: Directive, args: [{
-                selector: 'ng-template[cdkDragPreview]'
-            },] },
-];
-/** @nocollapse */
-CdkDragPreview.ctorParameters = () => [
-    { type: TemplateRef }
-];
-CdkDragPreview.propDecorators = {
-    data: [{ type: Input }]
-};
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * Parses a CSS time value to milliseconds.
- * @param {?} value
- * @return {?}
- */
-function parseCssTimeUnitsToMs(value) {
-    // Some browsers will return it in seconds, whereas others will return milliseconds.
-    /** @type {?} */
-    const multiplier = value.toLowerCase().indexOf('ms') > -1 ? 1 : 1000;
-    return parseFloat(value) * multiplier;
-}
-/**
- * Gets the transform transition duration, including the delay, of an element in milliseconds.
- * @param {?} element
- * @return {?}
- */
-function getTransformTransitionDurationInMs(element) {
-    /** @type {?} */
-    const computedStyle = getComputedStyle(element);
-    /** @type {?} */
-    const transitionedProperties = parseCssPropertyValue(computedStyle, 'transition-property');
-    /** @type {?} */
-    const property = transitionedProperties.find(prop => prop === 'transform' || prop === 'all');
-    // If there's no transition for `all` or `transform`, we shouldn't do anything.
-    if (!property) {
-        return 0;
+    /**
+     * Sets the layout direction of the draggable item.
+     * @template THIS
+     * @this {THIS}
+     * @param {?} direction
+     * @return {THIS}
+     */
+    withDirection(direction) {
+        (/** @type {?} */ (this))._direction = direction;
+        return (/** @type {?} */ (this));
     }
-    // Get the index of the property that we're interested in and match
-    // it up to the same index in `transition-delay` and `transition-duration`.
-    /** @type {?} */
-    const propertyIndex = transitionedProperties.indexOf(property);
-    /** @type {?} */
-    const rawDurations = parseCssPropertyValue(computedStyle, 'transition-duration');
-    /** @type {?} */
-    const rawDelays = parseCssPropertyValue(computedStyle, 'transition-delay');
-    return parseCssTimeUnitsToMs(rawDurations[propertyIndex]) +
-        parseCssTimeUnitsToMs(rawDelays[propertyIndex]);
-}
-/**
- * Parses out multiple values from a computed style into an array.
- * @param {?} computedStyle
- * @param {?} name
- * @return {?}
- */
-function parseCssPropertyValue(computedStyle, name) {
-    /** @type {?} */
-    const value = computedStyle.getPropertyValue(name);
-    return value.split(',').map(part => part.trim());
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Options that can be used to bind a passive event listener.
- * @type {?}
- */
-const passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true });
-/**
- * Options that can be used to bind an active event listener.
- * @type {?}
- */
-const activeEventListenerOptions = normalizePassiveListenerOptions({ passive: false });
-/**
- * Time in milliseconds for which to ignore mouse events, after
- * receiving a touch event. Used to avoid doing double work for
- * touch devices where the browser fires fake mouse events, in
- * addition to touch events.
- * @type {?}
- */
-const MOUSE_EVENT_IGNORE_TIME = 800;
-/**
- * Reference to a draggable item. Used to manipulate or dispose of the item.
- * \@docs-private
- * @template T
- */
-class DragRef {
     /**
-     * @param {?} element
-     * @param {?} _document
-     * @param {?} _ngZone
-     * @param {?} _viewContainerRef
-     * @param {?} _viewportRuler
-     * @param {?} _dragDropRegistry
-     * @param {?} _config
-     * @param {?=} dropContainer
-     * @param {?=} _dir
+     * Sets the container that the item is part of.
+     * @param {?} container
+     * @return {?}
      */
-    constructor(element, _document, _ngZone, _viewContainerRef, _viewportRuler, _dragDropRegistry, _config, dropContainer, _dir) {
-        this._document = _document;
-        this._ngZone = _ngZone;
-        this._viewContainerRef = _viewContainerRef;
-        this._viewportRuler = _viewportRuler;
-        this._dragDropRegistry = _dragDropRegistry;
-        this._config = _config;
-        this.dropContainer = dropContainer;
-        this._dir = _dir;
-        /**
-         * 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();
-        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((observer) => {
-            /** @type {?} */
-            const subscription = this._moveEvents.subscribe(observer);
-            this._moveEventSubscriptions++;
-            return () => {
-                subscription.unsubscribe();
-                this._moveEventSubscriptions--;
-            };
-        });
-        /**
-         * Handler for the `mousedown`/`touchstart` events.
-         */
-        this._pointerDown = (event) => {
-            this.beforeStarted.next();
-            // Delegate the event based on whether it started from a handle or the element itself.
-            if (this._handles.length) {
-                /** @type {?} */
-                const targetHandle = this._handles.find(handle => {
-                    /** @type {?} */
-                    const target = event.target;
-                    return !!target && (target === handle || handle.contains((/** @type {?} */ (target))));
-                });
-                if (targetHandle && !this._disabledHandles.has(targetHandle) && !this.disabled) {
-                    this._initializeDragSequence(targetHandle, event);
-                }
-            }
-            else if (!this.disabled) {
-                this._initializeDragSequence(this._rootElement, event);
-            }
-        };
-        /**
-         * Handler that is invoked when the user moves their pointer after they've initiated a drag.
-         */
-        this._pointerMove = (event) => {
-            if (!this._hasStartedDragging) {
-                /** @type {?} */
-                const pointerPosition = this._getPointerPositionOnPage(event);
-                /** @type {?} */
-                const distanceX = Math.abs(pointerPosition.x - this._pickupPositionOnPage.x);
-                /** @type {?} */
-                const distanceY = Math.abs(pointerPosition.y - this._pickupPositionOnPage.y);
-                // Only start dragging after the user has moved more than the minimum distance in either
-                // direction. Note that this is preferrable over doing something like `skip(minimumDistance)`
-                // in the `pointerMove` subscription, because we're not guaranteed to have one move event
-                // per pixel of movement (e.g. if the user moves their pointer quickly).
-                if (distanceX + distanceY >= this._config.dragStartThreshold) {
-                    this._hasStartedDragging = true;
-                    this._ngZone.run(() => 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();
-                }
-            }
+    _withDropContainer(container) {
+        this._dropContainer = container;
+    }
+    /**
+     * Unsubscribes from the global subscriptions.
+     * @private
+     * @return {?}
+     */
+    _removeSubscriptions() {
+        this._pointerMoveSubscription.unsubscribe();
+        this._pointerUpSubscription.unsubscribe();
+    }
+    /**
+     * Destroys the preview element and its ViewRef.
+     * @private
+     * @return {?}
+     */
+    _destroyPreview() {
+        if (this._preview) {
+            removeElement(this._preview);
+        }
+        if (this._previewRef) {
+            this._previewRef.destroy();
+        }
+        this._preview = this._previewRef = (/** @type {?} */ (null));
+    }
+    /**
+     * Destroys the placeholder element and its ViewRef.
+     * @private
+     * @return {?}
+     */
+    _destroyPlaceholder() {
+        if (this._placeholder) {
+            removeElement(this._placeholder);
+        }
+        if (this._placeholderRef) {
+            this._placeholderRef.destroy();
+        }
+        this._placeholder = this._placeholderRef = (/** @type {?} */ (null));
+    }
+    /**
+     * Starts the dragging sequence.
+     * @private
+     * @param {?} event
+     * @return {?}
+     */
+    _startDragSequence(event) {
+        // Emit the event on the item before the one on the container.
+        this.started.next({ source: this });
+        if (isTouchEvent(event)) {
+            this._lastTouchEventTime = Date.now();
+        }
+        if (this._dropContainer) {
             /** @type {?} */
-            const constrainedPointerPosition = this._getConstrainedPointerPosition(event);
-            this._hasMoved = true;
+            const element = this._rootElement;
+            // Grab the `nextSibling` before the preview and placeholder
+            // have been created so we don't get the preview by accident.
+            this._nextSibling = element.nextSibling;
+            /** @type {?} */
+            const preview = this._preview = this._createPreviewElement();
+            /** @type {?} */
+            const placeholder = this._placeholder = this._createPlaceholderElement();
+            // We move the element out at the end of the body and we make it hidden, because keeping it in
+            // place will throw off the consumer's `:last-child` selectors. We can't remove the element
+            // from the DOM completely, because iOS will stop firing all subsequent events in the chain.
+            element.style.display = 'none';
+            this._document.body.appendChild((/** @type {?} */ (element.parentNode)).replaceChild(placeholder, element));
+            this._document.body.appendChild(preview);
+            this._dropContainer.start();
+        }
+    }
+    /**
+     * Sets up the different variables and subscriptions
+     * that will be necessary for the dragging sequence.
+     * @private
+     * @param {?} referenceElement Element that started the drag sequence.
+     * @param {?} event Browser event object that started the sequence.
+     * @return {?}
+     */
+    _initializeDragSequence(referenceElement, event) {
+        // Always stop propagation for the event that initializes
+        // the dragging sequence, in order to prevent it from potentially
+        // starting another sequence for a draggable parent somewhere up the DOM tree.
+        event.stopPropagation();
+        /** @type {?} */
+        const isDragging = this.isDragging();
+        /** @type {?} */
+        const isTouchSequence = isTouchEvent(event);
+        /** @type {?} */
+        const isAuxiliaryMouseButton = !isTouchSequence && ((/** @type {?} */ (event))).button !== 0;
+        /** @type {?} */
+        const rootElement = this._rootElement;
+        /** @type {?} */
+        const isSyntheticEvent = !isTouchSequence && this._lastTouchEventTime &&
+            this._lastTouchEventTime + MOUSE_EVENT_IGNORE_TIME > Date.now();
+        // If the event started from an element with the native HTML drag&drop, it'll interfere
+        // with our own dragging (e.g. `img` tags do it by default). Prevent the default action
+        // to stop it from happening. Note that preventing on `dragstart` also seems to work, but
+        // it's flaky and it fails if the user drags it away quickly. Also note that we only want
+        // to do this for `mousedown` since doing the same for `touchstart` will stop any `click`
+        // events from firing on touch devices.
+        if (event.target && ((/** @type {?} */ (event.target))).draggable && event.type === 'mousedown') {
             event.preventDefault();
-            this._updatePointerDirectionDelta(constrainedPointerPosition);
-            if (this.dropContainer) {
-                this._updateActiveDropContainer(constrainedPointerPosition);
-            }
-            else {
+        }
+        // Abort if the user is already dragging or is using a mouse button other than the primary one.
+        if (isDragging || isAuxiliaryMouseButton || isSyntheticEvent) {
+            return;
+        }
+        // Cache the previous transform amount only after the first drag sequence, because
+        // we don't want our own transforms to stack on top of each other.
+        if (this._initialTransform == null) {
+            this._initialTransform = this._rootElement.style.transform || '';
+        }
+        // If we've got handles, we need to disable the tap highlight on the entire root element,
+        // otherwise iOS will still add it, even though all the drag interactions on the handle
+        // are disabled.
+        if (this._handles.length) {
+            this._rootElementTapHighlight = rootElement.style.webkitTapHighlightColor;
+            rootElement.style.webkitTapHighlightColor = 'transparent';
+        }
+        this._toggleNativeDragInteractions();
+        this._hasStartedDragging = this._hasMoved = false;
+        this._initialContainer = (/** @type {?} */ (this._dropContainer));
+        this._pointerMoveSubscription = this._dragDropRegistry.pointerMove.subscribe(this._pointerMove);
+        this._pointerUpSubscription = this._dragDropRegistry.pointerUp.subscribe(this._pointerUp);
+        this._scrollPosition = this._viewportRuler.getViewportScrollPosition();
+        if (this._boundaryElement) {
+            this._boundaryRect = this._boundaryElement.getBoundingClientRect();
+        }
+        // If we have a custom preview template, the element won't be visible anyway so we avoid the
+        // extra `getBoundingClientRect` calls and just move the preview next to the cursor.
+        this._pickupPositionInElement = this._previewTemplate && this._previewTemplate.template ?
+            { x: 0, y: 0 } :
+            this._getPointerPositionInElement(referenceElement, event);
+        /** @type {?} */
+        const pointerPosition = this._pickupPositionOnPage = this._getPointerPositionOnPage(event);
+        this._pointerDirectionDelta = { x: 0, y: 0 };
+        this._pointerPositionAtLastDirectionChange = { x: pointerPosition.x, y: pointerPosition.y };
+        this._dragDropRegistry.startDragging(this, event);
+    }
+    /**
+     * Cleans up the DOM artifacts that were added to facilitate the element being dragged.
+     * @private
+     * @param {?} event
+     * @return {?}
+     */
+    _cleanupDragArtifacts(event) {
+        // Restore the element's visibility and insert it at its old position in the DOM.
+        // It's important that we maintain the position, because moving the element around in the DOM
+        // can throw off `NgFor` which does smart diffing and re-creates elements only when necessary,
+        // while moving the existing elements in all other cases.
+        this._rootElement.style.display = '';
+        if (this._nextSibling) {
+            (/** @type {?} */ (this._nextSibling.parentNode)).insertBefore(this._rootElement, this._nextSibling);
+        }
+        else {
+            this._initialContainer.element.appendChild(this._rootElement);
+        }
+        this._destroyPreview();
+        this._destroyPlaceholder();
+        this._boundaryRect = this._previewRect = undefined;
+        // Re-enter the NgZone since we bound `document` events on the outside.
+        this._ngZone.run(() => {
+            /** @type {?} */
+            const container = (/** @type {?} */ (this._dropContainer));
+            /** @type {?} */
+            const currentIndex = container.getItemIndex(this);
+            const { x, y } = this._getPointerPositionOnPage(event);
+            /** @type {?} */
+            const isPointerOverContainer = container._isOverContainer(x, y);
+            this.ended.next({ source: this });
+            this.dropped.next({
+                item: this,
+                currentIndex,
+                previousIndex: this._initialContainer.getItemIndex(this),
+                container: container,
+                previousContainer: this._initialContainer,
+                isPointerOverContainer
+            });
+            container.drop(this, currentIndex, this._initialContainer, isPointerOverContainer);
+            this._dropContainer = this._initialContainer;
+        });
+    }
+    /**
+     * Updates the item's position in its drop container, or moves it
+     * into a new one, depending on its current drag position.
+     * @private
+     * @param {?} __0
+     * @return {?}
+     */
+    _updateActiveDropContainer({ x, y }) {
+        // Drop container that draggable has been moved into.
+        /** @type {?} */
+        let newContainer = (/** @type {?} */ (this._dropContainer))._getSiblingContainerFromPosition(this, x, y) ||
+            this._initialContainer._getSiblingContainerFromPosition(this, x, y);
+        // If we couldn't find a new container to move the item into, and the item has left it's
+        // initial container, check whether the it's over the initial container. This handles the
+        // case where two containers are connected one way and the user tries to undo dragging an
+        // item into a new container.
+        if (!newContainer && this._dropContainer !== this._initialContainer &&
+            this._initialContainer._isOverContainer(x, y)) {
+            newContainer = this._initialContainer;
+        }
+        if (newContainer && newContainer !== this._dropContainer) {
+            this._ngZone.run(() => {
+                // Notify the old container that the item has left.
+                this.exited.next({ item: this, container: (/** @type {?} */ (this._dropContainer)) });
+                (/** @type {?} */ (this._dropContainer)).exit(this);
+                // Notify the new container that the item has entered.
+                this.entered.next({ item: this, container: (/** @type {?} */ (newContainer)) });
+                this._dropContainer = (/** @type {?} */ (newContainer));
+                this._dropContainer.enter(this, x, y);
+            });
+        }
+        (/** @type {?} */ (this._dropContainer))._sortItem(this, x, y, this._pointerDirectionDelta);
+        this._preview.style.transform =
+            getTransform(x - this._pickupPositionInElement.x, y - this._pickupPositionInElement.y);
+    }
+    /**
+     * Creates the element that will be rendered next to the user's pointer
+     * and will be used as a preview of the element that is being dragged.
+     * @private
+     * @return {?}
+     */
+    _createPreviewElement() {
+        /** @type {?} */
+        const previewConfig = this._previewTemplate;
+        /** @type {?} */
+        const previewTemplate = previewConfig ? previewConfig.template : null;
+        /** @type {?} */
+        let preview;
+        if (previewTemplate) {
+            /** @type {?} */
+            const viewRef = (/** @type {?} */ (previewConfig)).viewContainer.createEmbeddedView(previewTemplate, (/** @type {?} */ (previewConfig)).context);
+            preview = viewRef.rootNodes[0];
+            this._previewRef = viewRef;
+            preview.style.transform =
+                getTransform(this._pickupPositionOnPage.x, this._pickupPositionOnPage.y);
+        }
+        else {
+            /** @type {?} */
+            const element = this._rootElement;
+            /** @type {?} */
+            const elementRect = element.getBoundingClientRect();
+            preview = deepCloneNode(element);
+            preview.style.width = `${elementRect.width}px`;
+            preview.style.height = `${elementRect.height}px`;
+            preview.style.transform = getTransform(elementRect.left, elementRect.top);
+        }
+        extendStyles(preview.style, {
+            // It's important that we disable the pointer events on the preview, because
+            // it can throw off the `document.elementFromPoint` calls in the `CdkDropList`.
+            pointerEvents: 'none',
+            position: 'fixed',
+            top: '0',
+            left: '0',
+            zIndex: '1000'
+        });
+        toggleNativeDragInteractions(preview, false);
+        preview.classList.add('cdk-drag-preview');
+        preview.setAttribute('dir', this._direction);
+        return preview;
+    }
+    /**
+     * Animates the preview element from its current position to the location of the drop placeholder.
+     * @private
+     * @return {?} Promise that resolves when the animation completes.
+     */
+    _animatePreviewToPlaceholder() {
+        // If the user hasn't moved yet, the transitionend event won't fire.
+        if (!this._hasMoved) {
+            return Promise.resolve();
+        }
+        /** @type {?} */
+        const placeholderRect = this._placeholder.getBoundingClientRect();
+        // Apply the class that adds a transition to the preview.
+        this._preview.classList.add('cdk-drag-animating');
+        // Move the preview to the placeholder position.
+        this._preview.style.transform = getTransform(placeholderRect.left, placeholderRect.top);
+        // If the element doesn't have a `transition`, the `transitionend` event won't fire. Since
+        // we need to trigger a style recalculation in order for the `cdk-drag-animating` class to
+        // apply its style, we take advantage of the available info to figure out whether we need to
+        // bind the event in the first place.
+        /** @type {?} */
+        const duration = getTransformTransitionDurationInMs(this._preview);
+        if (duration === 0) {
+            return Promise.resolve();
+        }
+        return this._ngZone.runOutsideAngular(() => {
+            return new Promise(resolve => {
                 /** @type {?} */
-                const activeTransform = this._activeTransform;
-                activeTransform.x =
-                    constrainedPointerPosition.x - this._pickupPositionOnPage.x + this._passiveTransform.x;
-                activeTransform.y =
-                    constrainedPointerPosition.y - this._pickupPositionOnPage.y + this._passiveTransform.y;
+                const handler = (/** @type {?} */ (((event) => {
+                    if (!event || (event.target === this._preview && event.propertyName === 'transform')) {
+                        this._preview.removeEventListener('transitionend', handler);
+                        resolve();
+                        clearTimeout(timeout);
+                    }
+                })));
+                // If a transition is short enough, the browser might not fire the `transitionend` event.
+                // Since we know how long it's supposed to take, add a timeout with a 50% buffer that'll
+                // fire if the transition hasn't completed when it was supposed to.
                 /** @type {?} */
-                const transform = getTransform(activeTransform.x, activeTransform.y);
-                // Preserve the previous `transform` value, if there was one. Note that we apply our own
-                // transform before the user's, because things like rotation can affect which direction
-                // the element will be translated towards.
-                this._rootElement.style.transform = this._initialTransform ?
-                    transform + ' ' + this._initialTransform : transform;
-                // Apply transform as attribute if dragging and svg element to work for IE
-                if (typeof SVGElement !== 'undefined' && this._rootElement instanceof SVGElement) {
-                    /** @type {?} */
-                    const appliedTransform = `translate(${activeTransform.x} ${activeTransform.y})`;
-                    this._rootElement.setAttribute('transform', appliedTransform);
-                }
-            }
-            // Since this event gets fired for every pixel while dragging, we only
-            // want to fire it if the consumer opted into it. Also we have to
-            // re-enter the zone because we run all of the events on the outside.
-            if (this._moveEventSubscriptions > 0) {
-                this._ngZone.run(() => {
-                    this._moveEvents.next({
-                        source: this,
-                        pointerPosition: constrainedPointerPosition,
-                        event,
-                        delta: this._pointerDirectionDelta
-                    });
-                });
-            }
-        };
-        /**
-         * Handler that is invoked when the user lifts their pointer up, after initiating a drag.
-         */
-        this._pointerUp = (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(() => this.ended.next({ source: this }));
-                this._dragDropRegistry.stopDragging(this);
-                return;
-            }
-            this._animatePreviewToPlaceholder().then(() => {
-                this._cleanupDragArtifacts(event);
-                this._dragDropRegistry.stopDragging(this);
+                const timeout = setTimeout((/** @type {?} */ (handler)), duration * 1.5);
+                this._preview.addEventListener('transitionend', handler);
             });
+        });
+    }
+    /**
+     * Creates an element that will be shown instead of the current element while dragging.
+     * @private
+     * @return {?}
+     */
+    _createPlaceholderElement() {
+        /** @type {?} */
+        const placeholderConfig = this._placeholderTemplate;
+        /** @type {?} */
+        const placeholderTemplate = placeholderConfig ? placeholderConfig.template : null;
+        /** @type {?} */
+        let placeholder;
+        if (placeholderTemplate) {
+            this._placeholderRef = (/** @type {?} */ (placeholderConfig)).viewContainer.createEmbeddedView(placeholderTemplate, (/** @type {?} */ (placeholderConfig)).context);
+            placeholder = this._placeholderRef.rootNodes[0];
+        }
+        else {
+            placeholder = deepCloneNode(this._rootElement);
+        }
+        placeholder.classList.add('cdk-drag-placeholder');
+        return placeholder;
+    }
+    /**
+     * Figures out the coordinates at which an element was picked up.
+     * @private
+     * @param {?} referenceElement Element that initiated the dragging.
+     * @param {?} event Event that initiated the dragging.
+     * @return {?}
+     */
+    _getPointerPositionInElement(referenceElement, event) {
+        /** @type {?} */
+        const elementRect = this._rootElement.getBoundingClientRect();
+        /** @type {?} */
+        const handleElement = referenceElement === this._rootElement ? null : referenceElement;
+        /** @type {?} */
+        const referenceRect = handleElement ? handleElement.getBoundingClientRect() : elementRect;
+        /** @type {?} */
+        const point = isTouchEvent(event) ? event.targetTouches[0] : event;
+        /** @type {?} */
+        const x = point.pageX - referenceRect.left - this._scrollPosition.left;
+        /** @type {?} */
+        const y = point.pageY - referenceRect.top - this._scrollPosition.top;
+        return {
+            x: referenceRect.left - elementRect.left + x,
+            y: referenceRect.top - elementRect.top + y
         };
-        this.withRootElement(element);
-        _dragDropRegistry.registerDragItem(this);
     }
     /**
-     * Whether starting to drag this element is disabled.
+     * Determines the point of the page that was touched by the user.
+     * @private
+     * @param {?} event
+     * @return {?}
+     */
+    _getPointerPositionOnPage(event) {
+        // `touches` will be empty for start/end events so we have to fall back to `changedTouches`.
+        /** @type {?} */
+        const point = isTouchEvent(event) ? (event.touches[0] || event.changedTouches[0]) : event;
+        return {
+            x: point.pageX - this._scrollPosition.left,
+            y: point.pageY - this._scrollPosition.top
+        };
+    }
+    /**
+     * Gets the pointer position on the page, accounting for any position constraints.
+     * @private
+     * @param {?} event
+     * @return {?}
+     */
+    _getConstrainedPointerPosition(event) {
+        /** @type {?} */
+        const point = this._getPointerPositionOnPage(event);
+        /** @type {?} */
+        const dropContainerLock = this._dropContainer ? this._dropContainer.lockAxis : null;
+        if (this.lockAxis === 'x' || dropContainerLock === 'x') {
+            point.y = this._pickupPositionOnPage.y;
+        }
+        else if (this.lockAxis === 'y' || dropContainerLock === 'y') {
+            point.x = this._pickupPositionOnPage.x;
+        }
+        if (this._boundaryRect) {
+            const { x: pickupX, y: pickupY } = this._pickupPositionInElement;
+            /** @type {?} */
+            const boundaryRect = this._boundaryRect;
+            /** @type {?} */
+            const previewRect = (/** @type {?} */ (this._previewRect));
+            /** @type {?} */
+            const minY = boundaryRect.top + pickupY;
+            /** @type {?} */
+            const maxY = boundaryRect.bottom - (previewRect.height - pickupY);
+            /** @type {?} */
+            const minX = boundaryRect.left + pickupX;
+            /** @type {?} */
+            const maxX = boundaryRect.right - (previewRect.width - pickupX);
+            point.x = clamp(point.x, minX, maxX);
+            point.y = clamp(point.y, minY, maxY);
+        }
+        return point;
+    }
+    /**
+     * Updates the current drag delta, based on the user's current pointer position on the page.
+     * @private
+     * @param {?} pointerPositionOnPage
      * @return {?}
      */
-    get disabled() {
-        return this._disabled || !!(this.dropContainer && this.dropContainer.disabled);
+    _updatePointerDirectionDelta(pointerPositionOnPage) {
+        const { x, y } = pointerPositionOnPage;
+        /** @type {?} */
+        const delta = this._pointerDirectionDelta;
+        /** @type {?} */
+        const positionSinceLastChange = this._pointerPositionAtLastDirectionChange;
+        // Amount of pixels the user has dragged since the last time the direction changed.
+        /** @type {?} */
+        const changeX = Math.abs(x - positionSinceLastChange.x);
+        /** @type {?} */
+        const changeY = Math.abs(y - positionSinceLastChange.y);
+        // Because we handle pointer events on a per-pixel basis, we don't want the delta
+        // to change for every pixel, otherwise anything that depends on it can look erratic.
+        // To make the delta more consistent, we track how much the user has moved since the last
+        // delta change and we only update it after it has reached a certain threshold.
+        if (changeX > this._config.pointerDirectionChangeThreshold) {
+            delta.x = x > positionSinceLastChange.x ? 1 : -1;
+            positionSinceLastChange.x = x;
+        }
+        if (changeY > this._config.pointerDirectionChangeThreshold) {
+            delta.y = y > positionSinceLastChange.y ? 1 : -1;
+            positionSinceLastChange.y = y;
+        }
+        return delta;
     }
     /**
-     * @param {?} value
+     * Toggles the native drag interactions, based on how many handles are registered.
+     * @private
      * @return {?}
      */
-    set disabled(value) {
+    _toggleNativeDragInteractions() {
+        if (!this._rootElement || !this._handles) {
+            return;
+        }
         /** @type {?} */
-        const newValue = coerceBooleanProperty(value);
-        if (newValue !== this._disabled) {
-            this._disabled = newValue;
-            this._toggleNativeDragInteractions();
+        const shouldEnable = this.disabled || this._handles.length > 0;
+        if (shouldEnable !== this._nativeInteractionsEnabled) {
+            this._nativeInteractionsEnabled = shouldEnable;
+            toggleNativeDragInteractions(this._rootElement, shouldEnable);
         }
     }
     /**
-     * Returns the element that is being used as a placeholder
-     * while the current element is being dragged.
+     * Removes the manually-added event listeners from the root element.
+     * @private
+     * @param {?} element
      * @return {?}
      */
-    getPlaceholderElement() {
-        return this._placeholder;
+    _removeRootElementListeners(element) {
+        element.removeEventListener('mousedown', this._pointerDown, activeEventListenerOptions);
+        element.removeEventListener('touchstart', this._pointerDown, passiveEventListenerOptions);
     }
-    /**
-     * Returns the root draggable element.
-     * @return {?}
-     */
-    getRootElement() {
-        return this._rootElement;
+}
+/**
+ * Gets a 3d `transform` that can be applied to an element.
+ * @param {?} x Desired position of the element along the X axis.
+ * @param {?} y Desired position of the element along the Y axis.
+ * @return {?}
+ */
+function getTransform(x, y) {
+    // Round the transforms since some browsers will
+    // blur the elements for sub-pixel transforms.
+    return `translate3d(${Math.round(x)}px, ${Math.round(y)}px, 0)`;
+}
+/**
+ * Creates a deep clone of an element.
+ * @param {?} node
+ * @return {?}
+ */
+function deepCloneNode(node) {
+    /** @type {?} */
+    const clone = (/** @type {?} */ (node.cloneNode(true)));
+    // Remove the `id` to avoid having multiple elements with the same id on the page.
+    clone.removeAttribute('id');
+    return clone;
+}
+/**
+ * Clamps a value between a minimum and a maximum.
+ * @param {?} value
+ * @param {?} min
+ * @param {?} max
+ * @return {?}
+ */
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+/**
+ * Helper to remove an element from the DOM and to do all the necessary null checks.
+ * @param {?} element Element to be removed.
+ * @return {?}
+ */
+function removeElement(element) {
+    if (element && element.parentNode) {
+        element.parentNode.removeChild(element);
     }
-    /**
-     * Registers the handles that can be used to drag the element.
-     * @template THIS
-     * @this {THIS}
-     * @param {?} handles
-     * @return {THIS}
-     */
-    withHandles(handles) {
-        (/** @type {?} */ (this))._handles = handles.map(handle => coerceElement(handle));
-        (/** @type {?} */ (this))._handles.forEach(handle => toggleNativeDragInteractions(handle, false));
-        (/** @type {?} */ (this))._toggleNativeDragInteractions();
-        return (/** @type {?} */ (this));
+}
+/**
+ * Determines whether an event is a touch event.
+ * @param {?} event
+ * @return {?}
+ */
+function isTouchEvent(event) {
+    return event.type.startsWith('touch');
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * Moves an item one index in an array to another.
+ * @template T
+ * @param {?} array Array in which to move the item.
+ * @param {?} fromIndex Starting index of the item.
+ * @param {?} toIndex Index to which the item should be moved.
+ * @return {?}
+ */
+function moveItemInArray(array, fromIndex, toIndex) {
+    /** @type {?} */
+    const from = clamp$1(fromIndex, array.length - 1);
+    /** @type {?} */
+    const to = clamp$1(toIndex, array.length - 1);
+    if (from === to) {
+        return;
     }
-    /**
-     * 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.
-     * @param {?=} context Variables to add to the template's context.
-     * @return {THIS}
-     */
-    withPreviewTemplate(template, context) {
-        (/** @type {?} */ (this))._previewTemplate = { template, context };
-        return (/** @type {?} */ (this));
+    /** @type {?} */
+    const target = array[from];
+    /** @type {?} */
+    const delta = to < from ? -1 : 1;
+    for (let i = from; i !== to; i += delta) {
+        array[i] = array[i + delta];
     }
-    /**
-     * 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.
-     * @param {?=} context Variables to add to the template's context.
-     * @return {THIS}
-     */
-    withPlaceholderTemplate(template, context) {
-        (/** @type {?} */ (this))._placeholderTemplate = { template, context };
-        return (/** @type {?} */ (this));
+    array[to] = target;
+}
+/**
+ * Moves an item from one array to another.
+ * @template T
+ * @param {?} currentArray Array from which to transfer the item.
+ * @param {?} targetArray Array into which to put the item.
+ * @param {?} currentIndex Index of the item in its current array.
+ * @param {?} targetIndex Index at which to insert the item.
+ * @return {?}
+ */
+function transferArrayItem(currentArray, targetArray, currentIndex, targetIndex) {
+    /** @type {?} */
+    const from = clamp$1(currentIndex, currentArray.length - 1);
+    /** @type {?} */
+    const to = clamp$1(targetIndex, targetArray.length);
+    if (currentArray.length) {
+        targetArray.splice(to, 0, currentArray.splice(from, 1)[0]);
     }
-    /**
-     * Sets an alternate drag root element. The root element is the element that will be moved as
-     * the user is dragging. Passing an alternate root element is useful when trying to enable
-     * dragging on an element that you might not have access to.
-     * @template THIS
-     * @this {THIS}
-     * @param {?} rootElement
-     * @return {THIS}
-     */
-    withRootElement(rootElement) {
-        /** @type {?} */
-        const element = coerceElement(rootElement);
-        if (element !== (/** @type {?} */ (this))._rootElement) {
-            if ((/** @type {?} */ (this))._rootElement) {
-                (/** @type {?} */ (this))._removeRootElementListeners((/** @type {?} */ (this))._rootElement);
-            }
-            element.addEventListener('mousedown', (/** @type {?} */ (this))._pointerDown, activeEventListenerOptions);
-            element.addEventListener('touchstart', (/** @type {?} */ (this))._pointerDown, passiveEventListenerOptions);
-            (/** @type {?} */ (this))._initialTransform = undefined;
-            (/** @type {?} */ (this))._rootElement = element;
-        }
-        return (/** @type {?} */ (this));
+}
+/**
+ * Copies an item from one array to another, leaving it in its
+ * original position in current array.
+ * @template T
+ * @param {?} currentArray Array from which to copy the item.
+ * @param {?} targetArray Array into which is copy the item.
+ * @param {?} currentIndex Index of the item in its current array.
+ * @param {?} targetIndex Index at which to insert the item.
+ *
+ * @return {?}
+ */
+function copyArrayItem(currentArray, targetArray, currentIndex, targetIndex) {
+    /** @type {?} */
+    const to = clamp$1(targetIndex, targetArray.length);
+    if (currentArray.length) {
+        targetArray.splice(to, 0, currentArray[currentIndex]);
     }
-    /**
-     * Element to which the draggable's position will be constrained.
-     * @template THIS
-     * @this {THIS}
-     * @param {?} boundaryElement
-     * @return {THIS}
+}
+/**
+ * Clamps a number between zero and a maximum.
+ * @param {?} value
+ * @param {?} max
+ * @return {?}
+ */
+function clamp$1(value, max) {
+    return Math.max(0, Math.min(max, value));
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Counter used to generate unique ids for drop refs.
+ * @type {?}
+ */
+let _uniqueIdCounter = 0;
+/**
+ * Proximity, as a ratio to width/height, at which a
+ * dragged item will affect the drop container.
+ * @type {?}
+ */
+const DROP_PROXIMITY_THRESHOLD = 0.05;
+/**
+ * Reference to a drop list. Used to manipulate or dispose of the container.
+ * \@docs-private
+ * @template T
+ */
+class DropListRef {
+    /**
+     * @param {?} element
+     * @param {?} _dragDropRegistry
+     * @param {?} _document
      */
-    withBoundaryElement(boundaryElement) {
-        (/** @type {?} */ (this))._boundaryElement = boundaryElement ? coerceElement(boundaryElement) : null;
-        return (/** @type {?} */ (this));
+    constructor(element, _dragDropRegistry, _document) {
+        this._dragDropRegistry = _dragDropRegistry;
+        /**
+         * Unique ID for the drop list.
+         * @deprecated No longer being used. To be removed.
+         * \@breaking-change 8.0.0
+         */
+        this.id = `cdk-drop-list-ref-${_uniqueIdCounter++}`;
+        /**
+         * Whether starting a dragging sequence from this container is disabled.
+         */
+        this.disabled = false;
+        /**
+         * Function that is used to determine whether an item
+         * is allowed to be moved into a drop container.
+         */
+        this.enterPredicate = () => true;
+        /**
+         * Emits right before dragging has started.
+         */
+        this.beforeStarted = new Subject();
+        /**
+         * Emits when the user has moved a new drag item into this container.
+         */
+        this.entered = new Subject();
+        /**
+         * Emits when the user removes an item from the container
+         * by dragging it into another container.
+         */
+        this.exited = new Subject();
+        /**
+         * Emits when the user drops an item inside the container.
+         */
+        this.dropped = new Subject();
+        /**
+         * Emits as the user is swapping items while actively dragging.
+         */
+        this.sorted = new Subject();
+        /**
+         * Whether an item in the list is being dragged.
+         */
+        this._isDragging = false;
+        /**
+         * Cache of the dimensions of all the items inside the container.
+         */
+        this._itemPositions = [];
+        /**
+         * Keeps track of the item that was last swapped with the dragged item, as
+         * well as what direction the pointer was moving in when the swap occured.
+         */
+        this._previousSwap = { drag: (/** @type {?} */ (null)), delta: 0 };
+        /**
+         * Drop lists that are connected to the current one.
+         */
+        this._siblings = [];
+        /**
+         * Direction in which the list is oriented.
+         */
+        this._orientation = 'vertical';
+        /**
+         * Connected siblings that currently have a dragged item.
+         */
+        this._activeSiblings = new Set();
+        /**
+         * Layout direction of the drop list.
+         */
+        this._direction = 'ltr';
+        _dragDropRegistry.registerDropContainer(this);
+        this._document = _document;
+        this.element = element instanceof ElementRef ? element.nativeElement : element;
     }
     /**
-     * Removes the dragging functionality from the DOM element.
+     * Removes the drop list functionality from the DOM element.
      * @return {?}
      */
     dispose() {
-        this._removeRootElementListeners(this._rootElement);
-        // Do this check before removing from the registry since it'll
-        // stop being considered as dragged once it is removed.
-        if (this.isDragging()) {
-            // Since we move out the element to the end of the body while it's being
-            // dragged, we have to make sure that it's removed if it gets destroyed.
-            removeElement(this._rootElement);
-        }
-        this._destroyPreview();
-        this._destroyPlaceholder();
-        this._dragDropRegistry.removeDragItem(this);
-        this._removeSubscriptions();
         this.beforeStarted.complete();
-        this.started.complete();
-        this.released.complete();
-        this.ended.complete();
         this.entered.complete();
         this.exited.complete();
         this.dropped.complete();
-        this._moveEvents.complete();
-        this._handles = [];
-        this._disabledHandles.clear();
-        this._boundaryElement = this._rootElement = this._placeholderTemplate =
-            this._previewTemplate = this._nextSibling = (/** @type {?} */ (null));
+        this.sorted.complete();
+        this._activeSiblings.clear();
+        this._dragDropRegistry.removeDropContainer(this);
     }
     /**
-     * Checks whether the element is currently being dragged.
+     * Whether an item from this list is currently being dragged.
      * @return {?}
      */
     isDragging() {
-        return this._hasStartedDragging && this._dragDropRegistry.isDragging(this);
+        return this._isDragging;
     }
     /**
-     * Resets a standalone drag item to its initial position.
+     * Starts dragging an item.
      * @return {?}
      */
-    reset() {
-        this._rootElement.style.transform = this._initialTransform || '';
-        this._activeTransform = { x: 0, y: 0 };
-        this._passiveTransform = { x: 0, y: 0 };
+    start() {
+        this.beforeStarted.next();
+        this._isDragging = true;
+        this._activeDraggables = this._draggables.slice();
+        this._cacheOwnPosition();
+        this._cacheItemPositions();
+        this._siblings.forEach(sibling => sibling._startReceiving(this));
     }
     /**
-     * Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.
-     * @param {?} handle Handle element that should be disabled.
+     * Emits an event to indicate that the user moved an item into the container.
+     * @param {?} item Item that was moved into the container.
+     * @param {?} pointerX Position of the item along the X axis.
+     * @param {?} pointerY Position of the item along the Y axis.
      * @return {?}
      */
-    disableHandle(handle) {
-        if (this._handles.indexOf(handle) > -1) {
-            this._disabledHandles.add(handle);
+    enter(item, pointerX, pointerY) {
+        this.entered.next({ item, container: this });
+        this.start();
+        // We use the coordinates of where the item entered the drop
+        // zone to figure out at which index it should be inserted.
+        /** @type {?} */
+        const newIndex = this._getItemIndexFromPointerPosition(item, pointerX, pointerY);
+        /** @type {?} */
+        const currentIndex = this._activeDraggables.indexOf(item);
+        /** @type {?} */
+        const newPositionReference = this._activeDraggables[newIndex];
+        /** @type {?} */
+        const placeholder = item.getPlaceholderElement();
+        // Since the item may be in the `activeDraggables` already (e.g. if the user dragged it
+        // into another container and back again), we have to ensure that it isn't duplicated.
+        if (currentIndex > -1) {
+            this._activeDraggables.splice(currentIndex, 1);
+        }
+        // Don't use items that are being dragged as a reference, because
+        // their element has been moved down to the bottom of the body.
+        if (newPositionReference && !this._dragDropRegistry.isDragging(newPositionReference)) {
+            /** @type {?} */
+            const element = newPositionReference.getRootElement();
+            (/** @type {?} */ (element.parentElement)).insertBefore(placeholder, element);
+            this._activeDraggables.splice(newIndex, 0, item);
+        }
+        else {
+            this.element.appendChild(placeholder);
+            this._activeDraggables.push(item);
         }
+        // The transform needs to be cleared so it doesn't throw off the measurements.
+        placeholder.style.transform = '';
+        // Note that the positions were already cached when we called `start` above,
+        // but we need to refresh them since the amount of items has changed.
+        this._cacheItemPositions();
     }
     /**
-     * Enables a handle, if it has been disabled.
-     * @param {?} handle Handle element to be enabled.
+     * Removes an item from the container after it was dragged into another container by the user.
+     * @param {?} item Item that was dragged out.
      * @return {?}
      */
-    enableHandle(handle) {
-        this._disabledHandles.delete(handle);
+    exit(item) {
+        this._reset();
+        this.exited.next({ item, container: this });
     }
     /**
-     * Unsubscribes from the global subscriptions.
-     * @private
+     * Drops an item into this container.
+     * @param {?} item Item being dropped into the container.
+     * @param {?} currentIndex Index at which the item should be inserted.
+     * @param {?} previousContainer Container from which the item got dragged in.
+     * @param {?} isPointerOverContainer Whether the user's pointer was over the
+     *    container when the item was dropped.
      * @return {?}
      */
-    _removeSubscriptions() {
-        this._pointerMoveSubscription.unsubscribe();
-        this._pointerUpSubscription.unsubscribe();
+    drop(item, currentIndex, previousContainer, isPointerOverContainer) {
+        this._reset();
+        this.dropped.next({
+            item,
+            currentIndex,
+            previousIndex: previousContainer.getItemIndex(item),
+            container: this,
+            previousContainer,
+            isPointerOverContainer
+        });
     }
     /**
-     * Destroys the preview element and its ViewRef.
-     * @private
-     * @return {?}
+     * Sets the draggable items that are a part of this list.
+     * @template THIS
+     * @this {THIS}
+     * @param {?} items Items that are a part of this list.
+     * @return {THIS}
      */
-    _destroyPreview() {
-        if (this._preview) {
-            removeElement(this._preview);
-        }
-        if (this._previewRef) {
-            this._previewRef.destroy();
-        }
-        this._preview = this._previewRef = (/** @type {?} */ (null));
+    withItems(items) {
+        (/** @type {?} */ (this))._draggables = items.slice();
+        items.forEach(item => item._withDropContainer((/** @type {?} */ (this))));
+        return (/** @type {?} */ (this));
     }
     /**
-     * Destroys the placeholder element and its ViewRef.
-     * @private
-     * @return {?}
+     * Sets the layout direction of the drop list.
+     * @template THIS
+     * @this {THIS}
+     * @param {?} direction
+     * @return {THIS}
      */
-    _destroyPlaceholder() {
-        if (this._placeholder) {
-            removeElement(this._placeholder);
-        }
-        if (this._placeholderRef) {
-            this._placeholderRef.destroy();
-        }
-        this._placeholder = this._placeholderRef = (/** @type {?} */ (null));
+    withDirection(direction) {
+        (/** @type {?} */ (this))._direction = direction;
+        return (/** @type {?} */ (this));
     }
     /**
-     * Starts the dragging sequence.
-     * @private
-     * @param {?} event
-     * @return {?}
-     */
-    _startDragSequence(event) {
-        // Emit the event on the item before the one on the container.
-        this.started.next({ source: this });
-        if (isTouchEvent(event)) {
-            this._lastTouchEventTime = Date.now();
-        }
-        if (this.dropContainer) {
-            /** @type {?} */
-            const element = this._rootElement;
-            // Grab the `nextSibling` before the preview and placeholder
-            // have been created so we don't get the preview by accident.
-            this._nextSibling = element.nextSibling;
-            /** @type {?} */
-            const preview = this._preview = this._createPreviewElement();
-            /** @type {?} */
-            const placeholder = this._placeholder = this._createPlaceholderElement();
-            // We move the element out at the end of the body and we make it hidden, because keeping it in
-            // place will throw off the consumer's `:last-child` selectors. We can't remove the element
-            // from the DOM completely, because iOS will stop firing all subsequent events in the chain.
-            element.style.display = 'none';
-            this._document.body.appendChild((/** @type {?} */ (element.parentNode)).replaceChild(placeholder, element));
-            this._document.body.appendChild(preview);
-            this.dropContainer.start();
-        }
+     * Sets the containers that are connected to this one. When two or more containers are
+     * connected, the user will be allowed to transfer items between them.
+     * @template THIS
+     * @this {THIS}
+     * @param {?} connectedTo Other containers that the current containers should be connected to.
+     * @return {THIS}
+     */
+    connectedTo(connectedTo) {
+        (/** @type {?} */ (this))._siblings = connectedTo.slice();
+        return (/** @type {?} */ (this));
     }
     /**
-     * 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 {?}
+     * Sets the orientation of the container.
+     * @template THIS
+     * @this {THIS}
+     * @param {?} orientation New orientation for the container.
+     * @return {THIS}
      */
-    _initializeDragSequence(referenceElement, event) {
-        // Always stop propagation for the event that initializes
-        // the dragging sequence, in order to prevent it from potentially
-        // starting another sequence for a draggable parent somewhere up the DOM tree.
-        event.stopPropagation();
-        /** @type {?} */
-        const isDragging = this.isDragging();
-        /** @type {?} */
-        const isTouchSequence = isTouchEvent(event);
-        /** @type {?} */
-        const isAuxiliaryMouseButton = !isTouchSequence && ((/** @type {?} */ (event))).button !== 0;
-        /** @type {?} */
-        const rootElement = this._rootElement;
-        /** @type {?} */
-        const isSyntheticEvent = !isTouchSequence && this._lastTouchEventTime &&
-            this._lastTouchEventTime + MOUSE_EVENT_IGNORE_TIME > Date.now();
-        // If the event started from an element with the native HTML drag&drop, it'll interfere
-        // with our own dragging (e.g. `img` tags do it by default). Prevent the default action
-        // to stop it from happening. Note that preventing on `dragstart` also seems to work, but
-        // it's flaky and it fails if the user drags it away quickly. Also note that we only want
-        // to do this for `mousedown` since doing the same for `touchstart` will stop any `click`
-        // events from firing on touch devices.
-        if (event.target && ((/** @type {?} */ (event.target))).draggable && event.type === 'mousedown') {
-            event.preventDefault();
-        }
-        // Abort if the user is already dragging or is using a mouse button other than the primary one.
-        if (isDragging || isAuxiliaryMouseButton || isSyntheticEvent) {
-            return;
-        }
-        // Cache the previous transform amount only after the first drag sequence, because
-        // we don't want our own transforms to stack on top of each other.
-        if (this._initialTransform == null) {
-            this._initialTransform = this._rootElement.style.transform || '';
-        }
-        // If we've got handles, we need to disable the tap highlight on the entire root element,
-        // otherwise iOS will still add it, even though all the drag interactions on the handle
-        // are disabled.
-        if (this._handles.length) {
-            this._rootElementTapHighlight = rootElement.style.webkitTapHighlightColor;
-            rootElement.style.webkitTapHighlightColor = 'transparent';
-        }
-        this._toggleNativeDragInteractions();
-        this._hasStartedDragging = this._hasMoved = false;
-        this._initialContainer = (/** @type {?} */ (this.dropContainer));
-        this._pointerMoveSubscription = this._dragDropRegistry.pointerMove.subscribe(this._pointerMove);
-        this._pointerUpSubscription = this._dragDropRegistry.pointerUp.subscribe(this._pointerUp);
-        this._scrollPosition = this._viewportRuler.getViewportScrollPosition();
-        if (this._boundaryElement) {
-            this._boundaryRect = this._boundaryElement.getBoundingClientRect();
-        }
-        // If we have a custom preview template, the element won't be visible anyway so we avoid the
-        // extra `getBoundingClientRect` calls and just move the preview next to the cursor.
-        this._pickupPositionInElement = this._previewTemplate && this._previewTemplate.template ?
-            { x: 0, y: 0 } :
-            this._getPointerPositionInElement(referenceElement, event);
-        /** @type {?} */
-        const pointerPosition = this._pickupPositionOnPage = this._getPointerPositionOnPage(event);
-        this._pointerDirectionDelta = { x: 0, y: 0 };
-        this._pointerPositionAtLastDirectionChange = { x: pointerPosition.x, y: pointerPosition.y };
-        this._dragDropRegistry.startDragging(this, event);
+    withOrientation(orientation) {
+        (/** @type {?} */ (this))._orientation = orientation;
+        return (/** @type {?} */ (this));
     }
     /**
-     * Cleans up the DOM artifacts that were added to facilitate the element being dragged.
-     * @private
-     * @param {?} event
+     * Figures out the index of an item in the container.
+     * @param {?} item Item whose index should be determined.
      * @return {?}
      */
-    _cleanupDragArtifacts(event) {
-        // Restore the element's visibility and insert it at its old position in the DOM.
-        // It's important that we maintain the position, because moving the element around in the DOM
-        // can throw off `NgFor` which does smart diffing and re-creates elements only when necessary,
-        // while moving the existing elements in all other cases.
-        this._rootElement.style.display = '';
-        if (this._nextSibling) {
-            (/** @type {?} */ (this._nextSibling.parentNode)).insertBefore(this._rootElement, this._nextSibling);
-        }
-        else {
-            this._initialContainer.element.nativeElement.appendChild(this._rootElement);
+    getItemIndex(item) {
+        if (!this._isDragging) {
+            return this._draggables.indexOf(item);
         }
-        this._destroyPreview();
-        this._destroyPlaceholder();
-        this._boundaryRect = this._previewRect = undefined;
-        // Re-enter the NgZone since we bound `document` events on the outside.
-        this._ngZone.run(() => {
-            /** @type {?} */
-            const container = (/** @type {?} */ (this.dropContainer));
-            /** @type {?} */
-            const currentIndex = container.getItemIndex(this);
-            const { x, y } = this._getPointerPositionOnPage(event);
-            /** @type {?} */
-            const isPointerOverContainer = container._isOverContainer(x, y);
-            this.ended.next({ source: this });
-            this.dropped.next({
-                item: this,
-                currentIndex,
-                previousIndex: this._initialContainer.getItemIndex(this),
-                container: container,
-                previousContainer: this._initialContainer,
-                isPointerOverContainer
-            });
-            container.drop(this, currentIndex, this._initialContainer, isPointerOverContainer);
-            this.dropContainer = this._initialContainer;
-        });
+        // Items are sorted always by top/left in the cache, however they flow differently in RTL.
+        // The rest of the logic still stands no matter what orientation we're in, however
+        // we need to invert the array when determining the index.
+        /** @type {?} */
+        const items = this._orientation === 'horizontal' && this._direction === 'rtl' ?
+            this._itemPositions.slice().reverse() : this._itemPositions;
+        return findIndex(items, currentItem => currentItem.drag === item);
     }
     /**
-     * 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
+     * Whether the list is able to receive the item that
+     * is currently being dragged inside a connected drop list.
      * @return {?}
      */
-    _updateActiveDropContainer({ x, y }) {
-        // Drop container that draggable has been moved into.
-        /** @type {?} */
-        let newContainer = (/** @type {?} */ (this.dropContainer))._getSiblingContainerFromPosition(this, x, y) ||
-            this._initialContainer._getSiblingContainerFromPosition(this, x, y);
-        // If we couldn't find a new container to move the item into, and the item has left it's
-        // initial container, check whether the it's over the initial container. This handles the
-        // case where two containers are connected one way and the user tries to undo dragging an
-        // item into a new container.
-        if (!newContainer && this.dropContainer !== this._initialContainer &&
-            this._initialContainer._isOverContainer(x, y)) {
-            newContainer = this._initialContainer;
-        }
-        if (newContainer && newContainer !== this.dropContainer) {
-            this._ngZone.run(() => {
-                // 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);
+    isReceiving() {
+        return this._activeSiblings.size > 0;
     }
     /**
-     * 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
+     * Sorts an item inside the container based on its position.
+     * @param {?} item Item to be sorted.
+     * @param {?} pointerX Position of the item along the X axis.
+     * @param {?} pointerY Position of the item along the Y axis.
+     * @param {?} pointerDelta Direction in which the pointer is moving along each axis.
      * @return {?}
      */
-    _createPreviewElement() {
+    _sortItem(item, pointerX, pointerY, pointerDelta) {
+        // Don't sort the item if it's out of range.
+        if (!this._isPointerNearDropContainer(pointerX, pointerY)) {
+            return;
+        }
         /** @type {?} */
-        const previewTemplate = this._previewTemplate;
+        const siblings = this._itemPositions;
         /** @type {?} */
-        let preview;
-        if (previewTemplate && previewTemplate.template) {
-            /** @type {?} */
-            const viewRef = this._viewContainerRef.createEmbeddedView(previewTemplate.template, previewTemplate.context);
-            preview = viewRef.rootNodes[0];
-            this._previewRef = viewRef;
-            preview.style.transform =
-                getTransform(this._pickupPositionOnPage.x, this._pickupPositionOnPage.y);
+        const newIndex = this._getItemIndexFromPointerPosition(item, pointerX, pointerY, pointerDelta);
+        if (newIndex === -1 && siblings.length > 0) {
+            return;
         }
-        else {
+        /** @type {?} */
+        const isHorizontal = this._orientation === 'horizontal';
+        /** @type {?} */
+        const currentIndex = findIndex(siblings, currentItem => currentItem.drag === item);
+        /** @type {?} */
+        const siblingAtNewPosition = siblings[newIndex];
+        /** @type {?} */
+        const currentPosition = siblings[currentIndex].clientRect;
+        /** @type {?} */
+        const newPosition = siblingAtNewPosition.clientRect;
+        /** @type {?} */
+        const delta = currentIndex > newIndex ? 1 : -1;
+        this._previousSwap.drag = siblingAtNewPosition.drag;
+        this._previousSwap.delta = isHorizontal ? pointerDelta.x : pointerDelta.y;
+        // How many pixels the item's placeholder should be offset.
+        /** @type {?} */
+        const itemOffset = this._getItemOffsetPx(currentPosition, newPosition, delta);
+        // How many pixels all the other items should be offset.
+        /** @type {?} */
+        const siblingOffset = this._getSiblingOffsetPx(currentIndex, siblings, delta);
+        // Save the previous order of the items before moving the item to its new index.
+        // We use this to check whether an item has been moved as a result of the sorting.
+        /** @type {?} */
+        const oldOrder = siblings.slice();
+        // Shuffle the array in place.
+        moveItemInArray(siblings, currentIndex, newIndex);
+        this.sorted.next({
+            previousIndex: currentIndex,
+            currentIndex: newIndex,
+            container: this,
+            item
+        });
+        siblings.forEach((sibling, index) => {
+            // Don't do anything if the position hasn't changed.
+            if (oldOrder[index] === sibling) {
+                return;
+            }
             /** @type {?} */
-            const element = this._rootElement;
+            const isDraggedItem = sibling.drag === item;
             /** @type {?} */
-            const elementRect = element.getBoundingClientRect();
-            preview = deepCloneNode(element);
-            preview.style.width = `${elementRect.width}px`;
-            preview.style.height = `${elementRect.height}px`;
-            preview.style.transform = getTransform(elementRect.left, elementRect.top);
-        }
-        extendStyles(preview.style, {
-            // It's important that we disable the pointer events on the preview, because
-            // it can throw off the `document.elementFromPoint` calls in the `CdkDropList`.
-            pointerEvents: 'none',
-            position: 'fixed',
-            top: '0',
-            left: '0',
-            zIndex: '1000'
+            const offset = isDraggedItem ? itemOffset : siblingOffset;
+            /** @type {?} */
+            const elementToOffset = isDraggedItem ? item.getPlaceholderElement() :
+                sibling.drag.getRootElement();
+            // Update the offset to reflect the new position.
+            sibling.offset += offset;
+            // Since we're moving the items with a `transform`, we need to adjust their cached
+            // client rects to reflect their new position, as well as swap their positions in the cache.
+            // Note that we shouldn't use `getBoundingClientRect` here to update the cache, because the
+            // elements may be mid-animation which will give us a wrong result.
+            if (isHorizontal) {
+                // Round the transforms since some browsers will
+                // blur the elements, for sub-pixel transforms.
+                elementToOffset.style.transform = `translate3d(${Math.round(sibling.offset)}px, 0, 0)`;
+                adjustClientRect(sibling.clientRect, 0, offset);
+            }
+            else {
+                elementToOffset.style.transform = `translate3d(0, ${Math.round(sibling.offset)}px, 0)`;
+                adjustClientRect(sibling.clientRect, offset, 0);
+            }
         });
-        toggleNativeDragInteractions(preview, false);
-        preview.classList.add('cdk-drag-preview');
-        preview.setAttribute('dir', this._dir ? this._dir.value : 'ltr');
-        return preview;
     }
     /**
-     * Animates the preview element from its current position to the location of the drop placeholder.
+     * Caches the position of the drop list.
+     * @private
+     * @return {?}
+     */
+    _cacheOwnPosition() {
+        this._clientRect = this.element.getBoundingClientRect();
+    }
+    /**
+     * Refreshes the position cache of the items and sibling containers.
      * @private
-     * @return {?} Promise that resolves when the animation completes.
+     * @return {?}
      */
-    _animatePreviewToPlaceholder() {
-        // If the user hasn't moved yet, the transitionend event won't fire.
-        if (!this._hasMoved) {
-            return Promise.resolve();
-        }
-        /** @type {?} */
-        const placeholderRect = this._placeholder.getBoundingClientRect();
-        // Apply the class that adds a transition to the preview.
-        this._preview.classList.add('cdk-drag-animating');
-        // Move the preview to the placeholder position.
-        this._preview.style.transform = getTransform(placeholderRect.left, placeholderRect.top);
-        // If the element doesn't have a `transition`, the `transitionend` event won't fire. Since
-        // we need to trigger a style recalculation in order for the `cdk-drag-animating` class to
-        // apply its style, we take advantage of the available info to figure out whether we need to
-        // bind the event in the first place.
+    _cacheItemPositions() {
         /** @type {?} */
-        const duration = getTransformTransitionDurationInMs(this._preview);
-        if (duration === 0) {
-            return Promise.resolve();
-        }
-        return this._ngZone.runOutsideAngular(() => {
-            return new Promise(resolve => {
-                /** @type {?} */
-                const handler = (/** @type {?} */ (((event) => {
-                    if (!event || (event.target === this._preview && event.propertyName === 'transform')) {
-                        this._preview.removeEventListener('transitionend', handler);
-                        resolve();
-                        clearTimeout(timeout);
-                    }
-                })));
-                // If a transition is short enough, the browser might not fire the `transitionend` event.
-                // Since we know how long it's supposed to take, add a timeout with a 50% buffer that'll
-                // fire if the transition hasn't completed when it was supposed to.
-                /** @type {?} */
-                const timeout = setTimeout((/** @type {?} */ (handler)), duration * 1.5);
-                this._preview.addEventListener('transitionend', handler);
-            });
+        const isHorizontal = this._orientation === 'horizontal';
+        this._itemPositions = this._activeDraggables.map(drag => {
+            /** @type {?} */
+            const elementToMeasure = this._dragDropRegistry.isDragging(drag) ?
+                // If the element is being dragged, we have to measure the
+                // placeholder, because the element is hidden.
+                drag.getPlaceholderElement() :
+                drag.getRootElement();
+            /** @type {?} */
+            const clientRect = elementToMeasure.getBoundingClientRect();
+            return {
+                drag,
+                offset: 0,
+                // We need to clone the `clientRect` here, because all the values on it are readonly
+                // and we need to be able to update them. Also we can't use a spread here, because
+                // the values on a `ClientRect` aren't own properties. See:
+                // https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect#Notes
+                clientRect: {
+                    top: clientRect.top,
+                    right: clientRect.right,
+                    bottom: clientRect.bottom,
+                    left: clientRect.left,
+                    width: clientRect.width,
+                    height: clientRect.height
+                }
+            };
+        }).sort((a, b) => {
+            return isHorizontal ? a.clientRect.left - b.clientRect.left :
+                a.clientRect.top - b.clientRect.top;
         });
     }
     /**
-     * Creates an element that will be shown instead of the current element while dragging.
+     * Resets the container to its initial state.
      * @private
      * @return {?}
      */
-    _createPlaceholderElement() {
-        /** @type {?} */
-        const placeholderTemplate = this._placeholderTemplate;
-        /** @type {?} */
-        let placeholder;
-        if (placeholderTemplate && placeholderTemplate.template) {
-            this._placeholderRef = this._viewContainerRef.createEmbeddedView(placeholderTemplate.template, placeholderTemplate.context);
-            placeholder = this._placeholderRef.rootNodes[0];
-        }
-        else {
-            placeholder = deepCloneNode(this._rootElement);
-        }
-        placeholder.classList.add('cdk-drag-placeholder');
-        return placeholder;
+    _reset() {
+        this._isDragging = false;
+        // TODO(crisbeto): may have to wait for the animations to finish.
+        this._activeDraggables.forEach(item => item.getRootElement().style.transform = '');
+        this._siblings.forEach(sibling => sibling._stopReceiving(this));
+        this._activeDraggables = [];
+        this._itemPositions = [];
+        this._previousSwap.drag = null;
+        this._previousSwap.delta = 0;
     }
     /**
-     * Figures out the coordinates at which an element was picked up.
+     * Gets the offset in pixels by which the items that aren't being dragged should be moved.
      * @private
-     * @param {?} referenceElement Element that initiated the dragging.
-     * @param {?} event Event that initiated the dragging.
+     * @param {?} currentIndex Index of the item currently being dragged.
+     * @param {?} siblings All of the items in the list.
+     * @param {?} delta Direction in which the user is moving.
      * @return {?}
      */
-    _getPointerPositionInElement(referenceElement, event) {
-        /** @type {?} */
-        const elementRect = this._rootElement.getBoundingClientRect();
-        /** @type {?} */
-        const handleElement = referenceElement === this._rootElement ? null : referenceElement;
+    _getSiblingOffsetPx(currentIndex, siblings, delta) {
         /** @type {?} */
-        const referenceRect = handleElement ? handleElement.getBoundingClientRect() : elementRect;
+        const isHorizontal = this._orientation === 'horizontal';
         /** @type {?} */
-        const point = isTouchEvent(event) ? event.targetTouches[0] : event;
+        const currentPosition = siblings[currentIndex].clientRect;
         /** @type {?} */
-        const x = point.pageX - referenceRect.left - this._scrollPosition.left;
+        const immediateSibling = siblings[currentIndex + delta * -1];
         /** @type {?} */
-        const y = point.pageY - referenceRect.top - this._scrollPosition.top;
-        return {
-            x: referenceRect.left - elementRect.left + x,
-            y: referenceRect.top - elementRect.top + y
-        };
+        let siblingOffset = currentPosition[isHorizontal ? 'width' : 'height'] * delta;
+        if (immediateSibling) {
+            /** @type {?} */
+            const start = isHorizontal ? 'left' : 'top';
+            /** @type {?} */
+            const end = isHorizontal ? 'right' : 'bottom';
+            // Get the spacing between the start of the current item and the end of the one immediately
+            // after it in the direction in which the user is dragging, or vice versa. We add it to the
+            // offset in order to push the element to where it will be when it's inline and is influenced
+            // by the `margin` of its siblings.
+            if (delta === -1) {
+                siblingOffset -= immediateSibling.clientRect[start] - currentPosition[end];
+            }
+            else {
+                siblingOffset += currentPosition[start] - immediateSibling.clientRect[end];
+            }
+        }
+        return siblingOffset;
     }
     /**
-     * Determines the point of the page that was touched by the user.
+     * Checks whether the pointer coordinates are close to the drop container.
      * @private
-     * @param {?} event
+     * @param {?} pointerX Coordinates along the X axis.
+     * @param {?} pointerY Coordinates along the Y axis.
      * @return {?}
      */
-    _getPointerPositionOnPage(event) {
-        // `touches` will be empty for start/end events so we have to fall back to `changedTouches`.
+    _isPointerNearDropContainer(pointerX, pointerY) {
+        const { top, right, bottom, left, width, height } = this._clientRect;
         /** @type {?} */
-        const point = isTouchEvent(event) ? (event.touches[0] || event.changedTouches[0]) : event;
-        return {
-            x: point.pageX - this._scrollPosition.left,
-            y: point.pageY - this._scrollPosition.top
-        };
+        const xThreshold = width * DROP_PROXIMITY_THRESHOLD;
+        /** @type {?} */
+        const yThreshold = height * DROP_PROXIMITY_THRESHOLD;
+        return pointerY > top - yThreshold && pointerY < bottom + yThreshold &&
+            pointerX > left - xThreshold && pointerX < right + xThreshold;
     }
     /**
-     * Gets the pointer position on the page, accounting for any position constraints.
+     * Gets the offset in pixels by which the item that is being dragged should be moved.
      * @private
-     * @param {?} event
+     * @param {?} currentPosition Current position of the item.
+     * @param {?} newPosition Position of the item where the current item should be moved.
+     * @param {?} delta Direction in which the user is moving.
      * @return {?}
      */
-    _getConstrainedPointerPosition(event) {
+    _getItemOffsetPx(currentPosition, newPosition, delta) {
         /** @type {?} */
-        const point = this._getPointerPositionOnPage(event);
+        const isHorizontal = this._orientation === 'horizontal';
         /** @type {?} */
-        const dropContainerLock = this.dropContainer ? this.dropContainer.lockAxis : null;
-        if (this.lockAxis === 'x' || dropContainerLock === 'x') {
-            point.y = this._pickupPositionOnPage.y;
-        }
-        else if (this.lockAxis === 'y' || dropContainerLock === 'y') {
-            point.x = this._pickupPositionOnPage.x;
-        }
-        if (this._boundaryRect) {
-            const { x: pickupX, y: pickupY } = this._pickupPositionInElement;
-            /** @type {?} */
-            const boundaryRect = this._boundaryRect;
-            /** @type {?} */
-            const previewRect = (/** @type {?} */ (this._previewRect));
-            /** @type {?} */
-            const minY = boundaryRect.top + pickupY;
-            /** @type {?} */
-            const maxY = boundaryRect.bottom - (previewRect.height - pickupY);
-            /** @type {?} */
-            const minX = boundaryRect.left + pickupX;
-            /** @type {?} */
-            const maxX = boundaryRect.right - (previewRect.width - pickupX);
-            point.x = clamp$1(point.x, minX, maxX);
-            point.y = clamp$1(point.y, minY, maxY);
+        let itemOffset = isHorizontal ? newPosition.left - currentPosition.left :
+            newPosition.top - currentPosition.top;
+        // Account for differences in the item width/height.
+        if (delta === -1) {
+            itemOffset += isHorizontal ? newPosition.width - currentPosition.width :
+                newPosition.height - currentPosition.height;
         }
-        return point;
+        return itemOffset;
     }
     /**
-     * Updates the current drag delta, based on the user's current pointer position on the page.
+     * Gets the index of an item in the drop container, based on the position of the user's pointer.
      * @private
-     * @param {?} pointerPositionOnPage
+     * @param {?} item Item that is being sorted.
+     * @param {?} pointerX Position of the user's pointer along the X axis.
+     * @param {?} pointerY Position of the user's pointer along the Y axis.
+     * @param {?=} delta Direction in which the user is moving their pointer.
      * @return {?}
      */
-    _updatePointerDirectionDelta(pointerPositionOnPage) {
-        const { x, y } = pointerPositionOnPage;
-        /** @type {?} */
-        const delta = this._pointerDirectionDelta;
-        /** @type {?} */
-        const positionSinceLastChange = this._pointerPositionAtLastDirectionChange;
-        // Amount of pixels the user has dragged since the last time the direction changed.
-        /** @type {?} */
-        const changeX = Math.abs(x - positionSinceLastChange.x);
+    _getItemIndexFromPointerPosition(item, pointerX, pointerY, delta) {
         /** @type {?} */
-        const changeY = Math.abs(y - positionSinceLastChange.y);
-        // Because we handle pointer events on a per-pixel basis, we don't want the delta
-        // to change for every pixel, otherwise anything that depends on it can look erratic.
-        // To make the delta more consistent, we track how much the user has moved since the last
-        // delta change and we only update it after it has reached a certain threshold.
-        if (changeX > this._config.pointerDirectionChangeThreshold) {
-            delta.x = x > positionSinceLastChange.x ? 1 : -1;
-            positionSinceLastChange.x = x;
+        const isHorizontal = this._orientation === 'horizontal';
+        return findIndex(this._itemPositions, ({ drag, clientRect }, _, array) => {
+            if (drag === item) {
+                // If there's only one item left in the container, it must be
+                // the dragged item itself so we use it as a reference.
+                return array.length < 2;
+            }
+            if (delta) {
+                /** @type {?} */
+                const direction = isHorizontal ? delta.x : delta.y;
+                // If the user is still hovering over the same item as last time, and they didn't change
+                // the direction in which they're dragging, we don't consider it a direction swap.
+                if (drag === this._previousSwap.drag && direction === this._previousSwap.delta) {
+                    return false;
+                }
+            }
+            return isHorizontal ?
+                // Round these down since most browsers report client rects with
+                // sub-pixel precision, whereas the pointer coordinates are rounded to pixels.
+                pointerX >= Math.floor(clientRect.left) && pointerX <= Math.floor(clientRect.right) :
+                pointerY >= Math.floor(clientRect.top) && pointerY <= Math.floor(clientRect.bottom);
+        });
+    }
+    /**
+     * Checks whether the user's pointer is positioned over the container.
+     * @param {?} x Pointer position along the X axis.
+     * @param {?} y Pointer position along the Y axis.
+     * @return {?}
+     */
+    _isOverContainer(x, y) {
+        return isInsideClientRect(this._clientRect, x, y);
+    }
+    /**
+     * Figures out whether an item should be moved into a sibling
+     * drop container, based on its current position.
+     * @param {?} item Drag item that is being moved.
+     * @param {?} x Position of the item along the X axis.
+     * @param {?} y Position of the item along the Y axis.
+     * @return {?}
+     */
+    _getSiblingContainerFromPosition(item, x, y) {
+        return this._siblings.find(sibling => sibling._canReceive(item, x, y));
+    }
+    /**
+     * Checks whether the drop list can receive the passed-in item.
+     * @param {?} item Item that is being dragged into the list.
+     * @param {?} x Position of the item along the X axis.
+     * @param {?} y Position of the item along the Y axis.
+     * @return {?}
+     */
+    _canReceive(item, x, y) {
+        if (!this.enterPredicate(item, this) || !isInsideClientRect(this._clientRect, x, y)) {
+            return false;
         }
-        if (changeY > this._config.pointerDirectionChangeThreshold) {
-            delta.y = y > positionSinceLastChange.y ? 1 : -1;
-            positionSinceLastChange.y = y;
+        /** @type {?} */
+        const elementFromPoint = this._document.elementFromPoint(x, y);
+        // If there's no element at the pointer position, then
+        // the client rect is probably scrolled out of the view.
+        if (!elementFromPoint) {
+            return false;
         }
-        return delta;
+        // The `ClientRect`, that we're using to find the container over which the user is
+        // hovering, doesn't give us any information on whether the element has been scrolled
+        // out of the view or whether it's overlapping with other containers. This means that
+        // we could end up transferring the item into a container that's invisible or is positioned
+        // below another one. We use the result from `elementFromPoint` to get the top-most element
+        // at the pointer position and to find whether it's one of the intersecting drop containers.
+        return elementFromPoint === this.element || this.element.contains(elementFromPoint);
     }
     /**
-     * Toggles the native drag interactions, based on how many handles are registered.
-     * @private
+     * Called by one of the connected drop lists when a dragging sequence has started.
+     * @param {?} sibling Sibling in which dragging has started.
      * @return {?}
      */
-    _toggleNativeDragInteractions() {
-        if (!this._rootElement || !this._handles) {
-            return;
-        }
+    _startReceiving(sibling) {
         /** @type {?} */
-        const shouldEnable = this.disabled || this._handles.length > 0;
-        if (shouldEnable !== this._nativeInteractionsEnabled) {
-            this._nativeInteractionsEnabled = shouldEnable;
-            toggleNativeDragInteractions(this._rootElement, shouldEnable);
+        const activeSiblings = this._activeSiblings;
+        if (!activeSiblings.has(sibling)) {
+            activeSiblings.add(sibling);
+            this._cacheOwnPosition();
         }
     }
     /**
-     * Removes the manually-added event listeners from the root element.
-     * @private
-     * @param {?} element
+     * Called by a connected drop list when dragging has stopped.
+     * @param {?} sibling Sibling whose dragging has stopped.
      * @return {?}
      */
-    _removeRootElementListeners(element) {
-        element.removeEventListener('mousedown', this._pointerDown, activeEventListenerOptions);
-        element.removeEventListener('touchstart', this._pointerDown, passiveEventListenerOptions);
+    _stopReceiving(sibling) {
+        this._activeSiblings.delete(sibling);
     }
 }
 /**
- * Gets a 3d `transform` that can be applied to an element.
- * @param {?} x Desired position of the element along the X axis.
- * @param {?} y Desired position of the element along the Y axis.
- * @return {?}
- */
-function getTransform(x, y) {
-    // Round the transforms since some browsers will
-    // blur the elements for sub-pixel transforms.
-    return `translate3d(${Math.round(x)}px, ${Math.round(y)}px, 0)`;
-}
-/**
- * Creates a deep clone of an element.
- * @param {?} node
- * @return {?}
- */
-function deepCloneNode(node) {
-    /** @type {?} */
-    const clone = (/** @type {?} */ (node.cloneNode(true)));
-    // Remove the `id` to avoid having multiple elements with the same id on the page.
-    clone.removeAttribute('id');
-    return clone;
-}
-/**
- * Clamps a value between a minimum and a maximum.
- * @param {?} value
- * @param {?} min
- * @param {?} max
+ * Updates the top/left positions of a `ClientRect`, as well as their bottom/right counterparts.
+ * @param {?} clientRect `ClientRect` that should be updated.
+ * @param {?} top Amount to add to the `top` position.
+ * @param {?} left Amount to add to the `left` position.
  * @return {?}
  */
-function clamp$1(value, min, max) {
-    return Math.max(min, Math.min(max, value));
+function adjustClientRect(clientRect, top, left) {
+    clientRect.top += top;
+    clientRect.bottom = clientRect.top + clientRect.height;
+    clientRect.left += left;
+    clientRect.right = clientRect.left + clientRect.width;
 }
 /**
- * Helper to remove an element from the DOM and to do all the necessary null checks.
- * @param {?} element Element to be removed.
+ * Finds the index of an item that matches a predicate function. Used as an equivalent
+ * of `Array.prototype.find` which isn't part of the standard Google typings.
+ * @template T
+ * @param {?} array Array in which to look for matches.
+ * @param {?} predicate Function used to determine whether an item is a match.
  * @return {?}
  */
-function removeElement(element) {
-    if (element && element.parentNode) {
-        element.parentNode.removeChild(element);
+function findIndex(array, predicate) {
+    for (let i = 0; i < array.length; i++) {
+        if (predicate(array[i], i, array)) {
+            return i;
+        }
     }
+    return -1;
 }
 /**
- * Determines whether an event is a touch event.
- * @param {?} event
+ * Checks whether some coordinates are within a `ClientRect`.
+ * @param {?} clientRect ClientRect that is being checked.
+ * @param {?} x Coordinates along the X axis.
+ * @param {?} y Coordinates along the Y axis.
  * @return {?}
  */
-function isTouchEvent(event) {
-    return event.type.startsWith('touch');
+function isInsideClientRect(clientRect, x, y) {
+    const { top, bottom, left, right } = clientRect;
+    return y >= top && y <= bottom && x >= left && x <= right;
 }
 
 /**
@@ -1515,1000 +1782,850 @@ function isTouchEvent(event) {
  * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
- * Injection token that can be used to configure the behavior of `CdkDrag`.
+ * Event options that can be used to bind an active, capturing event.
  * @type {?}
  */
-const CDK_DRAG_CONFIG = new InjectionToken('CDK_DRAG_CONFIG', {
-    providedIn: 'root',
-    factory: CDK_DRAG_CONFIG_FACTORY
+const activeCapturingEventOptions = normalizePassiveListenerOptions({
+    passive: false,
+    capture: true
 });
 /**
+ * Service that keeps track of all the drag item and drop container
+ * instances, and manages global event listeners on the `document`.
  * \@docs-private
- * @return {?}
- */
-function CDK_DRAG_CONFIG_FACTORY() {
-    return { dragStartThreshold: 5, pointerDirectionChangeThreshold: 5 };
-}
-/**
- * Element that can be moved inside a CdkDropList container.
- * @template T
+ * @template I, C
  */
-class CdkDrag {
+// Note: this class is generic, rather than referencing CdkDrag and CdkDropList directly, in order
+// to avoid circular imports. If we were to reference them here, importing the registry into the
+// classes that are registering themselves will introduce a circular import.
+class DragDropRegistry {
     /**
-     * @param {?} element
-     * @param {?} dropContainer
-     * @param {?} _document
      * @param {?} _ngZone
-     * @param {?} _viewContainerRef
-     * @param {?} _viewportRuler
-     * @param {?} _dragDropRegistry
-     * @param {?} _config
-     * @param {?} _dir
+     * @param {?} _document
      */
-    constructor(element, dropContainer, _document, _ngZone, _viewContainerRef, _viewportRuler, _dragDropRegistry, _config, _dir) {
-        this.element = element;
-        this.dropContainer = dropContainer;
-        this._document = _document;
+    constructor(_ngZone, _document) {
         this._ngZone = _ngZone;
-        this._viewContainerRef = _viewContainerRef;
-        this._viewportRuler = _viewportRuler;
-        this._dragDropRegistry = _dragDropRegistry;
-        this._config = _config;
-        this._dir = _dir;
-        this._destroyed = new Subject();
-        this._disabled = false;
         /**
-         * Emits when the user starts dragging the item.
+         * Registered drop container instances.
          */
-        this.started = new EventEmitter();
+        this._dropInstances = new Set();
         /**
-         * Emits when the user has released a drag item, before any animations have started.
+         * Registered drag item instances.
          */
-        this.released = new EventEmitter();
+        this._dragInstances = new Set();
         /**
-         * Emits when the user stops dragging an item in the container.
+         * Drag item instances that are currently being dragged.
          */
-        this.ended = new EventEmitter();
+        this._activeDragInstances = new Set();
         /**
-         * Emits when the user has moved the item into a new container.
+         * Keeps track of the event listeners that we've bound to the `document`.
          */
-        this.entered = new EventEmitter();
+        this._globalListeners = new Map();
         /**
-         * Emits when the user removes the item its container by dragging it into another container.
+         * Emits the `touchmove` or `mousemove` events that are dispatched
+         * while the user is dragging a drag item instance.
          */
-        this.exited = new EventEmitter();
+        this.pointerMove = new Subject();
         /**
-         * Emits when the user drops the item inside a container.
+         * Emits the `touchend` or `mouseup` events that are dispatched
+         * while the user is dragging a drag item instance.
          */
-        this.dropped = new EventEmitter();
+        this.pointerUp = 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.
+         * Event listener that will prevent the default browser action while the user is dragging.
+         * @param event Event whose default action should be prevented.
          */
-        this.moved = new Observable((observer) => {
-            /** @type {?} */
-            const subscription = this._dragRef.moved.pipe(map(movedEvent => ({
-                source: this,
-                pointerPosition: movedEvent.pointerPosition,
-                event: movedEvent.event,
-                delta: movedEvent.delta
-            }))).subscribe(observer);
-            return () => {
-                subscription.unsubscribe();
-            };
-        });
-        /** @type {?} */
-        const ref = this._dragRef = new DragRef(element, this._document, this._ngZone, this._viewContainerRef, this._viewportRuler, this._dragDropRegistry, this._config, this.dropContainer ? this.dropContainer._dropListRef : undefined, this._dir);
-        ref.data = this;
-        this._syncInputs(ref);
-        this._proxyEvents(ref);
-    }
-    /**
-     * Whether starting to drag this element is disabled.
-     * @return {?}
-     */
-    get disabled() {
-        return this._disabled || (this.dropContainer && this.dropContainer.disabled);
-    }
-    /**
-     * @param {?} value
-     * @return {?}
-     */
-    set disabled(value) {
-        this._disabled = coerceBooleanProperty(value);
-        this._dragRef.disabled = this._disabled;
+        this._preventDefaultWhileDragging = (event) => {
+            if (this._activeDragInstances.size) {
+                event.preventDefault();
+            }
+        };
+        this._document = _document;
     }
     /**
-     * Returns the element that is being used as a placeholder
-     * while the current element is being dragged.
+     * Adds a drop container to the registry.
+     * @param {?} drop
      * @return {?}
      */
-    getPlaceholderElement() {
-        return this._dragRef.getPlaceholderElement();
+    registerDropContainer(drop) {
+        if (!this._dropInstances.has(drop)) {
+            if (this.getDropContainer(drop.id)) {
+                throw Error(`Drop instance with id "${drop.id}" has already been registered.`);
+            }
+            this._dropInstances.add(drop);
+        }
     }
     /**
-     * Returns the root draggable element.
+     * Adds a drag item instance to the registry.
+     * @param {?} drag
      * @return {?}
      */
-    getRootElement() {
-        return this._dragRef.getRootElement();
+    registerDragItem(drag) {
+        this._dragInstances.add(drag);
+        // The `touchmove` event gets bound once, ahead of time, because WebKit
+        // won't preventDefault on a dynamically-added `touchmove` listener.
+        // See https://bugs.webkit.org/show_bug.cgi?id=184250.
+        if (this._dragInstances.size === 1) {
+            this._ngZone.runOutsideAngular(() => {
+                // The event handler has to be explicitly active,
+                // because newer browsers make it passive by default.
+                this._document.addEventListener('touchmove', this._preventDefaultWhileDragging, activeCapturingEventOptions);
+            });
+        }
     }
     /**
-     * Resets a standalone drag item to its initial position.
+     * Removes a drop container from the registry.
+     * @param {?} drop
      * @return {?}
      */
-    reset() {
-        this._dragRef.reset();
+    removeDropContainer(drop) {
+        this._dropInstances.delete(drop);
     }
     /**
+     * Removes a drag item instance from the registry.
+     * @param {?} drag
      * @return {?}
      */
-    ngAfterViewInit() {
-        // We need to wait for the zone to stabilize, in order for the reference
-        // element to be in the proper place in the DOM. This is mostly relevant
-        // for draggable elements inside portals since they get stamped out in
-        // their original DOM position and then they get transferred to the portal.
-        this._ngZone.onStable.asObservable()
-            .pipe(take(1), takeUntil(this._destroyed))
-            .subscribe(() => {
-            this._updateRootElement();
-            // Listen for any newly-added handles.
-            this._handles.changes.pipe(startWith(this._handles), 
-            // Sync the new handles with the DragRef.
-            tap((handles) => {
-                /** @type {?} */
-                const childHandleElements = handles
-                    .filter(handle => handle._parentDrag === this)
-                    .map(handle => handle.element);
-                this._dragRef.withHandles(childHandleElements);
-            }), 
-            // Listen if the state of any of the handles changes.
-            switchMap((handles) => {
-                return merge(...handles.map(item => item._stateChanges));
-            }), takeUntil(this._destroyed)).subscribe(handleInstance => {
-                // Enabled/disable the handle that changed in the DragRef.
-                /** @type {?} */
-                const dragRef = this._dragRef;
-                /** @type {?} */
-                const handle = handleInstance.element.nativeElement;
-                handleInstance.disabled ? dragRef.disableHandle(handle) : dragRef.enableHandle(handle);
-            });
-        });
+    removeDragItem(drag) {
+        this._dragInstances.delete(drag);
+        this.stopDragging(drag);
+        if (this._dragInstances.size === 0) {
+            this._document.removeEventListener('touchmove', this._preventDefaultWhileDragging, activeCapturingEventOptions);
+        }
     }
     /**
-     * @param {?} changes
+     * Starts the dragging sequence for a drag instance.
+     * @param {?} drag Drag instance which is being dragged.
+     * @param {?} event Event that initiated the dragging.
      * @return {?}
      */
-    ngOnChanges(changes) {
-        /** @type {?} */
-        const rootSelectorChange = changes.rootElementSelector;
-        // We don't have to react to the first change since it's being
-        // handled in `ngAfterViewInit` where it needs to be deferred.
-        if (rootSelectorChange && !rootSelectorChange.firstChange) {
-            this._updateRootElement();
+    startDragging(drag, event) {
+        this._activeDragInstances.add(drag);
+        if (this._activeDragInstances.size === 1) {
+            /** @type {?} */
+            const isTouchEvent = event.type.startsWith('touch');
+            /** @type {?} */
+            const moveEvent = isTouchEvent ? 'touchmove' : 'mousemove';
+            /** @type {?} */
+            const upEvent = isTouchEvent ? 'touchend' : 'mouseup';
+            // We explicitly bind __active__ listeners here, because newer browsers will default to
+            // passive ones for `mousemove` and `touchmove`. The events need to be active, because we
+            // use `preventDefault` to prevent the page from scrolling while the user is dragging.
+            this._globalListeners
+                .set(moveEvent, {
+                handler: (e) => this.pointerMove.next((/** @type {?} */ (e))),
+                options: activeCapturingEventOptions
+            })
+                .set(upEvent, {
+                handler: (e) => this.pointerUp.next((/** @type {?} */ (e))),
+                options: true
+            })
+                // Preventing the default action on `mousemove` isn't enough to disable text selection
+                // on Safari so we need to prevent the selection event as well. Alternatively this can
+                // be done by setting `user-select: none` on the `body`, however it has causes a style
+                // recalculation which can be expensive on pages with a lot of elements.
+                .set('selectstart', {
+                handler: this._preventDefaultWhileDragging,
+                options: activeCapturingEventOptions
+            });
+            // TODO(crisbeto): prevent mouse wheel scrolling while
+            // dragging until we've set up proper scroll handling.
+            if (!isTouchEvent) {
+                this._globalListeners.set('wheel', {
+                    handler: this._preventDefaultWhileDragging,
+                    options: activeCapturingEventOptions
+                });
+            }
+            this._ngZone.runOutsideAngular(() => {
+                this._globalListeners.forEach((config, name) => {
+                    this._document.addEventListener(name, config.handler, config.options);
+                });
+            });
         }
     }
     /**
+     * Stops dragging a drag item instance.
+     * @param {?} drag
      * @return {?}
      */
-    ngOnDestroy() {
-        this._destroyed.next();
-        this._destroyed.complete();
-        this._dragRef.dispose();
+    stopDragging(drag) {
+        this._activeDragInstances.delete(drag);
+        if (this._activeDragInstances.size === 0) {
+            this._clearGlobalListeners();
+        }
     }
     /**
-     * Syncs the root element with the `DragRef`.
-     * @private
+     * Gets whether a drag item instance is currently being dragged.
+     * @param {?} drag
      * @return {?}
      */
-    _updateRootElement() {
-        /** @type {?} */
-        const element = this.element.nativeElement;
-        /** @type {?} */
-        const rootElement = this.rootElementSelector ?
-            getClosestMatchingAncestor(element, this.rootElementSelector) : element;
-        if (rootElement && rootElement.nodeType !== this._document.ELEMENT_NODE) {
-            throw Error(`cdkDrag must be attached to an element node. ` +
-                `Currently attached to "${rootElement.nodeName}".`);
-        }
-        this._dragRef.withRootElement(rootElement || element);
+    isDragging(drag) {
+        return this._activeDragInstances.has(drag);
     }
     /**
-     * Gets the boundary element, based on the `boundaryElementSelector`.
-     * @private
+     * Gets a drop container by its id.
+     * @deprecated No longer being used. To be removed.
+     * \@breaking-change 8.0.0
+     * @param {?} id
      * @return {?}
      */
-    _getBoundaryElement() {
-        /** @type {?} */
-        const selector = this.boundaryElementSelector;
-        return selector ? getClosestMatchingAncestor(this.element.nativeElement, selector) : null;
+    getDropContainer(id) {
+        return Array.from(this._dropInstances).find(instance => instance.id === id);
     }
     /**
-     * Syncs the inputs of the CdkDrag with the options of the underlying DragRef.
-     * @private
-     * @param {?} ref
      * @return {?}
      */
-    _syncInputs(ref) {
-        ref.beforeStarted.subscribe(() => {
-            if (!ref.isDragging()) {
-                const { _placeholderTemplate: placeholder, _previewTemplate: preview } = this;
-                ref.disabled = this.disabled;
-                ref.lockAxis = this.lockAxis;
-                ref.withBoundaryElement(this._getBoundaryElement());
-                placeholder ? ref.withPlaceholderTemplate(placeholder.templateRef, placeholder.data) :
-                    ref.withPlaceholderTemplate(null);
-                preview ? ref.withPreviewTemplate(preview.templateRef, preview.data) :
-                    ref.withPreviewTemplate(null);
-            }
-        });
+    ngOnDestroy() {
+        this._dragInstances.forEach(instance => this.removeDragItem(instance));
+        this._dropInstances.forEach(instance => this.removeDropContainer(instance));
+        this._clearGlobalListeners();
+        this.pointerMove.complete();
+        this.pointerUp.complete();
     }
     /**
-     * Proxies the events from a DragRef to events that
-     * match the interfaces of the CdkDrag outputs.
+     * Clears out the global event listeners from the `document`.
      * @private
-     * @param {?} ref
      * @return {?}
      */
-    _proxyEvents(ref) {
-        ref.started.subscribe(() => {
-            this.started.emit({ source: this });
-        });
-        ref.released.subscribe(() => {
-            this.released.emit({ source: this });
-        });
-        ref.ended.subscribe(() => {
-            this.ended.emit({ source: this });
-        });
-        ref.entered.subscribe(event => {
-            this.entered.emit({
-                container: event.container.data,
-                item: this
-            });
-        });
-        ref.exited.subscribe(event => {
-            this.exited.emit({
-                container: event.container.data,
-                item: this
-            });
-        });
-        ref.dropped.subscribe(event => {
-            this.dropped.emit({
-                previousIndex: event.previousIndex,
-                currentIndex: event.currentIndex,
-                previousContainer: event.previousContainer.data,
-                container: event.container.data,
-                isPointerOverContainer: event.isPointerOverContainer,
-                item: this
-            });
+    _clearGlobalListeners() {
+        this._globalListeners.forEach((config, name) => {
+            this._document.removeEventListener(name, config.handler, config.options);
         });
+        this._globalListeners.clear();
     }
 }
-CdkDrag.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkDrag]',
-                exportAs: 'cdkDrag',
-                host: {
-                    'class': 'cdk-drag',
-                    '[class.cdk-drag-dragging]': '_dragRef.isDragging()',
-                },
-                providers: [{ provide: CDK_DRAG_PARENT, useExisting: CdkDrag }]
-            },] },
+DragDropRegistry.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] },
 ];
 /** @nocollapse */
-CdkDrag.ctorParameters = () => [
-    { type: ElementRef },
-    { type: undefined, decorators: [{ type: Inject, args: [CDK_DROP_LIST,] }, { type: Optional }, { type: SkipSelf }] },
-    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+DragDropRegistry.ctorParameters = () => [
     { type: NgZone },
-    { type: ViewContainerRef },
-    { type: ViewportRuler },
-    { type: DragDropRegistry },
-    { type: undefined, decorators: [{ type: Inject, args: [CDK_DRAG_CONFIG,] }] },
-    { type: Directionality, decorators: [{ type: Optional }] }
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
 ];
-CdkDrag.propDecorators = {
-    _handles: [{ type: ContentChildren, args: [CdkDragHandle, { descendants: true },] }],
-    _previewTemplate: [{ type: ContentChild, args: [CdkDragPreview,] }],
-    _placeholderTemplate: [{ type: ContentChild, args: [CdkDragPlaceholder,] }],
-    data: [{ type: Input, args: ['cdkDragData',] }],
-    lockAxis: [{ type: Input, args: ['cdkDragLockAxis',] }],
-    rootElementSelector: [{ type: Input, args: ['cdkDragRootElement',] }],
-    boundaryElementSelector: [{ type: Input, args: ['cdkDragBoundary',] }],
-    disabled: [{ type: Input, args: ['cdkDragDisabled',] }],
-    started: [{ type: Output, args: ['cdkDragStarted',] }],
-    released: [{ type: Output, args: ['cdkDragReleased',] }],
-    ended: [{ type: Output, args: ['cdkDragEnded',] }],
-    entered: [{ type: Output, args: ['cdkDragEntered',] }],
-    exited: [{ type: Output, args: ['cdkDragExited',] }],
-    dropped: [{ type: Output, args: ['cdkDragDropped',] }],
-    moved: [{ type: Output, args: ['cdkDragMoved',] }]
-};
-/**
- * Gets the closest ancestor of an element that matches a selector.
- * @param {?} element
- * @param {?} selector
- * @return {?}
- */
-function getClosestMatchingAncestor(element, selector) {
-    /** @type {?} */
-    let currentElement = (/** @type {?} */ (element.parentElement));
-    while (currentElement) {
-        // IE doesn't support `matches` so we have to fall back to `msMatchesSelector`.
-        if (currentElement.matches ? currentElement.matches(selector) :
-            ((/** @type {?} */ (currentElement))).msMatchesSelector(selector)) {
-            return currentElement;
-        }
-        currentElement = currentElement.parentElement;
-    }
-    return null;
-}
+/** @nocollapse */ DragDropRegistry.ngInjectableDef = defineInjectable({ factory: function DragDropRegistry_Factory() { return new DragDropRegistry(inject(NgZone), inject(DOCUMENT)); }, token: DragDropRegistry, providedIn: "root" });
 
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
- * Declaratively connects sibling `cdkDropList` instances together. All of the `cdkDropList`
- * elements that are placed inside a `cdkDropListGroup` will be connected to each other
- * automatically. Can be used as an alternative to the `cdkDropListConnectedTo` input
- * from `cdkDropList`.
- * @template T
+ * Default configuration to be used when creating a `DragRef`.
+ * @type {?}
  */
-class CdkDropListGroup {
-    constructor() {
-        /**
-         * Drop lists registered inside the group.
-         */
-        this._items = new Set();
-        this._disabled = false;
-    }
+const DEFAULT_CONFIG = {
+    dragStartThreshold: 5,
+    pointerDirectionChangeThreshold: 5
+};
+/**
+ * Service that allows for drag-and-drop functionality to be attached to DOM elements.
+ */
+class DragDrop {
     /**
-     * Whether starting a dragging sequence from inside this group is disabled.
-     * @return {?}
+     * @param {?} _document
+     * @param {?} _ngZone
+     * @param {?} _viewportRuler
+     * @param {?} _dragDropRegistry
      */
-    get disabled() { return this._disabled; }
+    constructor(_document, _ngZone, _viewportRuler, _dragDropRegistry) {
+        this._document = _document;
+        this._ngZone = _ngZone;
+        this._viewportRuler = _viewportRuler;
+        this._dragDropRegistry = _dragDropRegistry;
+    }
     /**
-     * @param {?} value
+     * Turns an element into a draggable item.
+     * @template T
+     * @param {?} element Element to which to attach the dragging functionality.
+     * @param {?=} config Object used to configure the dragging behavior.
      * @return {?}
      */
-    set disabled(value) {
-        this._disabled = coerceBooleanProperty(value);
+    createDrag(element, config = DEFAULT_CONFIG) {
+        return new DragRef(element, config, this._document, this._ngZone, this._viewportRuler, this._dragDropRegistry);
     }
     /**
+     * Turns an element into a drop list.
+     * @template T
+     * @param {?} element Element to which to attach the drop list functionality.
      * @return {?}
      */
-    ngOnDestroy() {
-        this._items.clear();
+    createDropList(element) {
+        return new DropListRef(element, this._dragDropRegistry, this._document);
     }
 }
-CdkDropListGroup.decorators = [
-    { type: Directive, args: [{
-                selector: '[cdkDropListGroup]',
-                exportAs: 'cdkDropListGroup',
-            },] },
+DragDrop.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] },
 ];
-CdkDropListGroup.propDecorators = {
-    disabled: [{ type: Input, args: ['cdkDropListGroupDisabled',] }]
-};
+/** @nocollapse */
+DragDrop.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: NgZone },
+    { type: ViewportRuler },
+    { type: DragDropRegistry }
+];
+/** @nocollapse */ DragDrop.ngInjectableDef = defineInjectable({ factory: function DragDrop_Factory() { return new DragDrop(inject(DOCUMENT), inject(NgZone), inject(ViewportRuler), inject(DragDropRegistry)); }, token: DragDrop, providedIn: "root" });
 
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
- * Counter used to generate unique ids for drop refs.
+ * Injection token that is used to provide a CdkDropList instance to CdkDrag.
+ * Used for avoiding circular imports.
  * @type {?}
  */
-let _uniqueIdCounter = 0;
+const CDK_DROP_LIST = new InjectionToken('CDK_DROP_LIST');
 /**
- * Proximity, as a ratio to width/height, at which a
- * dragged item will affect the drop container.
+ * Injection token that is used to provide a CdkDropList instance to CdkDrag.
+ * Used for avoiding circular imports.
+ * @deprecated Use `CDK_DROP_LIST` instead.
+ * \@breaking-change 8.0.0
  * @type {?}
  */
-const DROP_PROXIMITY_THRESHOLD = 0.05;
+const CDK_DROP_LIST_CONTAINER = CDK_DROP_LIST;
+
 /**
- * Reference to a drop list. Used to manipulate or dispose of the container.
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Injection token that can be used for a `CdkDrag` to provide itself as a parent to the
+ * drag-specific child directive (`CdkDragHandle`, `CdkDragPreview` etc.). Used primarily
+ * to avoid circular imports.
  * \@docs-private
- * @template T
+ * @type {?}
  */
-class DropListRef {
-    /**
-     * @param {?} element
-     * @param {?} _dragDropRegistry
-     * @param {?} _document
-     * @param {?=} _dir
-     */
-    constructor(element, _dragDropRegistry, _document, _dir) {
-        this.element = element;
-        this._dragDropRegistry = _dragDropRegistry;
-        this._dir = _dir;
-        /**
-         * Unique ID for the drop list.
-         * @deprecated No longer being used. To be removed.
-         * \@breaking-change 8.0.0
-         */
-        this.id = `cdk-drop-list-ref-${_uniqueIdCounter++}`;
-        /**
-         * Whether starting a dragging sequence from this container is disabled.
-         */
-        this.disabled = false;
-        /**
-         * Function that is used to determine whether an item
-         * is allowed to be moved into a drop container.
-         */
-        this.enterPredicate = () => true;
-        /**
-         * Emits right before dragging has started.
-         */
-        this.beforeStarted = new Subject();
-        /**
-         * Emits when the user has moved a new drag item into this container.
-         */
-        this.entered = new Subject();
-        /**
-         * Emits when the user removes an item from the container
-         * by dragging it into another container.
-         */
-        this.exited = new Subject();
-        /**
-         * Emits when the user drops an item inside the container.
-         */
-        this.dropped = new Subject();
-        /**
-         * Emits as the user is swapping items while actively dragging.
-         */
-        this.sorted = new Subject();
-        /**
-         * Whether an item in the list is being dragged.
-         */
-        this._isDragging = false;
-        /**
-         * Cache of the dimensions of all the items inside the container.
-         */
-        this._itemPositions = [];
-        /**
-         * Keeps track of the item that was last swapped with the dragged item, as
-         * well as what direction the pointer was moving in when the swap occured.
-         */
-        this._previousSwap = { drag: (/** @type {?} */ (null)), delta: 0 };
-        /**
-         * Drop lists that are connected to the current one.
-         */
-        this._siblings = [];
-        /**
-         * Direction in which the list is oriented.
-         */
-        this._orientation = 'vertical';
-        /**
-         * Connected siblings that currently have a dragged item.
-         */
-        this._activeSiblings = new Set();
-        _dragDropRegistry.registerDropContainer(this);
-        this._document = _document;
-    }
-    /**
-     * Removes the drop list functionality from the DOM element.
-     * @return {?}
-     */
-    dispose() {
-        this.beforeStarted.complete();
-        this.entered.complete();
-        this.exited.complete();
-        this.dropped.complete();
-        this.sorted.complete();
-        this._activeSiblings.clear();
-        this._dragDropRegistry.removeDropContainer(this);
-    }
-    /**
-     * Whether an item from this list is currently being dragged.
-     * @return {?}
-     */
-    isDragging() {
-        return this._isDragging;
-    }
-    /**
-     * Starts dragging an item.
-     * @return {?}
-     */
-    start() {
-        this.beforeStarted.next();
-        this._isDragging = true;
-        this._activeDraggables = this._draggables.slice();
-        this._cacheOwnPosition();
-        this._cacheItemPositions();
-        this._siblings.forEach(sibling => sibling._startReceiving(this));
-    }
-    /**
-     * Emits an event to indicate that the user moved an item into the container.
-     * @param {?} item Item that was moved into the container.
-     * @param {?} pointerX Position of the item along the X axis.
-     * @param {?} pointerY Position of the item along the Y axis.
-     * @return {?}
-     */
-    enter(item, pointerX, pointerY) {
-        this.entered.next({ item, container: this });
-        this.start();
-        // We use the coordinates of where the item entered the drop
-        // zone to figure out at which index it should be inserted.
-        /** @type {?} */
-        const newIndex = this._getItemIndexFromPointerPosition(item, pointerX, pointerY);
-        /** @type {?} */
-        const currentIndex = this._activeDraggables.indexOf(item);
-        /** @type {?} */
-        const newPositionReference = this._activeDraggables[newIndex];
-        /** @type {?} */
-        const placeholder = item.getPlaceholderElement();
-        // Since the item may be in the `activeDraggables` already (e.g. if the user dragged it
-        // into another container and back again), we have to ensure that it isn't duplicated.
-        if (currentIndex > -1) {
-            this._activeDraggables.splice(currentIndex, 1);
-        }
-        // Don't use items that are being dragged as a reference, because
-        // their element has been moved down to the bottom of the body.
-        if (newPositionReference && !this._dragDropRegistry.isDragging(newPositionReference)) {
-            /** @type {?} */
-            const element = newPositionReference.getRootElement();
-            (/** @type {?} */ (element.parentElement)).insertBefore(placeholder, element);
-            this._activeDraggables.splice(newIndex, 0, item);
-        }
-        else {
-            this.element.nativeElement.appendChild(placeholder);
-            this._activeDraggables.push(item);
-        }
-        // The transform needs to be cleared so it doesn't throw off the measurements.
-        placeholder.style.transform = '';
-        // Note that the positions were already cached when we called `start` above,
-        // but we need to refresh them since the amount of items has changed.
-        this._cacheItemPositions();
-    }
-    /**
-     * Removes an item from the container after it was dragged into another container by the user.
-     * @param {?} item Item that was dragged out.
-     * @return {?}
-     */
-    exit(item) {
-        this._reset();
-        this.exited.next({ item, container: this });
-    }
-    /**
-     * Drops an item into this container.
-     * @param {?} item Item being dropped into the container.
-     * @param {?} currentIndex Index at which the item should be inserted.
-     * @param {?} previousContainer Container from which the item got dragged in.
-     * @param {?} isPointerOverContainer Whether the user's pointer was over the
-     *    container when the item was dropped.
-     * @return {?}
-     */
-    drop(item, currentIndex, previousContainer, isPointerOverContainer) {
-        this._reset();
-        this.dropped.next({
-            item,
-            currentIndex,
-            previousIndex: previousContainer.getItemIndex(item),
-            container: this,
-            previousContainer,
-            isPointerOverContainer
-        });
-    }
+const CDK_DRAG_PARENT = new InjectionToken('CDK_DRAG_PARENT');
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Handle that can be used to drag and CdkDrag instance.
+ */
+class CdkDragHandle {
     /**
-     * Sets the draggable items that are a part of this list.
-     * @template THIS
-     * @this {THIS}
-     * @param {?} items Items that are a part of this list.
-     * @return {THIS}
+     * @param {?} element
+     * @param {?=} parentDrag
      */
-    withItems(items) {
-        (/** @type {?} */ (this))._draggables = items.slice();
-        return (/** @type {?} */ (this));
+    constructor(element, parentDrag) {
+        this.element = element;
+        /**
+         * Emits when the state of the handle has changed.
+         */
+        this._stateChanges = new Subject();
+        this._disabled = false;
+        this._parentDrag = parentDrag;
+        toggleNativeDragInteractions(element.nativeElement, false);
     }
     /**
-     * Sets the containers that are connected to this one. When two or more containers are
-     * connected, the user will be allowed to transfer items between them.
-     * @template THIS
-     * @this {THIS}
-     * @param {?} connectedTo Other containers that the current containers should be connected to.
-     * @return {THIS}
+     * Whether starting to drag through this handle is disabled.
+     * @return {?}
      */
-    connectedTo(connectedTo) {
-        (/** @type {?} */ (this))._siblings = connectedTo.slice();
-        return (/** @type {?} */ (this));
-    }
+    get disabled() { return this._disabled; }
     /**
-     * Sets the orientation of the container.
-     * @template THIS
-     * @this {THIS}
-     * @param {?} orientation New orientation for the container.
-     * @return {THIS}
+     * @param {?} value
+     * @return {?}
      */
-    withOrientation(orientation) {
-        (/** @type {?} */ (this))._orientation = orientation;
-        return (/** @type {?} */ (this));
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this._stateChanges.next(this);
     }
     /**
-     * Figures out the index of an item in the container.
-     * @param {?} item Item whose index should be determined.
      * @return {?}
      */
-    getItemIndex(item) {
-        if (!this._isDragging) {
-            return this._draggables.indexOf(item);
-        }
-        // Items are sorted always by top/left in the cache, however they flow differently in RTL.
-        // The rest of the logic still stands no matter what orientation we're in, however
-        // we need to invert the array when determining the index.
-        /** @type {?} */
-        const items = this._orientation === 'horizontal' && this._dir && this._dir.value === 'rtl' ?
-            this._itemPositions.slice().reverse() : this._itemPositions;
-        return findIndex(items, currentItem => currentItem.drag === item);
+    ngOnDestroy() {
+        this._stateChanges.complete();
     }
+}
+CdkDragHandle.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdkDragHandle]',
+                host: {
+                    'class': 'cdk-drag-handle'
+                }
+            },] },
+];
+/** @nocollapse */
+CdkDragHandle.ctorParameters = () => [
+    { type: ElementRef },
+    { type: undefined, decorators: [{ type: Inject, args: [CDK_DRAG_PARENT,] }, { type: Optional }] }
+];
+CdkDragHandle.propDecorators = {
+    disabled: [{ type: Input, args: ['cdkDragHandleDisabled',] }]
+};
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Element that will be used as a template for the placeholder of a CdkDrag when
+ * it is being dragged. The placeholder is displayed in place of the element being dragged.
+ * @template T
+ */
+class CdkDragPlaceholder {
     /**
-     * Whether the list is able to receive the item that
-     * is currently being dragged inside a connected drop list.
-     * @return {?}
+     * @param {?} templateRef
      */
-    isReceiving() {
-        return this._activeSiblings.size > 0;
+    constructor(templateRef) {
+        this.templateRef = templateRef;
     }
+}
+CdkDragPlaceholder.decorators = [
+    { type: Directive, args: [{
+                selector: 'ng-template[cdkDragPlaceholder]'
+            },] },
+];
+/** @nocollapse */
+CdkDragPlaceholder.ctorParameters = () => [
+    { type: TemplateRef }
+];
+CdkDragPlaceholder.propDecorators = {
+    data: [{ type: Input }]
+};
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Element that will be used as a template for the preview
+ * of a CdkDrag when it is being dragged.
+ * @template T
+ */
+class CdkDragPreview {
     /**
-     * Sorts an item inside the container based on its position.
-     * @param {?} item Item to be sorted.
-     * @param {?} pointerX Position of the item along the X axis.
-     * @param {?} pointerY Position of the item along the Y axis.
-     * @param {?} pointerDelta Direction in which the pointer is moving along each axis.
-     * @return {?}
+     * @param {?} templateRef
      */
-    _sortItem(item, pointerX, pointerY, pointerDelta) {
-        // Don't sort the item if it's out of range.
-        if (!this._isPointerNearDropContainer(pointerX, pointerY)) {
-            return;
-        }
-        /** @type {?} */
-        const siblings = this._itemPositions;
-        /** @type {?} */
-        const newIndex = this._getItemIndexFromPointerPosition(item, pointerX, pointerY, pointerDelta);
-        if (newIndex === -1 && siblings.length > 0) {
-            return;
-        }
-        /** @type {?} */
-        const isHorizontal = this._orientation === 'horizontal';
-        /** @type {?} */
-        const currentIndex = findIndex(siblings, currentItem => currentItem.drag === item);
-        /** @type {?} */
-        const siblingAtNewPosition = siblings[newIndex];
-        /** @type {?} */
-        const currentPosition = siblings[currentIndex].clientRect;
-        /** @type {?} */
-        const newPosition = siblingAtNewPosition.clientRect;
-        /** @type {?} */
-        const delta = currentIndex > newIndex ? 1 : -1;
-        this._previousSwap.drag = siblingAtNewPosition.drag;
-        this._previousSwap.delta = isHorizontal ? pointerDelta.x : pointerDelta.y;
-        // How many pixels the item's placeholder should be offset.
-        /** @type {?} */
-        const itemOffset = this._getItemOffsetPx(currentPosition, newPosition, delta);
-        // How many pixels all the other items should be offset.
-        /** @type {?} */
-        const siblingOffset = this._getSiblingOffsetPx(currentIndex, siblings, delta);
-        // Save the previous order of the items before moving the item to its new index.
-        // We use this to check whether an item has been moved as a result of the sorting.
-        /** @type {?} */
-        const oldOrder = siblings.slice();
-        // Shuffle the array in place.
-        moveItemInArray(siblings, currentIndex, newIndex);
-        this.sorted.next({
-            previousIndex: currentIndex,
-            currentIndex: newIndex,
-            container: this,
-            item
-        });
-        siblings.forEach((sibling, index) => {
-            // Don't do anything if the position hasn't changed.
-            if (oldOrder[index] === sibling) {
-                return;
-            }
-            /** @type {?} */
-            const isDraggedItem = sibling.drag === item;
-            /** @type {?} */
-            const offset = isDraggedItem ? itemOffset : siblingOffset;
-            /** @type {?} */
-            const elementToOffset = isDraggedItem ? item.getPlaceholderElement() :
-                sibling.drag.getRootElement();
-            // Update the offset to reflect the new position.
-            sibling.offset += offset;
-            // Since we're moving the items with a `transform`, we need to adjust their cached
-            // client rects to reflect their new position, as well as swap their positions in the cache.
-            // Note that we shouldn't use `getBoundingClientRect` here to update the cache, because the
-            // elements may be mid-animation which will give us a wrong result.
-            if (isHorizontal) {
-                // Round the transforms since some browsers will
-                // blur the elements, for sub-pixel transforms.
-                elementToOffset.style.transform = `translate3d(${Math.round(sibling.offset)}px, 0, 0)`;
-                adjustClientRect(sibling.clientRect, 0, offset);
-            }
-            else {
-                elementToOffset.style.transform = `translate3d(0, ${Math.round(sibling.offset)}px, 0)`;
-                adjustClientRect(sibling.clientRect, offset, 0);
-            }
-        });
+    constructor(templateRef) {
+        this.templateRef = templateRef;
     }
+}
+CdkDragPreview.decorators = [
+    { type: Directive, args: [{
+                selector: 'ng-template[cdkDragPreview]'
+            },] },
+];
+/** @nocollapse */
+CdkDragPreview.ctorParameters = () => [
+    { type: TemplateRef }
+];
+CdkDragPreview.propDecorators = {
+    data: [{ type: Input }]
+};
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Injection token that can be used to configure the behavior of `CdkDrag`.
+ * @type {?}
+ */
+const CDK_DRAG_CONFIG = new InjectionToken('CDK_DRAG_CONFIG', {
+    providedIn: 'root',
+    factory: CDK_DRAG_CONFIG_FACTORY
+});
+/**
+ * \@docs-private
+ * @return {?}
+ */
+function CDK_DRAG_CONFIG_FACTORY() {
+    return { dragStartThreshold: 5, pointerDirectionChangeThreshold: 5 };
+}
+/**
+ * Element that can be moved inside a CdkDropList container.
+ * @template T
+ */
+class CdkDrag {
     /**
-     * Caches the position of the drop list.
-     * @private
-     * @return {?}
+     * @param {?} element
+     * @param {?} dropContainer
+     * @param {?} _document
+     * @param {?} _ngZone
+     * @param {?} _viewContainerRef
+     * @param {?} viewportRuler
+     * @param {?} dragDropRegistry
+     * @param {?} config
+     * @param {?} _dir
+     * @param {?=} dragDrop
      */
-    _cacheOwnPosition() {
-        this._clientRect = this.element.nativeElement.getBoundingClientRect();
-    }
+    constructor(element, dropContainer, _document, _ngZone, _viewContainerRef, viewportRuler, dragDropRegistry, config, _dir, 
     /**
-     * Refreshes the position cache of the items and sibling containers.
-     * @private
-     * @return {?}
+     * @deprecated `viewportRuler` and `dragDropRegistry` parameters
+     * to be removed. Also `dragDrop` parameter to be made required.
+     * @breaking-change 8.0.0.
      */
-    _cacheItemPositions() {
-        /** @type {?} */
-        const isHorizontal = this._orientation === 'horizontal';
-        this._itemPositions = this._activeDraggables.map(drag => {
-            /** @type {?} */
-            const elementToMeasure = this._dragDropRegistry.isDragging(drag) ?
-                // If the element is being dragged, we have to measure the
-                // placeholder, because the element is hidden.
-                drag.getPlaceholderElement() :
-                drag.getRootElement();
+    dragDrop) {
+        this.element = element;
+        this.dropContainer = dropContainer;
+        this._document = _document;
+        this._ngZone = _ngZone;
+        this._viewContainerRef = _viewContainerRef;
+        this._dir = _dir;
+        this._destroyed = new Subject();
+        this._disabled = false;
+        /**
+         * Emits when the user starts dragging the item.
+         */
+        this.started = new EventEmitter();
+        /**
+         * Emits when the user has released a drag item, before any animations have started.
+         */
+        this.released = new EventEmitter();
+        /**
+         * Emits when the user stops dragging an item in the container.
+         */
+        this.ended = new EventEmitter();
+        /**
+         * Emits when the user has moved the item into a new container.
+         */
+        this.entered = new EventEmitter();
+        /**
+         * Emits when the user removes the item its container by dragging it into another container.
+         */
+        this.exited = new EventEmitter();
+        /**
+         * Emits when the user drops the item inside a container.
+         */
+        this.dropped = new EventEmitter();
+        /**
+         * 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((observer) => {
             /** @type {?} */
-            const clientRect = elementToMeasure.getBoundingClientRect();
-            return {
-                drag,
-                offset: 0,
-                // We need to clone the `clientRect` here, because all the values on it are readonly
-                // and we need to be able to update them. Also we can't use a spread here, because
-                // the values on a `ClientRect` aren't own properties. See:
-                // https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect#Notes
-                clientRect: {
-                    top: clientRect.top,
-                    right: clientRect.right,
-                    bottom: clientRect.bottom,
-                    left: clientRect.left,
-                    width: clientRect.width,
-                    height: clientRect.height
-                }
+            const subscription = this._dragRef.moved.pipe(map(movedEvent => ({
+                source: this,
+                pointerPosition: movedEvent.pointerPosition,
+                event: movedEvent.event,
+                delta: movedEvent.delta
+            }))).subscribe(observer);
+            return () => {
+                subscription.unsubscribe();
             };
-        }).sort((a, b) => {
-            return isHorizontal ? a.clientRect.left - b.clientRect.left :
-                a.clientRect.top - b.clientRect.top;
         });
+        // @breaking-change 8.0.0 Remove null check once the paramter is made required.
+        if (dragDrop) {
+            this._dragRef = dragDrop.createDrag(element, config);
+        }
+        else {
+            this._dragRef = new DragRef(element, config, _document, _ngZone, viewportRuler, dragDropRegistry);
+        }
+        this._dragRef.data = this;
+        this._syncInputs(this._dragRef);
+        this._proxyEvents(this._dragRef);
     }
     /**
-     * Resets the container to its initial state.
-     * @private
+     * Whether starting to drag this element is disabled.
      * @return {?}
      */
-    _reset() {
-        this._isDragging = false;
-        // TODO(crisbeto): may have to wait for the animations to finish.
-        this._activeDraggables.forEach(item => item.getRootElement().style.transform = '');
-        this._siblings.forEach(sibling => sibling._stopReceiving(this));
-        this._activeDraggables = [];
-        this._itemPositions = [];
-        this._previousSwap.drag = null;
-        this._previousSwap.delta = 0;
+    get disabled() {
+        return this._disabled || (this.dropContainer && this.dropContainer.disabled);
     }
     /**
-     * Gets the offset in pixels by which the items that aren't being dragged should be moved.
-     * @private
-     * @param {?} currentIndex Index of the item currently being dragged.
-     * @param {?} siblings All of the items in the list.
-     * @param {?} delta Direction in which the user is moving.
+     * @param {?} value
      * @return {?}
      */
-    _getSiblingOffsetPx(currentIndex, siblings, delta) {
-        /** @type {?} */
-        const isHorizontal = this._orientation === 'horizontal';
-        /** @type {?} */
-        const currentPosition = siblings[currentIndex].clientRect;
-        /** @type {?} */
-        const immediateSibling = siblings[currentIndex + delta * -1];
-        /** @type {?} */
-        let siblingOffset = currentPosition[isHorizontal ? 'width' : 'height'] * delta;
-        if (immediateSibling) {
-            /** @type {?} */
-            const start = isHorizontal ? 'left' : 'top';
-            /** @type {?} */
-            const end = isHorizontal ? 'right' : 'bottom';
-            // Get the spacing between the start of the current item and the end of the one immediately
-            // after it in the direction in which the user is dragging, or vice versa. We add it to the
-            // offset in order to push the element to where it will be when it's inline and is influenced
-            // by the `margin` of its siblings.
-            if (delta === -1) {
-                siblingOffset -= immediateSibling.clientRect[start] - currentPosition[end];
-            }
-            else {
-                siblingOffset += currentPosition[start] - immediateSibling.clientRect[end];
-            }
-        }
-        return siblingOffset;
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this._dragRef.disabled = this._disabled;
     }
     /**
-     * Checks whether the pointer coordinates are close to the drop container.
-     * @private
-     * @param {?} pointerX Coordinates along the X axis.
-     * @param {?} pointerY Coordinates along the Y axis.
+     * Returns the element that is being used as a placeholder
+     * while the current element is being dragged.
      * @return {?}
      */
-    _isPointerNearDropContainer(pointerX, pointerY) {
-        const { top, right, bottom, left, width, height } = this._clientRect;
-        /** @type {?} */
-        const xThreshold = width * DROP_PROXIMITY_THRESHOLD;
-        /** @type {?} */
-        const yThreshold = height * DROP_PROXIMITY_THRESHOLD;
-        return pointerY > top - yThreshold && pointerY < bottom + yThreshold &&
-            pointerX > left - xThreshold && pointerX < right + xThreshold;
+    getPlaceholderElement() {
+        return this._dragRef.getPlaceholderElement();
     }
     /**
-     * Gets the offset in pixels by which the item that is being dragged should be moved.
-     * @private
-     * @param {?} currentPosition Current position of the item.
-     * @param {?} newPosition Position of the item where the current item should be moved.
-     * @param {?} delta Direction in which the user is moving.
+     * Returns the root draggable element.
      * @return {?}
      */
-    _getItemOffsetPx(currentPosition, newPosition, delta) {
-        /** @type {?} */
-        const isHorizontal = this._orientation === 'horizontal';
-        /** @type {?} */
-        let itemOffset = isHorizontal ? newPosition.left - currentPosition.left :
-            newPosition.top - currentPosition.top;
-        // Account for differences in the item width/height.
-        if (delta === -1) {
-            itemOffset += isHorizontal ? newPosition.width - currentPosition.width :
-                newPosition.height - currentPosition.height;
-        }
-        return itemOffset;
+    getRootElement() {
+        return this._dragRef.getRootElement();
     }
     /**
-     * Gets the index of an item in the drop container, based on the position of the user's pointer.
-     * @private
-     * @param {?} item Item that is being sorted.
-     * @param {?} pointerX Position of the user's pointer along the X axis.
-     * @param {?} pointerY Position of the user's pointer along the Y axis.
-     * @param {?=} delta Direction in which the user is moving their pointer.
+     * Resets a standalone drag item to its initial position.
      * @return {?}
      */
-    _getItemIndexFromPointerPosition(item, pointerX, pointerY, delta) {
-        /** @type {?} */
-        const isHorizontal = this._orientation === 'horizontal';
-        return findIndex(this._itemPositions, ({ drag, clientRect }, _, array) => {
-            if (drag === item) {
-                // If there's only one item left in the container, it must be
-                // the dragged item itself so we use it as a reference.
-                return array.length < 2;
-            }
-            if (delta) {
+    reset() {
+        this._dragRef.reset();
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        // We need to wait for the zone to stabilize, in order for the reference
+        // element to be in the proper place in the DOM. This is mostly relevant
+        // for draggable elements inside portals since they get stamped out in
+        // their original DOM position and then they get transferred to the portal.
+        this._ngZone.onStable.asObservable()
+            .pipe(take(1), takeUntil(this._destroyed))
+            .subscribe(() => {
+            this._updateRootElement();
+            // Listen for any newly-added handles.
+            this._handles.changes.pipe(startWith(this._handles), 
+            // Sync the new handles with the DragRef.
+            tap((handles) => {
                 /** @type {?} */
-                const direction = isHorizontal ? delta.x : delta.y;
-                // If the user is still hovering over the same item as last time, and they didn't change
-                // the direction in which they're dragging, we don't consider it a direction swap.
-                if (drag === this._previousSwap.drag && direction === this._previousSwap.delta) {
-                    return false;
-                }
-            }
-            return isHorizontal ?
-                // Round these down since most browsers report client rects with
-                // sub-pixel precision, whereas the pointer coordinates are rounded to pixels.
-                pointerX >= Math.floor(clientRect.left) && pointerX <= Math.floor(clientRect.right) :
-                pointerY >= Math.floor(clientRect.top) && pointerY <= Math.floor(clientRect.bottom);
+                const childHandleElements = handles
+                    .filter(handle => handle._parentDrag === this)
+                    .map(handle => handle.element);
+                this._dragRef.withHandles(childHandleElements);
+            }), 
+            // Listen if the state of any of the handles changes.
+            switchMap((handles) => {
+                return merge(...handles.map(item => item._stateChanges));
+            }), takeUntil(this._destroyed)).subscribe(handleInstance => {
+                // Enabled/disable the handle that changed in the DragRef.
+                /** @type {?} */
+                const dragRef = this._dragRef;
+                /** @type {?} */
+                const handle = handleInstance.element.nativeElement;
+                handleInstance.disabled ? dragRef.disableHandle(handle) : dragRef.enableHandle(handle);
+            });
         });
     }
     /**
-     * Checks whether the user's pointer is positioned over the container.
-     * @param {?} x Pointer position along the X axis.
-     * @param {?} y Pointer position along the Y axis.
+     * @param {?} changes
      * @return {?}
      */
-    _isOverContainer(x, y) {
-        return isInsideClientRect(this._clientRect, x, y);
+    ngOnChanges(changes) {
+        /** @type {?} */
+        const rootSelectorChange = changes.rootElementSelector;
+        // We don't have to react to the first change since it's being
+        // handled in `ngAfterViewInit` where it needs to be deferred.
+        if (rootSelectorChange && !rootSelectorChange.firstChange) {
+            this._updateRootElement();
+        }
     }
     /**
-     * Figures out whether an item should be moved into a sibling
-     * drop container, based on its current position.
-     * @param {?} item Drag item that is being moved.
-     * @param {?} x Position of the item along the X axis.
-     * @param {?} y Position of the item along the Y axis.
      * @return {?}
      */
-    _getSiblingContainerFromPosition(item, x, y) {
-        return this._siblings.find(sibling => sibling._canReceive(item, x, y));
+    ngOnDestroy() {
+        this._destroyed.next();
+        this._destroyed.complete();
+        this._dragRef.dispose();
     }
     /**
-     * Checks whether the drop list can receive the passed-in item.
-     * @param {?} item Item that is being dragged into the list.
-     * @param {?} x Position of the item along the X axis.
-     * @param {?} y Position of the item along the Y axis.
+     * Syncs the root element with the `DragRef`.
+     * @private
      * @return {?}
      */
-    _canReceive(item, x, y) {
-        if (!this.enterPredicate(item, this) || !isInsideClientRect(this._clientRect, x, y)) {
-            return false;
-        }
-        /** @type {?} */
-        const elementFromPoint = this._document.elementFromPoint(x, y);
-        // If there's no element at the pointer position, then
-        // the client rect is probably scrolled out of the view.
-        if (!elementFromPoint) {
-            return false;
-        }
+    _updateRootElement() {
         /** @type {?} */
         const element = this.element.nativeElement;
-        // The `ClientRect`, that we're using to find the container over which the user is
-        // hovering, doesn't give us any information on whether the element has been scrolled
-        // out of the view or whether it's overlapping with other containers. This means that
-        // we could end up transferring the item into a container that's invisible or is positioned
-        // below another one. We use the result from `elementFromPoint` to get the top-most element
-        // at the pointer position and to find whether it's one of the intersecting drop containers.
-        return elementFromPoint === element || element.contains(elementFromPoint);
+        /** @type {?} */
+        const rootElement = this.rootElementSelector ?
+            getClosestMatchingAncestor(element, this.rootElementSelector) : element;
+        if (rootElement && rootElement.nodeType !== this._document.ELEMENT_NODE) {
+            throw Error(`cdkDrag must be attached to an element node. ` +
+                `Currently attached to "${rootElement.nodeName}".`);
+        }
+        this._dragRef.withRootElement(rootElement || element);
     }
     /**
-     * Called by one of the connected drop lists when a dragging sequence has started.
-     * @param {?} sibling Sibling in which dragging has started.
+     * Gets the boundary element, based on the `boundaryElementSelector`.
+     * @private
      * @return {?}
      */
-    _startReceiving(sibling) {
+    _getBoundaryElement() {
         /** @type {?} */
-        const activeSiblings = this._activeSiblings;
-        if (!activeSiblings.has(sibling)) {
-            activeSiblings.add(sibling);
-            this._cacheOwnPosition();
-        }
+        const selector = this.boundaryElementSelector;
+        return selector ? getClosestMatchingAncestor(this.element.nativeElement, selector) : null;
     }
     /**
-     * Called by a connected drop list when dragging has stopped.
-     * @param {?} sibling Sibling whose dragging has stopped.
+     * Syncs the inputs of the CdkDrag with the options of the underlying DragRef.
+     * @private
+     * @param {?} ref
      * @return {?}
      */
-    _stopReceiving(sibling) {
-        this._activeSiblings.delete(sibling);
+    _syncInputs(ref) {
+        ref.beforeStarted.subscribe(() => {
+            if (!ref.isDragging()) {
+                /** @type {?} */
+                const dir = this._dir;
+                /** @type {?} */
+                const placeholder = this._placeholderTemplate ? {
+                    template: this._placeholderTemplate.templateRef,
+                    context: this._placeholderTemplate.data,
+                    viewContainer: this._viewContainerRef
+                } : null;
+                /** @type {?} */
+                const preview = this._previewTemplate ? {
+                    template: this._previewTemplate.templateRef,
+                    context: this._previewTemplate.data,
+                    viewContainer: this._viewContainerRef
+                } : null;
+                ref.disabled = this.disabled;
+                ref.lockAxis = this.lockAxis;
+                ref
+                    .withBoundaryElement(this._getBoundaryElement())
+                    .withPlaceholderTemplate(placeholder)
+                    .withPreviewTemplate(preview);
+                if (dir) {
+                    ref.withDirection(dir.value);
+                }
+            }
+        });
+    }
+    /**
+     * Proxies the events from a DragRef to events that
+     * match the interfaces of the CdkDrag outputs.
+     * @private
+     * @param {?} ref
+     * @return {?}
+     */
+    _proxyEvents(ref) {
+        ref.started.subscribe(() => {
+            this.started.emit({ source: this });
+        });
+        ref.released.subscribe(() => {
+            this.released.emit({ source: this });
+        });
+        ref.ended.subscribe(() => {
+            this.ended.emit({ source: this });
+        });
+        ref.entered.subscribe(event => {
+            this.entered.emit({
+                container: event.container.data,
+                item: this
+            });
+        });
+        ref.exited.subscribe(event => {
+            this.exited.emit({
+                container: event.container.data,
+                item: this
+            });
+        });
+        ref.dropped.subscribe(event => {
+            this.dropped.emit({
+                previousIndex: event.previousIndex,
+                currentIndex: event.currentIndex,
+                previousContainer: event.previousContainer.data,
+                container: event.container.data,
+                isPointerOverContainer: event.isPointerOverContainer,
+                item: this
+            });
+        });
     }
 }
+CdkDrag.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdkDrag]',
+                exportAs: 'cdkDrag',
+                host: {
+                    'class': 'cdk-drag',
+                    '[class.cdk-drag-dragging]': '_dragRef.isDragging()',
+                },
+                providers: [{ provide: CDK_DRAG_PARENT, useExisting: CdkDrag }]
+            },] },
+];
+/** @nocollapse */
+CdkDrag.ctorParameters = () => [
+    { type: ElementRef },
+    { type: undefined, decorators: [{ type: Inject, args: [CDK_DROP_LIST,] }, { type: Optional }, { type: SkipSelf }] },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: NgZone },
+    { type: ViewContainerRef },
+    { type: ViewportRuler },
+    { type: DragDropRegistry },
+    { type: undefined, decorators: [{ type: Inject, args: [CDK_DRAG_CONFIG,] }] },
+    { type: Directionality, decorators: [{ type: Optional }] },
+    { type: DragDrop }
+];
+CdkDrag.propDecorators = {
+    _handles: [{ type: ContentChildren, args: [CdkDragHandle, { descendants: true },] }],
+    _previewTemplate: [{ type: ContentChild, args: [CdkDragPreview,] }],
+    _placeholderTemplate: [{ type: ContentChild, args: [CdkDragPlaceholder,] }],
+    data: [{ type: Input, args: ['cdkDragData',] }],
+    lockAxis: [{ type: Input, args: ['cdkDragLockAxis',] }],
+    rootElementSelector: [{ type: Input, args: ['cdkDragRootElement',] }],
+    boundaryElementSelector: [{ type: Input, args: ['cdkDragBoundary',] }],
+    disabled: [{ type: Input, args: ['cdkDragDisabled',] }],
+    started: [{ type: Output, args: ['cdkDragStarted',] }],
+    released: [{ type: Output, args: ['cdkDragReleased',] }],
+    ended: [{ type: Output, args: ['cdkDragEnded',] }],
+    entered: [{ type: Output, args: ['cdkDragEntered',] }],
+    exited: [{ type: Output, args: ['cdkDragExited',] }],
+    dropped: [{ type: Output, args: ['cdkDragDropped',] }],
+    moved: [{ type: Output, args: ['cdkDragMoved',] }]
+};
 /**
- * Updates the top/left positions of a `ClientRect`, as well as their bottom/right counterparts.
- * @param {?} clientRect `ClientRect` that should be updated.
- * @param {?} top Amount to add to the `top` position.
- * @param {?} left Amount to add to the `left` position.
- * @return {?}
- */
-function adjustClientRect(clientRect, top, left) {
-    clientRect.top += top;
-    clientRect.bottom = clientRect.top + clientRect.height;
-    clientRect.left += left;
-    clientRect.right = clientRect.left + clientRect.width;
-}
-/**
- * Finds the index of an item that matches a predicate function. Used as an equivalent
- * of `Array.prototype.find` which isn't part of the standard Google typings.
- * @template T
- * @param {?} array Array in which to look for matches.
- * @param {?} predicate Function used to determine whether an item is a match.
+ * Gets the closest ancestor of an element that matches a selector.
+ * @param {?} element
+ * @param {?} selector
  * @return {?}
  */
-function findIndex(array, predicate) {
-    for (let i = 0; i < array.length; i++) {
-        if (predicate(array[i], i, array)) {
-            return i;
+function getClosestMatchingAncestor(element, selector) {
+    /** @type {?} */
+    let currentElement = (/** @type {?} */ (element.parentElement));
+    while (currentElement) {
+        // IE doesn't support `matches` so we have to fall back to `msMatchesSelector`.
+        if (currentElement.matches ? currentElement.matches(selector) :
+            ((/** @type {?} */ (currentElement))).msMatchesSelector(selector)) {
+            return currentElement;
         }
+        currentElement = currentElement.parentElement;
     }
-    return -1;
+    return null;
 }
+
 /**
- * Checks whether some coordinates are within a `ClientRect`.
- * @param {?} clientRect ClientRect that is being checked.
- * @param {?} x Coordinates along the X axis.
- * @param {?} y Coordinates along the Y axis.
- * @return {?}
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
-function isInsideClientRect(clientRect, x, y) {
-    const { top, bottom, left, right } = clientRect;
-    return y >= top && y <= bottom && x >= left && x <= right;
+/**
+ * Declaratively connects sibling `cdkDropList` instances together. All of the `cdkDropList`
+ * elements that are placed inside a `cdkDropListGroup` will be connected to each other
+ * automatically. Can be used as an alternative to the `cdkDropListConnectedTo` input
+ * from `cdkDropList`.
+ * @template T
+ */
+class CdkDropListGroup {
+    constructor() {
+        /**
+         * Drop lists registered inside the group.
+         */
+        this._items = new Set();
+        this._disabled = false;
+    }
+    /**
+     * Whether starting a dragging sequence from inside this group is disabled.
+     * @return {?}
+     */
+    get disabled() { return this._disabled; }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this._items.clear();
+    }
 }
+CdkDropListGroup.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdkDropListGroup]',
+                exportAs: 'cdkDropListGroup',
+            },] },
+];
+CdkDropListGroup.propDecorators = {
+    disabled: [{ type: Input, args: ['cdkDropListGroupDisabled',] }]
+};
 
 /**
  * @fileoverview added by tsickle
@@ -2532,16 +2649,26 @@ class CdkDropList {
      * @param {?} element
      * @param {?} dragDropRegistry
      * @param {?} _changeDetectorRef
-     * @param {?=} dir
+     * @param {?=} _dir
      * @param {?=} _group
      * @param {?=} _document
+     * @param {?=} dragDrop
+     */
+    constructor(element, dragDropRegistry, _changeDetectorRef, _dir, _group, _document, 
+    /**
+     * @deprecated `dragDropRegistry` and `_document` parameters to be removed.
+     * Also `dragDrop` parameter to be made required.
+     * @breaking-change 8.0.0.
      */
-    constructor(element, dragDropRegistry, _changeDetectorRef, dir, _group, 
-    // @breaking-change 8.0.0 `_document` parameter to be made required.
-    _document) {
+    dragDrop) {
         this.element = element;
         this._changeDetectorRef = _changeDetectorRef;
+        this._dir = _dir;
         this._group = _group;
+        /**
+         * Emits when the list has been destroyed.
+         */
+        this._destroyed = new Subject();
         /**
          * Other draggable containers that this container is connected to and into which the
          * container's items can be transferred. Can either be references to other drop containers,
@@ -2580,15 +2707,19 @@ class CdkDropList {
          * Emits as the user is swapping items while actively dragging.
          */
         this.sorted = new EventEmitter();
-        // @breaking-change 8.0.0 Remove || once `_document` parameter is required.
-        /** @type {?} */
-        const ref = this._dropListRef = new DropListRef(element, dragDropRegistry, _document || document, dir);
-        ref.data = this;
-        ref.enterPredicate = (drag, drop) => {
+        // @breaking-change 8.0.0 Remove null check once `dragDrop` parameter is made required.
+        if (dragDrop) {
+            this._dropListRef = dragDrop.createDropList(element);
+        }
+        else {
+            this._dropListRef = new DropListRef(element, dragDropRegistry, _document || document);
+        }
+        this._dropListRef.data = this;
+        this._dropListRef.enterPredicate = (drag, drop) => {
             return this.enterPredicate(drag.data, drop.data);
         };
-        this._syncInputs(ref);
-        this._handleEvents(ref);
+        this._syncInputs(this._dropListRef);
+        this._handleEvents(this._dropListRef);
         CdkDropList._dropLists.push(this);
         if (_group) {
             _group._items.add(this);
@@ -2608,19 +2739,31 @@ class CdkDropList {
     set disabled(value) {
         this._disabled = coerceBooleanProperty(value);
     }
+    /**
+     * @return {?}
+     */
+    ngAfterContentInit() {
+        this._draggables.changes
+            .pipe(startWith(this._draggables), takeUntil(this._destroyed))
+            .subscribe((items) => {
+            this._dropListRef.withItems(items.map(drag => drag._dragRef));
+        });
+    }
     /**
      * @return {?}
      */
     ngOnDestroy() {
         /** @type {?} */
         const index = CdkDropList._dropLists.indexOf(this);
-        this._dropListRef.dispose();
         if (index > -1) {
             CdkDropList._dropLists.splice(index, 1);
         }
         if (this._group) {
             this._group._items.delete(this);
         }
+        this._dropListRef.dispose();
+        this._destroyed.next();
+        this._destroyed.complete();
     }
     /**
      * Starts dragging an item.
@@ -2707,6 +2850,11 @@ class CdkDropList {
      * @return {?}
      */
     _syncInputs(ref) {
+        if (this._dir) {
+            this._dir.change
+                .pipe(startWith(this._dir.value), takeUntil(this._destroyed))
+                .subscribe(value => ref.withDirection(value));
+        }
         ref.beforeStarted.subscribe(() => {
             /** @type {?} */
             const siblings = coerceArray(this.connectedTo).map(drop => {
@@ -2723,8 +2871,7 @@ class CdkDropList {
             ref.lockAxis = this.lockAxis;
             ref
                 .connectedTo(siblings.filter(drop => drop && drop !== this).map(list => list._dropListRef))
-                .withOrientation(this.orientation)
-                .withItems(this._draggables.map(drag => drag._dragRef));
+                .withOrientation(this.orientation);
         });
     }
     /**
@@ -2800,10 +2947,15 @@ CdkDropList.ctorParameters = () => [
     { type: ChangeDetectorRef },
     { type: Directionality, decorators: [{ type: Optional }] },
     { type: CdkDropListGroup, decorators: [{ type: Optional }, { type: SkipSelf }] },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] },
+    { type: DragDrop }
 ];
 CdkDropList.propDecorators = {
-    _draggables: [{ type: ContentChildren, args: [forwardRef(() => CdkDrag),] }],
+    _draggables: [{ type: ContentChildren, args: [forwardRef(() => CdkDrag), {
+                    // Explicitly set to false since some of the logic below makes assumptions about it.
+                    // The `.withItems` call below should be updated if we ever need to switch this to `true`.
+                    descendants: false
+                },] }],
     connectedTo: [{ type: Input, args: ['cdkDropListConnectedTo',] }],
     data: [{ type: Input, args: ['cdkDropListData',] }],
     orientation: [{ type: Input, args: ['cdkDropListOrientation',] }],
@@ -2841,6 +2993,9 @@ DragDropModule.decorators = [
                     CdkDragPreview,
                     CdkDragPlaceholder,
                 ],
+                providers: [
+                    DragDrop,
+                ]
             },] },
 ];
 
@@ -2854,5 +3009,5 @@ DragDropModule.decorators = [
  * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
-export { CDK_DROP_LIST, CDK_DROP_LIST_CONTAINER, moveItemInArray, transferArrayItem, copyArrayItem, DragDropModule, DragDropRegistry, CdkDropList, CdkDropListGroup, CDK_DRAG_CONFIG_FACTORY, CDK_DRAG_CONFIG, CdkDrag, CdkDragHandle, CdkDragPreview, CdkDragPlaceholder, CDK_DRAG_PARENT as ɵa };
+export { DragDrop, DragRef, DropListRef, CdkDropList, CDK_DROP_LIST, CDK_DROP_LIST_CONTAINER, moveItemInArray, transferArrayItem, copyArrayItem, DragDropModule, DragDropRegistry, CdkDropListGroup, CDK_DRAG_CONFIG_FACTORY, CDK_DRAG_CONFIG, CdkDrag, CdkDragHandle, CdkDragPreview, CdkDragPlaceholder, CDK_DRAG_PARENT as ɵb };
 //# sourceMappingURL=drag-drop.js.map