{"version":3,"file":"1555.412504d744eca304.js","mappings":"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","names":["_c0","policy","trustedHTMLFromString","html","getPolicy","undefined","window","ttWindow","trustedTypes","createPolicy","createHTML","s","getMatIconNameNotFoundError","iconName","Error","getMatIconFailedToSanitizeUrlError","url","getMatIconFailedToSanitizeLiteralError","literal","SvgIconConfig","constructor","svgText","options","this","MatIconRegistry","_httpClient","_sanitizer","document","_errorHandler","_svgIconConfigs","Map","_iconSetConfigs","_cachedIconsByUrl","_inProgressUrlFetches","_fontCssClassesByAlias","_resolvers","_defaultFontSetClass","_document","addSvgIcon","addSvgIconInNamespace","addSvgIconLiteral","addSvgIconLiteralInNamespace","namespace","_addSvgIconConfig","addSvgIconResolver","resolver","push","cleanLiteral","sanitize","SecurityContext","HTML","trustedLiteral","addSvgIconSet","addSvgIconSetInNamespace","addSvgIconSetLiteral","addSvgIconSetLiteralInNamespace","_addSvgIconSetConfig","registerFontClassAlias","alias","classNames","set","classNameForFontAlias","get","setDefaultFontSetClass","getDefaultFontSetClass","getSvgIconFromUrl","safeUrl","RESOURCE_URL","cachedIcon","of","cloneSvg","_loadSvgIconFromConfig","pipe","tap","svg","map","getNamedSvgIcon","name","key","iconKey","config","_getSvgFromConfig","_getIconConfigFromResolvers","iconSetConfigs","_getSvgFromIconSetConfigs","throwError","ngOnDestroy","clear","_svgElementFromConfig","namedIcon","_extractIconWithNameFromAnySet","iconSetFetchRequests","filter","iconSetConfig","_loadSvgIconSetFromConfig","catchError","err","errorMessage","message","handleError","forkJoin","foundIcon","i","length","toString","indexOf","_extractSvgIconFromSet","_fetchIcon","iconSet","iconSource","querySelector","iconElement","cloneNode","removeAttribute","nodeName","toLowerCase","_setSvgAttributes","_toSvgElement","_svgElementFromString","appendChild","str","div","createElement","innerHTML","element","attributes","value","setAttribute","childNodes","nodeType","ELEMENT_NODE","viewBox","iconConfig","withCredentials","getMatIconNoHttpProviderError","inProgressFetch","req","responseType","finalize","delete","share","configNamespace","svgElement","result","isSafeUrlWithOptions","ɵfac","t","i0","i1","i2","DOCUMENT","ɵprov","token","factory","providedIn","_MatIconBase","mixinColor","_elementRef","MAT_ICON_DEFAULT_OPTIONS","InjectionToken","MAT_ICON_LOCATION","MAT_ICON_LOCATION_FACTORY","inject","_location","location","getPathname","pathname","search","funcIriAttributes","funcIriAttributeSelector","attr","join","funcIriPattern","MatIcon","elementRef","_iconRegistry","ariaHidden","defaults","super","_inline","_previousFontSetClass","_currentIconFetch","Subscription","EMPTY","color","defaultColor","fontSet","nativeElement","inline","coerceBooleanProperty","svgIcon","_svgIcon","_updateSvgIcon","_clearSvgElement","_fontSet","newValue","_cleanupFontValue","_updateFontIconClasses","fontIcon","_fontIcon","_splitIconName","parts","split","ngOnInit","ngAfterViewChecked","cachedElements","_elementsWithExternalReferences","size","newPath","_previousPath","_prependPathToReferences","unsubscribe","_usingFontIcon","_setSvgElement","path","_cacheChildrenWithExternalReferences","layoutElement","childCount","child","remove","elem","fontSetClasses","className","forEach","classList","add","_previousFontIconClass","includes","trim","elements","attrs","elementsWithFuncIri","querySelectorAll","elementWithReference","getAttribute","match","rawName","_svgNamespace","_svgName","take","subscribe","ɵcmp","type","selectors","hostAttrs","hostVars","hostBindings","rf","ctx","inputs","exportAs","features","ngContentSelectors","decls","vars","template","styles","encapsulation","changeDetection","MatIconModule","ɵmod","ɵinj","imports","MatCommonModule"],"sourceRoot":"webpack:///","sources":["./node_modules/@angular/material/fesm2020/icon.mjs"],"sourcesContent":["import * as i0 from '@angular/core';\nimport { SecurityContext, Injectable, Optional, Inject, SkipSelf, ErrorHandler, InjectionToken, inject, Component, ViewEncapsulation, ChangeDetectionStrategy, Attribute, Input, NgModule } from '@angular/core';\nimport { mixinColor, MatCommonModule } from '@angular/material/core';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { DOCUMENT } from '@angular/common';\nimport { of, throwError, forkJoin, Subscription } from 'rxjs';\nimport { tap, map, catchError, finalize, share, take } from 'rxjs/operators';\nimport * as i1 from '@angular/common/http';\nimport { HttpClient } from '@angular/common/http';\nimport * as i2 from '@angular/platform-browser';\nimport { DomSanitizer } from '@angular/platform-browser';\n\n/**\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 Trusted Types policy, or null if Trusted Types are not\n * enabled/supported, or undefined if the policy has not been created yet.\n */\nlet policy;\n/**\n * Returns the Trusted Types policy, or null if Trusted Types are not\n * enabled/supported. The first call to this function will create the policy.\n */\nfunction getPolicy() {\n    if (policy === undefined) {\n        policy = null;\n        if (typeof window !== 'undefined') {\n            const ttWindow = window;\n            if (ttWindow.trustedTypes !== undefined) {\n                policy = ttWindow.trustedTypes.createPolicy('angular#components', {\n                    createHTML: (s) => s,\n                });\n            }\n        }\n    }\n    return policy;\n}\n/**\n * Unsafely promote a string to a TrustedHTML, falling back to strings when\n * Trusted Types are not available.\n * @security This is a security-sensitive function; any use of this function\n * must go through security review. In particular, it must be assured that the\n * provided string will never cause an XSS vulnerability if used in a context\n * that will be interpreted as HTML by a browser, e.g. when assigning to\n * element.innerHTML.\n */\nfunction trustedHTMLFromString(html) {\n    return getPolicy()?.createHTML(html) || html;\n}\n\n/**\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 * Returns an exception to be thrown in the case when attempting to\n * load an icon with a name that cannot be found.\n * @docs-private\n */\nfunction getMatIconNameNotFoundError(iconName) {\n    return Error(`Unable to find icon with the name \"${iconName}\"`);\n}\n/**\n * Returns an exception to be thrown when the consumer attempts to use\n * `<mat-icon>` without including @angular/common/http.\n * @docs-private\n */\nfunction getMatIconNoHttpProviderError() {\n    return Error('Could not find HttpClient provider for use with Angular Material icons. ' +\n        'Please include the HttpClientModule from @angular/common/http in your ' +\n        'app imports.');\n}\n/**\n * Returns an exception to be thrown when a URL couldn't be sanitized.\n * @param url URL that was attempted to be sanitized.\n * @docs-private\n */\nfunction getMatIconFailedToSanitizeUrlError(url) {\n    return Error(`The URL provided to MatIconRegistry was not trusted as a resource URL ` +\n        `via Angular's DomSanitizer. Attempted URL was \"${url}\".`);\n}\n/**\n * Returns an exception to be thrown when a HTML string couldn't be sanitized.\n * @param literal HTML that was attempted to be sanitized.\n * @docs-private\n */\nfunction getMatIconFailedToSanitizeLiteralError(literal) {\n    return Error(`The literal provided to MatIconRegistry was not trusted as safe HTML by ` +\n        `Angular's DomSanitizer. Attempted literal was \"${literal}\".`);\n}\n/**\n * Configuration for an icon, including the URL and possibly the cached SVG element.\n * @docs-private\n */\nclass SvgIconConfig {\n    constructor(url, svgText, options) {\n        this.url = url;\n        this.svgText = svgText;\n        this.options = options;\n    }\n}\n/**\n * Service to register and display icons used by the `<mat-icon>` component.\n * - Registers icon URLs by namespace and name.\n * - Registers icon set URLs by namespace.\n * - Registers aliases for CSS classes, for use with icon fonts.\n * - Loads icons from URLs and extracts individual icons from icon sets.\n */\nclass MatIconRegistry {\n    constructor(_httpClient, _sanitizer, document, _errorHandler) {\n        this._httpClient = _httpClient;\n        this._sanitizer = _sanitizer;\n        this._errorHandler = _errorHandler;\n        /**\n         * URLs and cached SVG elements for individual icons. Keys are of the format \"[namespace]:[icon]\".\n         */\n        this._svgIconConfigs = new Map();\n        /**\n         * SvgIconConfig objects and cached SVG elements for icon sets, keyed by namespace.\n         * Multiple icon sets can be registered under the same namespace.\n         */\n        this._iconSetConfigs = new Map();\n        /** Cache for icons loaded by direct URLs. */\n        this._cachedIconsByUrl = new Map();\n        /** In-progress icon fetches. Used to coalesce multiple requests to the same URL. */\n        this._inProgressUrlFetches = new Map();\n        /** Map from font identifiers to their CSS class names. Used for icon fonts. */\n        this._fontCssClassesByAlias = new Map();\n        /** Registered icon resolver functions. */\n        this._resolvers = [];\n        /**\n         * The CSS classes to apply when an `<mat-icon>` component has no icon name, url, or font\n         * specified. The default 'material-icons' value assumes that the material icon font has been\n         * loaded as described at http://google.github.io/material-design-icons/#icon-font-for-the-web\n         */\n        this._defaultFontSetClass = ['material-icons', 'mat-ligature-font'];\n        this._document = document;\n    }\n    /**\n     * Registers an icon by URL in the default namespace.\n     * @param iconName Name under which the icon should be registered.\n     * @param url\n     */\n    addSvgIcon(iconName, url, options) {\n        return this.addSvgIconInNamespace('', iconName, url, options);\n    }\n    /**\n     * Registers an icon using an HTML string in the default namespace.\n     * @param iconName Name under which the icon should be registered.\n     * @param literal SVG source of the icon.\n     */\n    addSvgIconLiteral(iconName, literal, options) {\n        return this.addSvgIconLiteralInNamespace('', iconName, literal, options);\n    }\n    /**\n     * Registers an icon by URL in the specified namespace.\n     * @param namespace Namespace in which the icon should be registered.\n     * @param iconName Name under which the icon should be registered.\n     * @param url\n     */\n    addSvgIconInNamespace(namespace, iconName, url, options) {\n        return this._addSvgIconConfig(namespace, iconName, new SvgIconConfig(url, null, options));\n    }\n    /**\n     * Registers an icon resolver function with the registry. The function will be invoked with the\n     * name and namespace of an icon when the registry tries to resolve the URL from which to fetch\n     * the icon. The resolver is expected to return a `SafeResourceUrl` that points to the icon,\n     * an object with the icon URL and icon options, or `null` if the icon is not supported. Resolvers\n     * will be invoked in the order in which they have been registered.\n     * @param resolver Resolver function to be registered.\n     */\n    addSvgIconResolver(resolver) {\n        this._resolvers.push(resolver);\n        return this;\n    }\n    /**\n     * Registers an icon using an HTML string in the specified namespace.\n     * @param namespace Namespace in which the icon should be registered.\n     * @param iconName Name under which the icon should be registered.\n     * @param literal SVG source of the icon.\n     */\n    addSvgIconLiteralInNamespace(namespace, iconName, literal, options) {\n        const cleanLiteral = this._sanitizer.sanitize(SecurityContext.HTML, literal);\n        // TODO: add an ngDevMode check\n        if (!cleanLiteral) {\n            throw getMatIconFailedToSanitizeLiteralError(literal);\n        }\n        // Security: The literal is passed in as SafeHtml, and is thus trusted.\n        const trustedLiteral = trustedHTMLFromString(cleanLiteral);\n        return this._addSvgIconConfig(namespace, iconName, new SvgIconConfig('', trustedLiteral, options));\n    }\n    /**\n     * Registers an icon set by URL in the default namespace.\n     * @param url\n     */\n    addSvgIconSet(url, options) {\n        return this.addSvgIconSetInNamespace('', url, options);\n    }\n    /**\n     * Registers an icon set using an HTML string in the default namespace.\n     * @param literal SVG source of the icon set.\n     */\n    addSvgIconSetLiteral(literal, options) {\n        return this.addSvgIconSetLiteralInNamespace('', literal, options);\n    }\n    /**\n     * Registers an icon set by URL in the specified namespace.\n     * @param namespace Namespace in which to register the icon set.\n     * @param url\n     */\n    addSvgIconSetInNamespace(namespace, url, options) {\n        return this._addSvgIconSetConfig(namespace, new SvgIconConfig(url, null, options));\n    }\n    /**\n     * Registers an icon set using an HTML string in the specified namespace.\n     * @param namespace Namespace in which to register the icon set.\n     * @param literal SVG source of the icon set.\n     */\n    addSvgIconSetLiteralInNamespace(namespace, literal, options) {\n        const cleanLiteral = this._sanitizer.sanitize(SecurityContext.HTML, literal);\n        if (!cleanLiteral) {\n            throw getMatIconFailedToSanitizeLiteralError(literal);\n        }\n        // Security: The literal is passed in as SafeHtml, and is thus trusted.\n        const trustedLiteral = trustedHTMLFromString(cleanLiteral);\n        return this._addSvgIconSetConfig(namespace, new SvgIconConfig('', trustedLiteral, options));\n    }\n    /**\n     * Defines an alias for CSS class names to be used for icon fonts. Creating an matIcon\n     * component with the alias as the fontSet input will cause the class name to be applied\n     * to the `<mat-icon>` element.\n     *\n     * If the registered font is a ligature font, then don't forget to also include the special\n     * class `mat-ligature-font` to allow the usage via attribute. So register like this:\n     *\n     * ```ts\n     * iconRegistry.registerFontClassAlias('f1', 'font1 mat-ligature-font');\n     * ```\n     *\n     * And use like this:\n     *\n     * ```html\n     * <mat-icon fontSet=\"f1\" fontIcon=\"home\"></mat-icon>\n     * ```\n     *\n     * @param alias Alias for the font.\n     * @param classNames Class names override to be used instead of the alias.\n     */\n    registerFontClassAlias(alias, classNames = alias) {\n        this._fontCssClassesByAlias.set(alias, classNames);\n        return this;\n    }\n    /**\n     * Returns the CSS class name associated with the alias by a previous call to\n     * registerFontClassAlias. If no CSS class has been associated, returns the alias unmodified.\n     */\n    classNameForFontAlias(alias) {\n        return this._fontCssClassesByAlias.get(alias) || alias;\n    }\n    /**\n     * Sets the CSS classes to be used for icon fonts when an `<mat-icon>` component does not\n     * have a fontSet input value, and is not loading an icon by name or URL.\n     */\n    setDefaultFontSetClass(...classNames) {\n        this._defaultFontSetClass = classNames;\n        return this;\n    }\n    /**\n     * Returns the CSS classes to be used for icon fonts when an `<mat-icon>` component does not\n     * have a fontSet input value, and is not loading an icon by name or URL.\n     */\n    getDefaultFontSetClass() {\n        return this._defaultFontSetClass;\n    }\n    /**\n     * Returns an Observable that produces the icon (as an `<svg>` DOM element) from the given URL.\n     * The response from the URL may be cached so this will not always cause an HTTP request, but\n     * the produced element will always be a new copy of the originally fetched icon. (That is,\n     * it will not contain any modifications made to elements previously returned).\n     *\n     * @param safeUrl URL from which to fetch the SVG icon.\n     */\n    getSvgIconFromUrl(safeUrl) {\n        const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, safeUrl);\n        if (!url) {\n            throw getMatIconFailedToSanitizeUrlError(safeUrl);\n        }\n        const cachedIcon = this._cachedIconsByUrl.get(url);\n        if (cachedIcon) {\n            return of(cloneSvg(cachedIcon));\n        }\n        return this._loadSvgIconFromConfig(new SvgIconConfig(safeUrl, null)).pipe(tap(svg => this._cachedIconsByUrl.set(url, svg)), map(svg => cloneSvg(svg)));\n    }\n    /**\n     * Returns an Observable that produces the icon (as an `<svg>` DOM element) with the given name\n     * and namespace. The icon must have been previously registered with addIcon or addIconSet;\n     * if not, the Observable will throw an error.\n     *\n     * @param name Name of the icon to be retrieved.\n     * @param namespace Namespace in which to look for the icon.\n     */\n    getNamedSvgIcon(name, namespace = '') {\n        const key = iconKey(namespace, name);\n        let config = this._svgIconConfigs.get(key);\n        // Return (copy of) cached icon if possible.\n        if (config) {\n            return this._getSvgFromConfig(config);\n        }\n        // Otherwise try to resolve the config from one of the resolver functions.\n        config = this._getIconConfigFromResolvers(namespace, name);\n        if (config) {\n            this._svgIconConfigs.set(key, config);\n            return this._getSvgFromConfig(config);\n        }\n        // See if we have any icon sets registered for the namespace.\n        const iconSetConfigs = this._iconSetConfigs.get(namespace);\n        if (iconSetConfigs) {\n            return this._getSvgFromIconSetConfigs(name, iconSetConfigs);\n        }\n        return throwError(getMatIconNameNotFoundError(key));\n    }\n    ngOnDestroy() {\n        this._resolvers = [];\n        this._svgIconConfigs.clear();\n        this._iconSetConfigs.clear();\n        this._cachedIconsByUrl.clear();\n    }\n    /**\n     * Returns the cached icon for a SvgIconConfig if available, or fetches it from its URL if not.\n     */\n    _getSvgFromConfig(config) {\n        if (config.svgText) {\n            // We already have the SVG element for this icon, return a copy.\n            return of(cloneSvg(this._svgElementFromConfig(config)));\n        }\n        else {\n            // Fetch the icon from the config's URL, cache it, and return a copy.\n            return this._loadSvgIconFromConfig(config).pipe(map(svg => cloneSvg(svg)));\n        }\n    }\n    /**\n     * Attempts to find an icon with the specified name in any of the SVG icon sets.\n     * First searches the available cached icons for a nested element with a matching name, and\n     * if found copies the element to a new `<svg>` element. If not found, fetches all icon sets\n     * that have not been cached, and searches again after all fetches are completed.\n     * The returned Observable produces the SVG element if possible, and throws\n     * an error if no icon with the specified name can be found.\n     */\n    _getSvgFromIconSetConfigs(name, iconSetConfigs) {\n        // For all the icon set SVG elements we've fetched, see if any contain an icon with the\n        // requested name.\n        const namedIcon = this._extractIconWithNameFromAnySet(name, iconSetConfigs);\n        if (namedIcon) {\n            // We could cache namedIcon in _svgIconConfigs, but since we have to make a copy every\n            // time anyway, there's probably not much advantage compared to just always extracting\n            // it from the icon set.\n            return of(namedIcon);\n        }\n        // Not found in any cached icon sets. If there are icon sets with URLs that we haven't\n        // fetched, fetch them now and look for iconName in the results.\n        const iconSetFetchRequests = iconSetConfigs\n            .filter(iconSetConfig => !iconSetConfig.svgText)\n            .map(iconSetConfig => {\n            return this._loadSvgIconSetFromConfig(iconSetConfig).pipe(catchError((err) => {\n                const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, iconSetConfig.url);\n                // Swallow errors fetching individual URLs so the\n                // combined Observable won't necessarily fail.\n                const errorMessage = `Loading icon set URL: ${url} failed: ${err.message}`;\n                this._errorHandler.handleError(new Error(errorMessage));\n                return of(null);\n            }));\n        });\n        // Fetch all the icon set URLs. When the requests complete, every IconSet should have a\n        // cached SVG element (unless the request failed), and we can check again for the icon.\n        return forkJoin(iconSetFetchRequests).pipe(map(() => {\n            const foundIcon = this._extractIconWithNameFromAnySet(name, iconSetConfigs);\n            // TODO: add an ngDevMode check\n            if (!foundIcon) {\n                throw getMatIconNameNotFoundError(name);\n            }\n            return foundIcon;\n        }));\n    }\n    /**\n     * Searches the cached SVG elements for the given icon sets for a nested icon element whose \"id\"\n     * tag matches the specified name. If found, copies the nested element to a new SVG element and\n     * returns it. Returns null if no matching element is found.\n     */\n    _extractIconWithNameFromAnySet(iconName, iconSetConfigs) {\n        // Iterate backwards, so icon sets added later have precedence.\n        for (let i = iconSetConfigs.length - 1; i >= 0; i--) {\n            const config = iconSetConfigs[i];\n            // Parsing the icon set's text into an SVG element can be expensive. We can avoid some of\n            // the parsing by doing a quick check using `indexOf` to see if there's any chance for the\n            // icon to be in the set. This won't be 100% accurate, but it should help us avoid at least\n            // some of the parsing.\n            if (config.svgText && config.svgText.toString().indexOf(iconName) > -1) {\n                const svg = this._svgElementFromConfig(config);\n                const foundIcon = this._extractSvgIconFromSet(svg, iconName, config.options);\n                if (foundIcon) {\n                    return foundIcon;\n                }\n            }\n        }\n        return null;\n    }\n    /**\n     * Loads the content of the icon URL specified in the SvgIconConfig and creates an SVG element\n     * from it.\n     */\n    _loadSvgIconFromConfig(config) {\n        return this._fetchIcon(config).pipe(tap(svgText => (config.svgText = svgText)), map(() => this._svgElementFromConfig(config)));\n    }\n    /**\n     * Loads the content of the icon set URL specified in the\n     * SvgIconConfig and attaches it to the config.\n     */\n    _loadSvgIconSetFromConfig(config) {\n        if (config.svgText) {\n            return of(null);\n        }\n        return this._fetchIcon(config).pipe(tap(svgText => (config.svgText = svgText)));\n    }\n    /**\n     * Searches the cached element of the given SvgIconConfig for a nested icon element whose \"id\"\n     * tag matches the specified name. If found, copies the nested element to a new SVG element and\n     * returns it. Returns null if no matching element is found.\n     */\n    _extractSvgIconFromSet(iconSet, iconName, options) {\n        // Use the `id=\"iconName\"` syntax in order to escape special\n        // characters in the ID (versus using the #iconName syntax).\n        const iconSource = iconSet.querySelector(`[id=\"${iconName}\"]`);\n        if (!iconSource) {\n            return null;\n        }\n        // Clone the element and remove the ID to prevent multiple elements from being added\n        // to the page with the same ID.\n        const iconElement = iconSource.cloneNode(true);\n        iconElement.removeAttribute('id');\n        // If the icon node is itself an <svg> node, clone and return it directly. If not, set it as\n        // the content of a new <svg> node.\n        if (iconElement.nodeName.toLowerCase() === 'svg') {\n            return this._setSvgAttributes(iconElement, options);\n        }\n        // If the node is a <symbol>, it won't be rendered so we have to convert it into <svg>. Note\n        // that the same could be achieved by referring to it via <use href=\"#id\">, however the <use>\n        // tag is problematic on Firefox, because it needs to include the current page path.\n        if (iconElement.nodeName.toLowerCase() === 'symbol') {\n            return this._setSvgAttributes(this._toSvgElement(iconElement), options);\n        }\n        // createElement('SVG') doesn't work as expected; the DOM ends up with\n        // the correct nodes, but the SVG content doesn't render. Instead we\n        // have to create an empty SVG node using innerHTML and append its content.\n        // Elements created using DOMParser.parseFromString have the same problem.\n        // http://stackoverflow.com/questions/23003278/svg-innerhtml-in-firefox-can-not-display\n        const svg = this._svgElementFromString(trustedHTMLFromString('<svg></svg>'));\n        // Clone the node so we don't remove it from the parent icon set element.\n        svg.appendChild(iconElement);\n        return this._setSvgAttributes(svg, options);\n    }\n    /**\n     * Creates a DOM element from the given SVG string.\n     */\n    _svgElementFromString(str) {\n        const div = this._document.createElement('DIV');\n        div.innerHTML = str;\n        const svg = div.querySelector('svg');\n        // TODO: add an ngDevMode check\n        if (!svg) {\n            throw Error('<svg> tag not found');\n        }\n        return svg;\n    }\n    /**\n     * Converts an element into an SVG node by cloning all of its children.\n     */\n    _toSvgElement(element) {\n        const svg = this._svgElementFromString(trustedHTMLFromString('<svg></svg>'));\n        const attributes = element.attributes;\n        // Copy over all the attributes from the `symbol` to the new SVG, except the id.\n        for (let i = 0; i < attributes.length; i++) {\n            const { name, value } = attributes[i];\n            if (name !== 'id') {\n                svg.setAttribute(name, value);\n            }\n        }\n        for (let i = 0; i < element.childNodes.length; i++) {\n            if (element.childNodes[i].nodeType === this._document.ELEMENT_NODE) {\n                svg.appendChild(element.childNodes[i].cloneNode(true));\n            }\n        }\n        return svg;\n    }\n    /**\n     * Sets the default attributes for an SVG element to be used as an icon.\n     */\n    _setSvgAttributes(svg, options) {\n        svg.setAttribute('fit', '');\n        svg.setAttribute('height', '100%');\n        svg.setAttribute('width', '100%');\n        svg.setAttribute('preserveAspectRatio', 'xMidYMid meet');\n        svg.setAttribute('focusable', 'false'); // Disable IE11 default behavior to make SVGs focusable.\n        if (options && options.viewBox) {\n            svg.setAttribute('viewBox', options.viewBox);\n        }\n        return svg;\n    }\n    /**\n     * Returns an Observable which produces the string contents of the given icon. Results may be\n     * cached, so future calls with the same URL may not cause another HTTP request.\n     */\n    _fetchIcon(iconConfig) {\n        const { url: safeUrl, options } = iconConfig;\n        const withCredentials = options?.withCredentials ?? false;\n        if (!this._httpClient) {\n            throw getMatIconNoHttpProviderError();\n        }\n        // TODO: add an ngDevMode check\n        if (safeUrl == null) {\n            throw Error(`Cannot fetch icon from URL \"${safeUrl}\".`);\n        }\n        const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, safeUrl);\n        // TODO: add an ngDevMode check\n        if (!url) {\n            throw getMatIconFailedToSanitizeUrlError(safeUrl);\n        }\n        // Store in-progress fetches to avoid sending a duplicate request for a URL when there is\n        // already a request in progress for that URL. It's necessary to call share() on the\n        // Observable returned by http.get() so that multiple subscribers don't cause multiple XHRs.\n        const inProgressFetch = this._inProgressUrlFetches.get(url);\n        if (inProgressFetch) {\n            return inProgressFetch;\n        }\n        const req = this._httpClient.get(url, { responseType: 'text', withCredentials }).pipe(map(svg => {\n            // Security: This SVG is fetched from a SafeResourceUrl, and is thus\n            // trusted HTML.\n            return trustedHTMLFromString(svg);\n        }), finalize(() => this._inProgressUrlFetches.delete(url)), share());\n        this._inProgressUrlFetches.set(url, req);\n        return req;\n    }\n    /**\n     * Registers an icon config by name in the specified namespace.\n     * @param namespace Namespace in which to register the icon config.\n     * @param iconName Name under which to register the config.\n     * @param config Config to be registered.\n     */\n    _addSvgIconConfig(namespace, iconName, config) {\n        this._svgIconConfigs.set(iconKey(namespace, iconName), config);\n        return this;\n    }\n    /**\n     * Registers an icon set config in the specified namespace.\n     * @param namespace Namespace in which to register the icon config.\n     * @param config Config to be registered.\n     */\n    _addSvgIconSetConfig(namespace, config) {\n        const configNamespace = this._iconSetConfigs.get(namespace);\n        if (configNamespace) {\n            configNamespace.push(config);\n        }\n        else {\n            this._iconSetConfigs.set(namespace, [config]);\n        }\n        return this;\n    }\n    /** Parses a config's text into an SVG element. */\n    _svgElementFromConfig(config) {\n        if (!config.svgElement) {\n            const svg = this._svgElementFromString(config.svgText);\n            this._setSvgAttributes(svg, config.options);\n            config.svgElement = svg;\n        }\n        return config.svgElement;\n    }\n    /** Tries to create an icon config through the registered resolver functions. */\n    _getIconConfigFromResolvers(namespace, name) {\n        for (let i = 0; i < this._resolvers.length; i++) {\n            const result = this._resolvers[i](name, namespace);\n            if (result) {\n                return isSafeUrlWithOptions(result)\n                    ? new SvgIconConfig(result.url, null, result.options)\n                    : new SvgIconConfig(result, null);\n            }\n        }\n        return undefined;\n    }\n}\nMatIconRegistry.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatIconRegistry, deps: [{ token: i1.HttpClient, optional: true }, { token: i2.DomSanitizer }, { token: DOCUMENT, optional: true }, { token: i0.ErrorHandler }], target: i0.ɵɵFactoryTarget.Injectable });\nMatIconRegistry.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatIconRegistry, providedIn: 'root' });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatIconRegistry, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () { return [{ type: i1.HttpClient, decorators: [{\n                    type: Optional\n                }] }, { type: i2.DomSanitizer }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: i0.ErrorHandler }]; } });\n/** @docs-private */\nfunction ICON_REGISTRY_PROVIDER_FACTORY(parentRegistry, httpClient, sanitizer, errorHandler, document) {\n    return parentRegistry || new MatIconRegistry(httpClient, sanitizer, document, errorHandler);\n}\n/** @docs-private */\nconst ICON_REGISTRY_PROVIDER = {\n    // If there is already an MatIconRegistry available, use that. Otherwise, provide a new one.\n    provide: MatIconRegistry,\n    deps: [\n        [new Optional(), new SkipSelf(), MatIconRegistry],\n        [new Optional(), HttpClient],\n        DomSanitizer,\n        ErrorHandler,\n        [new Optional(), DOCUMENT],\n    ],\n    useFactory: ICON_REGISTRY_PROVIDER_FACTORY,\n};\n/** Clones an SVGElement while preserving type information. */\nfunction cloneSvg(svg) {\n    return svg.cloneNode(true);\n}\n/** Returns the cache key to use for an icon namespace and name. */\nfunction iconKey(namespace, name) {\n    return namespace + ':' + name;\n}\nfunction isSafeUrlWithOptions(value) {\n    return !!(value.url && value.options);\n}\n\n/**\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// Boilerplate for applying mixins to MatIcon.\n/** @docs-private */\nconst _MatIconBase = mixinColor(class {\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n});\n/** Injection token to be used to override the default options for `mat-icon`. */\nconst MAT_ICON_DEFAULT_OPTIONS = new InjectionToken('MAT_ICON_DEFAULT_OPTIONS');\n/**\n * Injection token used to provide the current location to `MatIcon`.\n * Used to handle server-side rendering and to stub out during unit tests.\n * @docs-private\n */\nconst MAT_ICON_LOCATION = new InjectionToken('mat-icon-location', {\n    providedIn: 'root',\n    factory: MAT_ICON_LOCATION_FACTORY,\n});\n/** @docs-private */\nfunction MAT_ICON_LOCATION_FACTORY() {\n    const _document = inject(DOCUMENT);\n    const _location = _document ? _document.location : null;\n    return {\n        // Note that this needs to be a function, rather than a property, because Angular\n        // will only resolve it once, but we want the current path on each call.\n        getPathname: () => (_location ? _location.pathname + _location.search : ''),\n    };\n}\n/** SVG attributes that accept a FuncIRI (e.g. `url(<something>)`). */\nconst funcIriAttributes = [\n    'clip-path',\n    'color-profile',\n    'src',\n    'cursor',\n    'fill',\n    'filter',\n    'marker',\n    'marker-start',\n    'marker-mid',\n    'marker-end',\n    'mask',\n    'stroke',\n];\n/** Selector that can be used to find all elements that are using a `FuncIRI`. */\nconst funcIriAttributeSelector = funcIriAttributes.map(attr => `[${attr}]`).join(', ');\n/** Regex that can be used to extract the id out of a FuncIRI. */\nconst funcIriPattern = /^url\\(['\"]?#(.*?)['\"]?\\)$/;\n/**\n * Component to display an icon. It can be used in the following ways:\n *\n * - Specify the svgIcon input to load an SVG icon from a URL previously registered with the\n *   addSvgIcon, addSvgIconInNamespace, addSvgIconSet, or addSvgIconSetInNamespace methods of\n *   MatIconRegistry. If the svgIcon value contains a colon it is assumed to be in the format\n *   \"[namespace]:[name]\", if not the value will be the name of an icon in the default namespace.\n *   Examples:\n *     `<mat-icon svgIcon=\"left-arrow\"></mat-icon>\n *     <mat-icon svgIcon=\"animals:cat\"></mat-icon>`\n *\n * - Use a font ligature as an icon by putting the ligature text in the `fontIcon` attribute or the\n *   content of the `<mat-icon>` component. If you register a custom font class, don't forget to also\n *   include the special class `mat-ligature-font`. It is recommended to use the attribute alternative\n *   to prevent the ligature text to be selectable and to appear in search engine results.\n *   By default, the Material icons font is used as described at\n *   http://google.github.io/material-design-icons/#icon-font-for-the-web. You can specify an\n *   alternate font by setting the fontSet input to either the CSS class to apply to use the\n *   desired font, or to an alias previously registered with MatIconRegistry.registerFontClassAlias.\n *   Examples:\n *     `<mat-icon fontIcon=\"home\"></mat-icon>\n *     <mat-icon>home</mat-icon>\n *     <mat-icon fontSet=\"myfont\" fontIcon=\"sun\"></mat-icon>\n *     <mat-icon fontSet=\"myfont\">sun</mat-icon>`\n *\n * - Specify a font glyph to be included via CSS rules by setting the fontSet input to specify the\n *   font, and the fontIcon input to specify the icon. Typically the fontIcon will specify a\n *   CSS class which causes the glyph to be displayed via a :before selector, as in\n *   https://fortawesome.github.io/Font-Awesome/examples/\n *   Example:\n *     `<mat-icon fontSet=\"fa\" fontIcon=\"alarm\"></mat-icon>`\n */\nclass MatIcon extends _MatIconBase {\n    constructor(elementRef, _iconRegistry, ariaHidden, _location, _errorHandler, defaults) {\n        super(elementRef);\n        this._iconRegistry = _iconRegistry;\n        this._location = _location;\n        this._errorHandler = _errorHandler;\n        this._inline = false;\n        this._previousFontSetClass = [];\n        /** Subscription to the current in-progress SVG icon request. */\n        this._currentIconFetch = Subscription.EMPTY;\n        if (defaults) {\n            if (defaults.color) {\n                this.color = this.defaultColor = defaults.color;\n            }\n            if (defaults.fontSet) {\n                this.fontSet = defaults.fontSet;\n            }\n        }\n        // If the user has not explicitly set aria-hidden, mark the icon as hidden, as this is\n        // the right thing to do for the majority of icon use-cases.\n        if (!ariaHidden) {\n            elementRef.nativeElement.setAttribute('aria-hidden', 'true');\n        }\n    }\n    /**\n     * Whether the icon should be inlined, automatically sizing the icon to match the font size of\n     * the element the icon is contained in.\n     */\n    get inline() {\n        return this._inline;\n    }\n    set inline(inline) {\n        this._inline = coerceBooleanProperty(inline);\n    }\n    /** Name of the icon in the SVG icon set. */\n    get svgIcon() {\n        return this._svgIcon;\n    }\n    set svgIcon(value) {\n        if (value !== this._svgIcon) {\n            if (value) {\n                this._updateSvgIcon(value);\n            }\n            else if (this._svgIcon) {\n                this._clearSvgElement();\n            }\n            this._svgIcon = value;\n        }\n    }\n    /** Font set that the icon is a part of. */\n    get fontSet() {\n        return this._fontSet;\n    }\n    set fontSet(value) {\n        const newValue = this._cleanupFontValue(value);\n        if (newValue !== this._fontSet) {\n            this._fontSet = newValue;\n            this._updateFontIconClasses();\n        }\n    }\n    /** Name of an icon within a font set. */\n    get fontIcon() {\n        return this._fontIcon;\n    }\n    set fontIcon(value) {\n        const newValue = this._cleanupFontValue(value);\n        if (newValue !== this._fontIcon) {\n            this._fontIcon = newValue;\n            this._updateFontIconClasses();\n        }\n    }\n    /**\n     * Splits an svgIcon binding value into its icon set and icon name components.\n     * Returns a 2-element array of [(icon set), (icon name)].\n     * The separator for the two fields is ':'. If there is no separator, an empty\n     * string is returned for the icon set and the entire value is returned for\n     * the icon name. If the argument is falsy, returns an array of two empty strings.\n     * Throws an error if the name contains two or more ':' separators.\n     * Examples:\n     *   `'social:cake' -> ['social', 'cake']\n     *   'penguin' -> ['', 'penguin']\n     *   null -> ['', '']\n     *   'a:b:c' -> (throws Error)`\n     */\n    _splitIconName(iconName) {\n        if (!iconName) {\n            return ['', ''];\n        }\n        const parts = iconName.split(':');\n        switch (parts.length) {\n            case 1:\n                return ['', parts[0]]; // Use default namespace.\n            case 2:\n                return parts;\n            default:\n                throw Error(`Invalid icon name: \"${iconName}\"`); // TODO: add an ngDevMode check\n        }\n    }\n    ngOnInit() {\n        // Update font classes because ngOnChanges won't be called if none of the inputs are present,\n        // e.g. <mat-icon>arrow</mat-icon> In this case we need to add a CSS class for the default font.\n        this._updateFontIconClasses();\n    }\n    ngAfterViewChecked() {\n        const cachedElements = this._elementsWithExternalReferences;\n        if (cachedElements && cachedElements.size) {\n            const newPath = this._location.getPathname();\n            // We need to check whether the URL has changed on each change detection since\n            // the browser doesn't have an API that will let us react on link clicks and\n            // we can't depend on the Angular router. The references need to be updated,\n            // because while most browsers don't care whether the URL is correct after\n            // the first render, Safari will break if the user navigates to a different\n            // page and the SVG isn't re-rendered.\n            if (newPath !== this._previousPath) {\n                this._previousPath = newPath;\n                this._prependPathToReferences(newPath);\n            }\n        }\n    }\n    ngOnDestroy() {\n        this._currentIconFetch.unsubscribe();\n        if (this._elementsWithExternalReferences) {\n            this._elementsWithExternalReferences.clear();\n        }\n    }\n    _usingFontIcon() {\n        return !this.svgIcon;\n    }\n    _setSvgElement(svg) {\n        this._clearSvgElement();\n        // Note: we do this fix here, rather than the icon registry, because the\n        // references have to point to the URL at the time that the icon was created.\n        const path = this._location.getPathname();\n        this._previousPath = path;\n        this._cacheChildrenWithExternalReferences(svg);\n        this._prependPathToReferences(path);\n        this._elementRef.nativeElement.appendChild(svg);\n    }\n    _clearSvgElement() {\n        const layoutElement = this._elementRef.nativeElement;\n        let childCount = layoutElement.childNodes.length;\n        if (this._elementsWithExternalReferences) {\n            this._elementsWithExternalReferences.clear();\n        }\n        // Remove existing non-element child nodes and SVGs, and add the new SVG element. Note that\n        // we can't use innerHTML, because IE will throw if the element has a data binding.\n        while (childCount--) {\n            const child = layoutElement.childNodes[childCount];\n            // 1 corresponds to Node.ELEMENT_NODE. We remove all non-element nodes in order to get rid\n            // of any loose text nodes, as well as any SVG elements in order to remove any old icons.\n            if (child.nodeType !== 1 || child.nodeName.toLowerCase() === 'svg') {\n                child.remove();\n            }\n        }\n    }\n    _updateFontIconClasses() {\n        if (!this._usingFontIcon()) {\n            return;\n        }\n        const elem = this._elementRef.nativeElement;\n        const fontSetClasses = (this.fontSet\n            ? this._iconRegistry.classNameForFontAlias(this.fontSet).split(/ +/)\n            : this._iconRegistry.getDefaultFontSetClass()).filter(className => className.length > 0);\n        this._previousFontSetClass.forEach(className => elem.classList.remove(className));\n        fontSetClasses.forEach(className => elem.classList.add(className));\n        this._previousFontSetClass = fontSetClasses;\n        if (this.fontIcon !== this._previousFontIconClass &&\n            !fontSetClasses.includes('mat-ligature-font')) {\n            if (this._previousFontIconClass) {\n                elem.classList.remove(this._previousFontIconClass);\n            }\n            if (this.fontIcon) {\n                elem.classList.add(this.fontIcon);\n            }\n            this._previousFontIconClass = this.fontIcon;\n        }\n    }\n    /**\n     * Cleans up a value to be used as a fontIcon or fontSet.\n     * Since the value ends up being assigned as a CSS class, we\n     * have to trim the value and omit space-separated values.\n     */\n    _cleanupFontValue(value) {\n        return typeof value === 'string' ? value.trim().split(' ')[0] : value;\n    }\n    /**\n     * Prepends the current path to all elements that have an attribute pointing to a `FuncIRI`\n     * reference. This is required because WebKit browsers require references to be prefixed with\n     * the current path, if the page has a `base` tag.\n     */\n    _prependPathToReferences(path) {\n        const elements = this._elementsWithExternalReferences;\n        if (elements) {\n            elements.forEach((attrs, element) => {\n                attrs.forEach(attr => {\n                    element.setAttribute(attr.name, `url('${path}#${attr.value}')`);\n                });\n            });\n        }\n    }\n    /**\n     * Caches the children of an SVG element that have `url()`\n     * references that we need to prefix with the current path.\n     */\n    _cacheChildrenWithExternalReferences(element) {\n        const elementsWithFuncIri = element.querySelectorAll(funcIriAttributeSelector);\n        const elements = (this._elementsWithExternalReferences =\n            this._elementsWithExternalReferences || new Map());\n        for (let i = 0; i < elementsWithFuncIri.length; i++) {\n            funcIriAttributes.forEach(attr => {\n                const elementWithReference = elementsWithFuncIri[i];\n                const value = elementWithReference.getAttribute(attr);\n                const match = value ? value.match(funcIriPattern) : null;\n                if (match) {\n                    let attributes = elements.get(elementWithReference);\n                    if (!attributes) {\n                        attributes = [];\n                        elements.set(elementWithReference, attributes);\n                    }\n                    attributes.push({ name: attr, value: match[1] });\n                }\n            });\n        }\n    }\n    /** Sets a new SVG icon with a particular name. */\n    _updateSvgIcon(rawName) {\n        this._svgNamespace = null;\n        this._svgName = null;\n        this._currentIconFetch.unsubscribe();\n        if (rawName) {\n            const [namespace, iconName] = this._splitIconName(rawName);\n            if (namespace) {\n                this._svgNamespace = namespace;\n            }\n            if (iconName) {\n                this._svgName = iconName;\n            }\n            this._currentIconFetch = this._iconRegistry\n                .getNamedSvgIcon(iconName, namespace)\n                .pipe(take(1))\n                .subscribe(svg => this._setSvgElement(svg), (err) => {\n                const errorMessage = `Error retrieving icon ${namespace}:${iconName}! ${err.message}`;\n                this._errorHandler.handleError(new Error(errorMessage));\n            });\n        }\n    }\n}\nMatIcon.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatIcon, deps: [{ token: i0.ElementRef }, { token: MatIconRegistry }, { token: 'aria-hidden', attribute: true }, { token: MAT_ICON_LOCATION }, { token: i0.ErrorHandler }, { token: MAT_ICON_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nMatIcon.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"14.2.0\", type: MatIcon, selector: \"mat-icon\", inputs: { color: \"color\", inline: \"inline\", svgIcon: \"svgIcon\", fontSet: \"fontSet\", fontIcon: \"fontIcon\" }, host: { attributes: { \"role\": \"img\" }, properties: { \"attr.data-mat-icon-type\": \"_usingFontIcon() ? \\\"font\\\" : \\\"svg\\\"\", \"attr.data-mat-icon-name\": \"_svgName || fontIcon\", \"attr.data-mat-icon-namespace\": \"_svgNamespace || fontSet\", \"attr.fontIcon\": \"_usingFontIcon() ? fontIcon : null\", \"class.mat-icon-inline\": \"inline\", \"class.mat-icon-no-color\": \"color !== \\\"primary\\\" && color !== \\\"accent\\\" && color !== \\\"warn\\\"\" }, classAttribute: \"mat-icon notranslate\" }, exportAs: [\"matIcon\"], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, styles: [\".mat-icon{-webkit-user-select:none;user-select:none;background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px;overflow:hidden}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}.mat-icon.mat-ligature-font[fontIcon]::before{content:attr(fontIcon)}[dir=rtl] .mat-icon-rtl-mirror{transform:scale(-1, 1)}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon{display:block}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-icon{margin:auto}\"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatIcon, decorators: [{\n            type: Component,\n            args: [{ template: '<ng-content></ng-content>', selector: 'mat-icon', exportAs: 'matIcon', inputs: ['color'], host: {\n                        'role': 'img',\n                        'class': 'mat-icon notranslate',\n                        '[attr.data-mat-icon-type]': '_usingFontIcon() ? \"font\" : \"svg\"',\n                        '[attr.data-mat-icon-name]': '_svgName || fontIcon',\n                        '[attr.data-mat-icon-namespace]': '_svgNamespace || fontSet',\n                        '[attr.fontIcon]': '_usingFontIcon() ? fontIcon : null',\n                        '[class.mat-icon-inline]': 'inline',\n                        '[class.mat-icon-no-color]': 'color !== \"primary\" && color !== \"accent\" && color !== \"warn\"',\n                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, styles: [\".mat-icon{-webkit-user-select:none;user-select:none;background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px;overflow:hidden}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}.mat-icon.mat-ligature-font[fontIcon]::before{content:attr(fontIcon)}[dir=rtl] .mat-icon-rtl-mirror{transform:scale(-1, 1)}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon{display:block}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-icon{margin:auto}\"] }]\n        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: MatIconRegistry }, { type: undefined, decorators: [{\n                    type: Attribute,\n                    args: ['aria-hidden']\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [MAT_ICON_LOCATION]\n                }] }, { type: i0.ErrorHandler }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [MAT_ICON_DEFAULT_OPTIONS]\n                }] }]; }, propDecorators: { inline: [{\n                type: Input\n            }], svgIcon: [{\n                type: Input\n            }], fontSet: [{\n                type: Input\n            }], fontIcon: [{\n                type: Input\n            }] } });\n\n/**\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 */\nclass MatIconModule {\n}\nMatIconModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatIconModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatIconModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"14.2.0\", ngImport: i0, type: MatIconModule, declarations: [MatIcon], imports: [MatCommonModule], exports: [MatIcon, MatCommonModule] });\nMatIconModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatIconModule, imports: [MatCommonModule, MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"14.2.0\", ngImport: i0, type: MatIconModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [MatCommonModule],\n                    exports: [MatIcon, MatCommonModule],\n                    declarations: [MatIcon],\n                }]\n        }] });\n\n/**\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/**\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/**\n * Generated bundle index. Do not edit.\n */\n\nexport { ICON_REGISTRY_PROVIDER, ICON_REGISTRY_PROVIDER_FACTORY, MAT_ICON_DEFAULT_OPTIONS, MAT_ICON_LOCATION, MAT_ICON_LOCATION_FACTORY, MatIcon, MatIconModule, MatIconRegistry, getMatIconFailedToSanitizeLiteralError, getMatIconFailedToSanitizeUrlError, getMatIconNameNotFoundError, getMatIconNoHttpProviderError };\n"],"x_google_ignoreList":[0]}