{"version":3,"file":"471.js","mappings":"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","names":["BreakpointService","constructor","breakpointObserver","config","this","isMobile$","layout$","pipe","switchMap","layout","observe","Layout","Fresh","map","state","matches","shareReplay","refCount","bufferSize","window","inject","WINDOW","subscribe","isMobile","_isMobile","_isTablet","isTablet","isAndroid","uaString","navigator","userAgent","toLowerCase","test","static","t","i0","i1","i2","_angular_core__WEBPACK_IMPORTED_MODULE_6__","Yz7","factory","ɵfac","providedIn","forkJoin","args","resultSelector","popResultSelector","sources","keys","argsArgArrayOrObject","result","Observable","subscriber","length","complete","values","Array","remainingCompletions","remainingEmissions","sourceIndex","hasValue","innerFrom","createOperatorSubscriber","value","undefined","next","createObject","mapOneOrManyArgs","_c0","policy","trustedHTMLFromString","html","getPolicy","ttWindow","trustedTypes","createPolicy","createHTML","s","getMatIconNameNotFoundError","iconName","Error","getMatIconFailedToSanitizeUrlError","url","getMatIconFailedToSanitizeLiteralError","literal","SvgIconConfig","svgText","options","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","tap","svg","getNamedSvgIcon","name","key","iconKey","_getSvgFromConfig","_getIconConfigFromResolvers","iconSetConfigs","_getSvgFromIconSetConfigs","throwError","ngOnDestroy","clear","_svgElementFromConfig","namedIcon","_extractIconWithNameFromAnySet","iconSetFetchRequests","filter","iconSetConfig","_loadSvgIconSetFromConfig","catchError","err","errorMessage","message","handleError","foundIcon","i","toString","indexOf","_extractSvgIconFromSet","_fetchIcon","iconSet","iconSource","querySelector","iconElement","cloneNode","removeAttribute","nodeName","_setSvgAttributes","_toSvgElement","_svgElementFromString","appendChild","str","div","createElement","innerHTML","element","attributes","setAttribute","childNodes","nodeType","ELEMENT_NODE","viewBox","iconConfig","withCredentials","getMatIconNoHttpProviderError","inProgressFetch","req","responseType","finalize","delete","share","configNamespace","svgElement","isSafeUrlWithOptions","DOCUMENT","ɵprov","token","_MatIconBase","mixinColor","_elementRef","MAT_ICON_DEFAULT_OPTIONS","InjectionToken","MAT_ICON_LOCATION","MAT_ICON_LOCATION_FACTORY","_location","location","getPathname","pathname","search","funcIriAttributes","funcIriAttributeSelector","attr","join","funcIriPattern","MatIcon","inline","_inline","coerceBooleanProperty","svgIcon","_svgIcon","_updateSvgIcon","_clearSvgElement","fontSet","_fontSet","newValue","_cleanupFontValue","_updateFontIconClasses","fontIcon","_fontIcon","elementRef","_iconRegistry","ariaHidden","defaults","super","_previousFontSetClass","_currentIconFetch","Subscription","EMPTY","color","defaultColor","nativeElement","_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","ɵ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":["./src/app/shared/services/breakpoint.service.ts","./node_modules/rxjs/dist/esm/internal/observable/forkJoin.js","./node_modules/@angular/material/fesm2022/icon.mjs"],"sourcesContent":["import { BreakpointObserver, BreakpointState } from '@angular/cdk/layout';\nimport { inject, Injectable } from '@angular/core';\nimport { Observable, shareReplay, switchMap } from 'rxjs';\nimport { Layout } from '../../api/v1/models/layout';\nimport { ConfigRepository } from '../repositories/config.repository';\nimport { map } from 'rxjs/operators';\nimport { WINDOW } from '../tokens/window';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class BreakpointService {\n  constructor(\n    private breakpointObserver: BreakpointObserver,\n    private config: ConfigRepository,\n  ) {\n    this.isMobile$.subscribe(isMobile => this._isMobile = isMobile);\n\n    this.breakpointObserver.observe('(max-width: 1279px)').subscribe(state => {\n      this._isTablet = state.matches;\n    });\n  }\n\n  isMobile$: Observable<boolean> = this.config.layout$.pipe(\n    switchMap(layout => {\n      if (layout === Layout.Fresh) {\n        return this.breakpointObserver.observe('(max-width: 959px)');\n      }\n\n      return this.breakpointObserver.observe('(max-width: 767px)');\n    }),\n    map((state: BreakpointState) => state.matches),\n    shareReplay({refCount: true, bufferSize: 1}),\n  );\n\n  private _isMobile: boolean;\n  private _isTablet: boolean;\n\n  private window = inject(WINDOW);\n\n  get isMobile(): boolean {\n    return this._isMobile;\n  }\n  get isTablet(): boolean {\n    return this._isTablet;\n  }\n\n  get isAndroid(): boolean {\n    const uaString = this.window.navigator.userAgent.toLowerCase();\n    return /android/.test(uaString);\n  }\n}\n","import { Observable } from '../Observable';\nimport { argsArgArrayOrObject } from '../util/argsArgArrayOrObject';\nimport { innerFrom } from './innerFrom';\nimport { popResultSelector } from '../util/args';\nimport { createOperatorSubscriber } from '../operators/OperatorSubscriber';\nimport { mapOneOrManyArgs } from '../util/mapOneOrManyArgs';\nimport { createObject } from '../util/createObject';\nexport function forkJoin(...args) {\n    const resultSelector = popResultSelector(args);\n    const { args: sources, keys } = argsArgArrayOrObject(args);\n    const result = new Observable((subscriber) => {\n        const { length } = sources;\n        if (!length) {\n            subscriber.complete();\n            return;\n        }\n        const values = new Array(length);\n        let remainingCompletions = length;\n        let remainingEmissions = length;\n        for (let sourceIndex = 0; sourceIndex < length; sourceIndex++) {\n            let hasValue = false;\n            innerFrom(sources[sourceIndex]).subscribe(createOperatorSubscriber(subscriber, (value) => {\n                if (!hasValue) {\n                    hasValue = true;\n                    remainingEmissions--;\n                }\n                values[sourceIndex] = value;\n            }, () => remainingCompletions--, undefined, () => {\n                if (!remainingCompletions || !hasValue) {\n                    if (!remainingEmissions) {\n                        subscriber.next(keys ? createObject(keys, values) : values);\n                    }\n                    subscriber.complete();\n                }\n            }));\n        }\n    });\n    return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;\n}\n","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 * 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 * 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 https://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    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatIconRegistry, deps: [{ token: i1.HttpClient, optional: true }, { token: i2.DomSanitizer }, { token: DOCUMENT, optional: true }, { token: i0.ErrorHandler }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatIconRegistry, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", 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// 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    /**\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    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     * 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    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", 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 }); }\n    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"14.0.0\", version: \"16.1.1\", 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,mat-icon.mat-primary,mat-icon.mat-accent,mat-icon.mat-warn{color:var(--mat-icon-color)}.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 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", 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,mat-icon.mat-primary,mat-icon.mat-accent,mat-icon.mat-warn{color:var(--mat-icon-color)}.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\nclass MatIconModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatIconModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"16.1.1\", ngImport: i0, type: MatIconModule, declarations: [MatIcon], imports: [MatCommonModule], exports: [MatIcon, MatCommonModule] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"16.1.1\", ngImport: i0, type: MatIconModule, imports: [MatCommonModule, MatCommonModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"16.1.1\", 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 * 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":[1,2]}