@angular/cdk 10.0.0-rc.3 → 10.1.0

package/esm2015/a11y/aria-describer/aria-describer.js

@@ -8,8 +8,10 @@
 import { DOCUMENT } from '@angular/common';
 import { Inject, Injectable } from '@angular/core';
 import { addAriaReferencedId, getAriaReferenceIds, removeAriaReferencedId } from './aria-reference';
+import { Platform } from '@angular/cdk/platform';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/platform";
 /** ID used for the body container where all messages are appended. */
 export const MESSAGES_CONTAINER_ID = 'cdk-describedby-message-container';
 /** ID prefix used for each created message element. */
@@ -27,182 +29,190 @@ let messagesContainer = null;
  * want to use aria-describedby to further describe themselves without adding additional visual
  * content.
  */
-let AriaDescriber = /** @class */ (() => {
-    class AriaDescriber {
-        constructor(_document) {
-            this._document = _document;
-        }
-        /**
-         * Adds to the host element an aria-describedby reference to a hidden element that contains
-         * the message. If the same message has already been registered, then it will reuse the created
-         * message element.
-         */
-        describe(hostElement, message) {
-            if (!this._canBeDescribed(hostElement, message)) {
-                return;
-            }
-            if (typeof message !== 'string') {
-                // We need to ensure that the element has an ID.
-                this._setMessageId(message);
-                messageRegistry.set(message, { messageElement: message, referenceCount: 0 });
-            }
-            else if (!messageRegistry.has(message)) {
-                this._createMessageElement(message);
-            }
-            if (!this._isElementDescribedByMessage(hostElement, message)) {
-                this._addMessageReference(hostElement, message);
-            }
+export class AriaDescriber {
+    constructor(_document, 
+    /**
+     * @breaking-change 8.0.0 `_platform` parameter to be made required.
+     */
+    _platform) {
+        this._platform = _platform;
+        this._document = _document;
+    }
+    /**
+     * Adds to the host element an aria-describedby reference to a hidden element that contains
+     * the message. If the same message has already been registered, then it will reuse the created
+     * message element.
+     */
+    describe(hostElement, message) {
+        if (!this._canBeDescribed(hostElement, message)) {
+            return;
         }
-        /** Removes the host element's aria-describedby reference to the message element. */
-        removeDescription(hostElement, message) {
-            if (!this._isElementNode(hostElement)) {
-                return;
-            }
-            if (this._isElementDescribedByMessage(hostElement, message)) {
-                this._removeMessageReference(hostElement, message);
-            }
-            // If the message is a string, it means that it's one that we created for the
-            // consumer so we can remove it safely, otherwise we should leave it in place.
-            if (typeof message === 'string') {
-                const registeredMessage = messageRegistry.get(message);
-                if (registeredMessage && registeredMessage.referenceCount === 0) {
-                    this._deleteMessageElement(message);
-                }
-            }
-            if (messagesContainer && messagesContainer.childNodes.length === 0) {
-                this._deleteMessagesContainer();
-            }
+        if (typeof message !== 'string') {
+            // We need to ensure that the element has an ID.
+            this._setMessageId(message);
+            messageRegistry.set(message, { messageElement: message, referenceCount: 0 });
         }
-        /** Unregisters all created message elements and removes the message container. */
-        ngOnDestroy() {
-            const describedElements = this._document.querySelectorAll(`[${CDK_DESCRIBEDBY_HOST_ATTRIBUTE}]`);
-            for (let i = 0; i < describedElements.length; i++) {
-                this._removeCdkDescribedByReferenceIds(describedElements[i]);
-                describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
-            }
-            if (messagesContainer) {
-                this._deleteMessagesContainer();
-            }
-            messageRegistry.clear();
-        }
-        /**
-         * Creates a new element in the visually hidden message container element with the message
-         * as its content and adds it to the message registry.
-         */
-        _createMessageElement(message) {
-            const messageElement = this._document.createElement('div');
-            this._setMessageId(messageElement);
-            messageElement.textContent = message;
-            this._createMessagesContainer();
-            messagesContainer.appendChild(messageElement);
-            messageRegistry.set(message, { messageElement, referenceCount: 0 });
-        }
-        /** Assigns a unique ID to an element, if it doesn't have one already. */
-        _setMessageId(element) {
-            if (!element.id) {
-                element.id = `${CDK_DESCRIBEDBY_ID_PREFIX}-${nextId++}`;
-            }
+        else if (!messageRegistry.has(message)) {
+            this._createMessageElement(message);
+        }
+        if (!this._isElementDescribedByMessage(hostElement, message)) {
+            this._addMessageReference(hostElement, message);
+        }
+    }
+    /** Removes the host element's aria-describedby reference to the message element. */
+    removeDescription(hostElement, message) {
+        if (!this._isElementNode(hostElement)) {
+            return;
         }
-        /** Deletes the message element from the global messages container. */
-        _deleteMessageElement(message) {
+        if (this._isElementDescribedByMessage(hostElement, message)) {
+            this._removeMessageReference(hostElement, message);
+        }
+        // If the message is a string, it means that it's one that we created for the
+        // consumer so we can remove it safely, otherwise we should leave it in place.
+        if (typeof message === 'string') {
             const registeredMessage = messageRegistry.get(message);
-            const messageElement = registeredMessage && registeredMessage.messageElement;
-            if (messagesContainer && messageElement) {
-                messagesContainer.removeChild(messageElement);
-            }
-            messageRegistry.delete(message);
-        }
-        /** Creates the global container for all aria-describedby messages. */
-        _createMessagesContainer() {
-            if (!messagesContainer) {
-                const preExistingContainer = this._document.getElementById(MESSAGES_CONTAINER_ID);
-                // When going from the server to the client, we may end up in a situation where there's
-                // already a container on the page, but we don't have a reference to it. Clear the
-                // old container so we don't get duplicates. Doing this, instead of emptying the previous
-                // container, should be slightly faster.
-                if (preExistingContainer) {
-                    preExistingContainer.parentNode.removeChild(preExistingContainer);
-                }
-                messagesContainer = this._document.createElement('div');
-                messagesContainer.id = MESSAGES_CONTAINER_ID;
-                messagesContainer.setAttribute('aria-hidden', 'true');
-                messagesContainer.style.display = 'none';
-                this._document.body.appendChild(messagesContainer);
+            if (registeredMessage && registeredMessage.referenceCount === 0) {
+                this._deleteMessageElement(message);
             }
         }
-        /** Deletes the global messages container. */
-        _deleteMessagesContainer() {
-            if (messagesContainer && messagesContainer.parentNode) {
-                messagesContainer.parentNode.removeChild(messagesContainer);
-                messagesContainer = null;
-            }
+        if (messagesContainer && messagesContainer.childNodes.length === 0) {
+            this._deleteMessagesContainer();
         }
-        /** Removes all cdk-describedby messages that are hosted through the element. */
-        _removeCdkDescribedByReferenceIds(element) {
-            // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX
-            const originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')
-                .filter(id => id.indexOf(CDK_DESCRIBEDBY_ID_PREFIX) != 0);
-            element.setAttribute('aria-describedby', originalReferenceIds.join(' '));
-        }
-        /**
-         * Adds a message reference to the element using aria-describedby and increments the registered
-         * message's reference count.
-         */
-        _addMessageReference(element, message) {
-            const registeredMessage = messageRegistry.get(message);
-            // Add the aria-describedby reference and set the
-            // describedby_host attribute to mark the element.
-            addAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
-            element.setAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE, '');
-            registeredMessage.referenceCount++;
-        }
-        /**
-         * Removes a message reference from the element using aria-describedby
-         * and decrements the registered message's reference count.
-         */
-        _removeMessageReference(element, message) {
-            const registeredMessage = messageRegistry.get(message);
-            registeredMessage.referenceCount--;
-            removeAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
-            element.removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
+    }
+    /** Unregisters all created message elements and removes the message container. */
+    ngOnDestroy() {
+        const describedElements = this._document.querySelectorAll(`[${CDK_DESCRIBEDBY_HOST_ATTRIBUTE}]`);
+        for (let i = 0; i < describedElements.length; i++) {
+            this._removeCdkDescribedByReferenceIds(describedElements[i]);
+            describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
         }
-        /** Returns true if the element has been described by the provided message ID. */
-        _isElementDescribedByMessage(element, message) {
-            const referenceIds = getAriaReferenceIds(element, 'aria-describedby');
-            const registeredMessage = messageRegistry.get(message);
-            const messageId = registeredMessage && registeredMessage.messageElement.id;
-            return !!messageId && referenceIds.indexOf(messageId) != -1;
+        if (messagesContainer) {
+            this._deleteMessagesContainer();
         }
-        /** Determines whether a message can be described on a particular element. */
-        _canBeDescribed(element, message) {
-            if (!this._isElementNode(element)) {
-                return false;
-            }
-            if (message && typeof message === 'object') {
-                // We'd have to make some assumptions about the description element's text, if the consumer
-                // passed in an element. Assume that if an element is passed in, the consumer has verified
-                // that it can be used as a description.
-                return true;
-            }
-            const trimmedMessage = message == null ? '' : `${message}`.trim();
-            const ariaLabel = element.getAttribute('aria-label');
-            // We shouldn't set descriptions if they're exactly the same as the `aria-label` of the
-            // element, because screen readers will end up reading out the same text twice in a row.
-            return trimmedMessage ? (!ariaLabel || ariaLabel.trim() !== trimmedMessage) : false;
+        messageRegistry.clear();
+    }
+    /**
+     * Creates a new element in the visually hidden message container element with the message
+     * as its content and adds it to the message registry.
+     */
+    _createMessageElement(message) {
+        const messageElement = this._document.createElement('div');
+        this._setMessageId(messageElement);
+        messageElement.textContent = message;
+        this._createMessagesContainer();
+        messagesContainer.appendChild(messageElement);
+        messageRegistry.set(message, { messageElement, referenceCount: 0 });
+    }
+    /** Assigns a unique ID to an element, if it doesn't have one already. */
+    _setMessageId(element) {
+        if (!element.id) {
+            element.id = `${CDK_DESCRIBEDBY_ID_PREFIX}-${nextId++}`;
         }
-        /** Checks whether a node is an Element node. */
-        _isElementNode(element) {
-            return element.nodeType === this._document.ELEMENT_NODE;
+    }
+    /** Deletes the message element from the global messages container. */
+    _deleteMessageElement(message) {
+        const registeredMessage = messageRegistry.get(message);
+        const messageElement = registeredMessage && registeredMessage.messageElement;
+        if (messagesContainer && messageElement) {
+            messagesContainer.removeChild(messageElement);
         }
+        messageRegistry.delete(message);
+    }
+    /** Creates the global container for all aria-describedby messages. */
+    _createMessagesContainer() {
+        if (!messagesContainer) {
+            // @breaking-change 8.0.0 `_platform` null check can be removed once the parameter is required
+            const canBeAriaHidden = !this._platform || (!this._platform.EDGE && !this._platform.TRIDENT);
+            const preExistingContainer = this._document.getElementById(MESSAGES_CONTAINER_ID);
+            // When going from the server to the client, we may end up in a situation where there's
+            // already a container on the page, but we don't have a reference to it. Clear the
+            // old container so we don't get duplicates. Doing this, instead of emptying the previous
+            // container, should be slightly faster.
+            if (preExistingContainer) {
+                preExistingContainer.parentNode.removeChild(preExistingContainer);
+            }
+            messagesContainer = this._document.createElement('div');
+            messagesContainer.id = MESSAGES_CONTAINER_ID;
+            messagesContainer.classList.add('cdk-visually-hidden');
+            // IE and Edge won't read out the messages if they're in an `aria-hidden` container.
+            // We only disable `aria-hidden` for these platforms, because it comes with the
+            // disadvantage that people might hit the messages when they've navigated past
+            // the end of the document using the arrow keys.
+            messagesContainer.setAttribute('aria-hidden', canBeAriaHidden + '');
+            this._document.body.appendChild(messagesContainer);
+        }
+    }
+    /** Deletes the global messages container. */
+    _deleteMessagesContainer() {
+        if (messagesContainer && messagesContainer.parentNode) {
+            messagesContainer.parentNode.removeChild(messagesContainer);
+            messagesContainer = null;
+        }
+    }
+    /** Removes all cdk-describedby messages that are hosted through the element. */
+    _removeCdkDescribedByReferenceIds(element) {
+        // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX
+        const originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')
+            .filter(id => id.indexOf(CDK_DESCRIBEDBY_ID_PREFIX) != 0);
+        element.setAttribute('aria-describedby', originalReferenceIds.join(' '));
+    }
+    /**
+     * Adds a message reference to the element using aria-describedby and increments the registered
+     * message's reference count.
+     */
+    _addMessageReference(element, message) {
+        const registeredMessage = messageRegistry.get(message);
+        // Add the aria-describedby reference and set the
+        // describedby_host attribute to mark the element.
+        addAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
+        element.setAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE, '');
+        registeredMessage.referenceCount++;
+    }
+    /**
+     * Removes a message reference from the element using aria-describedby
+     * and decrements the registered message's reference count.
+     */
+    _removeMessageReference(element, message) {
+        const registeredMessage = messageRegistry.get(message);
+        registeredMessage.referenceCount--;
+        removeAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
+        element.removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
+    }
+    /** Returns true if the element has been described by the provided message ID. */
+    _isElementDescribedByMessage(element, message) {
+        const referenceIds = getAriaReferenceIds(element, 'aria-describedby');
+        const registeredMessage = messageRegistry.get(message);
+        const messageId = registeredMessage && registeredMessage.messageElement.id;
+        return !!messageId && referenceIds.indexOf(messageId) != -1;
+    }
+    /** Determines whether a message can be described on a particular element. */
+    _canBeDescribed(element, message) {
+        if (!this._isElementNode(element)) {
+            return false;
+        }
+        if (message && typeof message === 'object') {
+            // We'd have to make some assumptions about the description element's text, if the consumer
+            // passed in an element. Assume that if an element is passed in, the consumer has verified
+            // that it can be used as a description.
+            return true;
+        }
+        const trimmedMessage = message == null ? '' : `${message}`.trim();
+        const ariaLabel = element.getAttribute('aria-label');
+        // We shouldn't set descriptions if they're exactly the same as the `aria-label` of the
+        // element, because screen readers will end up reading out the same text twice in a row.
+        return trimmedMessage ? (!ariaLabel || ariaLabel.trim() !== trimmedMessage) : false;
+    }
+    /** Checks whether a node is an Element node. */
+    _isElementNode(element) {
+        return element.nodeType === this._document.ELEMENT_NODE;
     }
-    AriaDescriber.ɵprov = i0.ɵɵdefineInjectable({ factory: function AriaDescriber_Factory() { return new AriaDescriber(i0.ɵɵinject(i1.DOCUMENT)); }, token: AriaDescriber, providedIn: "root" });
-    AriaDescriber.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    AriaDescriber.ctorParameters = () => [
-        { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-    ];
-    return AriaDescriber;
-})();
-export { AriaDescriber };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aria-describer.js","sourceRoot":"","sources":["../../../../../../../src/cdk/a11y/aria-describer/aria-describer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAC,MAAM,EAAE,UAAU,EAAY,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAC,mBAAmB,EAAE,mBAAmB,EAAE,sBAAsB,EAAC,MAAM,kBAAkB,CAAC;;;AAelG,sEAAsE;AACtE,MAAM,CAAC,MAAM,qBAAqB,GAAG,mCAAmC,CAAC;AAEzE,uDAAuD;AACvD,MAAM,CAAC,MAAM,yBAAyB,GAAG,yBAAyB,CAAC;AAEnE,mFAAmF;AACnF,MAAM,CAAC,MAAM,8BAA8B,GAAG,sBAAsB,CAAC;AAErE,yEAAyE;AACzE,IAAI,MAAM,GAAG,CAAC,CAAC;AAEf,6FAA6F;AAC7F,MAAM,eAAe,GAAG,IAAI,GAAG,EAAyC,CAAC;AAEzE,6CAA6C;AAC7C,IAAI,iBAAiB,GAAuB,IAAI,CAAC;AAEjD;;;;GAIG;AACH;IAAA,MACa,aAAa;QAGxB,YAA8B,SAAc;YAC1C,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC7B,CAAC;QAED;;;;WAIG;QACH,QAAQ,CAAC,WAAoB,EAAE,OAA2B;YACxD,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE;gBAC/C,OAAO;aACR;YAED,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;gBAC/B,gDAAgD;gBAChD,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;gBAC5B,eAAe,CAAC,GAAG,CAAC,OAAO,EAAE,EAAC,cAAc,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,EAAC,CAAC,CAAC;aAC5E;iBAAM,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE;gBACxC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;aACrC;YAED,IAAI,CAAC,IAAI,CAAC,4BAA4B,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE;gBAC5D,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;aACjD;QACH,CAAC;QAED,oFAAoF;QACpF,iBAAiB,CAAC,WAAoB,EAAE,OAA2B;YACjE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,EAAE;gBACrC,OAAO;aACR;YAED,IAAI,IAAI,CAAC,4BAA4B,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE;gBAC3D,IAAI,CAAC,uBAAuB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;aACpD;YAED,6EAA6E;YAC7E,8EAA8E;YAC9E,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;gBAC/B,MAAM,iBAAiB,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBACvD,IAAI,iBAAiB,IAAI,iBAAiB,CAAC,cAAc,KAAK,CAAC,EAAE;oBAC/D,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;iBACrC;aACF;YAED,IAAI,iBAAiB,IAAI,iBAAiB,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;gBAClE,IAAI,CAAC,wBAAwB,EAAE,CAAC;aACjC;QACH,CAAC;QAED,kFAAkF;QAClF,WAAW;YACT,MAAM,iBAAiB,GACnB,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,IAAI,8BAA8B,GAAG,CAAC,CAAC;YAE3E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBACjD,IAAI,CAAC,iCAAiC,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC7D,iBAAiB,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,8BAA8B,CAAC,CAAC;aACtE;YAED,IAAI,iBAAiB,EAAE;gBACrB,IAAI,CAAC,wBAAwB,EAAE,CAAC;aACjC;YAED,eAAe,CAAC,KAAK,EAAE,CAAC;QAC1B,CAAC;QAED;;;WAGG;QACK,qBAAqB,CAAC,OAAe;YAC3C,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YAC3D,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;YACnC,cAAc,CAAC,WAAW,GAAG,OAAO,CAAC;YAErC,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,iBAAkB,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;YAE/C,eAAe,CAAC,GAAG,CAAC,OAAO,EAAE,EAAC,cAAc,EAAE,cAAc,EAAE,CAAC,EAAC,CAAC,CAAC;QACpE,CAAC;QAED,yEAAyE;QACjE,aAAa,CAAC,OAAoB;YACxC,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE;gBACf,OAAO,CAAC,EAAE,GAAG,GAAG,yBAAyB,IAAI,MAAM,EAAE,EAAE,CAAC;aACzD;QACH,CAAC;QAED,sEAAsE;QAC9D,qBAAqB,CAAC,OAAe;YAC3C,MAAM,iBAAiB,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YACvD,MAAM,cAAc,GAAG,iBAAiB,IAAI,iBAAiB,CAAC,cAAc,CAAC;YAC7E,IAAI,iBAAiB,IAAI,cAAc,EAAE;gBACvC,iBAAiB,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;aAC/C;YACD,eAAe,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC;QAED,sEAAsE;QAC9D,wBAAwB;YAC9B,IAAI,CAAC,iBAAiB,EAAE;gBACtB,MAAM,oBAAoB,GAAG,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAC;gBAElF,uFAAuF;gBACvF,kFAAkF;gBAClF,yFAAyF;gBACzF,wCAAwC;gBACxC,IAAI,oBAAoB,EAAE;oBACxB,oBAAoB,CAAC,UAAW,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC;iBACpE;gBAED,iBAAiB,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBACxD,iBAAiB,CAAC,EAAE,GAAG,qBAAqB,CAAC;gBAC7C,iBAAiB,CAAC,YAAY,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;gBACtD,iBAAiB,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;gBACzC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC;aACpD;QACH,CAAC;QAED,6CAA6C;QACrC,wBAAwB;YAC9B,IAAI,iBAAiB,IAAI,iBAAiB,CAAC,UAAU,EAAE;gBACrD,iBAAiB,CAAC,UAAU,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC;gBAC5D,iBAAiB,GAAG,IAAI,CAAC;aAC1B;QACH,CAAC;QAED,gFAAgF;QACxE,iCAAiC,CAAC,OAAgB;YACxD,2FAA2F;YAC3F,MAAM,oBAAoB,GAAG,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,CAAC;iBACxE,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC,CAAC;YAC9D,OAAO,CAAC,YAAY,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3E,CAAC;QAED;;;WAGG;QACK,oBAAoB,CAAC,OAAgB,EAAE,OAA2B;YACxE,MAAM,iBAAiB,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAE,CAAC;YAExD,iDAAiD;YACjD,kDAAkD;YAClD,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;YACtF,OAAO,CAAC,YAAY,CAAC,8BAA8B,EAAE,EAAE,CAAC,CAAC;YAEzD,iBAAiB,CAAC,cAAc,EAAE,CAAC;QACrC,CAAC;QAED;;;WAGG;QACK,uBAAuB,CAAC,OAAgB,EAAE,OAA2B;YAC3E,MAAM,iBAAiB,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAE,CAAC;YACxD,iBAAiB,CAAC,cAAc,EAAE,CAAC;YAEnC,sBAAsB,CAAC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;YACzF,OAAO,CAAC,eAAe,CAAC,8BAA8B,CAAC,CAAC;QAC1D,CAAC;QAED,iFAAiF;QACzE,4BAA4B,CAAC,OAAgB,EAAE,OAA2B;YAChF,MAAM,YAAY,GAAG,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC;YACtE,MAAM,iBAAiB,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YACvD,MAAM,SAAS,GAAG,iBAAiB,IAAI,iBAAiB,CAAC,cAAc,CAAC,EAAE,CAAC;YAE3E,OAAO,CAAC,CAAC,SAAS,IAAI,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9D,CAAC;QAED,6EAA6E;QACrE,eAAe,CAAC,OAAgB,EAAE,OAAgC;YACxE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE;gBACjC,OAAO,KAAK,CAAC;aACd;YAED,IAAI,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;gBAC1C,2FAA2F;gBAC3F,0FAA0F;gBAC1F,wCAAwC;gBACxC,OAAO,IAAI,CAAC;aACb;YAED,MAAM,cAAc,GAAG,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC;YAClE,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;YAErD,uFAAuF;YACvF,wFAAwF;YACxF,OAAO,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,SAAS,CAAC,IAAI,EAAE,KAAK,cAAc,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACtF,CAAC;QAED,gDAAgD;QACxC,cAAc,CAAC,OAAa;YAClC,OAAO,OAAO,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;QAC1D,CAAC;;;;gBAzMF,UAAU,SAAC,EAAC,UAAU,EAAE,MAAM,EAAC;;;gDAIjB,MAAM,SAAC,QAAQ;;wBApD9B;KA0PC;SAzMY,aAAa","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 {DOCUMENT} from '@angular/common';\nimport {Inject, Injectable, OnDestroy} from '@angular/core';\nimport {addAriaReferencedId, getAriaReferenceIds, removeAriaReferencedId} from './aria-reference';\n\n\n/**\n * Interface used to register message elements and keep a count of how many registrations have\n * the same message and the reference to the message element used for the `aria-describedby`.\n */\nexport interface RegisteredMessage {\n  /** The element containing the message. */\n  messageElement: Element;\n\n  /** The number of elements that reference this message element via `aria-describedby`. */\n  referenceCount: number;\n}\n\n/** ID used for the body container where all messages are appended. */\nexport const MESSAGES_CONTAINER_ID = 'cdk-describedby-message-container';\n\n/** ID prefix used for each created message element. */\nexport const CDK_DESCRIBEDBY_ID_PREFIX = 'cdk-describedby-message';\n\n/** Attribute given to each host element that is described by a message element. */\nexport const CDK_DESCRIBEDBY_HOST_ATTRIBUTE = 'cdk-describedby-host';\n\n/** Global incremental identifier for each registered message element. */\nlet nextId = 0;\n\n/** Global map of all registered message elements that have been placed into the document. */\nconst messageRegistry = new Map<string|HTMLElement, RegisteredMessage>();\n\n/** Container for all registered messages. */\nlet messagesContainer: HTMLElement | null = null;\n\n/**\n * Utility that creates visually hidden elements with a message content. Useful for elements that\n * want to use aria-describedby to further describe themselves without adding additional visual\n * content.\n */\n@Injectable({providedIn: 'root'})\nexport class AriaDescriber implements OnDestroy {\n  private _document: Document;\n\n  constructor(@Inject(DOCUMENT) _document: any) {\n    this._document = _document;\n  }\n\n  /**\n   * Adds to the host element an aria-describedby reference to a hidden element that contains\n   * the message. If the same message has already been registered, then it will reuse the created\n   * message element.\n   */\n  describe(hostElement: Element, message: string|HTMLElement) {\n    if (!this._canBeDescribed(hostElement, message)) {\n      return;\n    }\n\n    if (typeof message !== 'string') {\n      // We need to ensure that the element has an ID.\n      this._setMessageId(message);\n      messageRegistry.set(message, {messageElement: message, referenceCount: 0});\n    } else if (!messageRegistry.has(message)) {\n      this._createMessageElement(message);\n    }\n\n    if (!this._isElementDescribedByMessage(hostElement, message)) {\n      this._addMessageReference(hostElement, message);\n    }\n  }\n\n  /** Removes the host element's aria-describedby reference to the message element. */\n  removeDescription(hostElement: Element, message: string|HTMLElement) {\n    if (!this._isElementNode(hostElement)) {\n      return;\n    }\n\n    if (this._isElementDescribedByMessage(hostElement, message)) {\n      this._removeMessageReference(hostElement, message);\n    }\n\n    // If the message is a string, it means that it's one that we created for the\n    // consumer so we can remove it safely, otherwise we should leave it in place.\n    if (typeof message === 'string') {\n      const registeredMessage = messageRegistry.get(message);\n      if (registeredMessage && registeredMessage.referenceCount === 0) {\n        this._deleteMessageElement(message);\n      }\n    }\n\n    if (messagesContainer && messagesContainer.childNodes.length === 0) {\n      this._deleteMessagesContainer();\n    }\n  }\n\n  /** Unregisters all created message elements and removes the message container. */\n  ngOnDestroy() {\n    const describedElements =\n        this._document.querySelectorAll(`[${CDK_DESCRIBEDBY_HOST_ATTRIBUTE}]`);\n\n    for (let i = 0; i < describedElements.length; i++) {\n      this._removeCdkDescribedByReferenceIds(describedElements[i]);\n      describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);\n    }\n\n    if (messagesContainer) {\n      this._deleteMessagesContainer();\n    }\n\n    messageRegistry.clear();\n  }\n\n  /**\n   * Creates a new element in the visually hidden message container element with the message\n   * as its content and adds it to the message registry.\n   */\n  private _createMessageElement(message: string) {\n    const messageElement = this._document.createElement('div');\n    this._setMessageId(messageElement);\n    messageElement.textContent = message;\n\n    this._createMessagesContainer();\n    messagesContainer!.appendChild(messageElement);\n\n    messageRegistry.set(message, {messageElement, referenceCount: 0});\n  }\n\n  /** Assigns a unique ID to an element, if it doesn't have one already. */\n  private _setMessageId(element: HTMLElement) {\n    if (!element.id) {\n      element.id = `${CDK_DESCRIBEDBY_ID_PREFIX}-${nextId++}`;\n    }\n  }\n\n  /** Deletes the message element from the global messages container. */\n  private _deleteMessageElement(message: string) {\n    const registeredMessage = messageRegistry.get(message);\n    const messageElement = registeredMessage && registeredMessage.messageElement;\n    if (messagesContainer && messageElement) {\n      messagesContainer.removeChild(messageElement);\n    }\n    messageRegistry.delete(message);\n  }\n\n  /** Creates the global container for all aria-describedby messages. */\n  private _createMessagesContainer() {\n    if (!messagesContainer) {\n      const preExistingContainer = this._document.getElementById(MESSAGES_CONTAINER_ID);\n\n      // When going from the server to the client, we may end up in a situation where there's\n      // already a container on the page, but we don't have a reference to it. Clear the\n      // old container so we don't get duplicates. Doing this, instead of emptying the previous\n      // container, should be slightly faster.\n      if (preExistingContainer) {\n        preExistingContainer.parentNode!.removeChild(preExistingContainer);\n      }\n\n      messagesContainer = this._document.createElement('div');\n      messagesContainer.id = MESSAGES_CONTAINER_ID;\n      messagesContainer.setAttribute('aria-hidden', 'true');\n      messagesContainer.style.display = 'none';\n      this._document.body.appendChild(messagesContainer);\n    }\n  }\n\n  /** Deletes the global messages container. */\n  private _deleteMessagesContainer() {\n    if (messagesContainer && messagesContainer.parentNode) {\n      messagesContainer.parentNode.removeChild(messagesContainer);\n      messagesContainer = null;\n    }\n  }\n\n  /** Removes all cdk-describedby messages that are hosted through the element. */\n  private _removeCdkDescribedByReferenceIds(element: Element) {\n    // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX\n    const originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')\n        .filter(id => id.indexOf(CDK_DESCRIBEDBY_ID_PREFIX) != 0);\n    element.setAttribute('aria-describedby', originalReferenceIds.join(' '));\n  }\n\n  /**\n   * Adds a message reference to the element using aria-describedby and increments the registered\n   * message's reference count.\n   */\n  private _addMessageReference(element: Element, message: string|HTMLElement) {\n    const registeredMessage = messageRegistry.get(message)!;\n\n    // Add the aria-describedby reference and set the\n    // describedby_host attribute to mark the element.\n    addAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);\n    element.setAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE, '');\n\n    registeredMessage.referenceCount++;\n  }\n\n  /**\n   * Removes a message reference from the element using aria-describedby\n   * and decrements the registered message's reference count.\n   */\n  private _removeMessageReference(element: Element, message: string|HTMLElement) {\n    const registeredMessage = messageRegistry.get(message)!;\n    registeredMessage.referenceCount--;\n\n    removeAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);\n    element.removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);\n  }\n\n  /** Returns true if the element has been described by the provided message ID. */\n  private _isElementDescribedByMessage(element: Element, message: string|HTMLElement): boolean {\n    const referenceIds = getAriaReferenceIds(element, 'aria-describedby');\n    const registeredMessage = messageRegistry.get(message);\n    const messageId = registeredMessage && registeredMessage.messageElement.id;\n\n    return !!messageId && referenceIds.indexOf(messageId) != -1;\n  }\n\n  /** Determines whether a message can be described on a particular element. */\n  private _canBeDescribed(element: Element, message: string|HTMLElement|void): boolean {\n    if (!this._isElementNode(element)) {\n      return false;\n    }\n\n    if (message && typeof message === 'object') {\n      // We'd have to make some assumptions about the description element's text, if the consumer\n      // passed in an element. Assume that if an element is passed in, the consumer has verified\n      // that it can be used as a description.\n      return true;\n    }\n\n    const trimmedMessage = message == null ? '' : `${message}`.trim();\n    const ariaLabel = element.getAttribute('aria-label');\n\n    // We shouldn't set descriptions if they're exactly the same as the `aria-label` of the\n    // element, because screen readers will end up reading out the same text twice in a row.\n    return trimmedMessage ? (!ariaLabel || ariaLabel.trim() !== trimmedMessage) : false;\n  }\n\n  /** Checks whether a node is an Element node. */\n  private _isElementNode(element: Node): element is Element {\n    return element.nodeType === this._document.ELEMENT_NODE;\n  }\n}\n"]}
+}
+AriaDescriber.ɵprov = i0.ɵɵdefineInjectable({ factory: function AriaDescriber_Factory() { return new AriaDescriber(i0.ɵɵinject(i1.DOCUMENT), i0.ɵɵinject(i2.Platform)); }, token: AriaDescriber, providedIn: "root" });
+AriaDescriber.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+AriaDescriber.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: Platform }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aria-describer.js","sourceRoot":"","sources":["../../../../../../../src/cdk/a11y/aria-describer/aria-describer.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 {DOCUMENT} from '@angular/common';\nimport {Inject, Injectable, OnDestroy} from '@angular/core';\nimport {addAriaReferencedId, getAriaReferenceIds, removeAriaReferencedId} from './aria-reference';\nimport {Platform} from '@angular/cdk/platform';\n\n\n/**\n * Interface used to register message elements and keep a count of how many registrations have\n * the same message and the reference to the message element used for the `aria-describedby`.\n */\nexport interface RegisteredMessage {\n  /** The element containing the message. */\n  messageElement: Element;\n\n  /** The number of elements that reference this message element via `aria-describedby`. */\n  referenceCount: number;\n}\n\n/** ID used for the body container where all messages are appended. */\nexport const MESSAGES_CONTAINER_ID = 'cdk-describedby-message-container';\n\n/** ID prefix used for each created message element. */\nexport const CDK_DESCRIBEDBY_ID_PREFIX = 'cdk-describedby-message';\n\n/** Attribute given to each host element that is described by a message element. */\nexport const CDK_DESCRIBEDBY_HOST_ATTRIBUTE = 'cdk-describedby-host';\n\n/** Global incremental identifier for each registered message element. */\nlet nextId = 0;\n\n/** Global map of all registered message elements that have been placed into the document. */\nconst messageRegistry = new Map<string|HTMLElement, RegisteredMessage>();\n\n/** Container for all registered messages. */\nlet messagesContainer: HTMLElement | null = null;\n\n/**\n * Utility that creates visually hidden elements with a message content. Useful for elements that\n * want to use aria-describedby to further describe themselves without adding additional visual\n * content.\n */\n@Injectable({providedIn: 'root'})\nexport class AriaDescriber implements OnDestroy {\n  private _document: Document;\n\n  constructor(\n    @Inject(DOCUMENT) _document: any,\n    /**\n     * @breaking-change 8.0.0 `_platform` parameter to be made required.\n     */\n    private _platform?: Platform) {\n    this._document = _document;\n  }\n\n  /**\n   * Adds to the host element an aria-describedby reference to a hidden element that contains\n   * the message. If the same message has already been registered, then it will reuse the created\n   * message element.\n   */\n  describe(hostElement: Element, message: string|HTMLElement) {\n    if (!this._canBeDescribed(hostElement, message)) {\n      return;\n    }\n\n    if (typeof message !== 'string') {\n      // We need to ensure that the element has an ID.\n      this._setMessageId(message);\n      messageRegistry.set(message, {messageElement: message, referenceCount: 0});\n    } else if (!messageRegistry.has(message)) {\n      this._createMessageElement(message);\n    }\n\n    if (!this._isElementDescribedByMessage(hostElement, message)) {\n      this._addMessageReference(hostElement, message);\n    }\n  }\n\n  /** Removes the host element's aria-describedby reference to the message element. */\n  removeDescription(hostElement: Element, message: string|HTMLElement) {\n    if (!this._isElementNode(hostElement)) {\n      return;\n    }\n\n    if (this._isElementDescribedByMessage(hostElement, message)) {\n      this._removeMessageReference(hostElement, message);\n    }\n\n    // If the message is a string, it means that it's one that we created for the\n    // consumer so we can remove it safely, otherwise we should leave it in place.\n    if (typeof message === 'string') {\n      const registeredMessage = messageRegistry.get(message);\n      if (registeredMessage && registeredMessage.referenceCount === 0) {\n        this._deleteMessageElement(message);\n      }\n    }\n\n    if (messagesContainer && messagesContainer.childNodes.length === 0) {\n      this._deleteMessagesContainer();\n    }\n  }\n\n  /** Unregisters all created message elements and removes the message container. */\n  ngOnDestroy() {\n    const describedElements =\n        this._document.querySelectorAll(`[${CDK_DESCRIBEDBY_HOST_ATTRIBUTE}]`);\n\n    for (let i = 0; i < describedElements.length; i++) {\n      this._removeCdkDescribedByReferenceIds(describedElements[i]);\n      describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);\n    }\n\n    if (messagesContainer) {\n      this._deleteMessagesContainer();\n    }\n\n    messageRegistry.clear();\n  }\n\n  /**\n   * Creates a new element in the visually hidden message container element with the message\n   * as its content and adds it to the message registry.\n   */\n  private _createMessageElement(message: string) {\n    const messageElement = this._document.createElement('div');\n    this._setMessageId(messageElement);\n    messageElement.textContent = message;\n\n    this._createMessagesContainer();\n    messagesContainer!.appendChild(messageElement);\n\n    messageRegistry.set(message, {messageElement, referenceCount: 0});\n  }\n\n  /** Assigns a unique ID to an element, if it doesn't have one already. */\n  private _setMessageId(element: HTMLElement) {\n    if (!element.id) {\n      element.id = `${CDK_DESCRIBEDBY_ID_PREFIX}-${nextId++}`;\n    }\n  }\n\n  /** Deletes the message element from the global messages container. */\n  private _deleteMessageElement(message: string) {\n    const registeredMessage = messageRegistry.get(message);\n    const messageElement = registeredMessage && registeredMessage.messageElement;\n    if (messagesContainer && messageElement) {\n      messagesContainer.removeChild(messageElement);\n    }\n    messageRegistry.delete(message);\n  }\n\n  /** Creates the global container for all aria-describedby messages. */\n  private _createMessagesContainer() {\n    if (!messagesContainer) {\n      // @breaking-change 8.0.0 `_platform` null check can be removed once the parameter is required\n      const canBeAriaHidden = !this._platform || (!this._platform.EDGE && !this._platform.TRIDENT);\n      const preExistingContainer = this._document.getElementById(MESSAGES_CONTAINER_ID);\n\n      // When going from the server to the client, we may end up in a situation where there's\n      // already a container on the page, but we don't have a reference to it. Clear the\n      // old container so we don't get duplicates. Doing this, instead of emptying the previous\n      // container, should be slightly faster.\n      if (preExistingContainer) {\n        preExistingContainer.parentNode!.removeChild(preExistingContainer);\n      }\n\n      messagesContainer = this._document.createElement('div');\n      messagesContainer.id = MESSAGES_CONTAINER_ID;\n      messagesContainer.classList.add('cdk-visually-hidden');\n\n      // IE and Edge won't read out the messages if they're in an `aria-hidden` container.\n      // We only disable `aria-hidden` for these platforms, because it comes with the\n      // disadvantage that people might hit the messages when they've navigated past\n      // the end of the document using the arrow keys.\n      messagesContainer.setAttribute('aria-hidden', canBeAriaHidden + '');\n      this._document.body.appendChild(messagesContainer);\n    }\n  }\n\n  /** Deletes the global messages container. */\n  private _deleteMessagesContainer() {\n    if (messagesContainer && messagesContainer.parentNode) {\n      messagesContainer.parentNode.removeChild(messagesContainer);\n      messagesContainer = null;\n    }\n  }\n\n  /** Removes all cdk-describedby messages that are hosted through the element. */\n  private _removeCdkDescribedByReferenceIds(element: Element) {\n    // Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX\n    const originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')\n        .filter(id => id.indexOf(CDK_DESCRIBEDBY_ID_PREFIX) != 0);\n    element.setAttribute('aria-describedby', originalReferenceIds.join(' '));\n  }\n\n  /**\n   * Adds a message reference to the element using aria-describedby and increments the registered\n   * message's reference count.\n   */\n  private _addMessageReference(element: Element, message: string|HTMLElement) {\n    const registeredMessage = messageRegistry.get(message)!;\n\n    // Add the aria-describedby reference and set the\n    // describedby_host attribute to mark the element.\n    addAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);\n    element.setAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE, '');\n\n    registeredMessage.referenceCount++;\n  }\n\n  /**\n   * Removes a message reference from the element using aria-describedby\n   * and decrements the registered message's reference count.\n   */\n  private _removeMessageReference(element: Element, message: string|HTMLElement) {\n    const registeredMessage = messageRegistry.get(message)!;\n    registeredMessage.referenceCount--;\n\n    removeAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);\n    element.removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);\n  }\n\n  /** Returns true if the element has been described by the provided message ID. */\n  private _isElementDescribedByMessage(element: Element, message: string|HTMLElement): boolean {\n    const referenceIds = getAriaReferenceIds(element, 'aria-describedby');\n    const registeredMessage = messageRegistry.get(message);\n    const messageId = registeredMessage && registeredMessage.messageElement.id;\n\n    return !!messageId && referenceIds.indexOf(messageId) != -1;\n  }\n\n  /** Determines whether a message can be described on a particular element. */\n  private _canBeDescribed(element: Element, message: string|HTMLElement|void): boolean {\n    if (!this._isElementNode(element)) {\n      return false;\n    }\n\n    if (message && typeof message === 'object') {\n      // We'd have to make some assumptions about the description element's text, if the consumer\n      // passed in an element. Assume that if an element is passed in, the consumer has verified\n      // that it can be used as a description.\n      return true;\n    }\n\n    const trimmedMessage = message == null ? '' : `${message}`.trim();\n    const ariaLabel = element.getAttribute('aria-label');\n\n    // We shouldn't set descriptions if they're exactly the same as the `aria-label` of the\n    // element, because screen readers will end up reading out the same text twice in a row.\n    return trimmedMessage ? (!ariaLabel || ariaLabel.trim() !== trimmedMessage) : false;\n  }\n\n  /** Checks whether a node is an Element node. */\n  private _isElementNode(element: Node): element is Element {\n    return element.nodeType === this._document.ELEMENT_NODE;\n  }\n}\n"]}