@kato-lee/cdk 14.2.7

package/esm2020/a11y/focus-monitor/focus-monitor.mjs

@@ -0,0 +1,451 @@
+/**
+ * @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 { Platform, normalizePassiveListenerOptions, _getShadowRoot, _getEventTarget, } from '@kato-lee/cdk/platform';
+import { Directive, ElementRef, EventEmitter, Inject, Injectable, InjectionToken, NgZone, Optional, Output, } from '@angular/core';
+import { of as observableOf, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { coerceElement } from '@kato-lee/cdk/coercion';
+import { DOCUMENT } from '@angular/common';
+import { InputModalityDetector, TOUCH_BUFFER_MS } from '../input-modality/input-modality-detector';
+import * as i0 from "@angular/core";
+import * as i1 from "@kato-lee/cdk/platform";
+import * as i2 from "../input-modality/input-modality-detector";
+/** InjectionToken for FocusMonitorOptions. */
+export const FOCUS_MONITOR_DEFAULT_OPTIONS = new InjectionToken('cdk-focus-monitor-default-options');
+/**
+ * Event listener options that enable capturing and also
+ * mark the listener as passive if the browser supports it.
+ */
+const captureEventListenerOptions = normalizePassiveListenerOptions({
+    passive: true,
+    capture: true,
+});
+/** Monitors mouse and keyboard events to determine the cause of focus events. */
+export class FocusMonitor {
+    constructor(_ngZone, _platform, _inputModalityDetector,
+    /** @breaking-change 11.0.0 make document required */
+    document, options) {
+        this._ngZone = _ngZone;
+        this._platform = _platform;
+        this._inputModalityDetector = _inputModalityDetector;
+        /** The focus origin that the next focus event is a result of. */
+        this._origin = null;
+        /** Whether the window has just been focused. */
+        this._windowFocused = false;
+        /**
+         * Whether the origin was determined via a touch interaction. Necessary as properly attributing
+         * focus events to touch interactions requires special logic.
+         */
+        this._originFromTouchInteraction = false;
+        /** Map of elements being monitored to their info. */
+        this._elementInfo = new Map();
+        /** The number of elements currently being monitored. */
+        this._monitoredElementCount = 0;
+        /**
+         * Keeps track of the root nodes to which we've currently bound a focus/blur handler,
+         * as well as the number of monitored elements that they contain. We have to treat focus/blur
+         * handlers differently from the rest of the events, because the browser won't emit events
+         * to the document when focus moves inside of a shadow root.
+         */
+        this._rootNodeFocusListenerCount = new Map();
+        /**
+         * Event listener for `focus` events on the window.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
+         */
+        this._windowFocusListener = () => {
+            // Make a note of when the window regains focus, so we can
+            // restore the origin info for the focused element.
+            this._windowFocused = true;
+            this._windowFocusTimeoutId = window.setTimeout(() => (this._windowFocused = false));
+        };
+        /** Subject for stopping our InputModalityDetector subscription. */
+        this._stopInputModalityDetector = new Subject();
+        /**
+         * Event listener for `focus` and 'blur' events on the document.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
+         */
+        this._rootNodeFocusAndBlurListener = (event) => {
+            const target = _getEventTarget(event);
+            // We need to walk up the ancestor chain in order to support `checkChildren`.
+            for (let element = target; element; element = element.parentElement) {
+                if (event.type === 'focus') {
+                    this._onFocus(event, element);
+                }
+                else {
+                    this._onBlur(event, element);
+                }
+            }
+        };
+        this._document = document;
+        this._detectionMode = options?.detectionMode || 0 /* FocusMonitorDetectionMode.IMMEDIATE */;
+    }
+    monitor(element, checkChildren = false) {
+        const nativeElement = coerceElement(element);
+        // Do nothing if we're not on the browser platform or the passed in node isn't an element.
+        if (!this._platform.isBrowser || nativeElement.nodeType !== 1) {
+            return observableOf(null);
+        }
+        // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to
+        // the shadow root, rather than the `document`, because the browser won't emit focus events
+        // to the `document`, if focus is moving within the same shadow root.
+        const rootNode = _getShadowRoot(nativeElement) || this._getDocument();
+        const cachedInfo = this._elementInfo.get(nativeElement);
+        // Check if we're already monitoring this element.
+        if (cachedInfo) {
+            if (checkChildren) {
+                // TODO(COMP-318): this can be problematic, because it'll turn all non-checkChildren
+                // observers into ones that behave as if `checkChildren` was turned on. We need a more
+                // robust solution.
+                cachedInfo.checkChildren = true;
+            }
+            return cachedInfo.subject;
+        }
+        // Create monitored element info.
+        const info = {
+            checkChildren: checkChildren,
+            subject: new Subject(),
+            rootNode,
+        };
+        this._elementInfo.set(nativeElement, info);
+        this._registerGlobalListeners(info);
+        return info.subject;
+    }
+    stopMonitoring(element) {
+        const nativeElement = coerceElement(element);
+        const elementInfo = this._elementInfo.get(nativeElement);
+        if (elementInfo) {
+            elementInfo.subject.complete();
+            this._setClasses(nativeElement);
+            this._elementInfo.delete(nativeElement);
+            this._removeGlobalListeners(elementInfo);
+        }
+    }
+    focusVia(element, origin, options) {
+        const nativeElement = coerceElement(element);
+        const focusedElement = this._getDocument().activeElement;
+        // If the element is focused already, calling `focus` again won't trigger the event listener
+        // which means that the focus classes won't be updated. If that's the case, update the classes
+        // directly without waiting for an event.
+        if (nativeElement === focusedElement) {
+            this._getClosestElementsInfo(nativeElement).forEach(([currentElement, info]) => this._originChanged(currentElement, origin, info));
+        }
+        else {
+            this._setOrigin(origin);
+            // `focus` isn't available on the server
+            if (typeof nativeElement.focus === 'function') {
+                nativeElement.focus(options);
+            }
+        }
+    }
+    ngOnDestroy() {
+        this._elementInfo.forEach((_info, element) => this.stopMonitoring(element));
+    }
+    /** Access injected document if available or fallback to global document reference */
+    _getDocument() {
+        return this._document || document;
+    }
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    _getWindow() {
+        const doc = this._getDocument();
+        return doc.defaultView || window;
+    }
+    _getFocusOrigin(focusEventTarget) {
+        if (this._origin) {
+            // If the origin was realized via a touch interaction, we need to perform additional checks
+            // to determine whether the focus origin should be attributed to touch or program.
+            if (this._originFromTouchInteraction) {
+                return this._shouldBeAttributedToTouch(focusEventTarget) ? 'touch' : 'program';
+            }
+            else {
+                return this._origin;
+            }
+        }
+        // If the window has just regained focus, we can restore the most recent origin from before the
+        // window blurred. Otherwise, we've reached the point where we can't identify the source of the
+        // focus. This typically means one of two things happened:
+        //
+        // 1) The element was programmatically focused, or
+        // 2) The element was focused via screen reader navigation (which generally doesn't fire
+        //    events).
+        //
+        // Because we can't distinguish between these two cases, we default to setting `program`.
+        if (this._windowFocused && this._lastFocusOrigin) {
+            return this._lastFocusOrigin;
+        }
+        // If the interaction is coming from an input label, we consider it a mouse interactions.
+        // This is a special case where focus moves on `click`, rather than `mousedown` which breaks
+        // our detection, because all our assumptions are for `mousedown`. We need to handle this
+        // special case, because it's very common for checkboxes and radio buttons.
+        if (focusEventTarget && this._isLastInteractionFromInputLabel(focusEventTarget)) {
+            return 'mouse';
+        }
+        return 'program';
+    }
+    /**
+     * Returns whether the focus event should be attributed to touch. Recall that in IMMEDIATE mode, a
+     * touch origin isn't immediately reset at the next tick (see _setOrigin). This means that when we
+     * handle a focus event following a touch interaction, we need to determine whether (1) the focus
+     * event was directly caused by the touch interaction or (2) the focus event was caused by a
+     * subsequent programmatic focus call triggered by the touch interaction.
+     * @param focusEventTarget The target of the focus event under examination.
+     */
+    _shouldBeAttributedToTouch(focusEventTarget) {
+        // Please note that this check is not perfect. Consider the following edge case:
+        //
+        // <div #parent tabindex="0">
+        //   <div #child tabindex="0" (click)="#parent.focus()"></div>
+        // </div>
+        //
+        // Suppose there is a FocusMonitor in IMMEDIATE mode attached to #parent. When the user touches
+        // #child, #parent is programmatically focused. This code will attribute the focus to touch
+        // instead of program. This is a relatively minor edge-case that can be worked around by using
+        // focusVia(parent, 'program') to focus #parent.
+        return (this._detectionMode === 1 /* FocusMonitorDetectionMode.EVENTUAL */ ||
+            !!focusEventTarget?.contains(this._inputModalityDetector._mostRecentTarget));
+    }
+    /**
+     * Sets the focus classes on the element based on the given focus origin.
+     * @param element The element to update the classes on.
+     * @param origin The focus origin.
+     */
+    _setClasses(element, origin) {
+        element.classList.toggle('cdk-focused', !!origin);
+        element.classList.toggle('cdk-touch-focused', origin === 'touch');
+        element.classList.toggle('cdk-keyboard-focused', origin === 'keyboard');
+        element.classList.toggle('cdk-mouse-focused', origin === 'mouse');
+        element.classList.toggle('cdk-program-focused', origin === 'program');
+    }
+    /**
+     * Updates the focus origin. If we're using immediate detection mode, we schedule an async
+     * function to clear the origin at the end of a timeout. The duration of the timeout depends on
+     * the origin being set.
+     * @param origin The origin to set.
+     * @param isFromInteraction Whether we are setting the origin from an interaction event.
+     */
+    _setOrigin(origin, isFromInteraction = false) {
+        this._ngZone.runOutsideAngular(() => {
+            this._origin = origin;
+            this._originFromTouchInteraction = origin === 'touch' && isFromInteraction;
+            // If we're in IMMEDIATE mode, reset the origin at the next tick (or in `TOUCH_BUFFER_MS` ms
+            // for a touch event). We reset the origin at the next tick because Firefox focuses one tick
+            // after the interaction event. We wait `TOUCH_BUFFER_MS` ms before resetting the origin for
+            // a touch event because when a touch event is fired, the associated focus event isn't yet in
+            // the event queue. Before doing so, clear any pending timeouts.
+            if (this._detectionMode === 0 /* FocusMonitorDetectionMode.IMMEDIATE */) {
+                clearTimeout(this._originTimeoutId);
+                const ms = this._originFromTouchInteraction ? TOUCH_BUFFER_MS : 1;
+                this._originTimeoutId = setTimeout(() => (this._origin = null), ms);
+            }
+        });
+    }
+    /**
+     * Handles focus events on a registered element.
+     * @param event The focus event.
+     * @param element The monitored element.
+     */
+    _onFocus(event, element) {
+        // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent
+        // focus event affecting the monitored element. If we want to use the origin of the first event
+        // instead we should check for the cdk-focused class here and return if the element already has
+        // it. (This only matters for elements that have includesChildren = true).
+        // If we are not counting child-element-focus as focused, make sure that the event target is the
+        // monitored element itself.
+        const elementInfo = this._elementInfo.get(element);
+        const focusEventTarget = _getEventTarget(event);
+        if (!elementInfo || (!elementInfo.checkChildren && element !== focusEventTarget)) {
+            return;
+        }
+        this._originChanged(element, this._getFocusOrigin(focusEventTarget), elementInfo);
+    }
+    /**
+     * Handles blur events on a registered element.
+     * @param event The blur event.
+     * @param element The monitored element.
+     */
+    _onBlur(event, element) {
+        // If we are counting child-element-focus as focused, make sure that we aren't just blurring in
+        // order to focus another child of the monitored element.
+        const elementInfo = this._elementInfo.get(element);
+        if (!elementInfo ||
+            (elementInfo.checkChildren &&
+                event.relatedTarget instanceof Node &&
+                element.contains(event.relatedTarget))) {
+            return;
+        }
+        this._setClasses(element);
+        this._emitOrigin(elementInfo, null);
+    }
+    _emitOrigin(info, origin) {
+        if (info.subject.observers.length) {
+            this._ngZone.run(() => info.subject.next(origin));
+        }
+    }
+    _registerGlobalListeners(elementInfo) {
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        const rootNode = elementInfo.rootNode;
+        const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;
+        if (!rootNodeFocusListeners) {
+            this._ngZone.runOutsideAngular(() => {
+                rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+            });
+        }
+        this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);
+        // Register global listeners when first element is monitored.
+        if (++this._monitoredElementCount === 1) {
+            // Note: we listen to events in the capture phase so we
+            // can detect them even if the user stops propagation.
+            this._ngZone.runOutsideAngular(() => {
+                const window = this._getWindow();
+                window.addEventListener('focus', this._windowFocusListener);
+            });
+            // The InputModalityDetector is also just a collection of global listeners.
+            this._inputModalityDetector.modalityDetected
+                .pipe(takeUntil(this._stopInputModalityDetector))
+                .subscribe(modality => {
+                this._setOrigin(modality, true /* isFromInteraction */);
+            });
+        }
+    }
+    _removeGlobalListeners(elementInfo) {
+        const rootNode = elementInfo.rootNode;
+        if (this._rootNodeFocusListenerCount.has(rootNode)) {
+            const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode);
+            if (rootNodeFocusListeners > 1) {
+                this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);
+            }
+            else {
+                rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                this._rootNodeFocusListenerCount.delete(rootNode);
+            }
+        }
+        // Unregister global listeners when last element is unmonitored.
+        if (!--this._monitoredElementCount) {
+            const window = this._getWindow();
+            window.removeEventListener('focus', this._windowFocusListener);
+            // Equivalently, stop our InputModalityDetector subscription.
+            this._stopInputModalityDetector.next();
+            // Clear timeouts for all potentially pending timeouts to prevent the leaks.
+            clearTimeout(this._windowFocusTimeoutId);
+            clearTimeout(this._originTimeoutId);
+        }
+    }
+    /** Updates all the state on an element once its focus origin has changed. */
+    _originChanged(element, origin, elementInfo) {
+        this._setClasses(element, origin);
+        this._emitOrigin(elementInfo, origin);
+        this._lastFocusOrigin = origin;
+    }
+    /**
+     * Collects the `MonitoredElementInfo` of a particular element and
+     * all of its ancestors that have enabled `checkChildren`.
+     * @param element Element from which to start the search.
+     */
+    _getClosestElementsInfo(element) {
+        const results = [];
+        this._elementInfo.forEach((info, currentElement) => {
+            if (currentElement === element || (info.checkChildren && currentElement.contains(element))) {
+                results.push([currentElement, info]);
+            }
+        });
+        return results;
+    }
+    /**
+     * Returns whether an interaction is likely to have come from the user clicking the `label` of
+     * an `input` or `textarea` in order to focus it.
+     * @param focusEventTarget Target currently receiving focus.
+     */
+    _isLastInteractionFromInputLabel(focusEventTarget) {
+        const { _mostRecentTarget: mostRecentTarget, mostRecentModality } = this._inputModalityDetector;
+        // If the last interaction used the mouse on an element contained by one of the labels
+        // of an `input`/`textarea` that is currently focused, it is very likely that the
+        // user redirected focus using the label.
+        if (mostRecentModality !== 'mouse' ||
+            !mostRecentTarget ||
+            mostRecentTarget === focusEventTarget ||
+            (focusEventTarget.nodeName !== 'INPUT' && focusEventTarget.nodeName !== 'TEXTAREA') ||
+            focusEventTarget.disabled) {
+            return false;
+        }
+        const labels = focusEventTarget.labels;
+        if (labels) {
+            for (let i = 0; i < labels.length; i++) {
+                if (labels[i].contains(mostRecentTarget)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+FocusMonitor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: FocusMonitor, deps: [{ token: i0.NgZone }, { token: i1.Platform }, { token: i2.InputModalityDetector }, { token: DOCUMENT, optional: true }, { token: FOCUS_MONITOR_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+FocusMonitor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: FocusMonitor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: FocusMonitor, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i1.Platform }, { type: i2.InputModalityDetector }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FOCUS_MONITOR_DEFAULT_OPTIONS]
+                }] }]; } });
+/**
+ * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or
+ * programmatically) and adds corresponding classes to the element.
+ *
+ * There are two variants of this directive:
+ * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is
+ *    focused.
+ * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.
+ */
+export class CdkMonitorFocus {
+    constructor(_elementRef, _focusMonitor) {
+        this._elementRef = _elementRef;
+        this._focusMonitor = _focusMonitor;
+        this._focusOrigin = null;
+        this.cdkFocusChange = new EventEmitter();
+    }
+    get focusOrigin() {
+        return this._focusOrigin;
+    }
+    ngAfterViewInit() {
+        const element = this._elementRef.nativeElement;
+        this._monitorSubscription = this._focusMonitor
+            .monitor(element, element.nodeType === 1 && element.hasAttribute('cdkMonitorSubtreeFocus'))
+            .subscribe(origin => {
+            this._focusOrigin = origin;
+            this.cdkFocusChange.emit(origin);
+        });
+    }
+    ngOnDestroy() {
+        this._focusMonitor.stopMonitoring(this._elementRef);
+        if (this._monitorSubscription) {
+            this._monitorSubscription.unsubscribe();
+        }
+    }
+}
+CdkMonitorFocus.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkMonitorFocus, deps: [{ token: i0.ElementRef }, { token: FocusMonitor }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMonitorFocus.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: CdkMonitorFocus, selector: "[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]", outputs: { cdkFocusChange: "cdkFocusChange" }, exportAs: ["cdkMonitorFocus"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkMonitorFocus, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',
+                    exportAs: 'cdkMonitorFocus',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: FocusMonitor }]; }, propDecorators: { cdkFocusChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"focus-monitor.js","sourceRoot":"","sources":["../../../../../../../src/cdk/a11y/focus-monitor/focus-monitor.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 {\n  Platform,\n  normalizePassiveListenerOptions,\n  _getShadowRoot,\n  _getEventTarget,\n} from '@angular/cdk/platform';\nimport {\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Injectable,\n  InjectionToken,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Output,\n  AfterViewInit,\n} from '@angular/core';\nimport {Observable, of as observableOf, Subject, Subscription} from 'rxjs';\nimport {takeUntil} from 'rxjs/operators';\nimport {coerceElement} from '@angular/cdk/coercion';\nimport {DOCUMENT} from '@angular/common';\nimport {InputModalityDetector, TOUCH_BUFFER_MS} from '../input-modality/input-modality-detector';\n\nexport type FocusOrigin = 'touch' | 'mouse' | 'keyboard' | 'program' | null;\n\n/**\n * Corresponds to the options that can be passed to the native `focus` event.\n * via https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus\n */\nexport interface FocusOptions {\n  /** Whether the browser should scroll to the element when it is focused. */\n  preventScroll?: boolean;\n}\n\n/** Detection mode used for attributing the origin of a focus event. */\nexport const enum FocusMonitorDetectionMode {\n  /**\n   * Any mousedown, keydown, or touchstart event that happened in the previous\n   * tick or the current tick will be used to assign a focus event's origin (to\n   * either mouse, keyboard, or touch). This is the default option.\n   */\n  IMMEDIATE,\n  /**\n   * A focus event's origin is always attributed to the last corresponding\n   * mousedown, keydown, or touchstart event, no matter how long ago it occurred.\n   */\n  EVENTUAL,\n}\n\n/** Injectable service-level options for FocusMonitor. */\nexport interface FocusMonitorOptions {\n  detectionMode?: FocusMonitorDetectionMode;\n}\n\n/** InjectionToken for FocusMonitorOptions. */\nexport const FOCUS_MONITOR_DEFAULT_OPTIONS = new InjectionToken<FocusMonitorOptions>(\n  'cdk-focus-monitor-default-options',\n);\n\ntype MonitoredElementInfo = {\n  checkChildren: boolean;\n  readonly subject: Subject<FocusOrigin>;\n  rootNode: HTMLElement | ShadowRoot | Document;\n};\n\n/**\n * Event listener options that enable capturing and also\n * mark the listener as passive if the browser supports it.\n */\nconst captureEventListenerOptions = normalizePassiveListenerOptions({\n  passive: true,\n  capture: true,\n});\n\n/** Monitors mouse and keyboard events to determine the cause of focus events. */\n@Injectable({providedIn: 'root'})\nexport class FocusMonitor implements OnDestroy {\n  /** The focus origin that the next focus event is a result of. */\n  private _origin: FocusOrigin = null;\n\n  /** The FocusOrigin of the last focus event tracked by the FocusMonitor. */\n  private _lastFocusOrigin: FocusOrigin;\n\n  /** Whether the window has just been focused. */\n  private _windowFocused = false;\n\n  /** The timeout id of the window focus timeout. */\n  private _windowFocusTimeoutId: number;\n\n  /** The timeout id of the origin clearing timeout. */\n  private _originTimeoutId: number;\n\n  /**\n   * Whether the origin was determined via a touch interaction. Necessary as properly attributing\n   * focus events to touch interactions requires special logic.\n   */\n  private _originFromTouchInteraction = false;\n\n  /** Map of elements being monitored to their info. */\n  private _elementInfo = new Map<HTMLElement, MonitoredElementInfo>();\n\n  /** The number of elements currently being monitored. */\n  private _monitoredElementCount = 0;\n\n  /**\n   * Keeps track of the root nodes to which we've currently bound a focus/blur handler,\n   * as well as the number of monitored elements that they contain. We have to treat focus/blur\n   * handlers differently from the rest of the events, because the browser won't emit events\n   * to the document when focus moves inside of a shadow root.\n   */\n  private _rootNodeFocusListenerCount = new Map<HTMLElement | Document | ShadowRoot, number>();\n\n  /**\n   * The specified detection mode, used for attributing the origin of a focus\n   * event.\n   */\n  private readonly _detectionMode: FocusMonitorDetectionMode;\n\n  /**\n   * Event listener for `focus` events on the window.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _windowFocusListener = () => {\n    // Make a note of when the window regains focus, so we can\n    // restore the origin info for the focused element.\n    this._windowFocused = true;\n    this._windowFocusTimeoutId = window.setTimeout(() => (this._windowFocused = false));\n  };\n\n  /** Used to reference correct document/window */\n  protected _document?: Document;\n\n  /** Subject for stopping our InputModalityDetector subscription. */\n  private readonly _stopInputModalityDetector = new Subject<void>();\n\n  constructor(\n    private _ngZone: NgZone,\n    private _platform: Platform,\n    private readonly _inputModalityDetector: InputModalityDetector,\n    /** @breaking-change 11.0.0 make document required */\n    @Optional() @Inject(DOCUMENT) document: any | null,\n    @Optional() @Inject(FOCUS_MONITOR_DEFAULT_OPTIONS) options: FocusMonitorOptions | null,\n  ) {\n    this._document = document;\n    this._detectionMode = options?.detectionMode || FocusMonitorDetectionMode.IMMEDIATE;\n  }\n  /**\n   * Event listener for `focus` and 'blur' events on the document.\n   * Needs to be an arrow function in order to preserve the context when it gets bound.\n   */\n  private _rootNodeFocusAndBlurListener = (event: Event) => {\n    const target = _getEventTarget<HTMLElement>(event);\n\n    // We need to walk up the ancestor chain in order to support `checkChildren`.\n    for (let element = target; element; element = element.parentElement) {\n      if (event.type === 'focus') {\n        this._onFocus(event as FocusEvent, element);\n      } else {\n        this._onBlur(event as FocusEvent, element);\n      }\n    }\n  };\n\n  /**\n   * Monitors focus on an element and applies appropriate CSS classes.\n   * @param element The element to monitor\n   * @param checkChildren Whether to count the element as focused when its children are focused.\n   * @returns An observable that emits when the focus state of the element changes.\n   *     When the element is blurred, null will be emitted.\n   */\n  monitor(element: HTMLElement, checkChildren?: boolean): Observable<FocusOrigin>;\n\n  /**\n   * Monitors focus on an element and applies appropriate CSS classes.\n   * @param element The element to monitor\n   * @param checkChildren Whether to count the element as focused when its children are focused.\n   * @returns An observable that emits when the focus state of the element changes.\n   *     When the element is blurred, null will be emitted.\n   */\n  monitor(element: ElementRef<HTMLElement>, checkChildren?: boolean): Observable<FocusOrigin>;\n\n  monitor(\n    element: HTMLElement | ElementRef<HTMLElement>,\n    checkChildren: boolean = false,\n  ): Observable<FocusOrigin> {\n    const nativeElement = coerceElement(element);\n\n    // Do nothing if we're not on the browser platform or the passed in node isn't an element.\n    if (!this._platform.isBrowser || nativeElement.nodeType !== 1) {\n      return observableOf(null);\n    }\n\n    // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to\n    // the shadow root, rather than the `document`, because the browser won't emit focus events\n    // to the `document`, if focus is moving within the same shadow root.\n    const rootNode = _getShadowRoot(nativeElement) || this._getDocument();\n    const cachedInfo = this._elementInfo.get(nativeElement);\n\n    // Check if we're already monitoring this element.\n    if (cachedInfo) {\n      if (checkChildren) {\n        // TODO(COMP-318): this can be problematic, because it'll turn all non-checkChildren\n        // observers into ones that behave as if `checkChildren` was turned on. We need a more\n        // robust solution.\n        cachedInfo.checkChildren = true;\n      }\n\n      return cachedInfo.subject;\n    }\n\n    // Create monitored element info.\n    const info: MonitoredElementInfo = {\n      checkChildren: checkChildren,\n      subject: new Subject<FocusOrigin>(),\n      rootNode,\n    };\n    this._elementInfo.set(nativeElement, info);\n    this._registerGlobalListeners(info);\n\n    return info.subject;\n  }\n\n  /**\n   * Stops monitoring an element and removes all focus classes.\n   * @param element The element to stop monitoring.\n   */\n  stopMonitoring(element: HTMLElement): void;\n\n  /**\n   * Stops monitoring an element and removes all focus classes.\n   * @param element The element to stop monitoring.\n   */\n  stopMonitoring(element: ElementRef<HTMLElement>): void;\n\n  stopMonitoring(element: HTMLElement | ElementRef<HTMLElement>): void {\n    const nativeElement = coerceElement(element);\n    const elementInfo = this._elementInfo.get(nativeElement);\n\n    if (elementInfo) {\n      elementInfo.subject.complete();\n\n      this._setClasses(nativeElement);\n      this._elementInfo.delete(nativeElement);\n      this._removeGlobalListeners(elementInfo);\n    }\n  }\n\n  /**\n   * Focuses the element via the specified focus origin.\n   * @param element Element to focus.\n   * @param origin Focus origin.\n   * @param options Options that can be used to configure the focus behavior.\n   */\n  focusVia(element: HTMLElement, origin: FocusOrigin, options?: FocusOptions): void;\n\n  /**\n   * Focuses the element via the specified focus origin.\n   * @param element Element to focus.\n   * @param origin Focus origin.\n   * @param options Options that can be used to configure the focus behavior.\n   */\n  focusVia(element: ElementRef<HTMLElement>, origin: FocusOrigin, options?: FocusOptions): void;\n\n  focusVia(\n    element: HTMLElement | ElementRef<HTMLElement>,\n    origin: FocusOrigin,\n    options?: FocusOptions,\n  ): void {\n    const nativeElement = coerceElement(element);\n    const focusedElement = this._getDocument().activeElement;\n\n    // If the element is focused already, calling `focus` again won't trigger the event listener\n    // which means that the focus classes won't be updated. If that's the case, update the classes\n    // directly without waiting for an event.\n    if (nativeElement === focusedElement) {\n      this._getClosestElementsInfo(nativeElement).forEach(([currentElement, info]) =>\n        this._originChanged(currentElement, origin, info),\n      );\n    } else {\n      this._setOrigin(origin);\n\n      // `focus` isn't available on the server\n      if (typeof nativeElement.focus === 'function') {\n        nativeElement.focus(options);\n      }\n    }\n  }\n\n  ngOnDestroy() {\n    this._elementInfo.forEach((_info, element) => this.stopMonitoring(element));\n  }\n\n  /** Access injected document if available or fallback to global document reference */\n  private _getDocument(): Document {\n    return this._document || document;\n  }\n\n  /** Use defaultView of injected document if available or fallback to global window reference */\n  private _getWindow(): Window {\n    const doc = this._getDocument();\n    return doc.defaultView || window;\n  }\n\n  private _getFocusOrigin(focusEventTarget: HTMLElement | null): FocusOrigin {\n    if (this._origin) {\n      // If the origin was realized via a touch interaction, we need to perform additional checks\n      // to determine whether the focus origin should be attributed to touch or program.\n      if (this._originFromTouchInteraction) {\n        return this._shouldBeAttributedToTouch(focusEventTarget) ? 'touch' : 'program';\n      } else {\n        return this._origin;\n      }\n    }\n\n    // If the window has just regained focus, we can restore the most recent origin from before the\n    // window blurred. Otherwise, we've reached the point where we can't identify the source of the\n    // focus. This typically means one of two things happened:\n    //\n    // 1) The element was programmatically focused, or\n    // 2) The element was focused via screen reader navigation (which generally doesn't fire\n    //    events).\n    //\n    // Because we can't distinguish between these two cases, we default to setting `program`.\n    if (this._windowFocused && this._lastFocusOrigin) {\n      return this._lastFocusOrigin;\n    }\n\n    // If the interaction is coming from an input label, we consider it a mouse interactions.\n    // This is a special case where focus moves on `click`, rather than `mousedown` which breaks\n    // our detection, because all our assumptions are for `mousedown`. We need to handle this\n    // special case, because it's very common for checkboxes and radio buttons.\n    if (focusEventTarget && this._isLastInteractionFromInputLabel(focusEventTarget)) {\n      return 'mouse';\n    }\n\n    return 'program';\n  }\n\n  /**\n   * Returns whether the focus event should be attributed to touch. Recall that in IMMEDIATE mode, a\n   * touch origin isn't immediately reset at the next tick (see _setOrigin). This means that when we\n   * handle a focus event following a touch interaction, we need to determine whether (1) the focus\n   * event was directly caused by the touch interaction or (2) the focus event was caused by a\n   * subsequent programmatic focus call triggered by the touch interaction.\n   * @param focusEventTarget The target of the focus event under examination.\n   */\n  private _shouldBeAttributedToTouch(focusEventTarget: HTMLElement | null): boolean {\n    // Please note that this check is not perfect. Consider the following edge case:\n    //\n    // <div #parent tabindex=\"0\">\n    //   <div #child tabindex=\"0\" (click)=\"#parent.focus()\"></div>\n    // </div>\n    //\n    // Suppose there is a FocusMonitor in IMMEDIATE mode attached to #parent. When the user touches\n    // #child, #parent is programmatically focused. This code will attribute the focus to touch\n    // instead of program. This is a relatively minor edge-case that can be worked around by using\n    // focusVia(parent, 'program') to focus #parent.\n    return (\n      this._detectionMode === FocusMonitorDetectionMode.EVENTUAL ||\n      !!focusEventTarget?.contains(this._inputModalityDetector._mostRecentTarget)\n    );\n  }\n\n  /**\n   * Sets the focus classes on the element based on the given focus origin.\n   * @param element The element to update the classes on.\n   * @param origin The focus origin.\n   */\n  private _setClasses(element: HTMLElement, origin?: FocusOrigin): void {\n    element.classList.toggle('cdk-focused', !!origin);\n    element.classList.toggle('cdk-touch-focused', origin === 'touch');\n    element.classList.toggle('cdk-keyboard-focused', origin === 'keyboard');\n    element.classList.toggle('cdk-mouse-focused', origin === 'mouse');\n    element.classList.toggle('cdk-program-focused', origin === 'program');\n  }\n\n  /**\n   * Updates the focus origin. If we're using immediate detection mode, we schedule an async\n   * function to clear the origin at the end of a timeout. The duration of the timeout depends on\n   * the origin being set.\n   * @param origin The origin to set.\n   * @param isFromInteraction Whether we are setting the origin from an interaction event.\n   */\n  private _setOrigin(origin: FocusOrigin, isFromInteraction = false): void {\n    this._ngZone.runOutsideAngular(() => {\n      this._origin = origin;\n      this._originFromTouchInteraction = origin === 'touch' && isFromInteraction;\n\n      // If we're in IMMEDIATE mode, reset the origin at the next tick (or in `TOUCH_BUFFER_MS` ms\n      // for a touch event). We reset the origin at the next tick because Firefox focuses one tick\n      // after the interaction event. We wait `TOUCH_BUFFER_MS` ms before resetting the origin for\n      // a touch event because when a touch event is fired, the associated focus event isn't yet in\n      // the event queue. Before doing so, clear any pending timeouts.\n      if (this._detectionMode === FocusMonitorDetectionMode.IMMEDIATE) {\n        clearTimeout(this._originTimeoutId);\n        const ms = this._originFromTouchInteraction ? TOUCH_BUFFER_MS : 1;\n        this._originTimeoutId = setTimeout(() => (this._origin = null), ms);\n      }\n    });\n  }\n\n  /**\n   * Handles focus events on a registered element.\n   * @param event The focus event.\n   * @param element The monitored element.\n   */\n  private _onFocus(event: FocusEvent, element: HTMLElement) {\n    // NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent\n    // focus event affecting the monitored element. If we want to use the origin of the first event\n    // instead we should check for the cdk-focused class here and return if the element already has\n    // it. (This only matters for elements that have includesChildren = true).\n\n    // If we are not counting child-element-focus as focused, make sure that the event target is the\n    // monitored element itself.\n    const elementInfo = this._elementInfo.get(element);\n    const focusEventTarget = _getEventTarget<HTMLElement>(event);\n    if (!elementInfo || (!elementInfo.checkChildren && element !== focusEventTarget)) {\n      return;\n    }\n\n    this._originChanged(element, this._getFocusOrigin(focusEventTarget), elementInfo);\n  }\n\n  /**\n   * Handles blur events on a registered element.\n   * @param event The blur event.\n   * @param element The monitored element.\n   */\n  _onBlur(event: FocusEvent, element: HTMLElement) {\n    // If we are counting child-element-focus as focused, make sure that we aren't just blurring in\n    // order to focus another child of the monitored element.\n    const elementInfo = this._elementInfo.get(element);\n\n    if (\n      !elementInfo ||\n      (elementInfo.checkChildren &&\n        event.relatedTarget instanceof Node &&\n        element.contains(event.relatedTarget))\n    ) {\n      return;\n    }\n\n    this._setClasses(element);\n    this._emitOrigin(elementInfo, null);\n  }\n\n  private _emitOrigin(info: MonitoredElementInfo, origin: FocusOrigin) {\n    if (info.subject.observers.length) {\n      this._ngZone.run(() => info.subject.next(origin));\n    }\n  }\n\n  private _registerGlobalListeners(elementInfo: MonitoredElementInfo) {\n    if (!this._platform.isBrowser) {\n      return;\n    }\n\n    const rootNode = elementInfo.rootNode;\n    const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;\n\n    if (!rootNodeFocusListeners) {\n      this._ngZone.runOutsideAngular(() => {\n        rootNode.addEventListener(\n          'focus',\n          this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions,\n        );\n        rootNode.addEventListener(\n          'blur',\n          this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions,\n        );\n      });\n    }\n\n    this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);\n\n    // Register global listeners when first element is monitored.\n    if (++this._monitoredElementCount === 1) {\n      // Note: we listen to events in the capture phase so we\n      // can detect them even if the user stops propagation.\n      this._ngZone.runOutsideAngular(() => {\n        const window = this._getWindow();\n        window.addEventListener('focus', this._windowFocusListener);\n      });\n\n      // The InputModalityDetector is also just a collection of global listeners.\n      this._inputModalityDetector.modalityDetected\n        .pipe(takeUntil(this._stopInputModalityDetector))\n        .subscribe(modality => {\n          this._setOrigin(modality, true /* isFromInteraction */);\n        });\n    }\n  }\n\n  private _removeGlobalListeners(elementInfo: MonitoredElementInfo) {\n    const rootNode = elementInfo.rootNode;\n\n    if (this._rootNodeFocusListenerCount.has(rootNode)) {\n      const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode)!;\n\n      if (rootNodeFocusListeners > 1) {\n        this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);\n      } else {\n        rootNode.removeEventListener(\n          'focus',\n          this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions,\n        );\n        rootNode.removeEventListener(\n          'blur',\n          this._rootNodeFocusAndBlurListener,\n          captureEventListenerOptions,\n        );\n        this._rootNodeFocusListenerCount.delete(rootNode);\n      }\n    }\n\n    // Unregister global listeners when last element is unmonitored.\n    if (!--this._monitoredElementCount) {\n      const window = this._getWindow();\n      window.removeEventListener('focus', this._windowFocusListener);\n\n      // Equivalently, stop our InputModalityDetector subscription.\n      this._stopInputModalityDetector.next();\n\n      // Clear timeouts for all potentially pending timeouts to prevent the leaks.\n      clearTimeout(this._windowFocusTimeoutId);\n      clearTimeout(this._originTimeoutId);\n    }\n  }\n\n  /** Updates all the state on an element once its focus origin has changed. */\n  private _originChanged(\n    element: HTMLElement,\n    origin: FocusOrigin,\n    elementInfo: MonitoredElementInfo,\n  ) {\n    this._setClasses(element, origin);\n    this._emitOrigin(elementInfo, origin);\n    this._lastFocusOrigin = origin;\n  }\n\n  /**\n   * Collects the `MonitoredElementInfo` of a particular element and\n   * all of its ancestors that have enabled `checkChildren`.\n   * @param element Element from which to start the search.\n   */\n  private _getClosestElementsInfo(element: HTMLElement): [HTMLElement, MonitoredElementInfo][] {\n    const results: [HTMLElement, MonitoredElementInfo][] = [];\n\n    this._elementInfo.forEach((info, currentElement) => {\n      if (currentElement === element || (info.checkChildren && currentElement.contains(element))) {\n        results.push([currentElement, info]);\n      }\n    });\n\n    return results;\n  }\n\n  /**\n   * Returns whether an interaction is likely to have come from the user clicking the `label` of\n   * an `input` or `textarea` in order to focus it.\n   * @param focusEventTarget Target currently receiving focus.\n   */\n  private _isLastInteractionFromInputLabel(focusEventTarget: HTMLElement): boolean {\n    const {_mostRecentTarget: mostRecentTarget, mostRecentModality} = this._inputModalityDetector;\n\n    // If the last interaction used the mouse on an element contained by one of the labels\n    // of an `input`/`textarea` that is currently focused, it is very likely that the\n    // user redirected focus using the label.\n    if (\n      mostRecentModality !== 'mouse' ||\n      !mostRecentTarget ||\n      mostRecentTarget === focusEventTarget ||\n      (focusEventTarget.nodeName !== 'INPUT' && focusEventTarget.nodeName !== 'TEXTAREA') ||\n      (focusEventTarget as HTMLInputElement | HTMLTextAreaElement).disabled\n    ) {\n      return false;\n    }\n\n    const labels = (focusEventTarget as HTMLInputElement | HTMLTextAreaElement).labels;\n\n    if (labels) {\n      for (let i = 0; i < labels.length; i++) {\n        if (labels[i].contains(mostRecentTarget)) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n}\n\n/**\n * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or\n * programmatically) and adds corresponding classes to the element.\n *\n * There are two variants of this directive:\n * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is\n *    focused.\n * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.\n */\n@Directive({\n  selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',\n  exportAs: 'cdkMonitorFocus',\n})\nexport class CdkMonitorFocus implements AfterViewInit, OnDestroy {\n  private _monitorSubscription: Subscription;\n  private _focusOrigin: FocusOrigin = null;\n\n  @Output() readonly cdkFocusChange = new EventEmitter<FocusOrigin>();\n\n  constructor(private _elementRef: ElementRef<HTMLElement>, private _focusMonitor: FocusMonitor) {}\n\n  get focusOrigin(): FocusOrigin {\n    return this._focusOrigin;\n  }\n\n  ngAfterViewInit() {\n    const element = this._elementRef.nativeElement;\n    this._monitorSubscription = this._focusMonitor\n      .monitor(element, element.nodeType === 1 && element.hasAttribute('cdkMonitorSubtreeFocus'))\n      .subscribe(origin => {\n        this._focusOrigin = origin;\n        this.cdkFocusChange.emit(origin);\n      });\n  }\n\n  ngOnDestroy() {\n    this._focusMonitor.stopMonitoring(this._elementRef);\n\n    if (this._monitorSubscription) {\n      this._monitorSubscription.unsubscribe();\n    }\n  }\n}\n"]}

package/esm2020/a11y/focus-trap/configurable-focus-trap-config.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlndXJhYmxlLWZvY3VzLXRyYXAtY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2Nkay9hMTF5L2ZvY3VzLXRyYXAvY29uZmlndXJhYmxlLWZvY3VzLXRyYXAtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vKipcbiAqIE9wdGlvbnMgZm9yIGNyZWF0aW5nIGEgQ29uZmlndXJhYmxlRm9jdXNUcmFwLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIENvbmZpZ3VyYWJsZUZvY3VzVHJhcENvbmZpZyB7XG4gIC8qKlxuICAgKiBXaGV0aGVyIHRvIGRlZmVyIHRoZSBjcmVhdGlvbiBvZiBGb2N1c1RyYXAgZWxlbWVudHMgdG8gYmUgZG9uZSBtYW51YWxseSBieSB0aGUgdXNlci5cbiAgICovXG4gIGRlZmVyOiBib29sZWFuO1xufVxuIl19

package/esm2020/a11y/focus-trap/configurable-focus-trap-factory.mjs

@@ -0,0 +1,53 @@
+/**
+ * @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 { DOCUMENT } from '@angular/common';
+import { Inject, Injectable, Optional, NgZone } from '@angular/core';
+import { InteractivityChecker } from '../interactivity-checker/interactivity-checker';
+import { ConfigurableFocusTrap } from './configurable-focus-trap';
+import { FOCUS_TRAP_INERT_STRATEGY } from './focus-trap-inert-strategy';
+import { EventListenerFocusTrapInertStrategy } from './event-listener-inert-strategy';
+import { FocusTrapManager } from './focus-trap-manager';
+import * as i0 from "@angular/core";
+import * as i1 from "../interactivity-checker/interactivity-checker";
+import * as i2 from "./focus-trap-manager";
+/** Factory that allows easy instantiation of configurable focus traps. */
+export class ConfigurableFocusTrapFactory {
+    constructor(_checker, _ngZone, _focusTrapManager, _document, _inertStrategy) {
+        this._checker = _checker;
+        this._ngZone = _ngZone;
+        this._focusTrapManager = _focusTrapManager;
+        this._document = _document;
+        // TODO split up the strategies into different modules, similar to DateAdapter.
+        this._inertStrategy = _inertStrategy || new EventListenerFocusTrapInertStrategy();
+    }
+    create(element, config = { defer: false }) {
+        let configObject;
+        if (typeof config === 'boolean') {
+            configObject = { defer: config };
+        }
+        else {
+            configObject = config;
+        }
+        return new ConfigurableFocusTrap(element, this._checker, this._ngZone, this._document, this._focusTrapManager, this._inertStrategy, configObject);
+    }
+}
+ConfigurableFocusTrapFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ConfigurableFocusTrapFactory, deps: [{ token: i1.InteractivityChecker }, { token: i0.NgZone }, { token: i2.FocusTrapManager }, { token: DOCUMENT }, { token: FOCUS_TRAP_INERT_STRATEGY, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurableFocusTrapFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ConfigurableFocusTrapFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ConfigurableFocusTrapFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.InteractivityChecker }, { type: i0.NgZone }, { type: i2.FocusTrapManager }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FOCUS_TRAP_INERT_STRATEGY]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlndXJhYmxlLWZvY3VzLXRyYXAtZmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGsvYTExeS9mb2N1cy10cmFwL2NvbmZpZ3VyYWJsZS1mb2N1cy10cmFwLWZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQ3pDLE9BQU8sRUFBQyxNQUFNLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDbkUsT0FBTyxFQUFDLG9CQUFvQixFQUFDLE1BQU0sZ0RBQWdELENBQUM7QUFDcEYsT0FBTyxFQUFDLHFCQUFxQixFQUFDLE1BQU0sMkJBQTJCLENBQUM7QUFFaEUsT0FBTyxFQUFDLHlCQUF5QixFQUF5QixNQUFNLDZCQUE2QixDQUFDO0FBQzlGLE9BQU8sRUFBQyxtQ0FBbUMsRUFBQyxNQUFNLGlDQUFpQyxDQUFDO0FBQ3BGLE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLHNCQUFzQixDQUFDOzs7O0FBRXRELDBFQUEwRTtBQUUxRSxNQUFNLE9BQU8sNEJBQTRCO0lBSXZDLFlBQ1UsUUFBOEIsRUFDOUIsT0FBZSxFQUNmLGlCQUFtQyxFQUN6QixTQUFjLEVBQ2UsY0FBdUM7UUFKOUUsYUFBUSxHQUFSLFFBQVEsQ0FBc0I7UUFDOUIsWUFBTyxHQUFQLE9BQU8sQ0FBUTtRQUNmLHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBa0I7UUFJM0MsSUFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFDM0IsK0VBQStFO1FBQy9FLElBQUksQ0FBQyxjQUFjLEdBQUcsY0FBYyxJQUFJLElBQUksbUNBQW1DLEVBQUUsQ0FBQztJQUNwRixDQUFDO0lBZ0JELE1BQU0sQ0FDSixPQUFvQixFQUNwQixTQUFnRCxFQUFDLEtBQUssRUFBRSxLQUFLLEVBQUM7UUFFOUQsSUFBSSxZQUF5QyxDQUFDO1FBQzlDLElBQUksT0FBTyxNQUFNLEtBQUssU0FBUyxFQUFFO1lBQy9CLFlBQVksR0FBRyxFQUFDLEtBQUssRUFBRSxNQUFNLEVBQUMsQ0FBQztTQUNoQzthQUFNO1lBQ0wsWUFBWSxHQUFHLE1BQU0sQ0FBQztTQUN2QjtRQUNELE9BQU8sSUFBSSxxQkFBcUIsQ0FDOUIsT0FBTyxFQUNQLElBQUksQ0FBQyxRQUFRLEVBQ2IsSUFBSSxDQUFDLE9BQU8sRUFDWixJQUFJLENBQUMsU0FBUyxFQUNkLElBQUksQ0FBQyxpQkFBaUIsRUFDdEIsSUFBSSxDQUFDLGNBQWMsRUFDbkIsWUFBWSxDQUNiLENBQUM7SUFDSixDQUFDOzt5SEFqRFUsNEJBQTRCLDRHQVE3QixRQUFRLGFBQ0kseUJBQXlCOzZIQVRwQyw0QkFBNEIsY0FEaEIsTUFBTTsyRkFDbEIsNEJBQTRCO2tCQUR4QyxVQUFVO21CQUFDLEVBQUMsVUFBVSxFQUFFLE1BQU0sRUFBQzs7MEJBUzNCLE1BQU07MkJBQUMsUUFBUTs7MEJBQ2YsUUFBUTs7MEJBQUksTUFBTTsyQkFBQyx5QkFBeUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtET0NVTUVOVH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7SW5qZWN0LCBJbmplY3RhYmxlLCBPcHRpb25hbCwgTmdab25lfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7SW50ZXJhY3Rpdml0eUNoZWNrZXJ9IGZyb20gJy4uL2ludGVyYWN0aXZpdHktY2hlY2tlci9pbnRlcmFjdGl2aXR5LWNoZWNrZXInO1xuaW1wb3J0IHtDb25maWd1cmFibGVGb2N1c1RyYXB9IGZyb20gJy4vY29uZmlndXJhYmxlLWZvY3VzLXRyYXAnO1xuaW1wb3J0IHtDb25maWd1cmFibGVGb2N1c1RyYXBDb25maWd9IGZyb20gJy4vY29uZmlndXJhYmxlLWZvY3VzLXRyYXAtY29uZmlnJztcbmltcG9ydCB7Rk9DVVNfVFJBUF9JTkVSVF9TVFJBVEVHWSwgRm9jdXNUcmFwSW5lcnRTdHJhdGVneX0gZnJvbSAnLi9mb2N1cy10cmFwLWluZXJ0LXN0cmF0ZWd5JztcbmltcG9ydCB7RXZlbnRMaXN0ZW5lckZvY3VzVHJhcEluZXJ0U3RyYXRlZ3l9IGZyb20gJy4vZXZlbnQtbGlzdGVuZXItaW5lcnQtc3RyYXRlZ3knO1xuaW1wb3J0IHtGb2N1c1RyYXBNYW5hZ2VyfSBmcm9tICcuL2ZvY3VzLXRyYXAtbWFuYWdlcic7XG5cbi8qKiBGYWN0b3J5IHRoYXQgYWxsb3dzIGVhc3kgaW5zdGFudGlhdGlvbiBvZiBjb25maWd1cmFibGUgZm9jdXMgdHJhcHMuICovXG5ASW5qZWN0YWJsZSh7cHJvdmlkZWRJbjogJ3Jvb3QnfSlcbmV4cG9ydCBjbGFzcyBDb25maWd1cmFibGVGb2N1c1RyYXBGYWN0b3J5IHtcbiAgcHJpdmF0ZSBfZG9jdW1lbnQ6IERvY3VtZW50O1xuICBwcml2YXRlIF9pbmVydFN0cmF0ZWd5OiBGb2N1c1RyYXBJbmVydFN0cmF0ZWd5O1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgX2NoZWNrZXI6IEludGVyYWN0aXZpdHlDaGVja2VyLFxuICAgIHByaXZhdGUgX25nWm9uZTogTmdab25lLFxuICAgIHByaXZhdGUgX2ZvY3VzVHJhcE1hbmFnZXI6IEZvY3VzVHJhcE1hbmFnZXIsXG4gICAgQEluamVjdChET0NVTUVOVCkgX2RvY3VtZW50OiBhbnksXG4gICAgQE9wdGlvbmFsKCkgQEluamVjdChGT0NVU19UUkFQX0lORVJUX1NUUkFURUdZKSBfaW5lcnRTdHJhdGVneT86IEZvY3VzVHJhcEluZXJ0U3RyYXRlZ3ksXG4gICkge1xuICAgIHRoaXMuX2RvY3VtZW50ID0gX2RvY3VtZW50O1xuICAgIC8vIFRPRE8gc3BsaXQgdXAgdGhlIHN0cmF0ZWdpZXMgaW50byBkaWZmZXJlbnQgbW9kdWxlcywgc2ltaWxhciB0byBEYXRlQWRhcHRlci5cbiAgICB0aGlzLl9pbmVydFN0cmF0ZWd5ID0gX2luZXJ0U3RyYXRlZ3kgfHwgbmV3IEV2ZW50TGlzdGVuZXJGb2N1c1RyYXBJbmVydFN0cmF0ZWd5KCk7XG4gIH1cblxuICAvKipcbiAgICogQ3JlYXRlcyBhIGZvY3VzLXRyYXBwZWQgcmVnaW9uIGFyb3VuZCB0aGUgZ2l2ZW4gZWxlbWVudC5cbiAgICogQHBhcmFtIGVsZW1lbnQgVGhlIGVsZW1lbnQgYXJvdW5kIHdoaWNoIGZvY3VzIHdpbGwgYmUgdHJhcHBlZC5cbiAgICogQHBhcmFtIGNvbmZpZyBUaGUgZm9jdXMgdHJhcCBjb25maWd1cmF0aW9uLlxuICAgKiBAcmV0dXJucyBUaGUgY3JlYXRlZCBmb2N1cyB0cmFwIGluc3RhbmNlLlxuICAgKi9cbiAgY3JlYXRlKGVsZW1lbnQ6IEhUTUxFbGVtZW50LCBjb25maWc/OiBDb25maWd1cmFibGVGb2N1c1RyYXBDb25maWcpOiBDb25maWd1cmFibGVGb2N1c1RyYXA7XG5cbiAgLyoqXG4gICAqIEBkZXByZWNhdGVkIFBhc3MgYSBjb25maWcgb2JqZWN0IGluc3RlYWQgb2YgdGhlIGBkZWZlckNhcHR1cmVFbGVtZW50c2AgZmxhZy5cbiAgICogQGJyZWFraW5nLWNoYW5nZSAxMS4wLjBcbiAgICovXG4gIGNyZWF0ZShlbGVtZW50OiBIVE1MRWxlbWVudCwgZGVmZXJDYXB0dXJlRWxlbWVudHM6IGJvb2xlYW4pOiBDb25maWd1cmFibGVGb2N1c1RyYXA7XG5cbiAgY3JlYXRlKFxuICAgIGVsZW1lbnQ6IEhUTUxFbGVtZW50LFxuICAgIGNvbmZpZzogQ29uZmlndXJhYmxlRm9jdXNUcmFwQ29uZmlnIHwgYm9vbGVhbiA9IHtkZWZlcjogZmFsc2V9LFxuICApOiBDb25maWd1cmFibGVGb2N1c1RyYXAge1xuICAgIGxldCBjb25maWdPYmplY3Q6IENvbmZpZ3VyYWJsZUZvY3VzVHJhcENvbmZpZztcbiAgICBpZiAodHlwZW9mIGNvbmZpZyA9PT0gJ2Jvb2xlYW4nKSB7XG4gICAgICBjb25maWdPYmplY3QgPSB7ZGVmZXI6IGNvbmZpZ307XG4gICAgfSBlbHNlIHtcbiAgICAgIGNvbmZpZ09iamVjdCA9IGNvbmZpZztcbiAgICB9XG4gICAgcmV0dXJuIG5ldyBDb25maWd1cmFibGVGb2N1c1RyYXAoXG4gICAgICBlbGVtZW50LFxuICAgICAgdGhpcy5fY2hlY2tlcixcbiAgICAgIHRoaXMuX25nWm9uZSxcbiAgICAgIHRoaXMuX2RvY3VtZW50LFxuICAgICAgdGhpcy5fZm9jdXNUcmFwTWFuYWdlcixcbiAgICAgIHRoaXMuX2luZXJ0U3RyYXRlZ3ksXG4gICAgICBjb25maWdPYmplY3QsXG4gICAgKTtcbiAgfVxufVxuIl19