@kato-lee/cdk 14.2.7

package/esm2020/drag-drop/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL2RyYWctZHJvcC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/drag-drop/public-api.mjs

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export { DragDrop } from './drag-drop';
+export { DragRef } from './drag-ref';
+export { DropListRef } from './drop-list-ref';
+export { CDK_DRAG_PARENT } from './drag-parent';
+export * from './drag-events';
+export * from './drag-utils';
+export * from './drag-drop-module';
+export * from './drag-drop-registry';
+export { CdkDropList, CDK_DROP_LIST } from './directives/drop-list';
+export * from './directives/config';
+export * from './directives/drop-list-group';
+export * from './directives/drag';
+export * from './directives/drag-handle';
+export * from './directives/drag-preview';
+export * from './directives/drag-placeholder';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/drag-drop/sorting/drop-list-sort-strategy.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcC1saXN0LXNvcnQtc3RyYXRlZ3kuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL2RyYWctZHJvcC9zb3J0aW5nL2Ryb3AtbGlzdC1zb3J0LXN0cmF0ZWd5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0RpcmVjdGlvbn0gZnJvbSAnQGFuZ3VsYXIvY2RrL2JpZGknO1xuXG4vKipcbiAqIEZ1bmN0aW9uIHRoYXQgaXMgdXNlZCB0byBkZXRlcm1pbmUgd2hldGhlciBhbiBpdGVtIGNhbiBiZSBzb3J0ZWQgaW50byBhIHBhcnRpY3VsYXIgaW5kZXguXG4gKiBAZG9jcy1wcml2YXRlXG4gKi9cbmV4cG9ydCB0eXBlIFNvcnRQcmVkaWNhdGU8VD4gPSAoaW5kZXg6IG51bWJlciwgaXRlbTogVCkgPT4gYm9vbGVhbjtcblxuLyoqXG4gKiBJdGVtIHRoYXQgY2FuIGJlIHNvcnRlZCB3aXRoaW4gYERyb3BMaXN0U29ydFN0cmF0ZWd5YC4gVGhpcyBpcyBhIGxpbWl0ZWQgcmVwcmVzZW50YXRpb24gb2ZcbiAqIGBEcmFnUmVmYCB1c2VkIHRvIGF2b2lkIGNpcmN1bGFyIGRlcGVuZGVuY2llcy4gSXQgaXMgaW50ZW5kZWQgdG8gb25seSBiZSB1c2VkIHdpdGhpblxuICogYERyb3BMaXN0U29ydFN0cmF0ZWd5YC5cbiAqIEBkb2NzLXByaXZhdGVcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBEcm9wTGlzdFNvcnRTdHJhdGVneUl0ZW0ge1xuICBpc0RyYWdnaW5nKCk6IGJvb2xlYW47XG4gIGdldFBsYWNlaG9sZGVyRWxlbWVudCgpOiBIVE1MRWxlbWVudDtcbiAgZ2V0Um9vdEVsZW1lbnQoKTogSFRNTEVsZW1lbnQ7XG4gIF9zb3J0RnJvbUxhc3RQb2ludGVyUG9zaXRpb24oKTogdm9pZDtcbiAgZ2V0VmlzaWJsZUVsZW1lbnQoKTogSFRNTEVsZW1lbnQ7XG59XG5cbi8qKlxuICogU3RyYXRlZ3kgdXNlZCB0byBzb3J0IGFuZCBwb3NpdGlvbiBpdGVtcyB3aXRoaW4gYSBkcm9wIGxpc3QuXG4gKiBAZG9jcy1wcml2YXRlXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRHJvcExpc3RTb3J0U3RyYXRlZ3k8VCBleHRlbmRzIERyb3BMaXN0U29ydFN0cmF0ZWd5SXRlbT4ge1xuICBkaXJlY3Rpb246IERpcmVjdGlvbjtcbiAgc3RhcnQoaXRlbXM6IHJlYWRvbmx5IFRbXSk6IHZvaWQ7XG4gIHNvcnQoXG4gICAgaXRlbTogVCxcbiAgICBwb2ludGVyWDogbnVtYmVyLFxuICAgIHBvaW50ZXJZOiBudW1iZXIsXG4gICAgcG9pbnRlckRlbHRhOiB7eDogbnVtYmVyOyB5OiBudW1iZXJ9LFxuICApOiB7cHJldmlvdXNJbmRleDogbnVtYmVyOyBjdXJyZW50SW5kZXg6IG51bWJlcn0gfCBudWxsO1xuICBlbnRlcihpdGVtOiBULCBwb2ludGVyWDogbnVtYmVyLCBwb2ludGVyWTogbnVtYmVyLCBpbmRleD86IG51bWJlcik6IHZvaWQ7XG4gIHdpdGhJdGVtcyhpdGVtczogcmVhZG9ubHkgVFtdKTogdm9pZDtcbiAgd2l0aFNvcnRQcmVkaWNhdGUocHJlZGljYXRlOiBTb3J0UHJlZGljYXRlPFQ+KTogdm9pZDtcbiAgcmVzZXQoKTogdm9pZDtcbiAgZ2V0QWN0aXZlSXRlbXNTbmFwc2hvdCgpOiByZWFkb25seSBUW107XG4gIGdldEl0ZW1JbmRleChpdGVtOiBUKTogbnVtYmVyO1xuICB1cGRhdGVPblNjcm9sbCh0b3BEaWZmZXJlbmNlOiBudW1iZXIsIGxlZnREaWZmZXJlbmNlOiBudW1iZXIpOiB2b2lkO1xufVxuIl19

package/esm2020/drag-drop/sorting/single-axis-sort-strategy.mjs

@@ -0,0 +1,341 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { coerceElement } from '@kato-lee/cdk/coercion';
+import { moveItemInArray } from '../drag-utils';
+import { combineTransforms } from '../dom/styling';
+import { adjustClientRect, getMutableClientRect, isInsideClientRect } from '../dom/client-rect';
+/**
+ * Strategy that only supports sorting along a single axis.
+ * Items are reordered using CSS transforms which allows for sorting to be animated.
+ * @docs-private
+ */
+export class SingleAxisSortStrategy {
+    constructor(_element, _dragDropRegistry) {
+        this._element = _element;
+        this._dragDropRegistry = _dragDropRegistry;
+        /** Cache of the dimensions of all the items inside the container. */
+        this._itemPositions = [];
+        /** Direction in which the list is oriented. */
+        this.orientation = 'vertical';
+        /**
+         * 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 occurred and whether the user's pointer continued to
+         * overlap with the swapped item after the swapping occurred.
+         */
+        this._previousSwap = {
+            drag: null,
+            delta: 0,
+            overlaps: false,
+        };
+    }
+    /**
+     * To be called when the drag sequence starts.
+     * @param items Items that are currently in the list.
+     */
+    start(items) {
+        this.withItems(items);
+    }
+    /**
+     * To be called when an item is being sorted.
+     * @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.
+     */
+    sort(item, pointerX, pointerY, pointerDelta) {
+        const siblings = this._itemPositions;
+        const newIndex = this._getItemIndexFromPointerPosition(item, pointerX, pointerY, pointerDelta);
+        if (newIndex === -1 && siblings.length > 0) {
+            return null;
+        }
+        const isHorizontal = this.orientation === 'horizontal';
+        const currentIndex = siblings.findIndex(currentItem => currentItem.drag === item);
+        const siblingAtNewPosition = siblings[newIndex];
+        const currentPosition = siblings[currentIndex].clientRect;
+        const newPosition = siblingAtNewPosition.clientRect;
+        const delta = currentIndex > newIndex ? 1 : -1;
+        // How many pixels the item's placeholder should be offset.
+        const itemOffset = this._getItemOffsetPx(currentPosition, newPosition, delta);
+        // How many pixels all the other items should be offset.
+        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.
+        const oldOrder = siblings.slice();
+        // Shuffle the array in place.
+        moveItemInArray(siblings, currentIndex, newIndex);
+        siblings.forEach((sibling, index) => {
+            // Don't do anything if the position hasn't changed.
+            if (oldOrder[index] === sibling) {
+                return;
+            }
+            const isDraggedItem = sibling.drag === item;
+            const offset = isDraggedItem ? itemOffset : siblingOffset;
+            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 = combineTransforms(`translate3d(${Math.round(sibling.offset)}px, 0, 0)`, sibling.initialTransform);
+                adjustClientRect(sibling.clientRect, 0, offset);
+            }
+            else {
+                elementToOffset.style.transform = combineTransforms(`translate3d(0, ${Math.round(sibling.offset)}px, 0)`, sibling.initialTransform);
+                adjustClientRect(sibling.clientRect, offset, 0);
+            }
+        });
+        // Note that it's important that we do this after the client rects have been adjusted.
+        this._previousSwap.overlaps = isInsideClientRect(newPosition, pointerX, pointerY);
+        this._previousSwap.drag = siblingAtNewPosition.drag;
+        this._previousSwap.delta = isHorizontal ? pointerDelta.x : pointerDelta.y;
+        return { previousIndex: currentIndex, currentIndex: newIndex };
+    }
+    /**
+     * Called when an item is being moved 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.
+     * @param index Index at which the item entered. If omitted, the container will try to figure it
+     *   out automatically.
+     */
+    enter(item, pointerX, pointerY, index) {
+        const newIndex = index == null || index < 0
+            ? // We use the coordinates of where the item entered the drop
+                // zone to figure out at which index it should be inserted.
+                this._getItemIndexFromPointerPosition(item, pointerX, pointerY)
+            : index;
+        const activeDraggables = this._activeDraggables;
+        const currentIndex = activeDraggables.indexOf(item);
+        const placeholder = item.getPlaceholderElement();
+        let newPositionReference = activeDraggables[newIndex];
+        // If the item at the new position is the same as the item that is being dragged,
+        // it means that we're trying to restore the item to its initial position. In this
+        // case we should use the next item from the list as the reference.
+        if (newPositionReference === item) {
+            newPositionReference = activeDraggables[newIndex + 1];
+        }
+        // If we didn't find a new position reference, it means that either the item didn't start off
+        // in this container, or that the item requested to be inserted at the end of the list.
+        if (!newPositionReference &&
+            (newIndex == null || newIndex === -1 || newIndex < activeDraggables.length - 1) &&
+            this._shouldEnterAsFirstChild(pointerX, pointerY)) {
+            newPositionReference = activeDraggables[0];
+        }
+        // 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) {
+            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)) {
+            const element = newPositionReference.getRootElement();
+            element.parentElement.insertBefore(placeholder, element);
+            activeDraggables.splice(newIndex, 0, item);
+        }
+        else {
+            coerceElement(this._element).appendChild(placeholder);
+            activeDraggables.push(item);
+        }
+        // The transform needs to be cleared so it doesn't throw off the measurements.
+        placeholder.style.transform = '';
+        // Note that usually `start` is called together with `enter` when an item goes into a new
+        // container. This will cache item positions, but we need to refresh them since the amount
+        // of items has changed.
+        this._cacheItemPositions();
+    }
+    /** Sets the items that are currently part of the list. */
+    withItems(items) {
+        this._activeDraggables = items.slice();
+        this._cacheItemPositions();
+    }
+    /** Assigns a sort predicate to the strategy. */
+    withSortPredicate(predicate) {
+        this._sortPredicate = predicate;
+    }
+    /** Resets the strategy to its initial state before dragging was started. */
+    reset() {
+        // TODO(crisbeto): may have to wait for the animations to finish.
+        this._activeDraggables.forEach(item => {
+            const rootElement = item.getRootElement();
+            if (rootElement) {
+                const initialTransform = this._itemPositions.find(p => p.drag === item)?.initialTransform;
+                rootElement.style.transform = initialTransform || '';
+            }
+        });
+        this._itemPositions = [];
+        this._activeDraggables = [];
+        this._previousSwap.drag = null;
+        this._previousSwap.delta = 0;
+        this._previousSwap.overlaps = false;
+    }
+    /**
+     * Gets a snapshot of items currently in the list.
+     * Can include items that we dragged in from another list.
+     */
+    getActiveItemsSnapshot() {
+        return this._activeDraggables;
+    }
+    /** Gets the index of a specific item. */
+    getItemIndex(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.
+        const items = this.orientation === 'horizontal' && this.direction === 'rtl'
+            ? this._itemPositions.slice().reverse()
+            : this._itemPositions;
+        return items.findIndex(currentItem => currentItem.drag === item);
+    }
+    /** Used to notify the strategy that the scroll position has changed. */
+    updateOnScroll(topDifference, leftDifference) {
+        // Since we know the amount that the user has scrolled we can shift all of the
+        // client rectangles ourselves. This is cheaper than re-measuring everything and
+        // we can avoid inconsistent behavior where we might be measuring the element before
+        // its position has changed.
+        this._itemPositions.forEach(({ clientRect }) => {
+            adjustClientRect(clientRect, topDifference, leftDifference);
+        });
+        // We need two loops for this, because we want all of the cached
+        // positions to be up-to-date before we re-sort the item.
+        this._itemPositions.forEach(({ drag }) => {
+            if (this._dragDropRegistry.isDragging(drag)) {
+                // We need to re-sort the item manually, because the pointer move
+                // events won't be dispatched while the user is scrolling.
+                drag._sortFromLastPointerPosition();
+            }
+        });
+    }
+    /** Refreshes the position cache of the items and sibling containers. */
+    _cacheItemPositions() {
+        const isHorizontal = this.orientation === 'horizontal';
+        this._itemPositions = this._activeDraggables
+            .map(drag => {
+            const elementToMeasure = drag.getVisibleElement();
+            return {
+                drag,
+                offset: 0,
+                initialTransform: elementToMeasure.style.transform || '',
+                clientRect: getMutableClientRect(elementToMeasure),
+            };
+        })
+            .sort((a, b) => {
+            return isHorizontal
+                ? a.clientRect.left - b.clientRect.left
+                : a.clientRect.top - b.clientRect.top;
+        });
+    }
+    /**
+     * Gets the offset in pixels by which the item that is being dragged should be moved.
+     * @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.
+     */
+    _getItemOffsetPx(currentPosition, newPosition, delta) {
+        const isHorizontal = this.orientation === 'horizontal';
+        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;
+    }
+    /**
+     * Gets the offset in pixels by which the items that aren't being dragged should be moved.
+     * @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.
+     */
+    _getSiblingOffsetPx(currentIndex, siblings, delta) {
+        const isHorizontal = this.orientation === 'horizontal';
+        const currentPosition = siblings[currentIndex].clientRect;
+        const immediateSibling = siblings[currentIndex + delta * -1];
+        let siblingOffset = currentPosition[isHorizontal ? 'width' : 'height'] * delta;
+        if (immediateSibling) {
+            const start = isHorizontal ? 'left' : 'top';
+            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;
+    }
+    /**
+     * Checks if pointer is entering in the first position
+     * @param pointerX Position of the user's pointer along the X axis.
+     * @param pointerY Position of the user's pointer along the Y axis.
+     */
+    _shouldEnterAsFirstChild(pointerX, pointerY) {
+        if (!this._activeDraggables.length) {
+            return false;
+        }
+        const itemPositions = this._itemPositions;
+        const isHorizontal = this.orientation === 'horizontal';
+        // `itemPositions` are sorted by position while `activeDraggables` are sorted by child index
+        // check if container is using some sort of "reverse" ordering (eg: flex-direction: row-reverse)
+        const reversed = itemPositions[0].drag !== this._activeDraggables[0];
+        if (reversed) {
+            const lastItemRect = itemPositions[itemPositions.length - 1].clientRect;
+            return isHorizontal ? pointerX >= lastItemRect.right : pointerY >= lastItemRect.bottom;
+        }
+        else {
+            const firstItemRect = itemPositions[0].clientRect;
+            return isHorizontal ? pointerX <= firstItemRect.left : pointerY <= firstItemRect.top;
+        }
+    }
+    /**
+     * Gets the index of an item in the drop container, based on the position of the user's pointer.
+     * @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.
+     */
+    _getItemIndexFromPointerPosition(item, pointerX, pointerY, delta) {
+        const isHorizontal = this.orientation === 'horizontal';
+        const index = this._itemPositions.findIndex(({ drag, clientRect }) => {
+            // Skip the item itself.
+            if (drag === item) {
+                return false;
+            }
+            if (delta) {
+                const direction = isHorizontal ? delta.x : delta.y;
+                // If the user is still hovering over the same item as last time, their cursor hasn't left
+                // the item after we made the swap, 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 &&
+                    this._previousSwap.overlaps &&
+                    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);
+        });
+        return index === -1 || !this._sortPredicate(index, item) ? -1 : index;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"single-axis-sort-strategy.js","sourceRoot":"","sources":["../../../../../../../src/cdk/drag-drop/sorting/single-axis-sort-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Direction} from '@angular/cdk/bidi';\nimport {ElementRef} from '@angular/core';\nimport {coerceElement} from '@angular/cdk/coercion';\nimport {DragDropRegistry} from '../drag-drop-registry';\nimport {moveItemInArray} from '../drag-utils';\nimport {combineTransforms} from '../dom/styling';\nimport {adjustClientRect, getMutableClientRect, isInsideClientRect} from '../dom/client-rect';\nimport {\n  DropListSortStrategy,\n  DropListSortStrategyItem,\n  SortPredicate,\n} from './drop-list-sort-strategy';\n\n/**\n * Entry in the position cache for draggable items.\n * @docs-private\n */\ninterface CachedItemPosition<T> {\n  /** Instance of the drag item. */\n  drag: T;\n  /** Dimensions of the item. */\n  clientRect: ClientRect;\n  /** Amount by which the item has been moved since dragging started. */\n  offset: number;\n  /** Inline transform that the drag item had when dragging started. */\n  initialTransform: string;\n}\n\n/**\n * Strategy that only supports sorting along a single axis.\n * Items are reordered using CSS transforms which allows for sorting to be animated.\n * @docs-private\n */\nexport class SingleAxisSortStrategy<T extends DropListSortStrategyItem>\n  implements DropListSortStrategy<T>\n{\n  /** Function used to determine if an item can be sorted into a specific index. */\n  private _sortPredicate: SortPredicate<T>;\n\n  /** Cache of the dimensions of all the items inside the container. */\n  private _itemPositions: CachedItemPosition<T>[] = [];\n\n  /**\n   * Draggable items that are currently active inside the container. Includes the items\n   * that were there at the start of the sequence, as well as any items that have been dragged\n   * in, but haven't been dropped yet.\n   */\n  private _activeDraggables: T[];\n\n  /** Direction in which the list is oriented. */\n  orientation: 'vertical' | 'horizontal' = 'vertical';\n\n  /** Layout direction of the drop list. */\n  direction: Direction;\n\n  constructor(\n    private _element: HTMLElement | ElementRef<HTMLElement>,\n    private _dragDropRegistry: DragDropRegistry<T, unknown>,\n  ) {}\n\n  /**\n   * Keeps track of the item that was last swapped with the dragged item, as well as what direction\n   * the pointer was moving in when the swap occurred and whether the user's pointer continued to\n   * overlap with the swapped item after the swapping occurred.\n   */\n  private _previousSwap = {\n    drag: null as T | null,\n    delta: 0,\n    overlaps: false,\n  };\n\n  /**\n   * To be called when the drag sequence starts.\n   * @param items Items that are currently in the list.\n   */\n  start(items: readonly T[]) {\n    this.withItems(items);\n  }\n\n  /**\n   * To be called when an item is being sorted.\n   * @param item Item to be sorted.\n   * @param pointerX Position of the item along the X axis.\n   * @param pointerY Position of the item along the Y axis.\n   * @param pointerDelta Direction in which the pointer is moving along each axis.\n   */\n  sort(item: T, pointerX: number, pointerY: number, pointerDelta: {x: number; y: number}) {\n    const siblings = this._itemPositions;\n    const newIndex = this._getItemIndexFromPointerPosition(item, pointerX, pointerY, pointerDelta);\n\n    if (newIndex === -1 && siblings.length > 0) {\n      return null;\n    }\n\n    const isHorizontal = this.orientation === 'horizontal';\n    const currentIndex = siblings.findIndex(currentItem => currentItem.drag === item);\n    const siblingAtNewPosition = siblings[newIndex];\n    const currentPosition = siblings[currentIndex].clientRect;\n    const newPosition = siblingAtNewPosition.clientRect;\n    const delta = currentIndex > newIndex ? 1 : -1;\n\n    // How many pixels the item's placeholder should be offset.\n    const itemOffset = this._getItemOffsetPx(currentPosition, newPosition, delta);\n\n    // How many pixels all the other items should be offset.\n    const siblingOffset = this._getSiblingOffsetPx(currentIndex, siblings, delta);\n\n    // Save the previous order of the items before moving the item to its new index.\n    // We use this to check whether an item has been moved as a result of the sorting.\n    const oldOrder = siblings.slice();\n\n    // Shuffle the array in place.\n    moveItemInArray(siblings, currentIndex, newIndex);\n\n    siblings.forEach((sibling, index) => {\n      // Don't do anything if the position hasn't changed.\n      if (oldOrder[index] === sibling) {\n        return;\n      }\n\n      const isDraggedItem = sibling.drag === item;\n      const offset = isDraggedItem ? itemOffset : siblingOffset;\n      const elementToOffset = isDraggedItem\n        ? item.getPlaceholderElement()\n        : sibling.drag.getRootElement();\n\n      // Update the offset to reflect the new position.\n      sibling.offset += offset;\n\n      // Since we're moving the items with a `transform`, we need to adjust their cached\n      // client rects to reflect their new position, as well as swap their positions in the cache.\n      // Note that we shouldn't use `getBoundingClientRect` here to update the cache, because the\n      // elements may be mid-animation which will give us a wrong result.\n      if (isHorizontal) {\n        // Round the transforms since some browsers will\n        // blur the elements, for sub-pixel transforms.\n        elementToOffset.style.transform = combineTransforms(\n          `translate3d(${Math.round(sibling.offset)}px, 0, 0)`,\n          sibling.initialTransform,\n        );\n        adjustClientRect(sibling.clientRect, 0, offset);\n      } else {\n        elementToOffset.style.transform = combineTransforms(\n          `translate3d(0, ${Math.round(sibling.offset)}px, 0)`,\n          sibling.initialTransform,\n        );\n        adjustClientRect(sibling.clientRect, offset, 0);\n      }\n    });\n\n    // Note that it's important that we do this after the client rects have been adjusted.\n    this._previousSwap.overlaps = isInsideClientRect(newPosition, pointerX, pointerY);\n    this._previousSwap.drag = siblingAtNewPosition.drag;\n    this._previousSwap.delta = isHorizontal ? pointerDelta.x : pointerDelta.y;\n\n    return {previousIndex: currentIndex, currentIndex: newIndex};\n  }\n\n  /**\n   * Called when an item is being moved into the container.\n   * @param item Item that was moved into the container.\n   * @param pointerX Position of the item along the X axis.\n   * @param pointerY Position of the item along the Y axis.\n   * @param index Index at which the item entered. If omitted, the container will try to figure it\n   *   out automatically.\n   */\n  enter(item: T, pointerX: number, pointerY: number, index?: number): void {\n    const newIndex =\n      index == null || index < 0\n        ? // We use the coordinates of where the item entered the drop\n          // zone to figure out at which index it should be inserted.\n          this._getItemIndexFromPointerPosition(item, pointerX, pointerY)\n        : index;\n\n    const activeDraggables = this._activeDraggables;\n    const currentIndex = activeDraggables.indexOf(item);\n    const placeholder = item.getPlaceholderElement();\n    let newPositionReference: T | undefined = activeDraggables[newIndex];\n\n    // If the item at the new position is the same as the item that is being dragged,\n    // it means that we're trying to restore the item to its initial position. In this\n    // case we should use the next item from the list as the reference.\n    if (newPositionReference === item) {\n      newPositionReference = activeDraggables[newIndex + 1];\n    }\n\n    // If we didn't find a new position reference, it means that either the item didn't start off\n    // in this container, or that the item requested to be inserted at the end of the list.\n    if (\n      !newPositionReference &&\n      (newIndex == null || newIndex === -1 || newIndex < activeDraggables.length - 1) &&\n      this._shouldEnterAsFirstChild(pointerX, pointerY)\n    ) {\n      newPositionReference = activeDraggables[0];\n    }\n\n    // Since the item may be in the `activeDraggables` already (e.g. if the user dragged it\n    // into another container and back again), we have to ensure that it isn't duplicated.\n    if (currentIndex > -1) {\n      activeDraggables.splice(currentIndex, 1);\n    }\n\n    // Don't use items that are being dragged as a reference, because\n    // their element has been moved down to the bottom of the body.\n    if (newPositionReference && !this._dragDropRegistry.isDragging(newPositionReference)) {\n      const element = newPositionReference.getRootElement();\n      element.parentElement!.insertBefore(placeholder, element);\n      activeDraggables.splice(newIndex, 0, item);\n    } else {\n      coerceElement(this._element).appendChild(placeholder);\n      activeDraggables.push(item);\n    }\n\n    // The transform needs to be cleared so it doesn't throw off the measurements.\n    placeholder.style.transform = '';\n\n    // Note that usually `start` is called together with `enter` when an item goes into a new\n    // container. This will cache item positions, but we need to refresh them since the amount\n    // of items has changed.\n    this._cacheItemPositions();\n  }\n\n  /** Sets the items that are currently part of the list. */\n  withItems(items: readonly T[]): void {\n    this._activeDraggables = items.slice();\n    this._cacheItemPositions();\n  }\n\n  /** Assigns a sort predicate to the strategy. */\n  withSortPredicate(predicate: SortPredicate<T>): void {\n    this._sortPredicate = predicate;\n  }\n\n  /** Resets the strategy to its initial state before dragging was started. */\n  reset() {\n    // TODO(crisbeto): may have to wait for the animations to finish.\n    this._activeDraggables.forEach(item => {\n      const rootElement = item.getRootElement();\n\n      if (rootElement) {\n        const initialTransform = this._itemPositions.find(p => p.drag === item)?.initialTransform;\n        rootElement.style.transform = initialTransform || '';\n      }\n    });\n\n    this._itemPositions = [];\n    this._activeDraggables = [];\n    this._previousSwap.drag = null;\n    this._previousSwap.delta = 0;\n    this._previousSwap.overlaps = false;\n  }\n\n  /**\n   * Gets a snapshot of items currently in the list.\n   * Can include items that we dragged in from another list.\n   */\n  getActiveItemsSnapshot(): readonly T[] {\n    return this._activeDraggables;\n  }\n\n  /** Gets the index of a specific item. */\n  getItemIndex(item: T): number {\n    // Items are sorted always by top/left in the cache, however they flow differently in RTL.\n    // The rest of the logic still stands no matter what orientation we're in, however\n    // we need to invert the array when determining the index.\n    const items =\n      this.orientation === 'horizontal' && this.direction === 'rtl'\n        ? this._itemPositions.slice().reverse()\n        : this._itemPositions;\n\n    return items.findIndex(currentItem => currentItem.drag === item);\n  }\n\n  /** Used to notify the strategy that the scroll position has changed. */\n  updateOnScroll(topDifference: number, leftDifference: number) {\n    // Since we know the amount that the user has scrolled we can shift all of the\n    // client rectangles ourselves. This is cheaper than re-measuring everything and\n    // we can avoid inconsistent behavior where we might be measuring the element before\n    // its position has changed.\n    this._itemPositions.forEach(({clientRect}) => {\n      adjustClientRect(clientRect, topDifference, leftDifference);\n    });\n\n    // We need two loops for this, because we want all of the cached\n    // positions to be up-to-date before we re-sort the item.\n    this._itemPositions.forEach(({drag}) => {\n      if (this._dragDropRegistry.isDragging(drag)) {\n        // We need to re-sort the item manually, because the pointer move\n        // events won't be dispatched while the user is scrolling.\n        drag._sortFromLastPointerPosition();\n      }\n    });\n  }\n\n  /** Refreshes the position cache of the items and sibling containers. */\n  private _cacheItemPositions() {\n    const isHorizontal = this.orientation === 'horizontal';\n\n    this._itemPositions = this._activeDraggables\n      .map(drag => {\n        const elementToMeasure = drag.getVisibleElement();\n        return {\n          drag,\n          offset: 0,\n          initialTransform: elementToMeasure.style.transform || '',\n          clientRect: getMutableClientRect(elementToMeasure),\n        };\n      })\n      .sort((a, b) => {\n        return isHorizontal\n          ? a.clientRect.left - b.clientRect.left\n          : a.clientRect.top - b.clientRect.top;\n      });\n  }\n\n  /**\n   * Gets the offset in pixels by which the item that is being dragged should be moved.\n   * @param currentPosition Current position of the item.\n   * @param newPosition Position of the item where the current item should be moved.\n   * @param delta Direction in which the user is moving.\n   */\n  private _getItemOffsetPx(currentPosition: ClientRect, newPosition: ClientRect, delta: 1 | -1) {\n    const isHorizontal = this.orientation === 'horizontal';\n    let itemOffset = isHorizontal\n      ? newPosition.left - currentPosition.left\n      : newPosition.top - currentPosition.top;\n\n    // Account for differences in the item width/height.\n    if (delta === -1) {\n      itemOffset += isHorizontal\n        ? newPosition.width - currentPosition.width\n        : newPosition.height - currentPosition.height;\n    }\n\n    return itemOffset;\n  }\n\n  /**\n   * Gets the offset in pixels by which the items that aren't being dragged should be moved.\n   * @param currentIndex Index of the item currently being dragged.\n   * @param siblings All of the items in the list.\n   * @param delta Direction in which the user is moving.\n   */\n  private _getSiblingOffsetPx(\n    currentIndex: number,\n    siblings: CachedItemPosition<T>[],\n    delta: 1 | -1,\n  ) {\n    const isHorizontal = this.orientation === 'horizontal';\n    const currentPosition = siblings[currentIndex].clientRect;\n    const immediateSibling = siblings[currentIndex + delta * -1];\n    let siblingOffset = currentPosition[isHorizontal ? 'width' : 'height'] * delta;\n\n    if (immediateSibling) {\n      const start = isHorizontal ? 'left' : 'top';\n      const end = isHorizontal ? 'right' : 'bottom';\n\n      // Get the spacing between the start of the current item and the end of the one immediately\n      // after it in the direction in which the user is dragging, or vice versa. We add it to the\n      // offset in order to push the element to where it will be when it's inline and is influenced\n      // by the `margin` of its siblings.\n      if (delta === -1) {\n        siblingOffset -= immediateSibling.clientRect[start] - currentPosition[end];\n      } else {\n        siblingOffset += currentPosition[start] - immediateSibling.clientRect[end];\n      }\n    }\n\n    return siblingOffset;\n  }\n\n  /**\n   * Checks if pointer is entering in the first position\n   * @param pointerX Position of the user's pointer along the X axis.\n   * @param pointerY Position of the user's pointer along the Y axis.\n   */\n  private _shouldEnterAsFirstChild(pointerX: number, pointerY: number) {\n    if (!this._activeDraggables.length) {\n      return false;\n    }\n\n    const itemPositions = this._itemPositions;\n    const isHorizontal = this.orientation === 'horizontal';\n\n    // `itemPositions` are sorted by position while `activeDraggables` are sorted by child index\n    // check if container is using some sort of \"reverse\" ordering (eg: flex-direction: row-reverse)\n    const reversed = itemPositions[0].drag !== this._activeDraggables[0];\n    if (reversed) {\n      const lastItemRect = itemPositions[itemPositions.length - 1].clientRect;\n      return isHorizontal ? pointerX >= lastItemRect.right : pointerY >= lastItemRect.bottom;\n    } else {\n      const firstItemRect = itemPositions[0].clientRect;\n      return isHorizontal ? pointerX <= firstItemRect.left : pointerY <= firstItemRect.top;\n    }\n  }\n\n  /**\n   * Gets the index of an item in the drop container, based on the position of the user's pointer.\n   * @param item Item that is being sorted.\n   * @param pointerX Position of the user's pointer along the X axis.\n   * @param pointerY Position of the user's pointer along the Y axis.\n   * @param delta Direction in which the user is moving their pointer.\n   */\n  private _getItemIndexFromPointerPosition(\n    item: T,\n    pointerX: number,\n    pointerY: number,\n    delta?: {x: number; y: number},\n  ): number {\n    const isHorizontal = this.orientation === 'horizontal';\n    const index = this._itemPositions.findIndex(({drag, clientRect}) => {\n      // Skip the item itself.\n      if (drag === item) {\n        return false;\n      }\n\n      if (delta) {\n        const direction = isHorizontal ? delta.x : delta.y;\n\n        // If the user is still hovering over the same item as last time, their cursor hasn't left\n        // the item after we made the swap, and they didn't change the direction in which they're\n        // dragging, we don't consider it a direction swap.\n        if (\n          drag === this._previousSwap.drag &&\n          this._previousSwap.overlaps &&\n          direction === this._previousSwap.delta\n        ) {\n          return false;\n        }\n      }\n\n      return isHorizontal\n        ? // Round these down since most browsers report client rects with\n          // sub-pixel precision, whereas the pointer coordinates are rounded to pixels.\n          pointerX >= Math.floor(clientRect.left) && pointerX < Math.floor(clientRect.right)\n        : pointerY >= Math.floor(clientRect.top) && pointerY < Math.floor(clientRect.bottom);\n    });\n\n    return index === -1 || !this._sortPredicate(index, item) ? -1 : index;\n  }\n}\n"]}

package/esm2020/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvY2RrL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2020/keycodes/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL2tleWNvZGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2020/keycodes/keycodes.mjs

@@ -0,0 +1,127 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export const MAC_ENTER = 3;
+export const BACKSPACE = 8;
+export const TAB = 9;
+export const NUM_CENTER = 12;
+export const ENTER = 13;
+export const SHIFT = 16;
+export const CONTROL = 17;
+export const ALT = 18;
+export const PAUSE = 19;
+export const CAPS_LOCK = 20;
+export const ESCAPE = 27;
+export const SPACE = 32;
+export const PAGE_UP = 33;
+export const PAGE_DOWN = 34;
+export const END = 35;
+export const HOME = 36;
+export const LEFT_ARROW = 37;
+export const UP_ARROW = 38;
+export const RIGHT_ARROW = 39;
+export const DOWN_ARROW = 40;
+export const PLUS_SIGN = 43;
+export const PRINT_SCREEN = 44;
+export const INSERT = 45;
+export const DELETE = 46;
+export const ZERO = 48;
+export const ONE = 49;
+export const TWO = 50;
+export const THREE = 51;
+export const FOUR = 52;
+export const FIVE = 53;
+export const SIX = 54;
+export const SEVEN = 55;
+export const EIGHT = 56;
+export const NINE = 57;
+export const FF_SEMICOLON = 59; // Firefox (Gecko) fires this for semicolon instead of 186
+export const FF_EQUALS = 61; // Firefox (Gecko) fires this for equals instead of 187
+export const QUESTION_MARK = 63;
+export const AT_SIGN = 64;
+export const A = 65;
+export const B = 66;
+export const C = 67;
+export const D = 68;
+export const E = 69;
+export const F = 70;
+export const G = 71;
+export const H = 72;
+export const I = 73;
+export const J = 74;
+export const K = 75;
+export const L = 76;
+export const M = 77;
+export const N = 78;
+export const O = 79;
+export const P = 80;
+export const Q = 81;
+export const R = 82;
+export const S = 83;
+export const T = 84;
+export const U = 85;
+export const V = 86;
+export const W = 87;
+export const X = 88;
+export const Y = 89;
+export const Z = 90;
+export const META = 91; // WIN_KEY_LEFT
+export const MAC_WK_CMD_LEFT = 91;
+export const MAC_WK_CMD_RIGHT = 93;
+export const CONTEXT_MENU = 93;
+export const NUMPAD_ZERO = 96;
+export const NUMPAD_ONE = 97;
+export const NUMPAD_TWO = 98;
+export const NUMPAD_THREE = 99;
+export const NUMPAD_FOUR = 100;
+export const NUMPAD_FIVE = 101;
+export const NUMPAD_SIX = 102;
+export const NUMPAD_SEVEN = 103;
+export const NUMPAD_EIGHT = 104;
+export const NUMPAD_NINE = 105;
+export const NUMPAD_MULTIPLY = 106;
+export const NUMPAD_PLUS = 107;
+export const NUMPAD_MINUS = 109;
+export const NUMPAD_PERIOD = 110;
+export const NUMPAD_DIVIDE = 111;
+export const F1 = 112;
+export const F2 = 113;
+export const F3 = 114;
+export const F4 = 115;
+export const F5 = 116;
+export const F6 = 117;
+export const F7 = 118;
+export const F8 = 119;
+export const F9 = 120;
+export const F10 = 121;
+export const F11 = 122;
+export const F12 = 123;
+export const NUM_LOCK = 144;
+export const SCROLL_LOCK = 145;
+export const FIRST_MEDIA = 166;
+export const FF_MINUS = 173;
+export const MUTE = 173; // Firefox (Gecko) fires 181 for MUTE
+export const VOLUME_DOWN = 174; // Firefox (Gecko) fires 182 for VOLUME_DOWN
+export const VOLUME_UP = 175; // Firefox (Gecko) fires 183 for VOLUME_UP
+export const FF_MUTE = 181;
+export const FF_VOLUME_DOWN = 182;
+export const LAST_MEDIA = 183;
+export const FF_VOLUME_UP = 183;
+export const SEMICOLON = 186; // Firefox (Gecko) fires 59 for SEMICOLON
+export const EQUALS = 187; // Firefox (Gecko) fires 61 for EQUALS
+export const COMMA = 188;
+export const DASH = 189; // Firefox (Gecko) fires 173 for DASH/MINUS
+export const PERIOD = 190;
+export const SLASH = 191;
+export const APOSTROPHE = 192;
+export const TILDE = 192;
+export const OPEN_SQUARE_BRACKET = 219;
+export const BACKSLASH = 220;
+export const CLOSE_SQUARE_BRACKET = 221;
+export const SINGLE_QUOTE = 222;
+export const MAC_META = 224;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keycodes.js","sourceRoot":"","sources":["../../../../../../src/cdk/keycodes/keycodes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nexport const MAC_ENTER = 3;\nexport const BACKSPACE = 8;\nexport const TAB = 9;\nexport const NUM_CENTER = 12;\nexport const ENTER = 13;\nexport const SHIFT = 16;\nexport const CONTROL = 17;\nexport const ALT = 18;\nexport const PAUSE = 19;\nexport const CAPS_LOCK = 20;\nexport const ESCAPE = 27;\nexport const SPACE = 32;\nexport const PAGE_UP = 33;\nexport const PAGE_DOWN = 34;\nexport const END = 35;\nexport const HOME = 36;\nexport const LEFT_ARROW = 37;\nexport const UP_ARROW = 38;\nexport const RIGHT_ARROW = 39;\nexport const DOWN_ARROW = 40;\nexport const PLUS_SIGN = 43;\nexport const PRINT_SCREEN = 44;\nexport const INSERT = 45;\nexport const DELETE = 46;\nexport const ZERO = 48;\nexport const ONE = 49;\nexport const TWO = 50;\nexport const THREE = 51;\nexport const FOUR = 52;\nexport const FIVE = 53;\nexport const SIX = 54;\nexport const SEVEN = 55;\nexport const EIGHT = 56;\nexport const NINE = 57;\nexport const FF_SEMICOLON = 59; // Firefox (Gecko) fires this for semicolon instead of 186\nexport const FF_EQUALS = 61; // Firefox (Gecko) fires this for equals instead of 187\nexport const QUESTION_MARK = 63;\nexport const AT_SIGN = 64;\nexport const A = 65;\nexport const B = 66;\nexport const C = 67;\nexport const D = 68;\nexport const E = 69;\nexport const F = 70;\nexport const G = 71;\nexport const H = 72;\nexport const I = 73;\nexport const J = 74;\nexport const K = 75;\nexport const L = 76;\nexport const M = 77;\nexport const N = 78;\nexport const O = 79;\nexport const P = 80;\nexport const Q = 81;\nexport const R = 82;\nexport const S = 83;\nexport const T = 84;\nexport const U = 85;\nexport const V = 86;\nexport const W = 87;\nexport const X = 88;\nexport const Y = 89;\nexport const Z = 90;\nexport const META = 91; // WIN_KEY_LEFT\nexport const MAC_WK_CMD_LEFT = 91;\nexport const MAC_WK_CMD_RIGHT = 93;\nexport const CONTEXT_MENU = 93;\nexport const NUMPAD_ZERO = 96;\nexport const NUMPAD_ONE = 97;\nexport const NUMPAD_TWO = 98;\nexport const NUMPAD_THREE = 99;\nexport const NUMPAD_FOUR = 100;\nexport const NUMPAD_FIVE = 101;\nexport const NUMPAD_SIX = 102;\nexport const NUMPAD_SEVEN = 103;\nexport const NUMPAD_EIGHT = 104;\nexport const NUMPAD_NINE = 105;\nexport const NUMPAD_MULTIPLY = 106;\nexport const NUMPAD_PLUS = 107;\nexport const NUMPAD_MINUS = 109;\nexport const NUMPAD_PERIOD = 110;\nexport const NUMPAD_DIVIDE = 111;\nexport const F1 = 112;\nexport const F2 = 113;\nexport const F3 = 114;\nexport const F4 = 115;\nexport const F5 = 116;\nexport const F6 = 117;\nexport const F7 = 118;\nexport const F8 = 119;\nexport const F9 = 120;\nexport const F10 = 121;\nexport const F11 = 122;\nexport const F12 = 123;\nexport const NUM_LOCK = 144;\nexport const SCROLL_LOCK = 145;\nexport const FIRST_MEDIA = 166;\nexport const FF_MINUS = 173;\nexport const MUTE = 173; // Firefox (Gecko) fires 181 for MUTE\nexport const VOLUME_DOWN = 174; // Firefox (Gecko) fires 182 for VOLUME_DOWN\nexport const VOLUME_UP = 175; // Firefox (Gecko) fires 183 for VOLUME_UP\nexport const FF_MUTE = 181;\nexport const FF_VOLUME_DOWN = 182;\nexport const LAST_MEDIA = 183;\nexport const FF_VOLUME_UP = 183;\nexport const SEMICOLON = 186; // Firefox (Gecko) fires 59 for SEMICOLON\nexport const EQUALS = 187; // Firefox (Gecko) fires 61 for EQUALS\nexport const COMMA = 188;\nexport const DASH = 189; // Firefox (Gecko) fires 173 for DASH/MINUS\nexport const PERIOD = 190;\nexport const SLASH = 191;\nexport const APOSTROPHE = 192;\nexport const TILDE = 192;\nexport const OPEN_SQUARE_BRACKET = 219;\nexport const BACKSLASH = 220;\nexport const CLOSE_SQUARE_BRACKET = 221;\nexport const SINGLE_QUOTE = 222;\nexport const MAC_META = 224;\n"]}