{"version":3,"sources":["node_modules/.pnpm/@angular+material@18.2.0_4dclu6dcvm3o6pklgj2bjgy7sa/node_modules/@angular/material/fesm2022/icon.mjs"],"sourcesContent":["import * as i0 from '@angular/core';\nimport { SecurityContext, Injectable, Optional, Inject, SkipSelf, ErrorHandler, InjectionToken, inject, booleanAttribute, Component, ViewEncapsulation, ChangeDetectionStrategy, Attribute, Input, NgModule } from '@angular/core';\nimport { MatCommonModule } from '@angular/material/core';\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 */\nconst _c0 = [\"*\"];\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. ' + 'Please include the HttpClientModule from @angular/common/http in your ' + '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 ` + `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 ` + `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 */\nlet MatIconRegistry = /*#__PURE__*/(() => {\n  class 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      } 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.filter(iconSetConfig => !iconSetConfig.svgText).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 {\n          name,\n          value\n        } = 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 {\n        url: safeUrl,\n        options\n      } = 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, {\n        responseType: 'text',\n        withCredentials\n      }).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      } 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) ? new SvgIconConfig(result.url, null, result.options) : new SvgIconConfig(result, null);\n        }\n      }\n      return undefined;\n    }\n    static {\n      this.ɵfac = function MatIconRegistry_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || MatIconRegistry)(i0.ɵɵinject(i1.HttpClient, 8), i0.ɵɵinject(i2.DomSanitizer), i0.ɵɵinject(DOCUMENT, 8), i0.ɵɵinject(i0.ErrorHandler));\n      };\n    }\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: MatIconRegistry,\n        factory: MatIconRegistry.ɵfac,\n        providedIn: 'root'\n      });\n    }\n  }\n  return MatIconRegistry;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\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: [[/*#__PURE__*/new Optional(), /*#__PURE__*/new SkipSelf(), MatIconRegistry], [/*#__PURE__*/new Optional(), HttpClient], DomSanitizer, ErrorHandler, [/*#__PURE__*/new Optional(), DOCUMENT]],\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/** Injection token to be used to override the default options for `mat-icon`. */\nconst MAT_ICON_DEFAULT_OPTIONS = /*#__PURE__*/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 = /*#__PURE__*/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 = ['clip-path', 'color-profile', 'src', 'cursor', 'fill', 'filter', 'marker', 'marker-start', 'marker-mid', 'marker-end', 'mask', 'stroke'];\n/** Selector that can be used to find all elements that are using a `FuncIRI`. */\nconst funcIriAttributeSelector = /*#__PURE__*/ /*#__PURE__*/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 */\nlet MatIcon = /*#__PURE__*/(() => {\n  class MatIcon {\n    /**\n     * Theme color of the icon. This API is supported in M2 themes only, it\n     * has no effect in M3 themes.\n     *\n     * For information on applying color variants in M3, see\n     * https://material.angular.io/guide/theming#using-component-color-variants.\n     */\n    get color() {\n      return this._color || this._defaultColor;\n    }\n    set color(value) {\n      this._color = value;\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        } 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      this._elementRef = _elementRef;\n      this._iconRegistry = _iconRegistry;\n      this._location = _location;\n      this._errorHandler = _errorHandler;\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      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]];\n        // Use default namespace.\n        case 2:\n          return parts;\n        default:\n          throw Error(`Invalid icon name: \"${iconName}\"`);\n        // 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 ? this._iconRegistry.classNameForFontAlias(this.fontSet).split(/ +/) : 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 && !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 = 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({\n              name: attr,\n              value: match[1]\n            });\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.getNamedSvgIcon(iconName, namespace).pipe(take(1)).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 {\n      this.ɵfac = function MatIcon_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || MatIcon)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(MatIconRegistry), i0.ɵɵinjectAttribute('aria-hidden'), i0.ɵɵdirectiveInject(MAT_ICON_LOCATION), i0.ɵɵdirectiveInject(i0.ErrorHandler), i0.ɵɵdirectiveInject(MAT_ICON_DEFAULT_OPTIONS, 8));\n      };\n    }\n    static {\n      this.ɵcmp = /* @__PURE__ */i0.ɵɵdefineComponent({\n        type: MatIcon,\n        selectors: [[\"mat-icon\"]],\n        hostAttrs: [\"role\", \"img\", 1, \"mat-icon\", \"notranslate\"],\n        hostVars: 10,\n        hostBindings: function MatIcon_HostBindings(rf, ctx) {\n          if (rf & 2) {\n            i0.ɵɵattribute(\"data-mat-icon-type\", ctx._usingFontIcon() ? \"font\" : \"svg\")(\"data-mat-icon-name\", ctx._svgName || ctx.fontIcon)(\"data-mat-icon-namespace\", ctx._svgNamespace || ctx.fontSet)(\"fontIcon\", ctx._usingFontIcon() ? ctx.fontIcon : null);\n            i0.ɵɵclassMap(ctx.color ? \"mat-\" + ctx.color : \"\");\n            i0.ɵɵclassProp(\"mat-icon-inline\", ctx.inline)(\"mat-icon-no-color\", ctx.color !== \"primary\" && ctx.color !== \"accent\" && ctx.color !== \"warn\");\n          }\n        },\n        inputs: {\n          color: \"color\",\n          inline: [2, \"inline\", \"inline\", booleanAttribute],\n          svgIcon: \"svgIcon\",\n          fontSet: \"fontSet\",\n          fontIcon: \"fontIcon\"\n        },\n        exportAs: [\"matIcon\"],\n        standalone: true,\n        features: [i0.ɵɵInputTransformsFeature, i0.ɵɵStandaloneFeature],\n        ngContentSelectors: _c0,\n        decls: 1,\n        vars: 0,\n        template: function MatIcon_Template(rf, ctx) {\n          if (rf & 1) {\n            i0.ɵɵprojectionDef();\n            i0.ɵɵprojection(0);\n          }\n        },\n        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        encapsulation: 2,\n        changeDetection: 0\n      });\n    }\n  }\n  return MatIcon;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet MatIconModule = /*#__PURE__*/(() => {\n  class MatIconModule {\n    static {\n      this.ɵfac = function MatIconModule_Factory(__ngFactoryType__) {\n        return new (__ngFactoryType__ || MatIconModule)();\n      };\n    }\n    static {\n      this.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n        type: MatIconModule\n      });\n    }\n    static {\n      this.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({\n        imports: [MatCommonModule, MatCommonModule]\n      });\n    }\n  }\n  return MatIconModule;\n})();\n/*#__PURE__*/(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\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"],"mappings":"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","names":["_c0","policy","getPolicy","ttWindow","trustedHTMLFromString","html","getMatIconNameNotFoundError","iconName","getMatIconNoHttpProviderError","getMatIconFailedToSanitizeUrlError","url","getMatIconFailedToSanitizeLiteralError","literal","SvgIconConfig","svgText","options","MatIconRegistry","_MatIconRegistry","_httpClient","_sanitizer","document","_errorHandler","namespace","resolver","cleanLiteral","SecurityContext","trustedLiteral","alias","classNames","safeUrl","cachedIcon","of","cloneSvg","tap","svg","map","name","key","iconKey","config","iconSetConfigs","throwError","namedIcon","iconSetFetchRequests","iconSetConfig","catchError","err","errorMessage","forkJoin","foundIcon","i","iconSet","iconSource","iconElement","str","div","element","attributes","value","iconConfig","withCredentials","inProgressFetch","req","finalize","share","configNamespace","result","isSafeUrlWithOptions","__ngFactoryType__","ɵɵinject","HttpClient","DomSanitizer","DOCUMENT","ErrorHandler","ɵɵdefineInjectable","cloneSvg","svg","iconKey","namespace","name","isSafeUrlWithOptions","value","MAT_ICON_DEFAULT_OPTIONS","InjectionToken","MAT_ICON_LOCATION","MAT_ICON_LOCATION_FACTORY","_document","inject","DOCUMENT","_location","funcIriAttributes","funcIriAttributeSelector","attr","funcIriPattern","MatIcon","_MatIcon","newValue","_elementRef","_iconRegistry","ariaHidden","_errorHandler","defaults","Subscription","iconName","parts","cachedElements","newPath","path","layoutElement","childCount","child","elem","fontSetClasses","className","elements","attrs","element","elementsWithFuncIri","elementWithReference","match","attributes","rawName","take","err","errorMessage","__ngFactoryType__","ɵɵdirectiveInject","ElementRef","MatIconRegistry","ɵɵinjectAttribute","ErrorHandler","ɵɵdefineComponent","rf","ctx","ɵɵattribute","ɵɵclassMap","ɵɵclassProp","booleanAttribute","ɵɵInputTransformsFeature","ɵɵStandaloneFeature","_c0","ɵɵprojectionDef","ɵɵprojection","MatIconModule","_MatIconModule","ɵɵdefineNgModule","ɵɵdefineInjector","MatCommonModule"],"x_google_ignoreList":[0]}