{"version":3,"file":"5525.2137114ce9bc0acb.js","mappings":"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","names":["value","map","constructor","_multiple","initiallySelectedValues","_emitChanges","this","_selection","Set","_deselectedToEmit","_selectedToEmit","changed","Subject","length","forEach","_markSelected","selected","_selected","Array","from","values","select","_verifyValueAssignment","_emitChangeEvent","deselect","_unmarkSelected","toggle","isSelected","clear","_unmarkAll","has","isEmpty","size","hasValue","sort","predicate","isMultipleSelection","next","source","added","removed","add","push","delete","UniqueSelectionDispatcher","_listeners","notify","id","name","listener","listen","filter","registered","ngOnDestroy","ɵfac","ɵprov","i0","factory","policy","html","_a","undefined","window","ttWindow","trustedTypes","createPolicy","createHTML","s","getPolicy","iconName","Error","url","literal","svgText","options","MatIconRegistry","_httpClient","_sanitizer","document","_errorHandler","_svgIconConfigs","Map","_iconSetConfigs","_cachedIconsByUrl","_inProgressUrlFetches","_fontCssClassesByAlias","_resolvers","_defaultFontSetClass","_document","addSvgIcon","addSvgIconInNamespace","addSvgIconLiteral","addSvgIconLiteralInNamespace","namespace","_addSvgIconConfig","SvgIconConfig","addSvgIconResolver","resolver","cleanLiteral","sanitize","SecurityContext","getMatIconFailedToSanitizeLiteralError","trustedLiteral","trustedHTMLFromString","addSvgIconSet","addSvgIconSetInNamespace","addSvgIconSetLiteral","addSvgIconSetLiteralInNamespace","_addSvgIconSetConfig","registerFontClassAlias","alias","className","set","classNameForFontAlias","get","setDefaultFontSetClass","getDefaultFontSetClass","getSvgIconFromUrl","safeUrl","getMatIconFailedToSanitizeUrlError","cachedIcon","of","cloneSvg","_loadSvgIconFromConfig","pipe","tap","svg","getNamedSvgIcon","key","iconKey","config","_getSvgFromConfig","_getIconConfigFromResolvers","iconSetConfigs","_getSvgFromIconSetConfigs","throwError","getMatIconNameNotFoundError","_svgElementFromConfig","namedIcon","_extractIconWithNameFromAnySet","iconSetFetchRequests","iconSetConfig","_loadSvgIconSetFromConfig","catchError","err","errorMessage","message","handleError","forkJoin","foundIcon","i","toString","indexOf","_extractSvgIconFromSet","_fetchIcon","iconSet","iconSource","querySelector","iconElement","cloneNode","removeAttribute","nodeName","toLowerCase","_setSvgAttributes","_toSvgElement","_svgElementFromString","appendChild","str","div","createElement","innerHTML","element","attributes","setAttribute","childNodes","nodeType","ELEMENT_NODE","viewBox","iconConfig","withCredentials","getMatIconNoHttpProviderError","inProgressFetch","req","responseType","finalize","share","configNamespace","svgElement","result","isSafeUrlWithOptions","i1","i2","DOCUMENT","_MatIconBase","mixinColor","_elementRef","MAT_ICON_LOCATION","InjectionToken","providedIn","inject","_location","location","getPathname","pathname","search","funcIriAttributes","funcIriAttributeSelector","attr","join","funcIriPattern","MatIcon","elementRef","_iconRegistry","ariaHidden","super","_inline","_currentIconFetch","Subscription","nativeElement","inline","coerceBooleanProperty","svgIcon","_svgIcon","_updateSvgIcon","_clearSvgElement","fontSet","_fontSet","newValue","_cleanupFontValue","_updateFontIconClasses","fontIcon","_fontIcon","_splitIconName","parts","split","ngOnInit","ngAfterViewChecked","cachedElements","_elementsWithExternalReferences","newPath","_previousPath","_prependPathToReferences","unsubscribe","_usingFontIcon","_setSvgElement","path","_cacheChildrenWithExternalReferences","layoutElement","childCount","child","remove","elem","fontSetClass","_previousFontSetClass","classList","_previousFontIconClass","trim","elements","attrs","elementsWithFuncIri","querySelectorAll","elementWithReference","getAttribute","match","rawName","_svgNamespace","_svgName","take","subscribe","ɵcmp","selectors","ngContentSelectors","styles","MatIconModule","ɵmod","ɵinj","MatCommonModule","t","_onBackdropClicked","matDrawerAnimations","transformDrawer","trigger","state","style","transform","visibility","transition","animate","MAT_DRAWER_DEFAULT_AUTOSIZE","MAT_DRAWER_CONTAINER","MatDrawerContent","CdkScrollable","_changeDetectorRef","_container","scrollDispatcher","ngZone","ngAfterContentInit","_contentMarginChanges","markForCheck","forwardRef","MatDrawerContainer","provide","useExisting","encapsulation","MatDrawer","_focusTrapFactory","_focusMonitor","_platform","_ngZone","_interactivityChecker","_doc","_elementFocusedBeforeDrawerWasOpened","_enableAnimations","_position","_mode","_disableClose","_opened","_animationStarted","_animationEnd","_animationState","openedChange","EventEmitter","_openedStream","o","openedStart","e","fromState","toState","mapTo","_closedStream","closedStart","_destroyed","onPositionChanged","_modeChanged","opened","activeElement","_takeFocus","_isFocusWithinDrawer","_restoreFocus","_openedVia","runOutsideAngular","fromEvent","event","keyCode","ESCAPE","disableClose","hasModifierKey","takeUntil","run","close","stopPropagation","preventDefault","distinctUntilChanged","x","y","emit","position","_isAttached","_updatePositionInParent","mode","_updateFocusTrapState","autoFocus","_autoFocus","_forceFocus","isFocusable","tabIndex","callback","removeEventListener","addEventListener","focus","_focusByCssSelector","selector","elementToFocus","_focusTrap","focusInitialElementWhenReady","then","hasMovedFocus","focusOrigin","focusVia","blur","activeEl","contains","ngAfterViewInit","create","ngAfterContentChecked","isBrowser","destroy","_anchor","complete","open","openedVia","_closeViaBackdropClick","_setOpen","isOpen","restoreFocus","Promise","resolve","_getWidth","offsetWidth","enabled","newPosition","parent","parentNode","createComment","insertBefore","i3","H","f","directives","changeDetection","_dir","_element","viewportRuler","defaultAutosize","_animationMode","_drawers","QueryList","backdropClick","_doCheckSubject","_contentMargins","left","right","change","_validateDrawers","updateContentMargins","_autosize","start","_start","end","_end","autosize","hasBackdrop","_backdropOverride","scrollable","_userContent","_content","_allDrawers","changes","startWith","drawer","reset","item","notifyOnChanges","_watchDrawerToggle","_watchDrawerPosition","_watchDrawerMode","_isDrawerOpen","debounceTime","_left","width","_right","ngDoCheck","_isPushed","_setContainerClass","onMicrotaskEmpty","merge","isAdd","_closeModalDrawersViaBackdrop","_canHaveBackdrop","_isShowingBackdrop","i4","ANIMATION_MODULE_TYPE","D","G","i5","MatSidenavModule","CommonModule","CdkScrollableModule","_MatToolbarBase","MatToolbarRow","ɵdir","MatToolbar","_checkToolbarMixedModes","_toolbarRows","M","C","m","MatToolbarModule"],"sourceRoot":"webpack:///","sources":["./node_modules/rxjs/dist/esm/internal/operators/mapTo.js","./node_modules/@angular/cdk/fesm2015/collections.mjs","./node_modules/@angular/material/fesm2015/icon.mjs","./node_modules/@angular/material/fesm2015/sidenav.mjs","./node_modules/@angular/material/fesm2015/toolbar.mjs"],"sourcesContent":["import { map } from './map';\nexport function mapTo(value) {\n    return map(() => value);\n}\n","import { isObservable, of, Subject } from 'rxjs';\nimport * as i0 from '@angular/core';\nimport { Injectable, InjectionToken } from '@angular/core';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass DataSource {\n}\n/** Checks whether an object is a data source. */\nfunction isDataSource(value) {\n    // Check if the value is a DataSource by observing if it has a connect function. Cannot\n    // be checked as an `instanceof DataSource` since people could create their own sources\n    // that match the interface, but don't extend DataSource.\n    return value && typeof value.connect === 'function';\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** DataSource wrapper for a native array. */\nclass ArrayDataSource extends DataSource {\n    constructor(_data) {\n        super();\n        this._data = _data;\n    }\n    connect() {\n        return isObservable(this._data) ? this._data : of(this._data);\n    }\n    disconnect() { }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A repeater that destroys views when they are removed from a\n * {@link ViewContainerRef}. When new items are inserted into the container,\n * the repeater will always construct a new embedded view for each item.\n *\n * @template T The type for the embedded view's $implicit property.\n * @template R The type for the item in each IterableDiffer change record.\n * @template C The type for the context passed to each embedded view.\n */\nclass _DisposeViewRepeaterStrategy {\n    applyChanges(changes, viewContainerRef, itemContextFactory, itemValueResolver, itemViewChanged) {\n        changes.forEachOperation((record, adjustedPreviousIndex, currentIndex) => {\n            let view;\n            let operation;\n            if (record.previousIndex == null) {\n                const insertContext = itemContextFactory(record, adjustedPreviousIndex, currentIndex);\n                view = viewContainerRef.createEmbeddedView(insertContext.templateRef, insertContext.context, insertContext.index);\n                operation = 1 /* INSERTED */;\n            }\n            else if (currentIndex == null) {\n                viewContainerRef.remove(adjustedPreviousIndex);\n                operation = 3 /* REMOVED */;\n            }\n            else {\n                view = viewContainerRef.get(adjustedPreviousIndex);\n                viewContainerRef.move(view, currentIndex);\n                operation = 2 /* MOVED */;\n            }\n            if (itemViewChanged) {\n                itemViewChanged({\n                    context: view === null || view === void 0 ? void 0 : view.context,\n                    operation,\n                    record,\n                });\n            }\n        });\n    }\n    detach() { }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A repeater that caches views when they are removed from a\n * {@link ViewContainerRef}. When new items are inserted into the container,\n * the repeater will reuse one of the cached views instead of creating a new\n * embedded view. Recycling cached views reduces the quantity of expensive DOM\n * inserts.\n *\n * @template T The type for the embedded view's $implicit property.\n * @template R The type for the item in each IterableDiffer change record.\n * @template C The type for the context passed to each embedded view.\n */\nclass _RecycleViewRepeaterStrategy {\n    constructor() {\n        /**\n         * The size of the cache used to store unused views.\n         * Setting the cache size to `0` will disable caching. Defaults to 20 views.\n         */\n        this.viewCacheSize = 20;\n        /**\n         * View cache that stores embedded view instances that have been previously stamped out,\n         * but don't are not currently rendered. The view repeater will reuse these views rather than\n         * creating brand new ones.\n         *\n         * TODO(michaeljamesparsons) Investigate whether using a linked list would improve performance.\n         */\n        this._viewCache = [];\n    }\n    /** Apply changes to the DOM. */\n    applyChanges(changes, viewContainerRef, itemContextFactory, itemValueResolver, itemViewChanged) {\n        // Rearrange the views to put them in the right location.\n        changes.forEachOperation((record, adjustedPreviousIndex, currentIndex) => {\n            let view;\n            let operation;\n            if (record.previousIndex == null) {\n                // Item added.\n                const viewArgsFactory = () => itemContextFactory(record, adjustedPreviousIndex, currentIndex);\n                view = this._insertView(viewArgsFactory, currentIndex, viewContainerRef, itemValueResolver(record));\n                operation = view ? 1 /* INSERTED */ : 0 /* REPLACED */;\n            }\n            else if (currentIndex == null) {\n                // Item removed.\n                this._detachAndCacheView(adjustedPreviousIndex, viewContainerRef);\n                operation = 3 /* REMOVED */;\n            }\n            else {\n                // Item moved.\n                view = this._moveView(adjustedPreviousIndex, currentIndex, viewContainerRef, itemValueResolver(record));\n                operation = 2 /* MOVED */;\n            }\n            if (itemViewChanged) {\n                itemViewChanged({\n                    context: view === null || view === void 0 ? void 0 : view.context,\n                    operation,\n                    record,\n                });\n            }\n        });\n    }\n    detach() {\n        for (const view of this._viewCache) {\n            view.destroy();\n        }\n        this._viewCache = [];\n    }\n    /**\n     * Inserts a view for a new item, either from the cache or by creating a new\n     * one. Returns `undefined` if the item was inserted into a cached view.\n     */\n    _insertView(viewArgsFactory, currentIndex, viewContainerRef, value) {\n        const cachedView = this._insertViewFromCache(currentIndex, viewContainerRef);\n        if (cachedView) {\n            cachedView.context.$implicit = value;\n            return undefined;\n        }\n        const viewArgs = viewArgsFactory();\n        return viewContainerRef.createEmbeddedView(viewArgs.templateRef, viewArgs.context, viewArgs.index);\n    }\n    /** Detaches the view at the given index and inserts into the view cache. */\n    _detachAndCacheView(index, viewContainerRef) {\n        const detachedView = viewContainerRef.detach(index);\n        this._maybeCacheView(detachedView, viewContainerRef);\n    }\n    /** Moves view at the previous index to the current index. */\n    _moveView(adjustedPreviousIndex, currentIndex, viewContainerRef, value) {\n        const view = viewContainerRef.get(adjustedPreviousIndex);\n        viewContainerRef.move(view, currentIndex);\n        view.context.$implicit = value;\n        return view;\n    }\n    /**\n     * Cache the given detached view. If the cache is full, the view will be\n     * destroyed.\n     */\n    _maybeCacheView(view, viewContainerRef) {\n        if (this._viewCache.length < this.viewCacheSize) {\n            this._viewCache.push(view);\n        }\n        else {\n            const index = viewContainerRef.indexOf(view);\n            // The host component could remove views from the container outside of\n            // the view repeater. It's unlikely this will occur, but just in case,\n            // destroy the view on its own, otherwise destroy it through the\n            // container to ensure that all the references are removed.\n            if (index === -1) {\n                view.destroy();\n            }\n            else {\n                viewContainerRef.remove(index);\n            }\n        }\n    }\n    /** Inserts a recycled view from the cache at the given index. */\n    _insertViewFromCache(index, viewContainerRef) {\n        const cachedView = this._viewCache.pop();\n        if (cachedView) {\n            viewContainerRef.insert(cachedView, index);\n        }\n        return cachedView || null;\n    }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Class to be used to power selecting one or more options from a list.\n */\nclass SelectionModel {\n    constructor(_multiple = false, initiallySelectedValues, _emitChanges = true) {\n        this._multiple = _multiple;\n        this._emitChanges = _emitChanges;\n        /** Currently-selected values. */\n        this._selection = new Set();\n        /** Keeps track of the deselected options that haven't been emitted by the change event. */\n        this._deselectedToEmit = [];\n        /** Keeps track of the selected options that haven't been emitted by the change event. */\n        this._selectedToEmit = [];\n        /** Event emitted when the value has changed. */\n        this.changed = new Subject();\n        if (initiallySelectedValues && initiallySelectedValues.length) {\n            if (_multiple) {\n                initiallySelectedValues.forEach(value => this._markSelected(value));\n            }\n            else {\n                this._markSelected(initiallySelectedValues[0]);\n            }\n            // Clear the array in order to avoid firing the change event for preselected values.\n            this._selectedToEmit.length = 0;\n        }\n    }\n    /** Selected values. */\n    get selected() {\n        if (!this._selected) {\n            this._selected = Array.from(this._selection.values());\n        }\n        return this._selected;\n    }\n    /**\n     * Selects a value or an array of values.\n     */\n    select(...values) {\n        this._verifyValueAssignment(values);\n        values.forEach(value => this._markSelected(value));\n        this._emitChangeEvent();\n    }\n    /**\n     * Deselects a value or an array of values.\n     */\n    deselect(...values) {\n        this._verifyValueAssignment(values);\n        values.forEach(value => this._unmarkSelected(value));\n        this._emitChangeEvent();\n    }\n    /**\n     * Toggles a value between selected and deselected.\n     */\n    toggle(value) {\n        this.isSelected(value) ? this.deselect(value) : this.select(value);\n    }\n    /**\n     * Clears all of the selected values.\n     */\n    clear() {\n        this._unmarkAll();\n        this._emitChangeEvent();\n    }\n    /**\n     * Determines whether a value is selected.\n     */\n    isSelected(value) {\n        return this._selection.has(value);\n    }\n    /**\n     * Determines whether the model does not have a value.\n     */\n    isEmpty() {\n        return this._selection.size === 0;\n    }\n    /**\n     * Determines whether the model has a value.\n     */\n    hasValue() {\n        return !this.isEmpty();\n    }\n    /**\n     * Sorts the selected values based on a predicate function.\n     */\n    sort(predicate) {\n        if (this._multiple && this.selected) {\n            this._selected.sort(predicate);\n        }\n    }\n    /**\n     * Gets whether multiple values can be selected.\n     */\n    isMultipleSelection() {\n        return this._multiple;\n    }\n    /** Emits a change event and clears the records of selected and deselected values. */\n    _emitChangeEvent() {\n        // Clear the selected values so they can be re-cached.\n        this._selected = null;\n        if (this._selectedToEmit.length || this._deselectedToEmit.length) {\n            this.changed.next({\n                source: this,\n                added: this._selectedToEmit,\n                removed: this._deselectedToEmit,\n            });\n            this._deselectedToEmit = [];\n            this._selectedToEmit = [];\n        }\n    }\n    /** Selects a value. */\n    _markSelected(value) {\n        if (!this.isSelected(value)) {\n            if (!this._multiple) {\n                this._unmarkAll();\n            }\n            this._selection.add(value);\n            if (this._emitChanges) {\n                this._selectedToEmit.push(value);\n            }\n        }\n    }\n    /** Deselects a value. */\n    _unmarkSelected(value) {\n        if (this.isSelected(value)) {\n            this._selection.delete(value);\n            if (this._emitChanges) {\n                this._deselectedToEmit.push(value);\n            }\n        }\n    }\n    /** Clears out the selected values. */\n    _unmarkAll() {\n        if (!this.isEmpty()) {\n            this._selection.forEach(value => this._unmarkSelected(value));\n        }\n    }\n    /**\n     * Verifies the value assignment and throws an error if the specified value array is\n     * including multiple values while the selection model is not supporting multiple values.\n     */\n    _verifyValueAssignment(values) {\n        if (values.length > 1 && !this._multiple && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            throw getMultipleValuesInSingleSelectionError();\n        }\n    }\n}\n/**\n * Returns an error that reports that multiple values are passed into a selection model\n * with a single value.\n * @docs-private\n */\nfunction getMultipleValuesInSingleSelectionError() {\n    return Error('Cannot pass multiple values into SelectionModel with single-value mode.');\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Class to coordinate unique selection based on name.\n * Intended to be consumed as an Angular service.\n * This service is needed because native radio change events are only fired on the item currently\n * being selected, and we still need to uncheck the previous selection.\n *\n * This service does not *store* any IDs and names because they may change at any time, so it is\n * less error-prone if they are simply passed through when the events occur.\n */\nclass UniqueSelectionDispatcher {\n    constructor() {\n        this._listeners = [];\n    }\n    /**\n     * Notify other items that selection for the given name has been set.\n     * @param id ID of the item.\n     * @param name Name of the item.\n     */\n    notify(id, name) {\n        for (let listener of this._listeners) {\n            listener(id, name);\n        }\n    }\n    /**\n     * Listen for future changes to item selection.\n     * @return Function used to deregister listener\n     */\n    listen(listener) {\n        this._listeners.push(listener);\n        return () => {\n            this._listeners = this._listeners.filter((registered) => {\n                return listener !== registered;\n            });\n        };\n    }\n    ngOnDestroy() {\n        this._listeners = [];\n    }\n}\nUniqueSelectionDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: UniqueSelectionDispatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });\nUniqueSelectionDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: UniqueSelectionDispatcher, providedIn: 'root' });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: UniqueSelectionDispatcher, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Injection token for {@link _ViewRepeater}. This token is for use by Angular Material only.\n * @docs-private\n */\nconst _VIEW_REPEATER_STRATEGY = new InjectionToken('_ViewRepeater');\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { ArrayDataSource, DataSource, SelectionModel, UniqueSelectionDispatcher, _DisposeViewRepeaterStrategy, _RecycleViewRepeaterStrategy, _VIEW_REPEATER_STRATEGY, getMultipleValuesInSingleSelectionError, isDataSource };\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 * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * The Trusted Types policy, or null if Trusted Types are not\n * enabled/supported, or undefined if the policy has not been created yet.\n */\nlet policy;\n/**\n * Returns the Trusted Types policy, or null if Trusted Types are not\n * enabled/supported. The first call to this function will create the policy.\n */\nfunction getPolicy() {\n    if (policy === undefined) {\n        policy = null;\n        if (typeof window !== 'undefined') {\n            const ttWindow = window;\n            if (ttWindow.trustedTypes !== undefined) {\n                policy = ttWindow.trustedTypes.createPolicy('angular#components', {\n                    createHTML: (s) => s,\n                });\n            }\n        }\n    }\n    return policy;\n}\n/**\n * Unsafely promote a string to a TrustedHTML, falling back to strings when\n * Trusted Types are not available.\n * @security This is a security-sensitive function; any use of this function\n * must go through security review. In particular, it must be assured that the\n * provided string will never cause an XSS vulnerability if used in a context\n * that will be interpreted as HTML by a browser, e.g. when assigning to\n * element.innerHTML.\n */\nfunction trustedHTMLFromString(html) {\n    var _a;\n    return ((_a = getPolicy()) === null || _a === void 0 ? void 0 : _a.createHTML(html)) || html;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Returns an exception to be thrown in the case when attempting to\n * load an icon with a name that cannot be found.\n * @docs-private\n */\nfunction getMatIconNameNotFoundError(iconName) {\n    return Error(`Unable to find icon with the name \"${iconName}\"`);\n}\n/**\n * Returns an exception to be thrown when the consumer attempts to use\n * `<mat-icon>` without including @angular/common/http.\n * @docs-private\n */\nfunction getMatIconNoHttpProviderError() {\n    return Error('Could not find HttpClient provider for use with Angular Material icons. ' +\n        'Please include the HttpClientModule from @angular/common/http in your ' +\n        'app imports.');\n}\n/**\n * Returns an exception to be thrown when a URL couldn't be sanitized.\n * @param url URL that was attempted to be sanitized.\n * @docs-private\n */\nfunction getMatIconFailedToSanitizeUrlError(url) {\n    return Error(`The URL provided to MatIconRegistry was not trusted as a resource URL ` +\n        `via Angular's DomSanitizer. Attempted URL was \"${url}\".`);\n}\n/**\n * Returns an exception to be thrown when a HTML string couldn't be sanitized.\n * @param literal HTML that was attempted to be sanitized.\n * @docs-private\n */\nfunction getMatIconFailedToSanitizeLiteralError(literal) {\n    return Error(`The literal provided to MatIconRegistry was not trusted as safe HTML by ` +\n        `Angular's DomSanitizer. Attempted literal was \"${literal}\".`);\n}\n/**\n * Configuration for an icon, including the URL and possibly the cached SVG element.\n * @docs-private\n */\nclass SvgIconConfig {\n    constructor(url, svgText, options) {\n        this.url = url;\n        this.svgText = svgText;\n        this.options = options;\n    }\n}\n/**\n * Service to register and display icons used by the `<mat-icon>` component.\n * - Registers icon URLs by namespace and name.\n * - Registers icon set URLs by namespace.\n * - Registers aliases for CSS classes, for use with icon fonts.\n * - Loads icons from URLs and extracts individual icons from icon sets.\n */\nclass MatIconRegistry {\n    constructor(_httpClient, _sanitizer, document, _errorHandler) {\n        this._httpClient = _httpClient;\n        this._sanitizer = _sanitizer;\n        this._errorHandler = _errorHandler;\n        /**\n         * URLs and cached SVG elements for individual icons. Keys are of the format \"[namespace]:[icon]\".\n         */\n        this._svgIconConfigs = new Map();\n        /**\n         * SvgIconConfig objects and cached SVG elements for icon sets, keyed by namespace.\n         * Multiple icon sets can be registered under the same namespace.\n         */\n        this._iconSetConfigs = new Map();\n        /** Cache for icons loaded by direct URLs. */\n        this._cachedIconsByUrl = new Map();\n        /** In-progress icon fetches. Used to coalesce multiple requests to the same URL. */\n        this._inProgressUrlFetches = new Map();\n        /** Map from font identifiers to their CSS class names. Used for icon fonts. */\n        this._fontCssClassesByAlias = new Map();\n        /** Registered icon resolver functions. */\n        this._resolvers = [];\n        /**\n         * The CSS class to apply when an `<mat-icon>` component has no icon name, url, or font specified.\n         * The default 'material-icons' value assumes that the material icon font has been loaded as\n         * described at http://google.github.io/material-design-icons/#icon-font-for-the-web\n         */\n        this._defaultFontSetClass = 'material-icons';\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 a CSS class name 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     * @param alias Alias for the font.\n     * @param className Class name override to be used instead of the alias.\n     */\n    registerFontClassAlias(alias, className = alias) {\n        this._fontCssClassesByAlias.set(alias, className);\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 class name 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     * @param className\n     */\n    setDefaultFontSetClass(className) {\n        this._defaultFontSetClass = className;\n        return this;\n    }\n    /**\n     * Returns the CSS class name 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        var _a;\n        const { url: safeUrl, options } = iconConfig;\n        const withCredentials = (_a = options === null || options === void 0 ? void 0 : options.withCredentials) !== null && _a !== void 0 ? _a : false;\n        if (!this._httpClient) {\n            throw getMatIconNoHttpProviderError();\n        }\n        // TODO: add an ngDevMode check\n        if (safeUrl == null) {\n            throw Error(`Cannot fetch icon from URL \"${safeUrl}\".`);\n        }\n        const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, safeUrl);\n        // TODO: add an ngDevMode check\n        if (!url) {\n            throw getMatIconFailedToSanitizeUrlError(safeUrl);\n        }\n        // Store in-progress fetches to avoid sending a duplicate request for a URL when there is\n        // already a request in progress for that URL. It's necessary to call share() on the\n        // Observable returned by http.get() so that multiple subscribers don't cause multiple XHRs.\n        const inProgressFetch = this._inProgressUrlFetches.get(url);\n        if (inProgressFetch) {\n            return inProgressFetch;\n        }\n        const req = this._httpClient.get(url, { responseType: 'text', withCredentials }).pipe(map(svg => {\n            // Security: This SVG is fetched from a SafeResourceUrl, and is thus\n            // trusted HTML.\n            return trustedHTMLFromString(svg);\n        }), finalize(() => this._inProgressUrlFetches.delete(url)), share());\n        this._inProgressUrlFetches.set(url, req);\n        return req;\n    }\n    /**\n     * Registers an icon config by name in the specified namespace.\n     * @param namespace Namespace in which to register the icon config.\n     * @param iconName Name under which to register the config.\n     * @param config Config to be registered.\n     */\n    _addSvgIconConfig(namespace, iconName, config) {\n        this._svgIconConfigs.set(iconKey(namespace, iconName), config);\n        return this;\n    }\n    /**\n     * Registers an icon set config in the specified namespace.\n     * @param namespace Namespace in which to register the icon config.\n     * @param config Config to be registered.\n     */\n    _addSvgIconSetConfig(namespace, config) {\n        const configNamespace = this._iconSetConfigs.get(namespace);\n        if (configNamespace) {\n            configNamespace.push(config);\n        }\n        else {\n            this._iconSetConfigs.set(namespace, [config]);\n        }\n        return this;\n    }\n    /** Parses a config's text into an SVG element. */\n    _svgElementFromConfig(config) {\n        if (!config.svgElement) {\n            const svg = this._svgElementFromString(config.svgText);\n            this._setSvgAttributes(svg, config.options);\n            config.svgElement = svg;\n        }\n        return config.svgElement;\n    }\n    /** Tries to create an icon config through the registered resolver functions. */\n    _getIconConfigFromResolvers(namespace, name) {\n        for (let i = 0; i < this._resolvers.length; i++) {\n            const result = this._resolvers[i](name, namespace);\n            if (result) {\n                return isSafeUrlWithOptions(result)\n                    ? new SvgIconConfig(result.url, null, result.options)\n                    : new SvgIconConfig(result, null);\n            }\n        }\n        return undefined;\n    }\n}\nMatIconRegistry.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconRegistry, deps: [{ token: i1.HttpClient, optional: true }, { token: i2.DomSanitizer }, { token: DOCUMENT, optional: true }, { token: i0.ErrorHandler }], target: i0.ɵɵFactoryTarget.Injectable });\nMatIconRegistry.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconRegistry, providedIn: 'root' });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconRegistry, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: function () {\n        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    } });\n/** @docs-private */\nfunction ICON_REGISTRY_PROVIDER_FACTORY(parentRegistry, httpClient, sanitizer, errorHandler, document) {\n    return parentRegistry || new MatIconRegistry(httpClient, sanitizer, document, errorHandler);\n}\n/** @docs-private */\nconst ICON_REGISTRY_PROVIDER = {\n    // If there is already an MatIconRegistry available, use that. Otherwise, provide a new one.\n    provide: MatIconRegistry,\n    deps: [\n        [new Optional(), new SkipSelf(), MatIconRegistry],\n        [new Optional(), HttpClient],\n        DomSanitizer,\n        ErrorHandler,\n        [new Optional(), DOCUMENT],\n    ],\n    useFactory: ICON_REGISTRY_PROVIDER_FACTORY,\n};\n/** Clones an SVGElement while preserving type information. */\nfunction cloneSvg(svg) {\n    return svg.cloneNode(true);\n}\n/** Returns the cache key to use for an icon namespace and name. */\nfunction iconKey(namespace, name) {\n    return namespace + ':' + name;\n}\nfunction isSafeUrlWithOptions(value) {\n    return !!(value.url && value.options);\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Boilerplate for applying mixins to MatIcon.\n/** @docs-private */\nconst _MatIconBase = mixinColor(class {\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n});\n/**\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 content of the `<mat-icon>`\n *   component. 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>home</mat-icon>\n *     <mat-icon fontSet=\"myfont\">sun</mat-icon>`\n *\n * - Specify a font glyph to be included via CSS rules by setting the fontSet input to specify the\n *   font, and the fontIcon input to specify the icon. Typically the fontIcon will specify a\n *   CSS class which causes the glyph to be displayed via a :before selector, as in\n *   https://fortawesome.github.io/Font-Awesome/examples/\n *   Example:\n *     `<mat-icon fontSet=\"fa\" fontIcon=\"alarm\"></mat-icon>`\n */\nclass MatIcon extends _MatIconBase {\n    constructor(elementRef, _iconRegistry, ariaHidden, _location, _errorHandler) {\n        super(elementRef);\n        this._iconRegistry = _iconRegistry;\n        this._location = _location;\n        this._errorHandler = _errorHandler;\n        this._inline = false;\n        /** Subscription to the current in-progress SVG icon request. */\n        this._currentIconFetch = Subscription.EMPTY;\n        // If the user has not explicitly set aria-hidden, mark the icon as hidden, as this is\n        // the right thing to do for the majority of icon use-cases.\n        if (!ariaHidden) {\n            elementRef.nativeElement.setAttribute('aria-hidden', 'true');\n        }\n    }\n    /**\n     * Whether the icon should be inlined, automatically sizing the icon to match the font size of\n     * the element the icon is contained in.\n     */\n    get inline() {\n        return this._inline;\n    }\n    set inline(inline) {\n        this._inline = coerceBooleanProperty(inline);\n    }\n    /** Name of the icon in the SVG icon set. */\n    get svgIcon() {\n        return this._svgIcon;\n    }\n    set svgIcon(value) {\n        if (value !== this._svgIcon) {\n            if (value) {\n                this._updateSvgIcon(value);\n            }\n            else if (this._svgIcon) {\n                this._clearSvgElement();\n            }\n            this._svgIcon = value;\n        }\n    }\n    /** Font set that the icon is a part of. */\n    get fontSet() {\n        return this._fontSet;\n    }\n    set fontSet(value) {\n        const newValue = this._cleanupFontValue(value);\n        if (newValue !== this._fontSet) {\n            this._fontSet = newValue;\n            this._updateFontIconClasses();\n        }\n    }\n    /** Name of an icon within a font set. */\n    get fontIcon() {\n        return this._fontIcon;\n    }\n    set fontIcon(value) {\n        const newValue = this._cleanupFontValue(value);\n        if (newValue !== this._fontIcon) {\n            this._fontIcon = newValue;\n            this._updateFontIconClasses();\n        }\n    }\n    /**\n     * Splits an svgIcon binding value into its icon set and icon name components.\n     * Returns a 2-element array of [(icon set), (icon name)].\n     * The separator for the two fields is ':'. If there is no separator, an empty\n     * string is returned for the icon set and the entire value is returned for\n     * the icon name. If the argument is falsy, returns an array of two empty strings.\n     * Throws an error if the name contains two or more ':' separators.\n     * Examples:\n     *   `'social:cake' -> ['social', 'cake']\n     *   'penguin' -> ['', 'penguin']\n     *   null -> ['', '']\n     *   'a:b:c' -> (throws Error)`\n     */\n    _splitIconName(iconName) {\n        if (!iconName) {\n            return ['', ''];\n        }\n        const parts = iconName.split(':');\n        switch (parts.length) {\n            case 1:\n                return ['', parts[0]]; // Use default namespace.\n            case 2:\n                return parts;\n            default:\n                throw Error(`Invalid icon name: \"${iconName}\"`); // TODO: add an ngDevMode check\n        }\n    }\n    ngOnInit() {\n        // Update font classes because ngOnChanges won't be called if none of the inputs are present,\n        // e.g. <mat-icon>arrow</mat-icon> In this case we need to add a CSS class for the default font.\n        this._updateFontIconClasses();\n    }\n    ngAfterViewChecked() {\n        const cachedElements = this._elementsWithExternalReferences;\n        if (cachedElements && cachedElements.size) {\n            const newPath = this._location.getPathname();\n            // We need to check whether the URL has changed on each change detection since\n            // the browser doesn't have an API that will let us react on link clicks and\n            // we can't depend on the Angular router. The references need to be updated,\n            // because while most browsers don't care whether the URL is correct after\n            // the first render, Safari will break if the user navigates to a different\n            // page and the SVG isn't re-rendered.\n            if (newPath !== this._previousPath) {\n                this._previousPath = newPath;\n                this._prependPathToReferences(newPath);\n            }\n        }\n    }\n    ngOnDestroy() {\n        this._currentIconFetch.unsubscribe();\n        if (this._elementsWithExternalReferences) {\n            this._elementsWithExternalReferences.clear();\n        }\n    }\n    _usingFontIcon() {\n        return !this.svgIcon;\n    }\n    _setSvgElement(svg) {\n        this._clearSvgElement();\n        // Note: we do this fix here, rather than the icon registry, because the\n        // references have to point to the URL at the time that the icon was created.\n        const path = this._location.getPathname();\n        this._previousPath = path;\n        this._cacheChildrenWithExternalReferences(svg);\n        this._prependPathToReferences(path);\n        this._elementRef.nativeElement.appendChild(svg);\n    }\n    _clearSvgElement() {\n        const layoutElement = this._elementRef.nativeElement;\n        let childCount = layoutElement.childNodes.length;\n        if (this._elementsWithExternalReferences) {\n            this._elementsWithExternalReferences.clear();\n        }\n        // Remove existing non-element child nodes and SVGs, and add the new SVG element. Note that\n        // we can't use innerHTML, because IE will throw if the element has a data binding.\n        while (childCount--) {\n            const child = layoutElement.childNodes[childCount];\n            // 1 corresponds to Node.ELEMENT_NODE. We remove all non-element nodes in order to get rid\n            // of any loose text nodes, as well as any SVG elements in order to remove any old icons.\n            if (child.nodeType !== 1 || child.nodeName.toLowerCase() === 'svg') {\n                child.remove();\n            }\n        }\n    }\n    _updateFontIconClasses() {\n        if (!this._usingFontIcon()) {\n            return;\n        }\n        const elem = this._elementRef.nativeElement;\n        const fontSetClass = this.fontSet\n            ? this._iconRegistry.classNameForFontAlias(this.fontSet)\n            : this._iconRegistry.getDefaultFontSetClass();\n        if (fontSetClass != this._previousFontSetClass) {\n            if (this._previousFontSetClass) {\n                elem.classList.remove(this._previousFontSetClass);\n            }\n            if (fontSetClass) {\n                elem.classList.add(fontSetClass);\n            }\n            this._previousFontSetClass = fontSetClass;\n        }\n        if (this.fontIcon != this._previousFontIconClass) {\n            if (this._previousFontIconClass) {\n                elem.classList.remove(this._previousFontIconClass);\n            }\n            if (this.fontIcon) {\n                elem.classList.add(this.fontIcon);\n            }\n            this._previousFontIconClass = this.fontIcon;\n        }\n    }\n    /**\n     * Cleans up a value to be used as a fontIcon or fontSet.\n     * Since the value ends up being assigned as a CSS class, we\n     * have to trim the value and omit space-separated values.\n     */\n    _cleanupFontValue(value) {\n        return typeof value === 'string' ? value.trim().split(' ')[0] : value;\n    }\n    /**\n     * Prepends the current path to all elements that have an attribute pointing to a `FuncIRI`\n     * reference. This is required because WebKit browsers require references to be prefixed with\n     * the current path, if the page has a `base` tag.\n     */\n    _prependPathToReferences(path) {\n        const elements = this._elementsWithExternalReferences;\n        if (elements) {\n            elements.forEach((attrs, element) => {\n                attrs.forEach(attr => {\n                    element.setAttribute(attr.name, `url('${path}#${attr.value}')`);\n                });\n            });\n        }\n    }\n    /**\n     * Caches the children of an SVG element that have `url()`\n     * references that we need to prefix with the current path.\n     */\n    _cacheChildrenWithExternalReferences(element) {\n        const elementsWithFuncIri = element.querySelectorAll(funcIriAttributeSelector);\n        const elements = (this._elementsWithExternalReferences =\n            this._elementsWithExternalReferences || new Map());\n        for (let i = 0; i < elementsWithFuncIri.length; i++) {\n            funcIriAttributes.forEach(attr => {\n                const elementWithReference = elementsWithFuncIri[i];\n                const value = elementWithReference.getAttribute(attr);\n                const match = value ? value.match(funcIriPattern) : null;\n                if (match) {\n                    let attributes = elements.get(elementWithReference);\n                    if (!attributes) {\n                        attributes = [];\n                        elements.set(elementWithReference, attributes);\n                    }\n                    attributes.push({ name: attr, value: match[1] });\n                }\n            });\n        }\n    }\n    /** Sets a new SVG icon with a particular name. */\n    _updateSvgIcon(rawName) {\n        this._svgNamespace = null;\n        this._svgName = null;\n        this._currentIconFetch.unsubscribe();\n        if (rawName) {\n            const [namespace, iconName] = this._splitIconName(rawName);\n            if (namespace) {\n                this._svgNamespace = namespace;\n            }\n            if (iconName) {\n                this._svgName = iconName;\n            }\n            this._currentIconFetch = this._iconRegistry\n                .getNamedSvgIcon(iconName, namespace)\n                .pipe(take(1))\n                .subscribe(svg => this._setSvgElement(svg), (err) => {\n                const errorMessage = `Error retrieving icon ${namespace}:${iconName}! ${err.message}`;\n                this._errorHandler.handleError(new Error(errorMessage));\n            });\n        }\n    }\n}\nMatIcon.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIcon, deps: [{ token: i0.ElementRef }, { token: MatIconRegistry }, { token: 'aria-hidden', attribute: true }, { token: MAT_ICON_LOCATION }, { token: i0.ErrorHandler }], target: i0.ɵɵFactoryTarget.Component });\nMatIcon.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatIcon, selector: \"mat-icon\", inputs: { color: \"color\", inline: \"inline\", svgIcon: \"svgIcon\", fontSet: \"fontSet\", fontIcon: \"fontIcon\" }, host: { attributes: { \"role\": \"img\" }, properties: { \"attr.data-mat-icon-type\": \"_usingFontIcon() ? \\\"font\\\" : \\\"svg\\\"\", \"attr.data-mat-icon-name\": \"_svgName || fontIcon\", \"attr.data-mat-icon-namespace\": \"_svgNamespace || fontSet\", \"class.mat-icon-inline\": \"inline\", \"class.mat-icon-no-color\": \"color !== \\\"primary\\\" && color !== \\\"accent\\\" && color !== \\\"warn\\\"\" }, classAttribute: \"mat-icon notranslate\" }, exportAs: [\"matIcon\"], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, styles: [\".mat-icon{-webkit-user-select:none;user-select:none;background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}[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\"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIcon, decorators: [{\n            type: Component,\n            args: [{ template: '<ng-content></ng-content>', selector: 'mat-icon', exportAs: 'matIcon', inputs: ['color'], host: {\n                        'role': 'img',\n                        'class': 'mat-icon notranslate',\n                        '[attr.data-mat-icon-type]': '_usingFontIcon() ? \"font\" : \"svg\"',\n                        '[attr.data-mat-icon-name]': '_svgName || fontIcon',\n                        '[attr.data-mat-icon-namespace]': '_svgNamespace || fontSet',\n                        '[class.mat-icon-inline]': 'inline',\n                        '[class.mat-icon-no-color]': 'color !== \"primary\" && color !== \"accent\" && color !== \"warn\"',\n                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, styles: [\".mat-icon{-webkit-user-select:none;user-select:none;background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}[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\"] }]\n        }], ctorParameters: function () {\n        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 }];\n    }, propDecorators: { inline: [{\n                type: Input\n            }], svgIcon: [{\n                type: Input\n            }], fontSet: [{\n                type: Input\n            }], fontIcon: [{\n                type: Input\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatIconModule {\n}\nMatIconModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatIconModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconModule, declarations: [MatIcon], imports: [MatCommonModule], exports: [MatIcon, MatCommonModule] });\nMatIconModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconModule, imports: [[MatCommonModule], MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatIconModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [MatCommonModule],\n                    exports: [MatIcon, MatCommonModule],\n                    declarations: [MatIcon],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { ICON_REGISTRY_PROVIDER, ICON_REGISTRY_PROVIDER_FACTORY, MAT_ICON_LOCATION, MAT_ICON_LOCATION_FACTORY, MatIcon, MatIconModule, MatIconRegistry, getMatIconFailedToSanitizeLiteralError, getMatIconFailedToSanitizeUrlError, getMatIconNameNotFoundError, getMatIconNoHttpProviderError };\n","import * as i1 from '@angular/cdk/scrolling';\nimport { CdkScrollable, CdkScrollableModule } from '@angular/cdk/scrolling';\nimport * as i5 from '@angular/common';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, forwardRef, Component, ChangeDetectionStrategy, ViewEncapsulation, Inject, EventEmitter, Optional, Input, Output, ViewChild, QueryList, ContentChildren, ContentChild, NgModule } from '@angular/core';\nimport { MatCommonModule } from '@angular/material/core';\nimport { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\nimport { Subject, fromEvent, merge } from 'rxjs';\nimport { filter, map, mapTo, takeUntil, distinctUntilChanged, take, startWith, debounceTime } from 'rxjs/operators';\nimport { trigger, state, style, transition, animate } from '@angular/animations';\nimport { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';\nimport * as i2 from '@angular/cdk/a11y';\nimport * as i3 from '@angular/cdk/platform';\nimport * as i4 from '@angular/cdk/bidi';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Animations used by the Material drawers.\n * @docs-private\n */\nconst matDrawerAnimations = {\n    /** Animation that slides a drawer in and out. */\n    transformDrawer: trigger('transform', [\n        // We remove the `transform` here completely, rather than setting it to zero, because:\n        // 1. Having a transform can cause elements with ripples or an animated\n        //    transform to shift around in Chrome with an RTL layout (see #10023).\n        // 2. 3d transforms causes text to appear blurry on IE and Edge.\n        state('open, open-instant', style({\n            'transform': 'none',\n            'visibility': 'visible',\n        })),\n        state('void', style({\n            // Avoids the shadow showing up when closed in SSR.\n            'box-shadow': 'none',\n            'visibility': 'hidden',\n        })),\n        transition('void => open-instant', animate('0ms')),\n        transition('void <=> open, open-instant => void', animate('400ms cubic-bezier(0.25, 0.8, 0.25, 1)')),\n    ]),\n};\n\n/**\n * Throws an exception when two MatDrawer are matching the same position.\n * @docs-private\n */\nfunction throwMatDuplicatedDrawerError(position) {\n    throw Error(`A drawer was already declared for 'position=\"${position}\"'`);\n}\n/** Configures whether drawers should use auto sizing by default. */\nconst MAT_DRAWER_DEFAULT_AUTOSIZE = new InjectionToken('MAT_DRAWER_DEFAULT_AUTOSIZE', {\n    providedIn: 'root',\n    factory: MAT_DRAWER_DEFAULT_AUTOSIZE_FACTORY,\n});\n/**\n * Used to provide a drawer container to a drawer while avoiding circular references.\n * @docs-private\n */\nconst MAT_DRAWER_CONTAINER = new InjectionToken('MAT_DRAWER_CONTAINER');\n/** @docs-private */\nfunction MAT_DRAWER_DEFAULT_AUTOSIZE_FACTORY() {\n    return false;\n}\nclass MatDrawerContent extends CdkScrollable {\n    constructor(_changeDetectorRef, _container, elementRef, scrollDispatcher, ngZone) {\n        super(elementRef, scrollDispatcher, ngZone);\n        this._changeDetectorRef = _changeDetectorRef;\n        this._container = _container;\n    }\n    ngAfterContentInit() {\n        this._container._contentMarginChanges.subscribe(() => {\n            this._changeDetectorRef.markForCheck();\n        });\n    }\n}\nMatDrawerContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDrawerContent, deps: [{ token: i0.ChangeDetectorRef }, { token: forwardRef(() => MatDrawerContainer) }, { token: i0.ElementRef }, { token: i1.ScrollDispatcher }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });\nMatDrawerContent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDrawerContent, selector: \"mat-drawer-content\", host: { properties: { \"style.margin-left.px\": \"_container._contentMargins.left\", \"style.margin-right.px\": \"_container._contentMargins.right\" }, classAttribute: \"mat-drawer-content\" }, providers: [\n        {\n            provide: CdkScrollable,\n            useExisting: MatDrawerContent,\n        },\n    ], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDrawerContent, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'mat-drawer-content',\n                    template: '<ng-content></ng-content>',\n                    host: {\n                        'class': 'mat-drawer-content',\n                        '[style.margin-left.px]': '_container._contentMargins.left',\n                        '[style.margin-right.px]': '_container._contentMargins.right',\n                    },\n                    changeDetection: ChangeDetectionStrategy.OnPush,\n                    encapsulation: ViewEncapsulation.None,\n                    providers: [\n                        {\n                            provide: CdkScrollable,\n                            useExisting: MatDrawerContent,\n                        },\n                    ],\n                }]\n        }], ctorParameters: function () {\n        return [{ type: i0.ChangeDetectorRef }, { type: MatDrawerContainer, decorators: [{\n                        type: Inject,\n                        args: [forwardRef(() => MatDrawerContainer)]\n                    }] }, { type: i0.ElementRef }, { type: i1.ScrollDispatcher }, { type: i0.NgZone }];\n    } });\n/**\n * This component corresponds to a drawer that can be opened on the drawer container.\n */\nclass MatDrawer {\n    constructor(_elementRef, _focusTrapFactory, _focusMonitor, _platform, _ngZone, _interactivityChecker, _doc, _container) {\n        this._elementRef = _elementRef;\n        this._focusTrapFactory = _focusTrapFactory;\n        this._focusMonitor = _focusMonitor;\n        this._platform = _platform;\n        this._ngZone = _ngZone;\n        this._interactivityChecker = _interactivityChecker;\n        this._doc = _doc;\n        this._container = _container;\n        this._elementFocusedBeforeDrawerWasOpened = null;\n        /** Whether the drawer is initialized. Used for disabling the initial animation. */\n        this._enableAnimations = false;\n        this._position = 'start';\n        this._mode = 'over';\n        this._disableClose = false;\n        this._opened = false;\n        /** Emits whenever the drawer has started animating. */\n        this._animationStarted = new Subject();\n        /** Emits whenever the drawer is done animating. */\n        this._animationEnd = new Subject();\n        /** Current state of the sidenav animation. */\n        this._animationState = 'void';\n        /** Event emitted when the drawer open state is changed. */\n        this.openedChange =\n            // Note this has to be async in order to avoid some issues with two-bindings (see #8872).\n            new EventEmitter(/* isAsync */ true);\n        /** Event emitted when the drawer has been opened. */\n        this._openedStream = this.openedChange.pipe(filter(o => o), map(() => { }));\n        /** Event emitted when the drawer has started opening. */\n        this.openedStart = this._animationStarted.pipe(filter(e => e.fromState !== e.toState && e.toState.indexOf('open') === 0), mapTo(undefined));\n        /** Event emitted when the drawer has been closed. */\n        this._closedStream = this.openedChange.pipe(filter(o => !o), map(() => { }));\n        /** Event emitted when the drawer has started closing. */\n        this.closedStart = this._animationStarted.pipe(filter(e => e.fromState !== e.toState && e.toState === 'void'), mapTo(undefined));\n        /** Emits when the component is destroyed. */\n        this._destroyed = new Subject();\n        /** Event emitted when the drawer's position changes. */\n        // tslint:disable-next-line:no-output-on-prefix\n        this.onPositionChanged = new EventEmitter();\n        /**\n         * An observable that emits when the drawer mode changes. This is used by the drawer container to\n         * to know when to when the mode changes so it can adapt the margins on the content.\n         */\n        this._modeChanged = new Subject();\n        this.openedChange.subscribe((opened) => {\n            if (opened) {\n                if (this._doc) {\n                    this._elementFocusedBeforeDrawerWasOpened = this._doc.activeElement;\n                }\n                this._takeFocus();\n            }\n            else if (this._isFocusWithinDrawer()) {\n                this._restoreFocus(this._openedVia || 'program');\n            }\n        });\n        /**\n         * Listen to `keydown` events outside the zone so that change detection is not run every\n         * time a key is pressed. Instead we re-enter the zone only if the `ESC` key is pressed\n         * and we don't have close disabled.\n         */\n        this._ngZone.runOutsideAngular(() => {\n            fromEvent(this._elementRef.nativeElement, 'keydown')\n                .pipe(filter(event => {\n                return event.keyCode === ESCAPE && !this.disableClose && !hasModifierKey(event);\n            }), takeUntil(this._destroyed))\n                .subscribe(event => this._ngZone.run(() => {\n                this.close();\n                event.stopPropagation();\n                event.preventDefault();\n            }));\n        });\n        // We need a Subject with distinctUntilChanged, because the `done` event\n        // fires twice on some browsers. See https://github.com/angular/angular/issues/24084\n        this._animationEnd\n            .pipe(distinctUntilChanged((x, y) => {\n            return x.fromState === y.fromState && x.toState === y.toState;\n        }))\n            .subscribe((event) => {\n            const { fromState, toState } = event;\n            if ((toState.indexOf('open') === 0 && fromState === 'void') ||\n                (toState === 'void' && fromState.indexOf('open') === 0)) {\n                this.openedChange.emit(this._opened);\n            }\n        });\n    }\n    /** The side that the drawer is attached to. */\n    get position() {\n        return this._position;\n    }\n    set position(value) {\n        // Make sure we have a valid value.\n        value = value === 'end' ? 'end' : 'start';\n        if (value !== this._position) {\n            // Static inputs in Ivy are set before the element is in the DOM.\n            if (this._isAttached) {\n                this._updatePositionInParent(value);\n            }\n            this._position = value;\n            this.onPositionChanged.emit();\n        }\n    }\n    /** Mode of the drawer; one of 'over', 'push' or 'side'. */\n    get mode() {\n        return this._mode;\n    }\n    set mode(value) {\n        this._mode = value;\n        this._updateFocusTrapState();\n        this._modeChanged.next();\n    }\n    /** Whether the drawer can be closed with the escape key or by clicking on the backdrop. */\n    get disableClose() {\n        return this._disableClose;\n    }\n    set disableClose(value) {\n        this._disableClose = coerceBooleanProperty(value);\n    }\n    /**\n     * Whether the drawer should focus the first focusable element automatically when opened.\n     * Defaults to false in when `mode` is set to `side`, otherwise defaults to `true`. If explicitly\n     * enabled, focus will be moved into the sidenav in `side` mode as well.\n     * @breaking-change 14.0.0 Remove boolean option from autoFocus. Use string or AutoFocusTarget\n     * instead.\n     */\n    get autoFocus() {\n        const value = this._autoFocus;\n        // Note that usually we don't allow autoFocus to be set to `first-tabbable` in `side` mode,\n        // because we don't know how the sidenav is being used, but in some cases it still makes\n        // sense to do it. The consumer can explicitly set `autoFocus`.\n        if (value == null) {\n            if (this.mode === 'side') {\n                return 'dialog';\n            }\n            else {\n                return 'first-tabbable';\n            }\n        }\n        return value;\n    }\n    set autoFocus(value) {\n        if (value === 'true' || value === 'false' || value == null) {\n            value = coerceBooleanProperty(value);\n        }\n        this._autoFocus = value;\n    }\n    /**\n     * Whether the drawer is opened. We overload this because we trigger an event when it\n     * starts or end.\n     */\n    get opened() {\n        return this._opened;\n    }\n    set opened(value) {\n        this.toggle(coerceBooleanProperty(value));\n    }\n    /**\n     * Focuses the provided element. If the element is not focusable, it will add a tabIndex\n     * attribute to forcefully focus it. The attribute is removed after focus is moved.\n     * @param element The element to focus.\n     */\n    _forceFocus(element, options) {\n        if (!this._interactivityChecker.isFocusable(element)) {\n            element.tabIndex = -1;\n            // The tabindex attribute should be removed to avoid navigating to that element again\n            this._ngZone.runOutsideAngular(() => {\n                const callback = () => {\n                    element.removeEventListener('blur', callback);\n                    element.removeEventListener('mousedown', callback);\n                    element.removeAttribute('tabindex');\n                };\n                element.addEventListener('blur', callback);\n                element.addEventListener('mousedown', callback);\n            });\n        }\n        element.focus(options);\n    }\n    /**\n     * Focuses the first element that matches the given selector within the focus trap.\n     * @param selector The CSS selector for the element to set focus to.\n     */\n    _focusByCssSelector(selector, options) {\n        let elementToFocus = this._elementRef.nativeElement.querySelector(selector);\n        if (elementToFocus) {\n            this._forceFocus(elementToFocus, options);\n        }\n    }\n    /**\n     * Moves focus into the drawer. Note that this works even if\n     * the focus trap is disabled in `side` mode.\n     */\n    _takeFocus() {\n        if (!this._focusTrap) {\n            return;\n        }\n        const element = this._elementRef.nativeElement;\n        // When autoFocus is not on the sidenav, if the element cannot be focused or does\n        // not exist, focus the sidenav itself so the keyboard navigation still works.\n        // We need to check that `focus` is a function due to Universal.\n        switch (this.autoFocus) {\n            case false:\n            case 'dialog':\n                return;\n            case true:\n            case 'first-tabbable':\n                this._focusTrap.focusInitialElementWhenReady().then(hasMovedFocus => {\n                    if (!hasMovedFocus && typeof this._elementRef.nativeElement.focus === 'function') {\n                        element.focus();\n                    }\n                });\n                break;\n            case 'first-heading':\n                this._focusByCssSelector('h1, h2, h3, h4, h5, h6, [role=\"heading\"]');\n                break;\n            default:\n                this._focusByCssSelector(this.autoFocus);\n                break;\n        }\n    }\n    /**\n     * Restores focus to the element that was originally focused when the drawer opened.\n     * If no element was focused at that time, the focus will be restored to the drawer.\n     */\n    _restoreFocus(focusOrigin) {\n        if (this.autoFocus === 'dialog') {\n            return;\n        }\n        if (this._elementFocusedBeforeDrawerWasOpened) {\n            this._focusMonitor.focusVia(this._elementFocusedBeforeDrawerWasOpened, focusOrigin);\n        }\n        else {\n            this._elementRef.nativeElement.blur();\n        }\n        this._elementFocusedBeforeDrawerWasOpened = null;\n    }\n    /** Whether focus is currently within the drawer. */\n    _isFocusWithinDrawer() {\n        const activeEl = this._doc.activeElement;\n        return !!activeEl && this._elementRef.nativeElement.contains(activeEl);\n    }\n    ngAfterViewInit() {\n        this._isAttached = true;\n        this._focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement);\n        this._updateFocusTrapState();\n        // Only update the DOM position when the sidenav is positioned at\n        // the end since we project the sidenav before the content by default.\n        if (this._position === 'end') {\n            this._updatePositionInParent('end');\n        }\n    }\n    ngAfterContentChecked() {\n        // Enable the animations after the lifecycle hooks have run, in order to avoid animating\n        // drawers that are open by default. When we're on the server, we shouldn't enable the\n        // animations, because we don't want the drawer to animate the first time the user sees\n        // the page.\n        if (this._platform.isBrowser) {\n            this._enableAnimations = true;\n        }\n    }\n    ngOnDestroy() {\n        var _a;\n        if (this._focusTrap) {\n            this._focusTrap.destroy();\n        }\n        (_a = this._anchor) === null || _a === void 0 ? void 0 : _a.remove();\n        this._anchor = null;\n        this._animationStarted.complete();\n        this._animationEnd.complete();\n        this._modeChanged.complete();\n        this._destroyed.next();\n        this._destroyed.complete();\n    }\n    /**\n     * Open the drawer.\n     * @param openedVia Whether the drawer was opened by a key press, mouse click or programmatically.\n     * Used for focus management after the sidenav is closed.\n     */\n    open(openedVia) {\n        return this.toggle(true, openedVia);\n    }\n    /** Close the drawer. */\n    close() {\n        return this.toggle(false);\n    }\n    /** Closes the drawer with context that the backdrop was clicked. */\n    _closeViaBackdropClick() {\n        // If the drawer is closed upon a backdrop click, we always want to restore focus. We\n        // don't need to check whether focus is currently in the drawer, as clicking on the\n        // backdrop causes blurs the active element.\n        return this._setOpen(/* isOpen */ false, /* restoreFocus */ true, 'mouse');\n    }\n    /**\n     * Toggle this drawer.\n     * @param isOpen Whether the drawer should be open.\n     * @param openedVia Whether the drawer was opened by a key press, mouse click or programmatically.\n     * Used for focus management after the sidenav is closed.\n     */\n    toggle(isOpen = !this.opened, openedVia) {\n        // If the focus is currently inside the drawer content and we are closing the drawer,\n        // restore the focus to the initially focused element (when the drawer opened).\n        if (isOpen && openedVia) {\n            this._openedVia = openedVia;\n        }\n        const result = this._setOpen(isOpen, \n        /* restoreFocus */ !isOpen && this._isFocusWithinDrawer(), this._openedVia || 'program');\n        if (!isOpen) {\n            this._openedVia = null;\n        }\n        return result;\n    }\n    /**\n     * Toggles the opened state of the drawer.\n     * @param isOpen Whether the drawer should open or close.\n     * @param restoreFocus Whether focus should be restored on close.\n     * @param focusOrigin Origin to use when restoring focus.\n     */\n    _setOpen(isOpen, restoreFocus, focusOrigin) {\n        this._opened = isOpen;\n        if (isOpen) {\n            this._animationState = this._enableAnimations ? 'open' : 'open-instant';\n        }\n        else {\n            this._animationState = 'void';\n            if (restoreFocus) {\n                this._restoreFocus(focusOrigin);\n            }\n        }\n        this._updateFocusTrapState();\n        return new Promise(resolve => {\n            this.openedChange.pipe(take(1)).subscribe(open => resolve(open ? 'open' : 'close'));\n        });\n    }\n    _getWidth() {\n        return this._elementRef.nativeElement ? this._elementRef.nativeElement.offsetWidth || 0 : 0;\n    }\n    /** Updates the enabled state of the focus trap. */\n    _updateFocusTrapState() {\n        if (this._focusTrap) {\n            // The focus trap is only enabled when the drawer is open in any mode other than side.\n            this._focusTrap.enabled = this.opened && this.mode !== 'side';\n        }\n    }\n    /**\n     * Updates the position of the drawer in the DOM. We need to move the element around ourselves\n     * when it's in the `end` position so that it comes after the content and the visual order\n     * matches the tab order. We also need to be able to move it back to `start` if the sidenav\n     * started off as `end` and was changed to `start`.\n     */\n    _updatePositionInParent(newPosition) {\n        const element = this._elementRef.nativeElement;\n        const parent = element.parentNode;\n        if (newPosition === 'end') {\n            if (!this._anchor) {\n                this._anchor = this._doc.createComment('mat-drawer-anchor');\n                parent.insertBefore(this._anchor, element);\n            }\n            parent.appendChild(element);\n        }\n        else if (this._anchor) {\n            this._anchor.parentNode.insertBefore(element, this._anchor);\n        }\n    }\n}\nMatDrawer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDrawer, deps: [{ token: i0.ElementRef }, { token: i2.FocusTrapFactory }, { token: i2.FocusMonitor }, { token: i3.Platform }, { token: i0.NgZone }, { token: i2.InteractivityChecker }, { token: DOCUMENT, optional: true }, { token: MAT_DRAWER_CONTAINER, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nMatDrawer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDrawer, selector: \"mat-drawer\", inputs: { position: \"position\", mode: \"mode\", disableClose: \"disableClose\", autoFocus: \"autoFocus\", opened: \"opened\" }, outputs: { openedChange: \"openedChange\", _openedStream: \"opened\", openedStart: \"openedStart\", _closedStream: \"closed\", closedStart: \"closedStart\", onPositionChanged: \"positionChanged\" }, host: { attributes: { \"tabIndex\": \"-1\" }, listeners: { \"@transform.start\": \"_animationStarted.next($event)\", \"@transform.done\": \"_animationEnd.next($event)\" }, properties: { \"attr.align\": \"null\", \"class.mat-drawer-end\": \"position === \\\"end\\\"\", \"class.mat-drawer-over\": \"mode === \\\"over\\\"\", \"class.mat-drawer-push\": \"mode === \\\"push\\\"\", \"class.mat-drawer-side\": \"mode === \\\"side\\\"\", \"class.mat-drawer-opened\": \"opened\", \"@transform\": \"_animationState\" }, classAttribute: \"mat-drawer\" }, viewQueries: [{ propertyName: \"_content\", first: true, predicate: [\"content\"], descendants: true }], exportAs: [\"matDrawer\"], ngImport: i0, template: \"<div class=\\\"mat-drawer-inner-container\\\" cdkScrollable #content>\\r\\n  <ng-content></ng-content>\\r\\n</div>\\r\\n\", directives: [{ type: i1.CdkScrollable, selector: \"[cdk-scrollable], [cdkScrollable]\" }], animations: [matDrawerAnimations.transformDrawer], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDrawer, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-drawer', exportAs: 'matDrawer', animations: [matDrawerAnimations.transformDrawer], host: {\n                        'class': 'mat-drawer',\n                        // must prevent the browser from aligning text based on value\n                        '[attr.align]': 'null',\n                        '[class.mat-drawer-end]': 'position === \"end\"',\n                        '[class.mat-drawer-over]': 'mode === \"over\"',\n                        '[class.mat-drawer-push]': 'mode === \"push\"',\n                        '[class.mat-drawer-side]': 'mode === \"side\"',\n                        '[class.mat-drawer-opened]': 'opened',\n                        'tabIndex': '-1',\n                        '[@transform]': '_animationState',\n                        '(@transform.start)': '_animationStarted.next($event)',\n                        '(@transform.done)': '_animationEnd.next($event)',\n                    }, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: \"<div class=\\\"mat-drawer-inner-container\\\" cdkScrollable #content>\\r\\n  <ng-content></ng-content>\\r\\n</div>\\r\\n\" }]\n        }], ctorParameters: function () {\n        return [{ type: i0.ElementRef }, { type: i2.FocusTrapFactory }, { type: i2.FocusMonitor }, { type: i3.Platform }, { type: i0.NgZone }, { type: i2.InteractivityChecker }, { type: undefined, decorators: [{\n                        type: Optional\n                    }, {\n                        type: Inject,\n                        args: [DOCUMENT]\n                    }] }, { type: MatDrawerContainer, decorators: [{\n                        type: Optional\n                    }, {\n                        type: Inject,\n                        args: [MAT_DRAWER_CONTAINER]\n                    }] }];\n    }, propDecorators: { position: [{\n                type: Input\n            }], mode: [{\n                type: Input\n            }], disableClose: [{\n                type: Input\n            }], autoFocus: [{\n                type: Input\n            }], opened: [{\n                type: Input\n            }], openedChange: [{\n                type: Output\n            }], _openedStream: [{\n                type: Output,\n                args: ['opened']\n            }], openedStart: [{\n                type: Output\n            }], _closedStream: [{\n                type: Output,\n                args: ['closed']\n            }], closedStart: [{\n                type: Output\n            }], onPositionChanged: [{\n                type: Output,\n                args: ['positionChanged']\n            }], _content: [{\n                type: ViewChild,\n                args: ['content']\n            }] } });\n/**\n * `<mat-drawer-container>` component.\n *\n * This is the parent component to one or two `<mat-drawer>`s that validates the state internally\n * and coordinates the backdrop and content styling.\n */\nclass MatDrawerContainer {\n    constructor(_dir, _element, _ngZone, _changeDetectorRef, viewportRuler, defaultAutosize = false, _animationMode) {\n        this._dir = _dir;\n        this._element = _element;\n        this._ngZone = _ngZone;\n        this._changeDetectorRef = _changeDetectorRef;\n        this._animationMode = _animationMode;\n        /** Drawers that belong to this container. */\n        this._drawers = new QueryList();\n        /** Event emitted when the drawer backdrop is clicked. */\n        this.backdropClick = new EventEmitter();\n        /** Emits when the component is destroyed. */\n        this._destroyed = new Subject();\n        /** Emits on every ngDoCheck. Used for debouncing reflows. */\n        this._doCheckSubject = new Subject();\n        /**\n         * Margins to be applied to the content. These are used to push / shrink the drawer content when a\n         * drawer is open. We use margin rather than transform even for push mode because transform breaks\n         * fixed position elements inside of the transformed element.\n         */\n        this._contentMargins = { left: null, right: null };\n        this._contentMarginChanges = new Subject();\n        // If a `Dir` directive exists up the tree, listen direction changes\n        // and update the left/right properties to point to the proper start/end.\n        if (_dir) {\n            _dir.change.pipe(takeUntil(this._destroyed)).subscribe(() => {\n                this._validateDrawers();\n                this.updateContentMargins();\n            });\n        }\n        // Since the minimum width of the sidenav depends on the viewport width,\n        // we need to recompute the margins if the viewport changes.\n        viewportRuler\n            .change()\n            .pipe(takeUntil(this._destroyed))\n            .subscribe(() => this.updateContentMargins());\n        this._autosize = defaultAutosize;\n    }\n    /** The drawer child with the `start` position. */\n    get start() {\n        return this._start;\n    }\n    /** The drawer child with the `end` position. */\n    get end() {\n        return this._end;\n    }\n    /**\n     * Whether to automatically resize the container whenever\n     * the size of any of its drawers changes.\n     *\n     * **Use at your own risk!** Enabling this option can cause layout thrashing by measuring\n     * the drawers on every change detection cycle. Can be configured globally via the\n     * `MAT_DRAWER_DEFAULT_AUTOSIZE` token.\n     */\n    get autosize() {\n        return this._autosize;\n    }\n    set autosize(value) {\n        this._autosize = coerceBooleanProperty(value);\n    }\n    /**\n     * Whether the drawer container should have a backdrop while one of the sidenavs is open.\n     * If explicitly set to `true`, the backdrop will be enabled for drawers in the `side`\n     * mode as well.\n     */\n    get hasBackdrop() {\n        if (this._backdropOverride == null) {\n            return !this._start || this._start.mode !== 'side' || !this._end || this._end.mode !== 'side';\n        }\n        return this._backdropOverride;\n    }\n    set hasBackdrop(value) {\n        this._backdropOverride = value == null ? null : coerceBooleanProperty(value);\n    }\n    /** Reference to the CdkScrollable instance that wraps the scrollable content. */\n    get scrollable() {\n        return this._userContent || this._content;\n    }\n    ngAfterContentInit() {\n        this._allDrawers.changes\n            .pipe(startWith(this._allDrawers), takeUntil(this._destroyed))\n            .subscribe((drawer) => {\n            this._drawers.reset(drawer.filter(item => !item._container || item._container === this));\n            this._drawers.notifyOnChanges();\n        });\n        this._drawers.changes.pipe(startWith(null)).subscribe(() => {\n            this._validateDrawers();\n            this._drawers.forEach((drawer) => {\n                this._watchDrawerToggle(drawer);\n                this._watchDrawerPosition(drawer);\n                this._watchDrawerMode(drawer);\n            });\n            if (!this._drawers.length ||\n                this._isDrawerOpen(this._start) ||\n                this._isDrawerOpen(this._end)) {\n                this.updateContentMargins();\n            }\n            this._changeDetectorRef.markForCheck();\n        });\n        // Avoid hitting the NgZone through the debounce timeout.\n        this._ngZone.runOutsideAngular(() => {\n            this._doCheckSubject\n                .pipe(debounceTime(10), // Arbitrary debounce time, less than a frame at 60fps\n            takeUntil(this._destroyed))\n                .subscribe(() => this.updateContentMargins());\n        });\n    }\n    ngOnDestroy() {\n        this._contentMarginChanges.complete();\n        this._doCheckSubject.complete();\n        this._drawers.destroy();\n        this._destroyed.next();\n        this._destroyed.complete();\n    }\n    /** Calls `open` of both start and end drawers */\n    open() {\n        this._drawers.forEach(drawer => drawer.open());\n    }\n    /** Calls `close` of both start and end drawers */\n    close() {\n        this._drawers.forEach(drawer => drawer.close());\n    }\n    /**\n     * Recalculates and updates the inline styles for the content. Note that this should be used\n     * sparingly, because it causes a reflow.\n     */\n    updateContentMargins() {\n        // 1. For drawers in `over` mode, they don't affect the content.\n        // 2. For drawers in `side` mode they should shrink the content. We do this by adding to the\n        //    left margin (for left drawer) or right margin (for right the drawer).\n        // 3. For drawers in `push` mode the should shift the content without resizing it. We do this by\n        //    adding to the left or right margin and simultaneously subtracting the same amount of\n        //    margin from the other side.\n        let left = 0;\n        let right = 0;\n        if (this._left && this._left.opened) {\n            if (this._left.mode == 'side') {\n                left += this._left._getWidth();\n            }\n            else if (this._left.mode == 'push') {\n                const width = this._left._getWidth();\n                left += width;\n                right -= width;\n            }\n        }\n        if (this._right && this._right.opened) {\n            if (this._right.mode == 'side') {\n                right += this._right._getWidth();\n            }\n            else if (this._right.mode == 'push') {\n                const width = this._right._getWidth();\n                right += width;\n                left -= width;\n            }\n        }\n        // If either `right` or `left` is zero, don't set a style to the element. This\n        // allows users to specify a custom size via CSS class in SSR scenarios where the\n        // measured widths will always be zero. Note that we reset to `null` here, rather\n        // than below, in order to ensure that the types in the `if` below are consistent.\n        left = left || null;\n        right = right || null;\n        if (left !== this._contentMargins.left || right !== this._contentMargins.right) {\n            this._contentMargins = { left, right };\n            // Pull back into the NgZone since in some cases we could be outside. We need to be careful\n            // to do it only when something changed, otherwise we can end up hitting the zone too often.\n            this._ngZone.run(() => this._contentMarginChanges.next(this._contentMargins));\n        }\n    }\n    ngDoCheck() {\n        // If users opted into autosizing, do a check every change detection cycle.\n        if (this._autosize && this._isPushed()) {\n            // Run outside the NgZone, otherwise the debouncer will throw us into an infinite loop.\n            this._ngZone.runOutsideAngular(() => this._doCheckSubject.next());\n        }\n    }\n    /**\n     * Subscribes to drawer events in order to set a class on the main container element when the\n     * drawer is open and the backdrop is visible. This ensures any overflow on the container element\n     * is properly hidden.\n     */\n    _watchDrawerToggle(drawer) {\n        drawer._animationStarted\n            .pipe(filter((event) => event.fromState !== event.toState), takeUntil(this._drawers.changes))\n            .subscribe((event) => {\n            // Set the transition class on the container so that the animations occur. This should not\n            // be set initially because animations should only be triggered via a change in state.\n            if (event.toState !== 'open-instant' && this._animationMode !== 'NoopAnimations') {\n                this._element.nativeElement.classList.add('mat-drawer-transition');\n            }\n            this.updateContentMargins();\n            this._changeDetectorRef.markForCheck();\n        });\n        if (drawer.mode !== 'side') {\n            drawer.openedChange\n                .pipe(takeUntil(this._drawers.changes))\n                .subscribe(() => this._setContainerClass(drawer.opened));\n        }\n    }\n    /**\n     * Subscribes to drawer onPositionChanged event in order to\n     * re-validate drawers when the position changes.\n     */\n    _watchDrawerPosition(drawer) {\n        if (!drawer) {\n            return;\n        }\n        // NOTE: We need to wait for the microtask queue to be empty before validating,\n        // since both drawers may be swapping positions at the same time.\n        drawer.onPositionChanged.pipe(takeUntil(this._drawers.changes)).subscribe(() => {\n            this._ngZone.onMicrotaskEmpty.pipe(take(1)).subscribe(() => {\n                this._validateDrawers();\n            });\n        });\n    }\n    /** Subscribes to changes in drawer mode so we can run change detection. */\n    _watchDrawerMode(drawer) {\n        if (drawer) {\n            drawer._modeChanged\n                .pipe(takeUntil(merge(this._drawers.changes, this._destroyed)))\n                .subscribe(() => {\n                this.updateContentMargins();\n                this._changeDetectorRef.markForCheck();\n            });\n        }\n    }\n    /** Toggles the 'mat-drawer-opened' class on the main 'mat-drawer-container' element. */\n    _setContainerClass(isAdd) {\n        const classList = this._element.nativeElement.classList;\n        const className = 'mat-drawer-container-has-open';\n        if (isAdd) {\n            classList.add(className);\n        }\n        else {\n            classList.remove(className);\n        }\n    }\n    /** Validate the state of the drawer children components. */\n    _validateDrawers() {\n        this._start = this._end = null;\n        // Ensure that we have at most one start and one end drawer.\n        this._drawers.forEach(drawer => {\n            if (drawer.position == 'end') {\n                if (this._end != null && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                    throwMatDuplicatedDrawerError('end');\n                }\n                this._end = drawer;\n            }\n            else {\n                if (this._start != null && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n                    throwMatDuplicatedDrawerError('start');\n                }\n                this._start = drawer;\n            }\n        });\n        this._right = this._left = null;\n        // Detect if we're LTR or RTL.\n        if (this._dir && this._dir.value === 'rtl') {\n            this._left = this._end;\n            this._right = this._start;\n        }\n        else {\n            this._left = this._start;\n            this._right = this._end;\n        }\n    }\n    /** Whether the container is being pushed to the side by one of the drawers. */\n    _isPushed() {\n        return ((this._isDrawerOpen(this._start) && this._start.mode != 'over') ||\n            (this._isDrawerOpen(this._end) && this._end.mode != 'over'));\n    }\n    _onBackdropClicked() {\n        this.backdropClick.emit();\n        this._closeModalDrawersViaBackdrop();\n    }\n    _closeModalDrawersViaBackdrop() {\n        // Close all open drawers where closing is not disabled and the mode is not `side`.\n        [this._start, this._end]\n            .filter(drawer => drawer && !drawer.disableClose && this._canHaveBackdrop(drawer))\n            .forEach(drawer => drawer._closeViaBackdropClick());\n    }\n    _isShowingBackdrop() {\n        return ((this._isDrawerOpen(this._start) && this._canHaveBackdrop(this._start)) ||\n            (this._isDrawerOpen(this._end) && this._canHaveBackdrop(this._end)));\n    }\n    _canHaveBackdrop(drawer) {\n        return drawer.mode !== 'side' || !!this._backdropOverride;\n    }\n    _isDrawerOpen(drawer) {\n        return drawer != null && drawer.opened;\n    }\n}\nMatDrawerContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDrawerContainer, deps: [{ token: i4.Directionality, optional: true }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: i1.ViewportRuler }, { token: MAT_DRAWER_DEFAULT_AUTOSIZE }, { token: ANIMATION_MODULE_TYPE, optional: true }], target: i0.ɵɵFactoryTarget.Component });\nMatDrawerContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatDrawerContainer, selector: \"mat-drawer-container\", inputs: { autosize: \"autosize\", hasBackdrop: \"hasBackdrop\" }, outputs: { backdropClick: \"backdropClick\" }, host: { properties: { \"class.mat-drawer-container-explicit-backdrop\": \"_backdropOverride\" }, classAttribute: \"mat-drawer-container\" }, providers: [\n        {\n            provide: MAT_DRAWER_CONTAINER,\n            useExisting: MatDrawerContainer,\n        },\n    ], queries: [{ propertyName: \"_content\", first: true, predicate: MatDrawerContent, descendants: true }, { propertyName: \"_allDrawers\", predicate: MatDrawer, descendants: true }], viewQueries: [{ propertyName: \"_userContent\", first: true, predicate: MatDrawerContent, descendants: true }], exportAs: [\"matDrawerContainer\"], ngImport: i0, template: \"<div class=\\\"mat-drawer-backdrop\\\" (click)=\\\"_onBackdropClicked()\\\" *ngIf=\\\"hasBackdrop\\\"\\n     [class.mat-drawer-shown]=\\\"_isShowingBackdrop()\\\"></div>\\n\\n<ng-content select=\\\"mat-drawer\\\"></ng-content>\\n\\n<ng-content select=\\\"mat-drawer-content\\\">\\n</ng-content>\\n<mat-drawer-content *ngIf=\\\"!_content\\\">\\n  <ng-content></ng-content>\\n</mat-drawer-content>\\n\", styles: [\".mat-drawer-container{position:relative;z-index:1;box-sizing:border-box;-webkit-overflow-scrolling:touch;display:block;overflow:hidden}.mat-drawer-container[fullscreen]{top:0;left:0;right:0;bottom:0;position:absolute}.mat-drawer-container[fullscreen].mat-drawer-container-has-open{overflow:hidden}.mat-drawer-container.mat-drawer-container-explicit-backdrop .mat-drawer-side{z-index:3}.mat-drawer-container.ng-animate-disabled .mat-drawer-backdrop,.mat-drawer-container.ng-animate-disabled .mat-drawer-content,.ng-animate-disabled .mat-drawer-container .mat-drawer-backdrop,.ng-animate-disabled .mat-drawer-container .mat-drawer-content{transition:none}.mat-drawer-backdrop{top:0;left:0;right:0;bottom:0;position:absolute;display:block;z-index:3;visibility:hidden}.mat-drawer-backdrop.mat-drawer-shown{visibility:visible}.mat-drawer-transition .mat-drawer-backdrop{transition-duration:400ms;transition-timing-function:cubic-bezier(0.25, 0.8, 0.25, 1);transition-property:background-color,visibility}.cdk-high-contrast-active .mat-drawer-backdrop{opacity:.5}.mat-drawer-content{position:relative;z-index:1;display:block;height:100%;overflow:auto}.mat-drawer-transition .mat-drawer-content{transition-duration:400ms;transition-timing-function:cubic-bezier(0.25, 0.8, 0.25, 1);transition-property:transform,margin-left,margin-right}.mat-drawer{position:relative;z-index:4;display:block;position:absolute;top:0;bottom:0;z-index:3;outline:0;box-sizing:border-box;overflow-y:auto;transform:translate3d(-100%, 0, 0)}.cdk-high-contrast-active .mat-drawer,.cdk-high-contrast-active [dir=rtl] .mat-drawer.mat-drawer-end{border-right:solid 1px currentColor}.cdk-high-contrast-active [dir=rtl] .mat-drawer,.cdk-high-contrast-active .mat-drawer.mat-drawer-end{border-left:solid 1px currentColor;border-right:none}.mat-drawer.mat-drawer-side{z-index:2}.mat-drawer.mat-drawer-end{right:0;transform:translate3d(100%, 0, 0)}[dir=rtl] .mat-drawer{transform:translate3d(100%, 0, 0)}[dir=rtl] .mat-drawer.mat-drawer-end{left:0;right:auto;transform:translate3d(-100%, 0, 0)}.mat-drawer[style*=\\\"visibility: hidden\\\"]{display:none}.mat-drawer-inner-container{width:100%;height:100%;overflow:auto;-webkit-overflow-scrolling:touch}.mat-sidenav-fixed{position:fixed}\\n\"], components: [{ type: MatDrawerContent, selector: \"mat-drawer-content\" }], directives: [{ type: i5.NgIf, selector: \"[ngIf]\", inputs: [\"ngIf\", \"ngIfThen\", \"ngIfElse\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatDrawerContainer, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-drawer-container', exportAs: 'matDrawerContainer', host: {\n                        'class': 'mat-drawer-container',\n                        '[class.mat-drawer-container-explicit-backdrop]': '_backdropOverride',\n                    }, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, providers: [\n                        {\n                            provide: MAT_DRAWER_CONTAINER,\n                            useExisting: MatDrawerContainer,\n                        },\n                    ], template: \"<div class=\\\"mat-drawer-backdrop\\\" (click)=\\\"_onBackdropClicked()\\\" *ngIf=\\\"hasBackdrop\\\"\\n     [class.mat-drawer-shown]=\\\"_isShowingBackdrop()\\\"></div>\\n\\n<ng-content select=\\\"mat-drawer\\\"></ng-content>\\n\\n<ng-content select=\\\"mat-drawer-content\\\">\\n</ng-content>\\n<mat-drawer-content *ngIf=\\\"!_content\\\">\\n  <ng-content></ng-content>\\n</mat-drawer-content>\\n\", styles: [\".mat-drawer-container{position:relative;z-index:1;box-sizing:border-box;-webkit-overflow-scrolling:touch;display:block;overflow:hidden}.mat-drawer-container[fullscreen]{top:0;left:0;right:0;bottom:0;position:absolute}.mat-drawer-container[fullscreen].mat-drawer-container-has-open{overflow:hidden}.mat-drawer-container.mat-drawer-container-explicit-backdrop .mat-drawer-side{z-index:3}.mat-drawer-container.ng-animate-disabled .mat-drawer-backdrop,.mat-drawer-container.ng-animate-disabled .mat-drawer-content,.ng-animate-disabled .mat-drawer-container .mat-drawer-backdrop,.ng-animate-disabled .mat-drawer-container .mat-drawer-content{transition:none}.mat-drawer-backdrop{top:0;left:0;right:0;bottom:0;position:absolute;display:block;z-index:3;visibility:hidden}.mat-drawer-backdrop.mat-drawer-shown{visibility:visible}.mat-drawer-transition .mat-drawer-backdrop{transition-duration:400ms;transition-timing-function:cubic-bezier(0.25, 0.8, 0.25, 1);transition-property:background-color,visibility}.cdk-high-contrast-active .mat-drawer-backdrop{opacity:.5}.mat-drawer-content{position:relative;z-index:1;display:block;height:100%;overflow:auto}.mat-drawer-transition .mat-drawer-content{transition-duration:400ms;transition-timing-function:cubic-bezier(0.25, 0.8, 0.25, 1);transition-property:transform,margin-left,margin-right}.mat-drawer{position:relative;z-index:4;display:block;position:absolute;top:0;bottom:0;z-index:3;outline:0;box-sizing:border-box;overflow-y:auto;transform:translate3d(-100%, 0, 0)}.cdk-high-contrast-active .mat-drawer,.cdk-high-contrast-active [dir=rtl] .mat-drawer.mat-drawer-end{border-right:solid 1px currentColor}.cdk-high-contrast-active [dir=rtl] .mat-drawer,.cdk-high-contrast-active .mat-drawer.mat-drawer-end{border-left:solid 1px currentColor;border-right:none}.mat-drawer.mat-drawer-side{z-index:2}.mat-drawer.mat-drawer-end{right:0;transform:translate3d(100%, 0, 0)}[dir=rtl] .mat-drawer{transform:translate3d(100%, 0, 0)}[dir=rtl] .mat-drawer.mat-drawer-end{left:0;right:auto;transform:translate3d(-100%, 0, 0)}.mat-drawer[style*=\\\"visibility: hidden\\\"]{display:none}.mat-drawer-inner-container{width:100%;height:100%;overflow:auto;-webkit-overflow-scrolling:touch}.mat-sidenav-fixed{position:fixed}\\n\"] }]\n        }], ctorParameters: function () {\n        return [{ type: i4.Directionality, decorators: [{\n                        type: Optional\n                    }] }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i1.ViewportRuler }, { type: undefined, decorators: [{\n                        type: Inject,\n                        args: [MAT_DRAWER_DEFAULT_AUTOSIZE]\n                    }] }, { type: undefined, decorators: [{\n                        type: Optional\n                    }, {\n                        type: Inject,\n                        args: [ANIMATION_MODULE_TYPE]\n                    }] }];\n    }, propDecorators: { _allDrawers: [{\n                type: ContentChildren,\n                args: [MatDrawer, {\n                        // We need to use `descendants: true`, because Ivy will no longer match\n                        // indirect descendants if it's left as false.\n                        descendants: true,\n                    }]\n            }], _content: [{\n                type: ContentChild,\n                args: [MatDrawerContent]\n            }], _userContent: [{\n                type: ViewChild,\n                args: [MatDrawerContent]\n            }], autosize: [{\n                type: Input\n            }], hasBackdrop: [{\n                type: Input\n            }], backdropClick: [{\n                type: Output\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatSidenavContent extends MatDrawerContent {\n    constructor(changeDetectorRef, container, elementRef, scrollDispatcher, ngZone) {\n        super(changeDetectorRef, container, elementRef, scrollDispatcher, ngZone);\n    }\n}\nMatSidenavContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSidenavContent, deps: [{ token: i0.ChangeDetectorRef }, { token: forwardRef(() => MatSidenavContainer) }, { token: i0.ElementRef }, { token: i1.ScrollDispatcher }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });\nMatSidenavContent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatSidenavContent, selector: \"mat-sidenav-content\", host: { properties: { \"style.margin-left.px\": \"_container._contentMargins.left\", \"style.margin-right.px\": \"_container._contentMargins.right\" }, classAttribute: \"mat-drawer-content mat-sidenav-content\" }, providers: [\n        {\n            provide: CdkScrollable,\n            useExisting: MatSidenavContent,\n        },\n    ], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSidenavContent, decorators: [{\n            type: Component,\n            args: [{\n                    selector: 'mat-sidenav-content',\n                    template: '<ng-content></ng-content>',\n                    host: {\n                        'class': 'mat-drawer-content mat-sidenav-content',\n                        '[style.margin-left.px]': '_container._contentMargins.left',\n                        '[style.margin-right.px]': '_container._contentMargins.right',\n                    },\n                    changeDetection: ChangeDetectionStrategy.OnPush,\n                    encapsulation: ViewEncapsulation.None,\n                    providers: [\n                        {\n                            provide: CdkScrollable,\n                            useExisting: MatSidenavContent,\n                        },\n                    ],\n                }]\n        }], ctorParameters: function () {\n        return [{ type: i0.ChangeDetectorRef }, { type: MatSidenavContainer, decorators: [{\n                        type: Inject,\n                        args: [forwardRef(() => MatSidenavContainer)]\n                    }] }, { type: i0.ElementRef }, { type: i1.ScrollDispatcher }, { type: i0.NgZone }];\n    } });\nclass MatSidenav extends MatDrawer {\n    constructor() {\n        super(...arguments);\n        this._fixedInViewport = false;\n        this._fixedTopGap = 0;\n        this._fixedBottomGap = 0;\n    }\n    /** Whether the sidenav is fixed in the viewport. */\n    get fixedInViewport() {\n        return this._fixedInViewport;\n    }\n    set fixedInViewport(value) {\n        this._fixedInViewport = coerceBooleanProperty(value);\n    }\n    /**\n     * The gap between the top of the sidenav and the top of the viewport when the sidenav is in fixed\n     * mode.\n     */\n    get fixedTopGap() {\n        return this._fixedTopGap;\n    }\n    set fixedTopGap(value) {\n        this._fixedTopGap = coerceNumberProperty(value);\n    }\n    /**\n     * The gap between the bottom of the sidenav and the bottom of the viewport when the sidenav is in\n     * fixed mode.\n     */\n    get fixedBottomGap() {\n        return this._fixedBottomGap;\n    }\n    set fixedBottomGap(value) {\n        this._fixedBottomGap = coerceNumberProperty(value);\n    }\n}\nMatSidenav.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSidenav, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatSidenav.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatSidenav, selector: \"mat-sidenav\", inputs: { fixedInViewport: \"fixedInViewport\", fixedTopGap: \"fixedTopGap\", fixedBottomGap: \"fixedBottomGap\" }, host: { attributes: { \"tabIndex\": \"-1\" }, properties: { \"attr.align\": \"null\", \"class.mat-drawer-end\": \"position === \\\"end\\\"\", \"class.mat-drawer-over\": \"mode === \\\"over\\\"\", \"class.mat-drawer-push\": \"mode === \\\"push\\\"\", \"class.mat-drawer-side\": \"mode === \\\"side\\\"\", \"class.mat-drawer-opened\": \"opened\", \"class.mat-sidenav-fixed\": \"fixedInViewport\", \"style.top.px\": \"fixedInViewport ? fixedTopGap : null\", \"style.bottom.px\": \"fixedInViewport ? fixedBottomGap : null\" }, classAttribute: \"mat-drawer mat-sidenav\" }, exportAs: [\"matSidenav\"], usesInheritance: true, ngImport: i0, template: \"<div class=\\\"mat-drawer-inner-container\\\" cdkScrollable #content>\\r\\n  <ng-content></ng-content>\\r\\n</div>\\r\\n\", directives: [{ type: i1.CdkScrollable, selector: \"[cdk-scrollable], [cdkScrollable]\" }], animations: [matDrawerAnimations.transformDrawer], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSidenav, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-sidenav', exportAs: 'matSidenav', animations: [matDrawerAnimations.transformDrawer], host: {\n                        'class': 'mat-drawer mat-sidenav',\n                        'tabIndex': '-1',\n                        // must prevent the browser from aligning text based on value\n                        '[attr.align]': 'null',\n                        '[class.mat-drawer-end]': 'position === \"end\"',\n                        '[class.mat-drawer-over]': 'mode === \"over\"',\n                        '[class.mat-drawer-push]': 'mode === \"push\"',\n                        '[class.mat-drawer-side]': 'mode === \"side\"',\n                        '[class.mat-drawer-opened]': 'opened',\n                        '[class.mat-sidenav-fixed]': 'fixedInViewport',\n                        '[style.top.px]': 'fixedInViewport ? fixedTopGap : null',\n                        '[style.bottom.px]': 'fixedInViewport ? fixedBottomGap : null',\n                    }, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: \"<div class=\\\"mat-drawer-inner-container\\\" cdkScrollable #content>\\r\\n  <ng-content></ng-content>\\r\\n</div>\\r\\n\" }]\n        }], propDecorators: { fixedInViewport: [{\n                type: Input\n            }], fixedTopGap: [{\n                type: Input\n            }], fixedBottomGap: [{\n                type: Input\n            }] } });\nclass MatSidenavContainer extends MatDrawerContainer {\n}\nMatSidenavContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSidenavContainer, deps: null, target: i0.ɵɵFactoryTarget.Component });\nMatSidenavContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatSidenavContainer, selector: \"mat-sidenav-container\", host: { properties: { \"class.mat-drawer-container-explicit-backdrop\": \"_backdropOverride\" }, classAttribute: \"mat-drawer-container mat-sidenav-container\" }, providers: [\n        {\n            provide: MAT_DRAWER_CONTAINER,\n            useExisting: MatSidenavContainer,\n        },\n    ], queries: [{ propertyName: \"_content\", first: true, predicate: MatSidenavContent, descendants: true }, { propertyName: \"_allDrawers\", predicate: MatSidenav, descendants: true }], exportAs: [\"matSidenavContainer\"], usesInheritance: true, ngImport: i0, template: \"<div class=\\\"mat-drawer-backdrop\\\" (click)=\\\"_onBackdropClicked()\\\" *ngIf=\\\"hasBackdrop\\\"\\n     [class.mat-drawer-shown]=\\\"_isShowingBackdrop()\\\"></div>\\n\\n<ng-content select=\\\"mat-sidenav\\\"></ng-content>\\n\\n<ng-content select=\\\"mat-sidenav-content\\\">\\n</ng-content>\\n<mat-sidenav-content *ngIf=\\\"!_content\\\">\\n  <ng-content></ng-content>\\n</mat-sidenav-content>\\n\", styles: [\".mat-drawer-container{position:relative;z-index:1;box-sizing:border-box;-webkit-overflow-scrolling:touch;display:block;overflow:hidden}.mat-drawer-container[fullscreen]{top:0;left:0;right:0;bottom:0;position:absolute}.mat-drawer-container[fullscreen].mat-drawer-container-has-open{overflow:hidden}.mat-drawer-container.mat-drawer-container-explicit-backdrop .mat-drawer-side{z-index:3}.mat-drawer-container.ng-animate-disabled .mat-drawer-backdrop,.mat-drawer-container.ng-animate-disabled .mat-drawer-content,.ng-animate-disabled .mat-drawer-container .mat-drawer-backdrop,.ng-animate-disabled .mat-drawer-container .mat-drawer-content{transition:none}.mat-drawer-backdrop{top:0;left:0;right:0;bottom:0;position:absolute;display:block;z-index:3;visibility:hidden}.mat-drawer-backdrop.mat-drawer-shown{visibility:visible}.mat-drawer-transition .mat-drawer-backdrop{transition-duration:400ms;transition-timing-function:cubic-bezier(0.25, 0.8, 0.25, 1);transition-property:background-color,visibility}.cdk-high-contrast-active .mat-drawer-backdrop{opacity:.5}.mat-drawer-content{position:relative;z-index:1;display:block;height:100%;overflow:auto}.mat-drawer-transition .mat-drawer-content{transition-duration:400ms;transition-timing-function:cubic-bezier(0.25, 0.8, 0.25, 1);transition-property:transform,margin-left,margin-right}.mat-drawer{position:relative;z-index:4;display:block;position:absolute;top:0;bottom:0;z-index:3;outline:0;box-sizing:border-box;overflow-y:auto;transform:translate3d(-100%, 0, 0)}.cdk-high-contrast-active .mat-drawer,.cdk-high-contrast-active [dir=rtl] .mat-drawer.mat-drawer-end{border-right:solid 1px currentColor}.cdk-high-contrast-active [dir=rtl] .mat-drawer,.cdk-high-contrast-active .mat-drawer.mat-drawer-end{border-left:solid 1px currentColor;border-right:none}.mat-drawer.mat-drawer-side{z-index:2}.mat-drawer.mat-drawer-end{right:0;transform:translate3d(100%, 0, 0)}[dir=rtl] .mat-drawer{transform:translate3d(100%, 0, 0)}[dir=rtl] .mat-drawer.mat-drawer-end{left:0;right:auto;transform:translate3d(-100%, 0, 0)}.mat-drawer[style*=\\\"visibility: hidden\\\"]{display:none}.mat-drawer-inner-container{width:100%;height:100%;overflow:auto;-webkit-overflow-scrolling:touch}.mat-sidenav-fixed{position:fixed}\\n\"], components: [{ type: MatSidenavContent, selector: \"mat-sidenav-content\" }], directives: [{ type: i5.NgIf, selector: \"[ngIf]\", inputs: [\"ngIf\", \"ngIfThen\", \"ngIfElse\"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSidenavContainer, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-sidenav-container', exportAs: 'matSidenavContainer', host: {\n                        'class': 'mat-drawer-container mat-sidenav-container',\n                        '[class.mat-drawer-container-explicit-backdrop]': '_backdropOverride',\n                    }, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, providers: [\n                        {\n                            provide: MAT_DRAWER_CONTAINER,\n                            useExisting: MatSidenavContainer,\n                        },\n                    ], template: \"<div class=\\\"mat-drawer-backdrop\\\" (click)=\\\"_onBackdropClicked()\\\" *ngIf=\\\"hasBackdrop\\\"\\n     [class.mat-drawer-shown]=\\\"_isShowingBackdrop()\\\"></div>\\n\\n<ng-content select=\\\"mat-sidenav\\\"></ng-content>\\n\\n<ng-content select=\\\"mat-sidenav-content\\\">\\n</ng-content>\\n<mat-sidenav-content *ngIf=\\\"!_content\\\">\\n  <ng-content></ng-content>\\n</mat-sidenav-content>\\n\", styles: [\".mat-drawer-container{position:relative;z-index:1;box-sizing:border-box;-webkit-overflow-scrolling:touch;display:block;overflow:hidden}.mat-drawer-container[fullscreen]{top:0;left:0;right:0;bottom:0;position:absolute}.mat-drawer-container[fullscreen].mat-drawer-container-has-open{overflow:hidden}.mat-drawer-container.mat-drawer-container-explicit-backdrop .mat-drawer-side{z-index:3}.mat-drawer-container.ng-animate-disabled .mat-drawer-backdrop,.mat-drawer-container.ng-animate-disabled .mat-drawer-content,.ng-animate-disabled .mat-drawer-container .mat-drawer-backdrop,.ng-animate-disabled .mat-drawer-container .mat-drawer-content{transition:none}.mat-drawer-backdrop{top:0;left:0;right:0;bottom:0;position:absolute;display:block;z-index:3;visibility:hidden}.mat-drawer-backdrop.mat-drawer-shown{visibility:visible}.mat-drawer-transition .mat-drawer-backdrop{transition-duration:400ms;transition-timing-function:cubic-bezier(0.25, 0.8, 0.25, 1);transition-property:background-color,visibility}.cdk-high-contrast-active .mat-drawer-backdrop{opacity:.5}.mat-drawer-content{position:relative;z-index:1;display:block;height:100%;overflow:auto}.mat-drawer-transition .mat-drawer-content{transition-duration:400ms;transition-timing-function:cubic-bezier(0.25, 0.8, 0.25, 1);transition-property:transform,margin-left,margin-right}.mat-drawer{position:relative;z-index:4;display:block;position:absolute;top:0;bottom:0;z-index:3;outline:0;box-sizing:border-box;overflow-y:auto;transform:translate3d(-100%, 0, 0)}.cdk-high-contrast-active .mat-drawer,.cdk-high-contrast-active [dir=rtl] .mat-drawer.mat-drawer-end{border-right:solid 1px currentColor}.cdk-high-contrast-active [dir=rtl] .mat-drawer,.cdk-high-contrast-active .mat-drawer.mat-drawer-end{border-left:solid 1px currentColor;border-right:none}.mat-drawer.mat-drawer-side{z-index:2}.mat-drawer.mat-drawer-end{right:0;transform:translate3d(100%, 0, 0)}[dir=rtl] .mat-drawer{transform:translate3d(100%, 0, 0)}[dir=rtl] .mat-drawer.mat-drawer-end{left:0;right:auto;transform:translate3d(-100%, 0, 0)}.mat-drawer[style*=\\\"visibility: hidden\\\"]{display:none}.mat-drawer-inner-container{width:100%;height:100%;overflow:auto;-webkit-overflow-scrolling:touch}.mat-sidenav-fixed{position:fixed}\\n\"] }]\n        }], propDecorators: { _allDrawers: [{\n                type: ContentChildren,\n                args: [MatSidenav, {\n                        // We need to use `descendants: true`, because Ivy will no longer match\n                        // indirect descendants if it's left as false.\n                        descendants: true,\n                    }]\n            }], _content: [{\n                type: ContentChild,\n                args: [MatSidenavContent]\n            }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatSidenavModule {\n}\nMatSidenavModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSidenavModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatSidenavModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSidenavModule, declarations: [MatDrawer,\n        MatDrawerContainer,\n        MatDrawerContent,\n        MatSidenav,\n        MatSidenavContainer,\n        MatSidenavContent], imports: [CommonModule, MatCommonModule, CdkScrollableModule], exports: [CdkScrollableModule,\n        MatCommonModule,\n        MatDrawer,\n        MatDrawerContainer,\n        MatDrawerContent,\n        MatSidenav,\n        MatSidenavContainer,\n        MatSidenavContent] });\nMatSidenavModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSidenavModule, imports: [[CommonModule, MatCommonModule, CdkScrollableModule], CdkScrollableModule,\n        MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatSidenavModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [CommonModule, MatCommonModule, CdkScrollableModule],\n                    exports: [\n                        CdkScrollableModule,\n                        MatCommonModule,\n                        MatDrawer,\n                        MatDrawerContainer,\n                        MatDrawerContent,\n                        MatSidenav,\n                        MatSidenavContainer,\n                        MatSidenavContent,\n                    ],\n                    declarations: [\n                        MatDrawer,\n                        MatDrawerContainer,\n                        MatDrawerContent,\n                        MatSidenav,\n                        MatSidenavContainer,\n                        MatSidenavContent,\n                    ],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MAT_DRAWER_DEFAULT_AUTOSIZE, MAT_DRAWER_DEFAULT_AUTOSIZE_FACTORY, MatDrawer, MatDrawerContainer, MatDrawerContent, MatSidenav, MatSidenavContainer, MatSidenavContent, MatSidenavModule, matDrawerAnimations, throwMatDuplicatedDrawerError };\n","import * as i0 from '@angular/core';\nimport { Directive, Component, ChangeDetectionStrategy, ViewEncapsulation, Inject, ContentChildren, NgModule } from '@angular/core';\nimport { mixinColor, MatCommonModule } from '@angular/material/core';\nimport { DOCUMENT } from '@angular/common';\nimport * as i1 from '@angular/cdk/platform';\n\n// Boilerplate for applying mixins to MatToolbar.\n/** @docs-private */\nconst _MatToolbarBase = mixinColor(class {\n    constructor(_elementRef) {\n        this._elementRef = _elementRef;\n    }\n});\nclass MatToolbarRow {\n}\nMatToolbarRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatToolbarRow, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nMatToolbarRow.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatToolbarRow, selector: \"mat-toolbar-row\", host: { classAttribute: \"mat-toolbar-row\" }, exportAs: [\"matToolbarRow\"], ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatToolbarRow, decorators: [{\n            type: Directive,\n            args: [{\n                    selector: 'mat-toolbar-row',\n                    exportAs: 'matToolbarRow',\n                    host: { 'class': 'mat-toolbar-row' },\n                }]\n        }] });\nclass MatToolbar extends _MatToolbarBase {\n    constructor(elementRef, _platform, document) {\n        super(elementRef);\n        this._platform = _platform;\n        // TODO: make the document a required param when doing breaking changes.\n        this._document = document;\n    }\n    ngAfterViewInit() {\n        if (this._platform.isBrowser) {\n            this._checkToolbarMixedModes();\n            this._toolbarRows.changes.subscribe(() => this._checkToolbarMixedModes());\n        }\n    }\n    /**\n     * Throws an exception when developers are attempting to combine the different toolbar row modes.\n     */\n    _checkToolbarMixedModes() {\n        if (this._toolbarRows.length && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n            // Check if there are any other DOM nodes that can display content but aren't inside of\n            // a <mat-toolbar-row> element.\n            const isCombinedUsage = Array.from(this._elementRef.nativeElement.childNodes)\n                .filter(node => !(node.classList && node.classList.contains('mat-toolbar-row')))\n                .filter(node => node.nodeType !== (this._document ? this._document.COMMENT_NODE : 8))\n                .some(node => !!(node.textContent && node.textContent.trim()));\n            if (isCombinedUsage) {\n                throwToolbarMixedModesError();\n            }\n        }\n    }\n}\nMatToolbar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatToolbar, deps: [{ token: i0.ElementRef }, { token: i1.Platform }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });\nMatToolbar.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: \"12.0.0\", version: \"13.3.0\", type: MatToolbar, selector: \"mat-toolbar\", inputs: { color: \"color\" }, host: { properties: { \"class.mat-toolbar-multiple-rows\": \"_toolbarRows.length > 0\", \"class.mat-toolbar-single-row\": \"_toolbarRows.length === 0\" }, classAttribute: \"mat-toolbar\" }, queries: [{ propertyName: \"_toolbarRows\", predicate: MatToolbarRow, descendants: true }], exportAs: [\"matToolbar\"], usesInheritance: true, ngImport: i0, template: \"<ng-content></ng-content>\\n<ng-content select=\\\"mat-toolbar-row\\\"></ng-content>\\n\", styles: [\".cdk-high-contrast-active .mat-toolbar{outline:solid 1px}.mat-toolbar-row,.mat-toolbar-single-row{display:flex;box-sizing:border-box;padding:0 16px;width:100%;flex-direction:row;align-items:center;white-space:nowrap}.mat-toolbar-multiple-rows{display:flex;box-sizing:border-box;flex-direction:column;width:100%}\\n\"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatToolbar, decorators: [{\n            type: Component,\n            args: [{ selector: 'mat-toolbar', exportAs: 'matToolbar', inputs: ['color'], host: {\n                        'class': 'mat-toolbar',\n                        '[class.mat-toolbar-multiple-rows]': '_toolbarRows.length > 0',\n                        '[class.mat-toolbar-single-row]': '_toolbarRows.length === 0',\n                    }, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: \"<ng-content></ng-content>\\n<ng-content select=\\\"mat-toolbar-row\\\"></ng-content>\\n\", styles: [\".cdk-high-contrast-active .mat-toolbar{outline:solid 1px}.mat-toolbar-row,.mat-toolbar-single-row{display:flex;box-sizing:border-box;padding:0 16px;width:100%;flex-direction:row;align-items:center;white-space:nowrap}.mat-toolbar-multiple-rows{display:flex;box-sizing:border-box;flex-direction:column;width:100%}\\n\"] }]\n        }], ctorParameters: function () {\n        return [{ type: i0.ElementRef }, { type: i1.Platform }, { type: undefined, decorators: [{\n                        type: Inject,\n                        args: [DOCUMENT]\n                    }] }];\n    }, propDecorators: { _toolbarRows: [{\n                type: ContentChildren,\n                args: [MatToolbarRow, { descendants: true }]\n            }] } });\n/**\n * Throws an exception when attempting to combine the different toolbar row modes.\n * @docs-private\n */\nfunction throwToolbarMixedModesError() {\n    throw Error('MatToolbar: Attempting to combine different toolbar modes. ' +\n        'Either specify multiple `<mat-toolbar-row>` elements explicitly or just place content ' +\n        'inside of a `<mat-toolbar>` for a single row.');\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass MatToolbarModule {\n}\nMatToolbarModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatToolbarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nMatToolbarModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatToolbarModule, declarations: [MatToolbar, MatToolbarRow], imports: [MatCommonModule], exports: [MatToolbar, MatToolbarRow, MatCommonModule] });\nMatToolbarModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatToolbarModule, imports: [[MatCommonModule], MatCommonModule] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.0\", ngImport: i0, type: MatToolbarModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    imports: [MatCommonModule],\n                    exports: [MatToolbar, MatToolbarRow, MatCommonModule],\n                    declarations: [MatToolbar, MatToolbarRow],\n                }]\n        }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { MatToolbar, MatToolbarModule, MatToolbarRow, throwToolbarMixedModesError };\n"]}