@angular/cdk/bundles/cdk-platform.umd.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common')) :
    typeof define === 'function' && define.amd ? define('@angular/cdk/platform', ['exports', '@angular/core', '@angular/common'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.ng = global.ng || {}, global.ng.cdk = global.ng.cdk || {}, global.ng.cdk.platform = {}), global.ng.core, global.ng.common));
}(this, (function (exports, i0, common) { 'use strict';

    function _interopNamespace(e) {
        if (e && e.__esModule) return e;
        var n = Object.create(null);
        if (e) {
            Object.keys(e).forEach(function (k) {
                if (k !== 'default') {
                    var d = Object.getOwnPropertyDescriptor(e, k);
                    Object.defineProperty(n, k, d.get ? d : {
                        enumerable: true,
                        get: function () {
                            return e[k];
                        }
                    });
                }
            });
        }
        n['default'] = e;
        return Object.freeze(n);
    }

    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);

    /**
     * @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
     */
    // Whether the current platform supports the V8 Break Iterator. The V8 check
    // is necessary to detect all Blink based browsers.
    var hasV8BreakIterator;
    // We need a try/catch around the reference to `Intl`, because accessing it in some cases can
    // cause IE to throw. These cases are tied to particular versions of Windows and can happen if
    // the consumer is providing a polyfilled `Map`. See:
    // https://github.com/Microsoft/ChakraCore/issues/3189
    // https://github.com/angular/components/issues/15687
    try {
        hasV8BreakIterator = (typeof Intl !== 'undefined' && Intl.v8BreakIterator);
    }
    catch (_a) {
        hasV8BreakIterator = false;
    }
    /**
     * Service to detect the current platform by comparing the userAgent strings and
     * checking browser-specific global properties.
     */
    var Platform = /** @class */ (function () {
        function Platform(_platformId) {
            this._platformId = _platformId;
            // We want to use the Angular platform check because if the Document is shimmed
            // without the navigator, the following checks will fail. This is preferred because
            // sometimes the Document may be shimmed without the user's knowledge or intention
            /** Whether the Angular application is being rendered in the browser. */
            this.isBrowser = this._platformId ?
                common.isPlatformBrowser(this._platformId) : typeof document === 'object' && !!document;
            /** Whether the current browser is Microsoft Edge. */
            this.EDGE = this.isBrowser && /(edge)/i.test(navigator.userAgent);
            /** Whether the current rendering engine is Microsoft Trident. */
            this.TRIDENT = this.isBrowser && /(msie|trident)/i.test(navigator.userAgent);
            // EdgeHTML and Trident mock Blink specific things and need to be excluded from this check.
            /** Whether the current rendering engine is Blink. */
            this.BLINK = this.isBrowser && (!!(window.chrome || hasV8BreakIterator) &&
                typeof CSS !== 'undefined' && !this.EDGE && !this.TRIDENT);
            // Webkit is part of the userAgent in EdgeHTML, Blink and Trident. Therefore we need to
            // ensure that Webkit runs standalone and is not used as another engine's base.
            /** Whether the current rendering engine is WebKit. */
            this.WEBKIT = this.isBrowser &&
                /AppleWebKit/i.test(navigator.userAgent) && !this.BLINK && !this.EDGE && !this.TRIDENT;
            /** Whether the current platform is Apple iOS. */
            this.IOS = this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) &&
                !('MSStream' in window);
            // It's difficult to detect the plain Gecko engine, because most of the browsers identify
            // them self as Gecko-like browsers and modify the userAgent's according to that.
            // Since we only cover one explicit Firefox case, we can simply check for Firefox
            // instead of having an unstable check for Gecko.
            /** Whether the current browser is Firefox. */
            this.FIREFOX = this.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);
            /** Whether the current platform is Android. */
            // Trident on mobile adds the android platform to the userAgent to trick detections.
            this.ANDROID = this.isBrowser && /android/i.test(navigator.userAgent) && !this.TRIDENT;
            // Safari browsers will include the Safari keyword in their userAgent. Some browsers may fake
            // this and just place the Safari keyword in the userAgent. To be more safe about Safari every
            // Safari browser should also use Webkit as its layout engine.
            /** Whether the current browser is Safari. */
            this.SAFARI = this.isBrowser && /safari/i.test(navigator.userAgent) && this.WEBKIT;
        }
        return Platform;
    }());
    Platform.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function Platform_Factory() { return new Platform(i0__namespace.ɵɵinject(i0__namespace.PLATFORM_ID)); }, token: Platform, providedIn: "root" });
    Platform.decorators = [
        { type: i0.Injectable, args: [{ providedIn: 'root' },] }
    ];
    Platform.ctorParameters = function () { return [
        { type: Object, decorators: [{ type: i0.Inject, args: [i0.PLATFORM_ID,] }] }
    ]; };

    /**
     * @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
     */
    var PlatformModule = /** @class */ (function () {
        function PlatformModule() {
        }
        return PlatformModule;
    }());
    PlatformModule.decorators = [
        { type: i0.NgModule, args: [{},] }
    ];

    /**
     * @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
     */
    /** Cached result Set of input types support by the current browser. */
    var supportedInputTypes;
    /** Types of `<input>` that *might* be supported. */
    var candidateInputTypes = [
        // `color` must come first. Chrome 56 shows a warning if we change the type to `color` after
        // first changing it to something else:
        // The specified value "" does not conform to the required format.
        // The format is "#rrggbb" where rr, gg, bb are two-digit hexadecimal numbers.
        'color',
        'button',
        'checkbox',
        'date',
        'datetime-local',
        'email',
        'file',
        'hidden',
        'image',
        'month',
        'number',
        'password',
        'radio',
        'range',
        'reset',
        'search',
        'submit',
        'tel',
        'text',
        'time',
        'url',
        'week',
    ];
    /** @returns The input types supported by this browser. */
    function getSupportedInputTypes() {
        // Result is cached.
        if (supportedInputTypes) {
            return supportedInputTypes;
        }
        // We can't check if an input type is not supported until we're on the browser, so say that
        // everything is supported when not on the browser. We don't use `Platform` here since it's
        // just a helper function and can't inject it.
        if (typeof document !== 'object' || !document) {
            supportedInputTypes = new Set(candidateInputTypes);
            return supportedInputTypes;
        }
        var featureTestInput = document.createElement('input');
        supportedInputTypes = new Set(candidateInputTypes.filter(function (value) {
            featureTestInput.setAttribute('type', value);
            return featureTestInput.type === value;
        }));
        return supportedInputTypes;
    }

    /**
     * @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
     */
    /** Cached result of whether the user's browser supports passive event listeners. */
    var supportsPassiveEvents;
    /**
     * Checks whether the user's browser supports passive event listeners.
     * See: https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md
     */
    function supportsPassiveEventListeners() {
        if (supportsPassiveEvents == null && typeof window !== 'undefined') {
            try {
                window.addEventListener('test', null, Object.defineProperty({}, 'passive', {
                    get: function () { return supportsPassiveEvents = true; }
                }));
            }
            finally {
                supportsPassiveEvents = supportsPassiveEvents || false;
            }
        }
        return supportsPassiveEvents;
    }
    /**
     * Normalizes an `AddEventListener` object to something that can be passed
     * to `addEventListener` on any browser, no matter whether it supports the
     * `options` parameter.
     * @param options Object to be normalized.
     */
    function normalizePassiveListenerOptions(options) {
        return supportsPassiveEventListeners() ? options : !!options.capture;
    }

    /**
     * @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
     */
    /** Cached result of the way the browser handles the horizontal scroll axis in RTL mode. */
    var rtlScrollAxisType;
    /** Cached result of the check that indicates whether the browser supports scroll behaviors. */
    var scrollBehaviorSupported;
    /** Check whether the browser supports scroll behaviors. */
    function supportsScrollBehavior() {
        if (scrollBehaviorSupported == null) {
            // If we're not in the browser, it can't be supported. Also check for `Element`, because
            // some projects stub out the global `document` during SSR which can throw us off.
            if (typeof document !== 'object' || !document || typeof Element !== 'function' || !Element) {
                scrollBehaviorSupported = false;
                return scrollBehaviorSupported;
            }
            // If the element can have a `scrollBehavior` style, we can be sure that it's supported.
            if ('scrollBehavior' in document.documentElement.style) {
                scrollBehaviorSupported = true;
            }
            else {
                // At this point we have 3 possibilities: `scrollTo` isn't supported at all, it's
                // supported but it doesn't handle scroll behavior, or it has been polyfilled.
                var scrollToFunction = Element.prototype.scrollTo;
                if (scrollToFunction) {
                    // We can detect if the function has been polyfilled by calling `toString` on it. Native
                    // functions are obfuscated using `[native code]`, whereas if it was overwritten we'd get
                    // the actual function source. Via https://davidwalsh.name/detect-native-function. Consider
                    // polyfilled functions as supporting scroll behavior.
                    scrollBehaviorSupported = !/\{\s*\[native code\]\s*\}/.test(scrollToFunction.toString());
                }
                else {
                    scrollBehaviorSupported = false;
                }
            }
        }
        return scrollBehaviorSupported;
    }
    /**
     * Checks the type of RTL scroll axis used by this browser. As of time of writing, Chrome is NORMAL,
     * Firefox & Safari are NEGATED, and IE & Edge are INVERTED.
     */
    function getRtlScrollAxisType() {
        // We can't check unless we're on the browser. Just assume 'normal' if we're not.
        if (typeof document !== 'object' || !document) {
            return 0 /* NORMAL */;
        }
        if (rtlScrollAxisType == null) {
            // Create a 1px wide scrolling container and a 2px wide content element.
            var scrollContainer = document.createElement('div');
            var containerStyle = scrollContainer.style;
            scrollContainer.dir = 'rtl';
            containerStyle.width = '1px';
            containerStyle.overflow = 'auto';
            containerStyle.visibility = 'hidden';
            containerStyle.pointerEvents = 'none';
            containerStyle.position = 'absolute';
            var content = document.createElement('div');
            var contentStyle = content.style;
            contentStyle.width = '2px';
            contentStyle.height = '1px';
            scrollContainer.appendChild(content);
            document.body.appendChild(scrollContainer);
            rtlScrollAxisType = 0 /* NORMAL */;
            // The viewport starts scrolled all the way to the right in RTL mode. If we are in a NORMAL
            // browser this would mean that the scrollLeft should be 1. If it's zero instead we know we're
            // dealing with one of the other two types of browsers.
            if (scrollContainer.scrollLeft === 0) {
                // In a NEGATED browser the scrollLeft is always somewhere in [-maxScrollAmount, 0]. For an
                // INVERTED browser it is always somewhere in [0, maxScrollAmount]. We can determine which by
                // setting to the scrollLeft to 1. This is past the max for a NEGATED browser, so it will
                // return 0 when we read it again.
                scrollContainer.scrollLeft = 1;
                rtlScrollAxisType =
                    scrollContainer.scrollLeft === 0 ? 1 /* NEGATED */ : 2 /* INVERTED */;
            }
            scrollContainer.parentNode.removeChild(scrollContainer);
        }
        return rtlScrollAxisType;
    }

    /**
     * @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
     */
    var shadowDomIsSupported;
    /** Checks whether the user's browser support Shadow DOM. */
    function _supportsShadowDom() {
        if (shadowDomIsSupported == null) {
            var head = typeof document !== 'undefined' ? document.head : null;
            shadowDomIsSupported = !!(head && (head.createShadowRoot || head.attachShadow));
        }
        return shadowDomIsSupported;
    }
    /** Gets the shadow root of an element, if supported and the element is inside the Shadow DOM. */
    function _getShadowRoot(element) {
        if (_supportsShadowDom()) {
            var rootNode = element.getRootNode ? element.getRootNode() : null;
            // Note that this should be caught by `_supportsShadowDom`, but some
            // teams have been able to hit this code path on unsupported browsers.
            if (typeof ShadowRoot !== 'undefined' && ShadowRoot && rootNode instanceof ShadowRoot) {
                return rootNode;
            }
        }
        return null;
    }
    /**
     * Gets the currently-focused element on the page while
     * also piercing through Shadow DOM boundaries.
     */
    function _getFocusedElementPierceShadowDom() {
        var activeElement = typeof document !== 'undefined' && document ?
            document.activeElement : null;
        while (activeElement && activeElement.shadowRoot) {
            var newActiveElement = activeElement.shadowRoot.activeElement;
            if (newActiveElement === activeElement) {
                break;
            }
            else {
                activeElement = newActiveElement;
            }
        }
        return activeElement;
    }
    /** Gets the target of an event while accounting for Shadow DOM. */
    function _getEventTarget(event) {
        // If an event is bound outside the Shadow DOM, the `event.target` will
        // point to the shadow root so we have to use `composedPath` instead.
        return (event.composedPath ? event.composedPath()[0] : event.target);
    }

    /**
     * @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
     */

    /**
     * Generated bundle index. Do not edit.
     */

    exports.Platform = Platform;
    exports.PlatformModule = PlatformModule;
    exports._getEventTarget = _getEventTarget;
    exports._getFocusedElementPierceShadowDom = _getFocusedElementPierceShadowDom;
    exports._getShadowRoot = _getShadowRoot;
    exports._supportsShadowDom = _supportsShadowDom;
    exports.getRtlScrollAxisType = getRtlScrollAxisType;
    exports.getSupportedInputTypes = getSupportedInputTypes;
    exports.normalizePassiveListenerOptions = normalizePassiveListenerOptions;
    exports.supportsPassiveEventListeners = supportsPassiveEventListeners;
    exports.supportsScrollBehavior = supportsScrollBehavior;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=cdk-platform.umd.js.map