{"version":3,"sources":["node_modules/@angular/cdk/fesm2022/coercion.mjs","node_modules/@angular/cdk/fesm2022/platform.mjs","node_modules/@angular/cdk/fesm2022/layout.mjs"],"sourcesContent":["import { ElementRef } from '@angular/core';\n\n/** Coerces a data-bound value (typically a string) to a boolean. */\nfunction coerceBooleanProperty(value) {\n return value != null && `${value}` !== 'false';\n}\nfunction coerceNumberProperty(value, fallbackValue = 0) {\n if (_isNumberValue(value)) {\n return Number(value);\n }\n return arguments.length === 2 ? fallbackValue : 0;\n}\n/**\n * Whether the provided value is considered a number.\n * @docs-private\n */\nfunction _isNumberValue(value) {\n // parseFloat(value) handles most of the cases we're interested in (it treats null, empty string,\n // and other non-number values as NaN, where Number just uses 0) but it considers the string\n // '123hello' to be a valid number. Therefore we also check if Number(value) is NaN.\n return !isNaN(parseFloat(value)) && !isNaN(Number(value));\n}\nfunction coerceArray(value) {\n return Array.isArray(value) ? value : [value];\n}\n\n/** Coerces a value to a CSS pixel value. */\nfunction coerceCssPixelValue(value) {\n if (value == null) {\n return '';\n }\n return typeof value === 'string' ? value : `${value}px`;\n}\n\n/**\n * Coerces an ElementRef or an Element into an element.\n * Useful for APIs that can accept either a ref or the native element itself.\n */\nfunction coerceElement(elementOrRef) {\n return elementOrRef instanceof ElementRef ? elementOrRef.nativeElement : elementOrRef;\n}\n\n/**\n * Coerces a value to an array of trimmed non-empty strings.\n * Any input that is not an array, `null` or `undefined` will be turned into a string\n * via `toString()` and subsequently split with the given separator.\n * `null` and `undefined` will result in an empty array.\n * This results in the following outcomes:\n * - `null` -> `[]`\n * - `[null]` -> `[\"null\"]`\n * - `[\"a\", \"b \", \" \"]` -> `[\"a\", \"b\"]`\n * - `[1, [2, 3]]` -> `[\"1\", \"2,3\"]`\n * - `[{ a: 0 }]` -> `[\"[object Object]\"]`\n * - `{ a: 0 }` -> `[\"[object\", \"Object]\"]`\n *\n * Useful for defining CSS classes or table columns.\n * @param value the value to coerce into an array of strings\n * @param separator split-separator if value isn't an array\n */\nfunction coerceStringArray(value, separator = /\\s+/) {\n const result = [];\n if (value != null) {\n const sourceValues = Array.isArray(value) ? value : `${value}`.split(separator);\n for (const sourceValue of sourceValues) {\n const trimmedString = `${sourceValue}`.trim();\n if (trimmedString) {\n result.push(trimmedString);\n }\n }\n }\n return result;\n}\nexport { _isNumberValue, coerceArray, coerceBooleanProperty, coerceCssPixelValue, coerceElement, coerceNumberProperty, coerceStringArray };\n","import * as i0 from '@angular/core';\nimport { inject, PLATFORM_ID, Injectable, NgModule, VERSION } from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\n\n// Whether the current platform supports the V8 Break Iterator. The V8 check\n// is necessary to detect all Blink based browsers.\nlet hasV8BreakIterator;\n// We need a try/catch around the reference to `Intl`, because accessing it in some cases can\n// cause IE to throw. These cases are tied to particular versions of Windows and can happen if\n// the consumer is providing a polyfilled `Map`. See:\n// https://github.com/Microsoft/ChakraCore/issues/3189\n// https://github.com/angular/components/issues/15687\ntry {\n hasV8BreakIterator = typeof Intl !== 'undefined' && Intl.v8BreakIterator;\n} catch {\n hasV8BreakIterator = false;\n}\n/**\n * Service to detect the current platform by comparing the userAgent strings and\n * checking browser-specific global properties.\n */\nlet Platform = /*#__PURE__*/(() => {\n class Platform {\n _platformId = inject(PLATFORM_ID);\n // We want to use the Angular platform check because if the Document is shimmed\n // without the navigator, the following checks will fail. This is preferred because\n // sometimes the Document may be shimmed without the user's knowledge or intention\n /** Whether the Angular application is being rendered in the browser. */\n isBrowser = this._platformId ? isPlatformBrowser(this._platformId) : typeof document === 'object' && !!document;\n /** Whether the current browser is Microsoft Edge. */\n EDGE = this.isBrowser && /(edge)/i.test(navigator.userAgent);\n /** Whether the current rendering engine is Microsoft Trident. */\n TRIDENT = this.isBrowser && /(msie|trident)/i.test(navigator.userAgent);\n // EdgeHTML and Trident mock Blink specific things and need to be excluded from this check.\n /** Whether the current rendering engine is Blink. */\n BLINK = this.isBrowser && !!(window.chrome || hasV8BreakIterator) && typeof CSS !== 'undefined' && !this.EDGE && !this.TRIDENT;\n // Webkit is part of the userAgent in EdgeHTML, Blink and Trident. Therefore we need to\n // ensure that Webkit runs standalone and is not used as another engine's base.\n /** Whether the current rendering engine is WebKit. */\n WEBKIT = this.isBrowser && /AppleWebKit/i.test(navigator.userAgent) && !this.BLINK && !this.EDGE && !this.TRIDENT;\n /** Whether the current platform is Apple iOS. */\n IOS = this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) && !('MSStream' in window);\n // It's difficult to detect the plain Gecko engine, because most of the browsers identify\n // them self as Gecko-like browsers and modify the userAgent's according to that.\n // Since we only cover one explicit Firefox case, we can simply check for Firefox\n // instead of having an unstable check for Gecko.\n /** Whether the current browser is Firefox. */\n FIREFOX = this.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);\n /** Whether the current platform is Android. */\n // Trident on mobile adds the android platform to the userAgent to trick detections.\n ANDROID = this.isBrowser && /android/i.test(navigator.userAgent) && !this.TRIDENT;\n // Safari browsers will include the Safari keyword in their userAgent. Some browsers may fake\n // this and just place the Safari keyword in the userAgent. To be more safe about Safari every\n // Safari browser should also use Webkit as its layout engine.\n /** Whether the current browser is Safari. */\n SAFARI = this.isBrowser && /safari/i.test(navigator.userAgent) && this.WEBKIT;\n constructor() {}\n static ɵfac = function Platform_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || Platform)();\n };\n static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n token: Platform,\n factory: Platform.ɵfac,\n providedIn: 'root'\n });\n }\n return Platform;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet PlatformModule = /*#__PURE__*/(() => {\n class PlatformModule {\n static ɵfac = function PlatformModule_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || PlatformModule)();\n };\n static ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n type: PlatformModule\n });\n static ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({});\n }\n return PlatformModule;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/** Cached result Set of input types support by the current browser. */\nlet supportedInputTypes;\n/** Types of `` that *might* be supported. */\nconst candidateInputTypes = [\n// `color` must come first. Chrome 56 shows a warning if we change the type to `color` after\n// first changing it to something else:\n// The specified value \"\" does not conform to the required format.\n// The format is \"#rrggbb\" where rr, gg, bb are two-digit hexadecimal numbers.\n'color', 'button', 'checkbox', 'date', 'datetime-local', 'email', 'file', 'hidden', 'image', 'month', 'number', 'password', 'radio', 'range', 'reset', 'search', 'submit', 'tel', 'text', 'time', 'url', 'week'];\n/** @returns The input types supported by this browser. */\nfunction getSupportedInputTypes() {\n // Result is cached.\n if (supportedInputTypes) {\n return supportedInputTypes;\n }\n // We can't check if an input type is not supported until we're on the browser, so say that\n // everything is supported when not on the browser. We don't use `Platform` here since it's\n // just a helper function and can't inject it.\n if (typeof document !== 'object' || !document) {\n supportedInputTypes = new Set(candidateInputTypes);\n return supportedInputTypes;\n }\n let featureTestInput = document.createElement('input');\n supportedInputTypes = new Set(candidateInputTypes.filter(value => {\n featureTestInput.setAttribute('type', value);\n return featureTestInput.type === value;\n }));\n return supportedInputTypes;\n}\n\n/** Cached result of whether the user's browser supports passive event listeners. */\nlet supportsPassiveEvents;\n/**\n * Checks whether the user's browser supports passive event listeners.\n * See: https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md\n */\nfunction supportsPassiveEventListeners() {\n if (supportsPassiveEvents == null && typeof window !== 'undefined') {\n try {\n window.addEventListener('test', null, Object.defineProperty({}, 'passive', {\n get: () => supportsPassiveEvents = true\n }));\n } finally {\n supportsPassiveEvents = supportsPassiveEvents || false;\n }\n }\n return supportsPassiveEvents;\n}\n/**\n * Normalizes an `AddEventListener` object to something that can be passed\n * to `addEventListener` on any browser, no matter whether it supports the\n * `options` parameter.\n * @param options Object to be normalized.\n */\nfunction normalizePassiveListenerOptions(options) {\n return supportsPassiveEventListeners() ? options : !!options.capture;\n}\n\n/** The possible ways the browser may handle the horizontal scroll axis in RTL languages. */\nvar RtlScrollAxisType = /*#__PURE__*/function (RtlScrollAxisType) {\n /**\n * scrollLeft is 0 when scrolled all the way left and (scrollWidth - clientWidth) when scrolled\n * all the way right.\n */\n RtlScrollAxisType[RtlScrollAxisType[\"NORMAL\"] = 0] = \"NORMAL\";\n /**\n * scrollLeft is -(scrollWidth - clientWidth) when scrolled all the way left and 0 when scrolled\n * all the way right.\n */\n RtlScrollAxisType[RtlScrollAxisType[\"NEGATED\"] = 1] = \"NEGATED\";\n /**\n * scrollLeft is (scrollWidth - clientWidth) when scrolled all the way left and 0 when scrolled\n * all the way right.\n */\n RtlScrollAxisType[RtlScrollAxisType[\"INVERTED\"] = 2] = \"INVERTED\";\n return RtlScrollAxisType;\n}(RtlScrollAxisType || {});\n/** Cached result of the way the browser handles the horizontal scroll axis in RTL mode. */\nlet rtlScrollAxisType;\n/** Cached result of the check that indicates whether the browser supports scroll behaviors. */\nlet scrollBehaviorSupported;\n/** Check whether the browser supports scroll behaviors. */\nfunction supportsScrollBehavior() {\n if (scrollBehaviorSupported == null) {\n // If we're not in the browser, it can't be supported. Also check for `Element`, because\n // some projects stub out the global `document` during SSR which can throw us off.\n if (typeof document !== 'object' || !document || typeof Element !== 'function' || !Element) {\n scrollBehaviorSupported = false;\n return scrollBehaviorSupported;\n }\n // If the element can have a `scrollBehavior` style, we can be sure that it's supported.\n if ('scrollBehavior' in document.documentElement.style) {\n scrollBehaviorSupported = true;\n } else {\n // At this point we have 3 possibilities: `scrollTo` isn't supported at all, it's\n // supported but it doesn't handle scroll behavior, or it has been polyfilled.\n const scrollToFunction = Element.prototype.scrollTo;\n if (scrollToFunction) {\n // We can detect if the function has been polyfilled by calling `toString` on it. Native\n // functions are obfuscated using `[native code]`, whereas if it was overwritten we'd get\n // the actual function source. Via https://davidwalsh.name/detect-native-function. Consider\n // polyfilled functions as supporting scroll behavior.\n scrollBehaviorSupported = !/\\{\\s*\\[native code\\]\\s*\\}/.test(scrollToFunction.toString());\n } else {\n scrollBehaviorSupported = false;\n }\n }\n }\n return scrollBehaviorSupported;\n}\n/**\n * Checks the type of RTL scroll axis used by this browser. As of time of writing, Chrome is NORMAL,\n * Firefox & Safari are NEGATED, and IE & Edge are INVERTED.\n */\nfunction getRtlScrollAxisType() {\n // We can't check unless we're on the browser. Just assume 'normal' if we're not.\n if (typeof document !== 'object' || !document) {\n return RtlScrollAxisType.NORMAL;\n }\n if (rtlScrollAxisType == null) {\n // Create a 1px wide scrolling container and a 2px wide content element.\n const scrollContainer = document.createElement('div');\n const containerStyle = scrollContainer.style;\n scrollContainer.dir = 'rtl';\n containerStyle.width = '1px';\n containerStyle.overflow = 'auto';\n containerStyle.visibility = 'hidden';\n containerStyle.pointerEvents = 'none';\n containerStyle.position = 'absolute';\n const content = document.createElement('div');\n const contentStyle = content.style;\n contentStyle.width = '2px';\n contentStyle.height = '1px';\n scrollContainer.appendChild(content);\n document.body.appendChild(scrollContainer);\n rtlScrollAxisType = RtlScrollAxisType.NORMAL;\n // The viewport starts scrolled all the way to the right in RTL mode. If we are in a NORMAL\n // browser this would mean that the scrollLeft should be 1. If it's zero instead we know we're\n // dealing with one of the other two types of browsers.\n if (scrollContainer.scrollLeft === 0) {\n // In a NEGATED browser the scrollLeft is always somewhere in [-maxScrollAmount, 0]. For an\n // INVERTED browser it is always somewhere in [0, maxScrollAmount]. We can determine which by\n // setting to the scrollLeft to 1. This is past the max for a NEGATED browser, so it will\n // return 0 when we read it again.\n scrollContainer.scrollLeft = 1;\n rtlScrollAxisType = scrollContainer.scrollLeft === 0 ? RtlScrollAxisType.NEGATED : RtlScrollAxisType.INVERTED;\n }\n scrollContainer.remove();\n }\n return rtlScrollAxisType;\n}\nlet shadowDomIsSupported;\n/** Checks whether the user's browser support Shadow DOM. */\nfunction _supportsShadowDom() {\n if (shadowDomIsSupported == null) {\n const head = typeof document !== 'undefined' ? document.head : null;\n shadowDomIsSupported = !!(head && (head.createShadowRoot || head.attachShadow));\n }\n return shadowDomIsSupported;\n}\n/** Gets the shadow root of an element, if supported and the element is inside the Shadow DOM. */\nfunction _getShadowRoot(element) {\n if (_supportsShadowDom()) {\n const rootNode = element.getRootNode ? element.getRootNode() : null;\n // Note that this should be caught by `_supportsShadowDom`, but some\n // teams have been able to hit this code path on unsupported browsers.\n if (typeof ShadowRoot !== 'undefined' && ShadowRoot && rootNode instanceof ShadowRoot) {\n return rootNode;\n }\n }\n return null;\n}\n/**\n * Gets the currently-focused element on the page while\n * also piercing through Shadow DOM boundaries.\n */\nfunction _getFocusedElementPierceShadowDom() {\n let activeElement = typeof document !== 'undefined' && document ? document.activeElement : null;\n while (activeElement && activeElement.shadowRoot) {\n const newActiveElement = activeElement.shadowRoot.activeElement;\n if (newActiveElement === activeElement) {\n break;\n } else {\n activeElement = newActiveElement;\n }\n }\n return activeElement;\n}\n/** Gets the target of an event while accounting for Shadow DOM. */\nfunction _getEventTarget(event) {\n // If an event is bound outside the Shadow DOM, the `event.target` will\n // point to the shadow root so we have to use `composedPath` instead.\n return event.composedPath ? event.composedPath()[0] : event.target;\n}\n\n/** Gets whether the code is currently running in a test environment. */\nfunction _isTestEnvironment() {\n // We can't use `declare const` because it causes conflicts inside Google with the real typings\n // for these symbols and we can't read them off the global object, because they don't appear to\n // be attached there for some runners like Jest.\n // (see: https://github.com/angular/components/issues/23365#issuecomment-938146643)\n return (\n // @ts-ignore\n typeof __karma__ !== 'undefined' && !!__karma__ ||\n // @ts-ignore\n typeof jasmine !== 'undefined' && !!jasmine ||\n // @ts-ignore\n typeof jest !== 'undefined' && !!jest ||\n // @ts-ignore\n typeof Mocha !== 'undefined' && !!Mocha\n );\n}\n\n// TODO(crisbeto): remove this function when making breaking changes for v20.\n/**\n * Binds an event listener with specific options in a backwards-compatible way.\n * This function is necessary, because `Renderer2.listen` only supports listener options\n * after 19.1 and during the v19 period we support any 19.x version.\n * @docs-private\n */\nfunction _bindEventWithOptions(renderer, target, eventName, callback, options) {\n const major = parseInt(VERSION.major);\n const minor = parseInt(VERSION.minor);\n // Event options in `listen` are only supported in 19.1 and beyond.\n // We also allow 0.0.x, because that indicates a build at HEAD.\n if (major > 19 || major === 19 && minor > 0 || major === 0 && minor === 0) {\n return renderer.listen(target, eventName, callback, options);\n }\n target.addEventListener(eventName, callback, options);\n return () => {\n target.removeEventListener(eventName, callback, options);\n };\n}\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { Platform, PlatformModule, RtlScrollAxisType, _bindEventWithOptions, _getEventTarget, _getFocusedElementPierceShadowDom, _getShadowRoot, _isTestEnvironment, _supportsShadowDom, getRtlScrollAxisType, getSupportedInputTypes, normalizePassiveListenerOptions, supportsPassiveEventListeners, supportsScrollBehavior };\n","import * as i0 from '@angular/core';\nimport { NgModule, inject, CSP_NONCE, Injectable, NgZone } from '@angular/core';\nimport { coerceArray } from '@angular/cdk/coercion';\nimport { Subject, combineLatest, concat, Observable } from 'rxjs';\nimport { take, skip, debounceTime, map, startWith, takeUntil } from 'rxjs/operators';\nimport { Platform } from '@angular/cdk/platform';\nlet LayoutModule = /*#__PURE__*/(() => {\n class LayoutModule {\n static ɵfac = function LayoutModule_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || LayoutModule)();\n };\n static ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n type: LayoutModule\n });\n static ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({});\n }\n return LayoutModule;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n/** Global registry for all dynamically-created, injected media queries. */\nconst mediaQueriesForWebkitCompatibility = /*#__PURE__*/new Set();\n/** Style tag that holds all of the dynamically-created media queries. */\nlet mediaQueryStyleNode;\n/** A utility for calling matchMedia queries. */\nlet MediaMatcher = /*#__PURE__*/(() => {\n class MediaMatcher {\n _platform = inject(Platform);\n _nonce = inject(CSP_NONCE, {\n optional: true\n });\n /** The internal matchMedia method to return back a MediaQueryList like object. */\n _matchMedia;\n constructor() {\n this._matchMedia = this._platform.isBrowser && window.matchMedia ?\n // matchMedia is bound to the window scope intentionally as it is an illegal invocation to\n // call it from a different scope.\n window.matchMedia.bind(window) : noopMatchMedia;\n }\n /**\n * Evaluates the given media query and returns the native MediaQueryList from which results\n * can be retrieved.\n * Confirms the layout engine will trigger for the selector query provided and returns the\n * MediaQueryList for the query provided.\n */\n matchMedia(query) {\n if (this._platform.WEBKIT || this._platform.BLINK) {\n createEmptyStyleRule(query, this._nonce);\n }\n return this._matchMedia(query);\n }\n static ɵfac = function MediaMatcher_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || MediaMatcher)();\n };\n static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n token: MediaMatcher,\n factory: MediaMatcher.ɵfac,\n providedIn: 'root'\n });\n }\n return MediaMatcher;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/**\n * Creates an empty stylesheet that is used to work around browser inconsistencies related to\n * `matchMedia`. At the time of writing, it handles the following cases:\n * 1. On WebKit browsers, a media query has to have at least one rule in order for `matchMedia`\n * to fire. We work around it by declaring a dummy stylesheet with a `@media` declaration.\n * 2. In some cases Blink browsers will stop firing the `matchMedia` listener if none of the rules\n * inside the `@media` match existing elements on the page. We work around it by having one rule\n * targeting the `body`. See https://github.com/angular/components/issues/23546.\n */\nfunction createEmptyStyleRule(query, nonce) {\n if (mediaQueriesForWebkitCompatibility.has(query)) {\n return;\n }\n try {\n if (!mediaQueryStyleNode) {\n mediaQueryStyleNode = document.createElement('style');\n if (nonce) {\n mediaQueryStyleNode.setAttribute('nonce', nonce);\n }\n mediaQueryStyleNode.setAttribute('type', 'text/css');\n document.head.appendChild(mediaQueryStyleNode);\n }\n if (mediaQueryStyleNode.sheet) {\n mediaQueryStyleNode.sheet.insertRule(`@media ${query} {body{ }}`, 0);\n mediaQueriesForWebkitCompatibility.add(query);\n }\n } catch (e) {\n console.error(e);\n }\n}\n/** No-op matchMedia replacement for non-browser platforms. */\nfunction noopMatchMedia(query) {\n // Use `as any` here to avoid adding additional necessary properties for\n // the noop matcher.\n return {\n matches: query === 'all' || query === '',\n media: query,\n addListener: () => {},\n removeListener: () => {}\n };\n}\n\n/** Utility for checking the matching state of `@media` queries. */\nlet BreakpointObserver = /*#__PURE__*/(() => {\n class BreakpointObserver {\n _mediaMatcher = inject(MediaMatcher);\n _zone = inject(NgZone);\n /** A map of all media queries currently being listened for. */\n _queries = new Map();\n /** A subject for all other observables to takeUntil based on. */\n _destroySubject = new Subject();\n constructor() {}\n /** Completes the active subject, signalling to all other observables to complete. */\n ngOnDestroy() {\n this._destroySubject.next();\n this._destroySubject.complete();\n }\n /**\n * Whether one or more media queries match the current viewport size.\n * @param value One or more media queries to check.\n * @returns Whether any of the media queries match.\n */\n isMatched(value) {\n const queries = splitQueries(coerceArray(value));\n return queries.some(mediaQuery => this._registerQuery(mediaQuery).mql.matches);\n }\n /**\n * Gets an observable of results for the given queries that will emit new results for any changes\n * in matching of the given queries.\n * @param value One or more media queries to check.\n * @returns A stream of matches for the given queries.\n */\n observe(value) {\n const queries = splitQueries(coerceArray(value));\n const observables = queries.map(query => this._registerQuery(query).observable);\n let stateObservable = combineLatest(observables);\n // Emit the first state immediately, and then debounce the subsequent emissions.\n stateObservable = concat(stateObservable.pipe(take(1)), stateObservable.pipe(skip(1), debounceTime(0)));\n return stateObservable.pipe(map(breakpointStates => {\n const response = {\n matches: false,\n breakpoints: {}\n };\n breakpointStates.forEach(({\n matches,\n query\n }) => {\n response.matches = response.matches || matches;\n response.breakpoints[query] = matches;\n });\n return response;\n }));\n }\n /** Registers a specific query to be listened for. */\n _registerQuery(query) {\n // Only set up a new MediaQueryList if it is not already being listened for.\n if (this._queries.has(query)) {\n return this._queries.get(query);\n }\n const mql = this._mediaMatcher.matchMedia(query);\n // Create callback for match changes and add it is as a listener.\n const queryObservable = new Observable(observer => {\n // Listener callback methods are wrapped to be placed back in ngZone. Callbacks must be placed\n // back into the zone because matchMedia is only included in Zone.js by loading the\n // webapis-media-query.js file alongside the zone.js file. Additionally, some browsers do not\n // have MediaQueryList inherit from EventTarget, which causes inconsistencies in how Zone.js\n // patches it.\n const handler = e => this._zone.run(() => observer.next(e));\n mql.addListener(handler);\n return () => {\n mql.removeListener(handler);\n };\n }).pipe(startWith(mql), map(({\n matches\n }) => ({\n query,\n matches\n })), takeUntil(this._destroySubject));\n // Add the MediaQueryList to the set of queries.\n const output = {\n observable: queryObservable,\n mql\n };\n this._queries.set(query, output);\n return output;\n }\n static ɵfac = function BreakpointObserver_Factory(__ngFactoryType__) {\n return new (__ngFactoryType__ || BreakpointObserver)();\n };\n static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n token: BreakpointObserver,\n factory: BreakpointObserver.ɵfac,\n providedIn: 'root'\n });\n }\n return BreakpointObserver;\n})();\n/*#__PURE__*/(() => {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n/**\n * Split each query string into separate query strings if two queries are provided as comma\n * separated.\n */\nfunction splitQueries(queries) {\n return queries.map(query => query.split(',')).reduce((a1, a2) => a1.concat(a2)).map(query => query.trim());\n}\n\n// PascalCase is being used as Breakpoints is used like an enum.\n// tslint:disable-next-line:variable-name\nconst Breakpoints = {\n XSmall: '(max-width: 599.98px)',\n Small: '(min-width: 600px) and (max-width: 959.98px)',\n Medium: '(min-width: 960px) and (max-width: 1279.98px)',\n Large: '(min-width: 1280px) and (max-width: 1919.98px)',\n XLarge: '(min-width: 1920px)',\n Handset: '(max-width: 599.98px) and (orientation: portrait), ' + '(max-width: 959.98px) and (orientation: landscape)',\n Tablet: '(min-width: 600px) and (max-width: 839.98px) and (orientation: portrait), ' + '(min-width: 960px) and (max-width: 1279.98px) and (orientation: landscape)',\n Web: '(min-width: 840px) and (orientation: portrait), ' + '(min-width: 1280px) and (orientation: landscape)',\n HandsetPortrait: '(max-width: 599.98px) and (orientation: portrait)',\n TabletPortrait: '(min-width: 600px) and (max-width: 839.98px) and (orientation: portrait)',\n WebPortrait: '(min-width: 840px) and (orientation: portrait)',\n HandsetLandscape: '(max-width: 959.98px) and (orientation: landscape)',\n TabletLandscape: '(min-width: 960px) and (max-width: 1279.98px) and (orientation: landscape)',\n WebLandscape: '(min-width: 1280px) and (orientation: landscape)'\n};\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { BreakpointObserver, Breakpoints, LayoutModule, MediaMatcher };\n"],"mappings":"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","names":["coerceArray","value","coerceCssPixelValue","coerceElement","elementOrRef","ElementRef","hasV8BreakIterator","Platform","_Platform","__publicField","inject","PLATFORM_ID","isPlatformBrowser","__ngFactoryType__","ɵɵdefineInjectable","scrollBehaviorSupported","supportsScrollBehavior","scrollToFunction","_getFocusedElementPierceShadowDom","activeElement","newActiveElement","_getEventTarget","event","_isTestEnvironment","mediaQueriesForWebkitCompatibility","mediaQueryStyleNode","MediaMatcher","_MediaMatcher","__publicField","inject","Platform","CSP_NONCE","noopMatchMedia","query","createEmptyStyleRule","__ngFactoryType__","ɵɵdefineInjectable","nonce","e","BreakpointObserver","_BreakpointObserver","NgZone","Subject","value","splitQueries","coerceArray","mediaQuery","observables","stateObservable","combineLatest","concat","take","skip","debounceTime","map","breakpointStates","response","matches","mql","output","Observable","observer","handler","startWith","takeUntil","queries","a1","a2"],"x_google_ignoreList":[0,1,2]}