@angular/cdk 13.0.0-next.6 → 13.0.0-rc.1

package/esm2020/platform/features/passive-listeners.mjs

@@ -0,0 +1,36 @@
+/**
+ * @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. */
+let supportsPassiveEvents;
+/**
+ * Checks whether the user's browser supports passive event listeners.
+ * See: https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md
+ */
+export function supportsPassiveEventListeners() {
+    if (supportsPassiveEvents == null && typeof window !== 'undefined') {
+        try {
+            window.addEventListener('test', null, Object.defineProperty({}, 'passive', {
+                get: () => (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.
+ */
+export function normalizePassiveListenerOptions(options) {
+    return supportsPassiveEventListeners() ? options : !!options.capture;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/platform/features/scrolling.mjs

@@ -0,0 +1,85 @@
+/**
+ * @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. */
+let rtlScrollAxisType;
+/** Cached result of the check that indicates whether the browser supports scroll behaviors. */
+let scrollBehaviorSupported;
+/** Check whether the browser supports scroll behaviors. */
+export 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.
+            const 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.
+ */
+export 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.
+        const scrollContainer = document.createElement('div');
+        const containerStyle = scrollContainer.style;
+        scrollContainer.dir = 'rtl';
+        containerStyle.width = '1px';
+        containerStyle.overflow = 'auto';
+        containerStyle.visibility = 'hidden';
+        containerStyle.pointerEvents = 'none';
+        containerStyle.position = 'absolute';
+        const content = document.createElement('div');
+        const 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.remove();
+    }
+    return rtlScrollAxisType;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scrolling.js","sourceRoot":"","sources":["../../../../../../../src/cdk/platform/features/scrolling.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAqBH,2FAA2F;AAC3F,IAAI,iBAAgD,CAAC;AAErD,+FAA+F;AAC/F,IAAI,uBAA4C,CAAC;AAEjD,2DAA2D;AAC3D,MAAM,UAAU,sBAAsB;IACpC,IAAI,uBAAuB,IAAI,IAAI,EAAE;QACnC,wFAAwF;QACxF,kFAAkF;QAClF,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,QAAQ,IAAI,OAAO,OAAO,KAAK,UAAU,IAAI,CAAC,OAAO,EAAE;YAC1F,uBAAuB,GAAG,KAAK,CAAC;YAChC,OAAO,uBAAuB,CAAC;SAChC;QAED,wFAAwF;QACxF,IAAI,gBAAgB,IAAI,QAAQ,CAAC,eAAgB,CAAC,KAAK,EAAE;YACvD,uBAAuB,GAAG,IAAI,CAAC;SAChC;aAAM;YACL,iFAAiF;YACjF,8EAA8E;YAC9E,MAAM,gBAAgB,GAAyB,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC;YAE1E,IAAI,gBAAgB,EAAE;gBACpB,wFAAwF;gBACxF,yFAAyF;gBACzF,2FAA2F;gBAC3F,sDAAsD;gBACtD,uBAAuB,GAAG,CAAC,2BAA2B,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,CAAC;aAC1F;iBAAM;gBACL,uBAAuB,GAAG,KAAK,CAAC;aACjC;SACF;KACF;IAED,OAAO,uBAAuB,CAAC;AACjC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB;IAClC,iFAAiF;IACjF,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,QAAQ,EAAE;QAC7C,sBAAgC;KACjC;IAED,IAAI,iBAAiB,IAAI,IAAI,EAAE;QAC7B,wEAAwE;QACxE,MAAM,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACtD,MAAM,cAAc,GAAG,eAAe,CAAC,KAAK,CAAC;QAC7C,eAAe,CAAC,GAAG,GAAG,KAAK,CAAC;QAC5B,cAAc,CAAC,KAAK,GAAG,KAAK,CAAC;QAC7B,cAAc,CAAC,QAAQ,GAAG,MAAM,CAAC;QACjC,cAAc,CAAC,UAAU,GAAG,QAAQ,CAAC;QACrC,cAAc,CAAC,aAAa,GAAG,MAAM,CAAC;QACtC,cAAc,CAAC,QAAQ,GAAG,UAAU,CAAC;QAErC,MAAM,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC9C,MAAM,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC;QACnC,YAAY,CAAC,KAAK,GAAG,KAAK,CAAC;QAC3B,YAAY,CAAC,MAAM,GAAG,KAAK,CAAC;QAE5B,eAAe,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACrC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC;QAE3C,iBAAiB,iBAA2B,CAAC;QAE7C,2FAA2F;QAC3F,8FAA8F;QAC9F,uDAAuD;QACvD,IAAI,eAAe,CAAC,UAAU,KAAK,CAAC,EAAE;YACpC,2FAA2F;YAC3F,6FAA6F;YAC7F,yFAAyF;YACzF,kCAAkC;YAClC,eAAe,CAAC,UAAU,GAAG,CAAC,CAAC;YAC/B,iBAAiB;gBACf,eAAe,CAAC,UAAU,KAAK,CAAC,CAAC,CAAC,iBAA2B,CAAC,iBAA2B,CAAC;SAC7F;QAED,eAAe,CAAC,MAAM,EAAE,CAAC;KAC1B;IACD,OAAO,iBAAiB,CAAC;AAC3B,CAAC","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\n/** The possible ways the browser may handle the horizontal scroll axis in RTL languages. */\nexport const enum RtlScrollAxisType {\n  /**\n   * scrollLeft is 0 when scrolled all the way left and (scrollWidth - clientWidth) when scrolled\n   * all the way right.\n   */\n  NORMAL,\n  /**\n   * scrollLeft is -(scrollWidth - clientWidth) when scrolled all the way left and 0 when scrolled\n   * all the way right.\n   */\n  NEGATED,\n  /**\n   * scrollLeft is (scrollWidth - clientWidth) when scrolled all the way left and 0 when scrolled\n   * all the way right.\n   */\n  INVERTED,\n}\n\n/** Cached result of the way the browser handles the horizontal scroll axis in RTL mode. */\nlet rtlScrollAxisType: RtlScrollAxisType | undefined;\n\n/** Cached result of the check that indicates whether the browser supports scroll behaviors. */\nlet scrollBehaviorSupported: boolean | undefined;\n\n/** Check whether the browser supports scroll behaviors. */\nexport function supportsScrollBehavior(): boolean {\n  if (scrollBehaviorSupported == null) {\n    // If we're not in the browser, it can't be supported. Also check for `Element`, because\n    // some projects stub out the global `document` during SSR which can throw us off.\n    if (typeof document !== 'object' || !document || typeof Element !== 'function' || !Element) {\n      scrollBehaviorSupported = false;\n      return scrollBehaviorSupported;\n    }\n\n    // If the element can have a `scrollBehavior` style, we can be sure that it's supported.\n    if ('scrollBehavior' in document.documentElement!.style) {\n      scrollBehaviorSupported = true;\n    } else {\n      // At this point we have 3 possibilities: `scrollTo` isn't supported at all, it's\n      // supported but it doesn't handle scroll behavior, or it has been polyfilled.\n      const scrollToFunction: Function | undefined = Element.prototype.scrollTo;\n\n      if (scrollToFunction) {\n        // We can detect if the function has been polyfilled by calling `toString` on it. Native\n        // functions are obfuscated using `[native code]`, whereas if it was overwritten we'd get\n        // the actual function source. Via https://davidwalsh.name/detect-native-function. Consider\n        // polyfilled functions as supporting scroll behavior.\n        scrollBehaviorSupported = !/\\{\\s*\\[native code\\]\\s*\\}/.test(scrollToFunction.toString());\n      } else {\n        scrollBehaviorSupported = false;\n      }\n    }\n  }\n\n  return scrollBehaviorSupported;\n}\n\n/**\n * Checks the type of RTL scroll axis used by this browser. As of time of writing, Chrome is NORMAL,\n * Firefox & Safari are NEGATED, and IE & Edge are INVERTED.\n */\nexport function getRtlScrollAxisType(): RtlScrollAxisType {\n  // We can't check unless we're on the browser. Just assume 'normal' if we're not.\n  if (typeof document !== 'object' || !document) {\n    return RtlScrollAxisType.NORMAL;\n  }\n\n  if (rtlScrollAxisType == null) {\n    // Create a 1px wide scrolling container and a 2px wide content element.\n    const scrollContainer = document.createElement('div');\n    const containerStyle = scrollContainer.style;\n    scrollContainer.dir = 'rtl';\n    containerStyle.width = '1px';\n    containerStyle.overflow = 'auto';\n    containerStyle.visibility = 'hidden';\n    containerStyle.pointerEvents = 'none';\n    containerStyle.position = 'absolute';\n\n    const content = document.createElement('div');\n    const contentStyle = content.style;\n    contentStyle.width = '2px';\n    contentStyle.height = '1px';\n\n    scrollContainer.appendChild(content);\n    document.body.appendChild(scrollContainer);\n\n    rtlScrollAxisType = RtlScrollAxisType.NORMAL;\n\n    // The viewport starts scrolled all the way to the right in RTL mode. If we are in a NORMAL\n    // browser this would mean that the scrollLeft should be 1. If it's zero instead we know we're\n    // dealing with one of the other two types of browsers.\n    if (scrollContainer.scrollLeft === 0) {\n      // In a NEGATED browser the scrollLeft is always somewhere in [-maxScrollAmount, 0]. For an\n      // INVERTED browser it is always somewhere in [0, maxScrollAmount]. We can determine which by\n      // setting to the scrollLeft to 1. This is past the max for a NEGATED browser, so it will\n      // return 0 when we read it again.\n      scrollContainer.scrollLeft = 1;\n      rtlScrollAxisType =\n        scrollContainer.scrollLeft === 0 ? RtlScrollAxisType.NEGATED : RtlScrollAxisType.INVERTED;\n    }\n\n    scrollContainer.remove();\n  }\n  return rtlScrollAxisType;\n}\n"]}

package/{esm2015/platform/features/shadow-dom.js → esm2020/platform/features/shadow-dom.mjs}

@@ -31,8 +31,9 @@ export function _getShadowRoot(element) {
  * also piercing through Shadow DOM boundaries.
  */
 export function _getFocusedElementPierceShadowDom() {
-    let activeElement = typeof document !== 'undefined' && document ?
-        document.activeElement : null;
+    let activeElement = typeof document !== 'undefined' && document
+        ? document.activeElement
+        : null;
     while (activeElement && activeElement.shadowRoot) {
         const newActiveElement = activeElement.shadowRoot.activeElement;
         if (newActiveElement === activeElement) {
@@ -50,4 +51,4 @@ export function _getEventTarget(event) {
     // point to the shadow root so we have to use `composedPath` instead.
     return (event.composedPath ? event.composedPath()[0] : event.target);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/platform/features/test-environment.mjs

@@ -0,0 +1,27 @@
+/**
+ * @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
+ */
+let testGlobals;
+// We check the Node-specific `global` first, because tools tend to add a fake
+// `window` in Node environments which won't actually receive global variables.
+if (typeof global !== 'undefined') {
+    testGlobals = global;
+}
+else if (typeof window !== 'undefined') {
+    testGlobals = window;
+}
+else {
+    testGlobals = {};
+}
+/** Gets whether the code is currently running in a test environment. */
+export function _isTestEnvironment() {
+    return ((typeof testGlobals.__karma__ !== 'undefined' && !!testGlobals.__karma__) ||
+        (typeof testGlobals.jasmine !== 'undefined' && !!testGlobals.jasmine) ||
+        (typeof testGlobals.jest !== 'undefined' && !!testGlobals.jest) ||
+        (typeof testGlobals.Mocha !== 'undefined' && !!testGlobals.Mocha));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/platform/platform-module.mjs

@@ -0,0 +1,19 @@
+/**
+ * @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 { NgModule } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PlatformModule {
+}
+PlatformModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: PlatformModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+PlatformModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: PlatformModule });
+PlatformModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: PlatformModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: PlatformModule, decorators: [{
+            type: NgModule,
+            args: [{}]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhdGZvcm0tbW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2Nkay9wbGF0Zm9ybS9wbGF0Zm9ybS1tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQzs7QUFHdkMsTUFBTSxPQUFPLGNBQWM7O21IQUFkLGNBQWM7b0hBQWQsY0FBYztvSEFBZCxjQUFjO21HQUFkLGNBQWM7a0JBRDFCLFFBQVE7bUJBQUMsRUFBRSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQE5nTW9kdWxlKHt9KVxuZXhwb3J0IGNsYXNzIFBsYXRmb3JtTW9kdWxlIHt9XG4iXX0=

package/esm2020/platform/platform.mjs

@@ -0,0 +1,85 @@
+/**
+ * @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 { Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+// Whether the current platform supports the V8 Break Iterator. The V8 check
+// is necessary to detect all Blink based browsers.
+let 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 {
+    hasV8BreakIterator = false;
+}
+/**
+ * Service to detect the current platform by comparing the userAgent strings and
+ * checking browser-specific global properties.
+ */
+export class Platform {
+    constructor(_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
+            ? 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;
+    }
+}
+Platform.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: Platform, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+Platform.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: Platform, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: Platform, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform.js","sourceRoot":"","sources":["../../../../../../src/cdk/platform/platform.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,WAAW,EAAC,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAC,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;;AAElD,4EAA4E;AAC5E,mDAAmD;AACnD,IAAI,kBAA2B,CAAC;AAEhC,6FAA6F;AAC7F,8FAA8F;AAC9F,qDAAqD;AACrD,sDAAsD;AACtD,qDAAqD;AACrD,IAAI;IACF,kBAAkB,GAAG,OAAO,IAAI,KAAK,WAAW,IAAK,IAAY,CAAC,eAAe,CAAC;CACnF;AAAC,MAAM;IACN,kBAAkB,GAAG,KAAK,CAAC;CAC5B;AAED;;;GAGG;AAEH,MAAM,OAAO,QAAQ;IAuDnB,YAAyC,WAAmB;QAAnB,gBAAW,GAAX,WAAW,CAAQ;QAtD5D,+EAA+E;QAC/E,mFAAmF;QACnF,kFAAkF;QAClF,wEAAwE;QACxE,cAAS,GAAY,IAAI,CAAC,WAAW;YACnC,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,WAAW,CAAC;YACrC,CAAC,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,CAAC,QAAQ,CAAC;QAE/C,qDAAqD;QACrD,SAAI,GAAY,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAEtE,iEAAiE;QACjE,YAAO,GAAY,IAAI,CAAC,SAAS,IAAI,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAEjF,2FAA2F;QAC3F,qDAAqD;QACrD,UAAK,GACH,IAAI,CAAC,SAAS;YACd,CAAC,CAAC,CAAE,MAAc,CAAC,MAAM,IAAI,kBAAkB,CAAC;YAChD,OAAO,GAAG,KAAK,WAAW;YAC1B,CAAC,IAAI,CAAC,IAAI;YACV,CAAC,IAAI,CAAC,OAAO,CAAC;QAEhB,uFAAuF;QACvF,+EAA+E;QAC/E,sDAAsD;QACtD,WAAM,GACJ,IAAI,CAAC,SAAS;YACd,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;YACxC,CAAC,IAAI,CAAC,KAAK;YACX,CAAC,IAAI,CAAC,IAAI;YACV,CAAC,IAAI,CAAC,OAAO,CAAC;QAEhB,iDAAiD;QACjD,QAAG,GACD,IAAI,CAAC,SAAS,IAAI,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,UAAU,IAAI,MAAM,CAAC,CAAC;QAE5F,yFAAyF;QACzF,iFAAiF;QACjF,iFAAiF;QACjF,iDAAiD;QACjD,8CAA8C;QAC9C,YAAO,GAAY,IAAI,CAAC,SAAS,IAAI,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAEtF,+CAA+C;QAC/C,oFAAoF;QACpF,YAAO,GAAY,IAAI,CAAC,SAAS,IAAI,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;QAE3F,6FAA6F;QAC7F,8FAA8F;QAC9F,8DAA8D;QAC9D,6CAA6C;QAC7C,WAAM,GAAY,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC;IAExB,CAAC;;6GAvDrD,QAAQ,kBAuDC,WAAW;iHAvDpB,QAAQ,cADI,MAAM;mGAClB,QAAQ;kBADpB,UAAU;mBAAC,EAAC,UAAU,EAAE,MAAM,EAAC;0DAwDwB,MAAM;0BAA/C,MAAM;2BAAC,WAAW","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 {Inject, Injectable, PLATFORM_ID} from '@angular/core';\nimport {isPlatformBrowser} from '@angular/common';\n\n// Whether the current platform supports the V8 Break Iterator. The V8 check\n// is necessary to detect all Blink based browsers.\nlet hasV8BreakIterator: boolean;\n\n// We need a try/catch around the reference to `Intl`, because accessing it in some cases can\n// cause IE to throw. These cases are tied to particular versions of Windows and can happen if\n// the consumer is providing a polyfilled `Map`. See:\n// https://github.com/Microsoft/ChakraCore/issues/3189\n// https://github.com/angular/components/issues/15687\ntry {\n  hasV8BreakIterator = typeof Intl !== 'undefined' && (Intl as any).v8BreakIterator;\n} catch {\n  hasV8BreakIterator = false;\n}\n\n/**\n * Service to detect the current platform by comparing the userAgent strings and\n * checking browser-specific global properties.\n */\n@Injectable({providedIn: 'root'})\nexport class Platform {\n  // We want to use the Angular platform check because if the Document is shimmed\n  // without the navigator, the following checks will fail. This is preferred because\n  // sometimes the Document may be shimmed without the user's knowledge or intention\n  /** Whether the Angular application is being rendered in the browser. */\n  isBrowser: boolean = this._platformId\n    ? isPlatformBrowser(this._platformId)\n    : typeof document === 'object' && !!document;\n\n  /** Whether the current browser is Microsoft Edge. */\n  EDGE: boolean = this.isBrowser && /(edge)/i.test(navigator.userAgent);\n\n  /** Whether the current rendering engine is Microsoft Trident. */\n  TRIDENT: boolean = this.isBrowser && /(msie|trident)/i.test(navigator.userAgent);\n\n  // EdgeHTML and Trident mock Blink specific things and need to be excluded from this check.\n  /** Whether the current rendering engine is Blink. */\n  BLINK: boolean =\n    this.isBrowser &&\n    !!((window as any).chrome || hasV8BreakIterator) &&\n    typeof CSS !== 'undefined' &&\n    !this.EDGE &&\n    !this.TRIDENT;\n\n  // Webkit is part of the userAgent in EdgeHTML, Blink and Trident. Therefore we need to\n  // ensure that Webkit runs standalone and is not used as another engine's base.\n  /** Whether the current rendering engine is WebKit. */\n  WEBKIT: boolean =\n    this.isBrowser &&\n    /AppleWebKit/i.test(navigator.userAgent) &&\n    !this.BLINK &&\n    !this.EDGE &&\n    !this.TRIDENT;\n\n  /** Whether the current platform is Apple iOS. */\n  IOS: boolean =\n    this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) && !('MSStream' in window);\n\n  // It's difficult to detect the plain Gecko engine, because most of the browsers identify\n  // them self as Gecko-like browsers and modify the userAgent's according to that.\n  // Since we only cover one explicit Firefox case, we can simply check for Firefox\n  // instead of having an unstable check for Gecko.\n  /** Whether the current browser is Firefox. */\n  FIREFOX: boolean = this.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);\n\n  /** Whether the current platform is Android. */\n  // Trident on mobile adds the android platform to the userAgent to trick detections.\n  ANDROID: boolean = this.isBrowser && /android/i.test(navigator.userAgent) && !this.TRIDENT;\n\n  // Safari browsers will include the Safari keyword in their userAgent. Some browsers may fake\n  // this and just place the Safari keyword in the userAgent. To be more safe about Safari every\n  // Safari browser should also use Webkit as its layout engine.\n  /** Whether the current browser is Safari. */\n  SAFARI: boolean = this.isBrowser && /safari/i.test(navigator.userAgent) && this.WEBKIT;\n\n  constructor(@Inject(PLATFORM_ID) private _platformId: Object) {}\n}\n"]}

package/esm2020/portal/dom-portal-outlet.mjs

@@ -0,0 +1,134 @@
+/**
+ * @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 { BasePortalOutlet } from './portal';
+/**
+ * A PortalOutlet for attaching portals to an arbitrary DOM element outside of the Angular
+ * application context.
+ */
+export class DomPortalOutlet extends BasePortalOutlet {
+    constructor(
+    /** Element into which the content is projected. */
+    outletElement, _componentFactoryResolver, _appRef, _defaultInjector, 
+    /**
+     * @deprecated `_document` Parameter to be made required.
+     * @breaking-change 10.0.0
+     */
+    _document) {
+        super();
+        this.outletElement = outletElement;
+        this._componentFactoryResolver = _componentFactoryResolver;
+        this._appRef = _appRef;
+        this._defaultInjector = _defaultInjector;
+        /**
+         * Attaches a DOM portal by transferring its content into the outlet.
+         * @param portal Portal to be attached.
+         * @deprecated To be turned into a method.
+         * @breaking-change 10.0.0
+         */
+        this.attachDomPortal = (portal) => {
+            // @breaking-change 10.0.0 Remove check and error once the
+            // `_document` constructor parameter is required.
+            if (!this._document && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+                throw Error('Cannot attach DOM portal without _document constructor parameter');
+            }
+            const element = portal.element;
+            if (!element.parentNode && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+                throw Error('DOM portal content must be attached to a parent node.');
+            }
+            // Anchor used to save the element's previous position so
+            // that we can restore it when the portal is detached.
+            const anchorNode = this._document.createComment('dom-portal');
+            element.parentNode.insertBefore(anchorNode, element);
+            this.outletElement.appendChild(element);
+            this._attachedPortal = portal;
+            super.setDisposeFn(() => {
+                // We can't use `replaceWith` here because IE doesn't support it.
+                if (anchorNode.parentNode) {
+                    anchorNode.parentNode.replaceChild(element, anchorNode);
+                }
+            });
+        };
+        this._document = _document;
+    }
+    /**
+     * Attach the given ComponentPortal to DOM element using the ComponentFactoryResolver.
+     * @param portal Portal to be attached
+     * @returns Reference to the created component.
+     */
+    attachComponentPortal(portal) {
+        const resolver = portal.componentFactoryResolver || this._componentFactoryResolver;
+        const componentFactory = resolver.resolveComponentFactory(portal.component);
+        let componentRef;
+        // If the portal specifies a ViewContainerRef, we will use that as the attachment point
+        // for the component (in terms of Angular's component tree, not rendering).
+        // When the ViewContainerRef is missing, we use the factory to create the component directly
+        // and then manually attach the view to the application.
+        if (portal.viewContainerRef) {
+            componentRef = portal.viewContainerRef.createComponent(componentFactory, portal.viewContainerRef.length, portal.injector || portal.viewContainerRef.injector);
+            this.setDisposeFn(() => componentRef.destroy());
+        }
+        else {
+            componentRef = componentFactory.create(portal.injector || this._defaultInjector);
+            this._appRef.attachView(componentRef.hostView);
+            this.setDisposeFn(() => {
+                this._appRef.detachView(componentRef.hostView);
+                componentRef.destroy();
+            });
+        }
+        // At this point the component has been instantiated, so we move it to the location in the DOM
+        // where we want it to be rendered.
+        this.outletElement.appendChild(this._getComponentRootNode(componentRef));
+        this._attachedPortal = portal;
+        return componentRef;
+    }
+    /**
+     * Attaches a template portal to the DOM as an embedded view.
+     * @param portal Portal to be attached.
+     * @returns Reference to the created embedded view.
+     */
+    attachTemplatePortal(portal) {
+        let viewContainer = portal.viewContainerRef;
+        let viewRef = viewContainer.createEmbeddedView(portal.templateRef, portal.context);
+        // The method `createEmbeddedView` will add the view as a child of the viewContainer.
+        // But for the DomPortalOutlet the view can be added everywhere in the DOM
+        // (e.g Overlay Container) To move the view to the specified host element. We just
+        // re-append the existing root nodes.
+        viewRef.rootNodes.forEach(rootNode => this.outletElement.appendChild(rootNode));
+        // Note that we want to detect changes after the nodes have been moved so that
+        // any directives inside the portal that are looking at the DOM inside a lifecycle
+        // hook won't be invoked too early.
+        viewRef.detectChanges();
+        this.setDisposeFn(() => {
+            let index = viewContainer.indexOf(viewRef);
+            if (index !== -1) {
+                viewContainer.remove(index);
+            }
+        });
+        this._attachedPortal = portal;
+        // TODO(jelbourn): Return locals from view.
+        return viewRef;
+    }
+    /**
+     * Clears out a portal from the DOM.
+     */
+    dispose() {
+        super.dispose();
+        this.outletElement.remove();
+    }
+    /** Gets the root HTMLElement for an instantiated component. */
+    _getComponentRootNode(componentRef) {
+        return componentRef.hostView.rootNodes[0];
+    }
+}
+/**
+ * @deprecated Use `DomPortalOutlet` instead.
+ * @breaking-change 9.0.0
+ */
+export class DomPortalHost extends DomPortalOutlet {
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dom-portal-outlet.js","sourceRoot":"","sources":["../../../../../../src/cdk/portal/dom-portal-outlet.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  ComponentFactoryResolver,\n  ComponentRef,\n  EmbeddedViewRef,\n  ApplicationRef,\n  Injector,\n} from '@angular/core';\nimport {BasePortalOutlet, ComponentPortal, TemplatePortal, DomPortal} from './portal';\n\n/**\n * A PortalOutlet for attaching portals to an arbitrary DOM element outside of the Angular\n * application context.\n */\nexport class DomPortalOutlet extends BasePortalOutlet {\n  private _document: Document;\n\n  constructor(\n    /** Element into which the content is projected. */\n    public outletElement: Element,\n    private _componentFactoryResolver: ComponentFactoryResolver,\n    private _appRef: ApplicationRef,\n    private _defaultInjector: Injector,\n\n    /**\n     * @deprecated `_document` Parameter to be made required.\n     * @breaking-change 10.0.0\n     */\n    _document?: any,\n  ) {\n    super();\n    this._document = _document;\n  }\n\n  /**\n   * Attach the given ComponentPortal to DOM element using the ComponentFactoryResolver.\n   * @param portal Portal to be attached\n   * @returns Reference to the created component.\n   */\n  attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T> {\n    const resolver = portal.componentFactoryResolver || this._componentFactoryResolver;\n    const componentFactory = resolver.resolveComponentFactory(portal.component);\n    let componentRef: ComponentRef<T>;\n\n    // If the portal specifies a ViewContainerRef, we will use that as the attachment point\n    // for the component (in terms of Angular's component tree, not rendering).\n    // When the ViewContainerRef is missing, we use the factory to create the component directly\n    // and then manually attach the view to the application.\n    if (portal.viewContainerRef) {\n      componentRef = portal.viewContainerRef.createComponent(\n        componentFactory,\n        portal.viewContainerRef.length,\n        portal.injector || portal.viewContainerRef.injector,\n      );\n\n      this.setDisposeFn(() => componentRef.destroy());\n    } else {\n      componentRef = componentFactory.create(portal.injector || this._defaultInjector);\n      this._appRef.attachView(componentRef.hostView);\n      this.setDisposeFn(() => {\n        this._appRef.detachView(componentRef.hostView);\n        componentRef.destroy();\n      });\n    }\n    // At this point the component has been instantiated, so we move it to the location in the DOM\n    // where we want it to be rendered.\n    this.outletElement.appendChild(this._getComponentRootNode(componentRef));\n    this._attachedPortal = portal;\n\n    return componentRef;\n  }\n\n  /**\n   * Attaches a template portal to the DOM as an embedded view.\n   * @param portal Portal to be attached.\n   * @returns Reference to the created embedded view.\n   */\n  attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C> {\n    let viewContainer = portal.viewContainerRef;\n    let viewRef = viewContainer.createEmbeddedView(portal.templateRef, portal.context);\n\n    // The method `createEmbeddedView` will add the view as a child of the viewContainer.\n    // But for the DomPortalOutlet the view can be added everywhere in the DOM\n    // (e.g Overlay Container) To move the view to the specified host element. We just\n    // re-append the existing root nodes.\n    viewRef.rootNodes.forEach(rootNode => this.outletElement.appendChild(rootNode));\n\n    // Note that we want to detect changes after the nodes have been moved so that\n    // any directives inside the portal that are looking at the DOM inside a lifecycle\n    // hook won't be invoked too early.\n    viewRef.detectChanges();\n\n    this.setDisposeFn(() => {\n      let index = viewContainer.indexOf(viewRef);\n      if (index !== -1) {\n        viewContainer.remove(index);\n      }\n    });\n\n    this._attachedPortal = portal;\n\n    // TODO(jelbourn): Return locals from view.\n    return viewRef;\n  }\n\n  /**\n   * Attaches a DOM portal by transferring its content into the outlet.\n   * @param portal Portal to be attached.\n   * @deprecated To be turned into a method.\n   * @breaking-change 10.0.0\n   */\n  override attachDomPortal = (portal: DomPortal) => {\n    // @breaking-change 10.0.0 Remove check and error once the\n    // `_document` constructor parameter is required.\n    if (!this._document && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('Cannot attach DOM portal without _document constructor parameter');\n    }\n\n    const element = portal.element;\n    if (!element.parentNode && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('DOM portal content must be attached to a parent node.');\n    }\n\n    // Anchor used to save the element's previous position so\n    // that we can restore it when the portal is detached.\n    const anchorNode = this._document.createComment('dom-portal');\n\n    element.parentNode!.insertBefore(anchorNode, element);\n    this.outletElement.appendChild(element);\n    this._attachedPortal = portal;\n\n    super.setDisposeFn(() => {\n      // We can't use `replaceWith` here because IE doesn't support it.\n      if (anchorNode.parentNode) {\n        anchorNode.parentNode.replaceChild(element, anchorNode);\n      }\n    });\n  };\n\n  /**\n   * Clears out a portal from the DOM.\n   */\n  override dispose(): void {\n    super.dispose();\n    this.outletElement.remove();\n  }\n\n  /** Gets the root HTMLElement for an instantiated component. */\n  private _getComponentRootNode(componentRef: ComponentRef<any>): HTMLElement {\n    return (componentRef.hostView as EmbeddedViewRef<any>).rootNodes[0] as HTMLElement;\n  }\n}\n\n/**\n * @deprecated Use `DomPortalOutlet` instead.\n * @breaking-change 9.0.0\n */\nexport class DomPortalHost extends DomPortalOutlet {}\n"]}