{"version":3,"file":"scripts/@angular/platform-browser/angular-platform-browser-18.min.js","mappings":"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","sources":["webpack://baas-static-web/webpack/runtime/create fake namespace object","webpack://baas-static-web/webpack/bootstrap","webpack://baas-static-web/webpack/runtime/define property getters","webpack://baas-static-web/webpack/runtime/hasOwnProperty shorthand","webpack://baas-static-web/webpack/runtime/make namespace object","webpack://baas-static-web/external var \"ng.common\"","webpack://baas-static-web/external var \"ng.core\"","webpack://baas-static-web/external var \"ng.common.http\"","webpack://baas-static-web/./node_modules/@angular/platform-browser/fesm2022/platform-browser.mjs","webpack://baas-static-web/./src/@angular/angular-platform-browser.ts"],"sourcesContent":["var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","const __WEBPACK_NAMESPACE_OBJECT__ = ng.common;","const __WEBPACK_NAMESPACE_OBJECT__ = ng.core;","const __WEBPACK_NAMESPACE_OBJECT__ = ng.common.http;","/**\n * @license Angular v18.2.13\n * (c) 2010-2024 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport { ɵDomAdapter, ɵsetRootDomAdapter, ɵparseCookieValue, ɵgetDOM, isPlatformServer, DOCUMENT, ɵPLATFORM_BROWSER_ID, XhrFactory, CommonModule } from '@angular/common';\nexport { ɵgetDOM } from '@angular/common';\nimport * as i0 from '@angular/core';\nimport { ɵglobal, ɵRuntimeError, Injectable, InjectionToken, Inject, APP_ID, CSP_NONCE, PLATFORM_ID, Optional, ViewEncapsulation, RendererStyleFlags2, ɵinternalCreateApplication, ErrorHandler, ɵsetDocument, PLATFORM_INITIALIZER, createPlatformFactory, platformCore, ɵTESTABILITY_GETTER, ɵTESTABILITY, Testability, NgZone, TestabilityRegistry, ɵINJECTOR_SCOPE, RendererFactory2, ApplicationModule, NgModule, SkipSelf, ApplicationRef, ɵConsole, forwardRef, ɵXSS_SECURITY_URL, SecurityContext, ɵallowSanitizationBypassAndThrow, ɵunwrapSafeValue, ɵ_sanitizeUrl, ɵ_sanitizeHtml, ɵbypassSanitizationTrustHtml, ɵbypassSanitizationTrustStyle, ɵbypassSanitizationTrustScript, ɵbypassSanitizationTrustUrl, ɵbypassSanitizationTrustResourceUrl, ɵwithI18nSupport, ɵwithEventReplay, ENVIRONMENT_INITIALIZER, inject, ɵZONELESS_ENABLED, ɵformatRuntimeError, makeEnvironmentProviders, ɵwithDomHydration, Version } from '@angular/core';\nimport { ɵwithHttpTransferCache } from '@angular/common/http';\n\n/**\n * Provides DOM operations in any browser environment.\n *\n * @security Tread carefully! Interacting with the DOM directly is dangerous and\n * can introduce XSS risks.\n */\nclass GenericBrowserDomAdapter extends ɵDomAdapter {\n    constructor() {\n        super(...arguments);\n        this.supportsDOMEvents = true;\n    }\n}\n\n/**\n * A `DomAdapter` powered by full browser DOM APIs.\n *\n * @security Tread carefully! Interacting with the DOM directly is dangerous and\n * can introduce XSS risks.\n */\n/* tslint:disable:requireParameterType no-console */\nclass BrowserDomAdapter extends GenericBrowserDomAdapter {\n    static makeCurrent() {\n        ɵsetRootDomAdapter(new BrowserDomAdapter());\n    }\n    onAndCancel(el, evt, listener) {\n        el.addEventListener(evt, listener);\n        return () => {\n            el.removeEventListener(evt, listener);\n        };\n    }\n    dispatchEvent(el, evt) {\n        el.dispatchEvent(evt);\n    }\n    remove(node) {\n        node.remove();\n    }\n    createElement(tagName, doc) {\n        doc = doc || this.getDefaultDocument();\n        return doc.createElement(tagName);\n    }\n    createHtmlDocument() {\n        return document.implementation.createHTMLDocument('fakeTitle');\n    }\n    getDefaultDocument() {\n        return document;\n    }\n    isElementNode(node) {\n        return node.nodeType === Node.ELEMENT_NODE;\n    }\n    isShadowRoot(node) {\n        return node instanceof DocumentFragment;\n    }\n    /** @deprecated No longer being used in Ivy code. To be removed in version 14. */\n    getGlobalEventTarget(doc, target) {\n        if (target === 'window') {\n            return window;\n        }\n        if (target === 'document') {\n            return doc;\n        }\n        if (target === 'body') {\n            return doc.body;\n        }\n        return null;\n    }\n    getBaseHref(doc) {\n        const href = getBaseElementHref();\n        return href == null ? null : relativePath(href);\n    }\n    resetBaseElement() {\n        baseElement = null;\n    }\n    getUserAgent() {\n        return window.navigator.userAgent;\n    }\n    getCookie(name) {\n        return ɵparseCookieValue(document.cookie, name);\n    }\n}\nlet baseElement = null;\nfunction getBaseElementHref() {\n    baseElement = baseElement || document.querySelector('base');\n    return baseElement ? baseElement.getAttribute('href') : null;\n}\nfunction relativePath(url) {\n    // The base URL doesn't really matter, we just need it so relative paths have something\n    // to resolve against. In the browser `HTMLBaseElement.href` is always absolute.\n    return new URL(url, document.baseURI).pathname;\n}\n\nclass BrowserGetTestability {\n    addToWindow(registry) {\n        ɵglobal['getAngularTestability'] = (elem, findInAncestors = true) => {\n            const testability = registry.findTestabilityInTree(elem, findInAncestors);\n            if (testability == null) {\n                throw new ɵRuntimeError(5103 /* RuntimeErrorCode.TESTABILITY_NOT_FOUND */, (typeof ngDevMode === 'undefined' || ngDevMode) &&\n                    'Could not find testability for element.');\n            }\n            return testability;\n        };\n        ɵglobal['getAllAngularTestabilities'] = () => registry.getAllTestabilities();\n        ɵglobal['getAllAngularRootElements'] = () => registry.getAllRootElements();\n        const whenAllStable = (callback) => {\n            const testabilities = ɵglobal['getAllAngularTestabilities']();\n            let count = testabilities.length;\n            const decrement = function () {\n                count--;\n                if (count == 0) {\n                    callback();\n                }\n            };\n            testabilities.forEach((testability) => {\n                testability.whenStable(decrement);\n            });\n        };\n        if (!ɵglobal['frameworkStabilizers']) {\n            ɵglobal['frameworkStabilizers'] = [];\n        }\n        ɵglobal['frameworkStabilizers'].push(whenAllStable);\n    }\n    findTestabilityInTree(registry, elem, findInAncestors) {\n        if (elem == null) {\n            return null;\n        }\n        const t = registry.getTestability(elem);\n        if (t != null) {\n            return t;\n        }\n        else if (!findInAncestors) {\n            return null;\n        }\n        if (ɵgetDOM().isShadowRoot(elem)) {\n            return this.findTestabilityInTree(registry, elem.host, true);\n        }\n        return this.findTestabilityInTree(registry, elem.parentElement, true);\n    }\n}\n\n/**\n * A factory for `HttpXhrBackend` that uses the `XMLHttpRequest` browser API.\n */\nclass BrowserXhr {\n    build() {\n        return new XMLHttpRequest();\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: BrowserXhr, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: BrowserXhr }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: BrowserXhr, decorators: [{\n            type: Injectable\n        }] });\n\n/**\n * The injection token for plugins of the `EventManager` service.\n *\n * @publicApi\n */\nconst EVENT_MANAGER_PLUGINS = new InjectionToken(ngDevMode ? 'EventManagerPlugins' : '');\n/**\n * An injectable service that provides event management for Angular\n * through a browser plug-in.\n *\n * @publicApi\n */\nclass EventManager {\n    /**\n     * Initializes an instance of the event-manager service.\n     */\n    constructor(plugins, _zone) {\n        this._zone = _zone;\n        this._eventNameToPlugin = new Map();\n        plugins.forEach((plugin) => {\n            plugin.manager = this;\n        });\n        this._plugins = plugins.slice().reverse();\n    }\n    /**\n     * Registers a handler for a specific element and event.\n     *\n     * @param element The HTML element to receive event notifications.\n     * @param eventName The name of the event to listen for.\n     * @param handler A function to call when the notification occurs. Receives the\n     * event object as an argument.\n     * @returns  A callback function that can be used to remove the handler.\n     */\n    addEventListener(element, eventName, handler) {\n        const plugin = this._findPluginFor(eventName);\n        return plugin.addEventListener(element, eventName, handler);\n    }\n    /**\n     * Retrieves the compilation zone in which event listeners are registered.\n     */\n    getZone() {\n        return this._zone;\n    }\n    /** @internal */\n    _findPluginFor(eventName) {\n        let plugin = this._eventNameToPlugin.get(eventName);\n        if (plugin) {\n            return plugin;\n        }\n        const plugins = this._plugins;\n        plugin = plugins.find((plugin) => plugin.supports(eventName));\n        if (!plugin) {\n            throw new ɵRuntimeError(5101 /* RuntimeErrorCode.NO_PLUGIN_FOR_EVENT */, (typeof ngDevMode === 'undefined' || ngDevMode) &&\n                `No event manager plugin found for event ${eventName}`);\n        }\n        this._eventNameToPlugin.set(eventName, plugin);\n        return plugin;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: EventManager, deps: [{ token: EVENT_MANAGER_PLUGINS }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: EventManager }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: EventManager, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [EVENT_MANAGER_PLUGINS]\n                }] }, { type: i0.NgZone }] });\n/**\n * The plugin definition for the `EventManager` class\n *\n * It can be used as a base class to create custom manager plugins, i.e. you can create your own\n * class that extends the `EventManagerPlugin` one.\n *\n * @publicApi\n */\nclass EventManagerPlugin {\n    // TODO: remove (has some usage in G3)\n    constructor(_doc) {\n        this._doc = _doc;\n    }\n}\n\n/** The style elements attribute name used to set value of `APP_ID` token. */\nconst APP_ID_ATTRIBUTE_NAME = 'ng-app-id';\nclass SharedStylesHost {\n    constructor(doc, appId, nonce, platformId = {}) {\n        this.doc = doc;\n        this.appId = appId;\n        this.nonce = nonce;\n        this.platformId = platformId;\n        // Maps all registered host nodes to a list of style nodes that have been added to the host node.\n        this.styleRef = new Map();\n        this.hostNodes = new Set();\n        this.styleNodesInDOM = this.collectServerRenderedStyles();\n        this.platformIsServer = isPlatformServer(platformId);\n        this.resetHostNodes();\n    }\n    addStyles(styles) {\n        for (const style of styles) {\n            const usageCount = this.changeUsageCount(style, 1);\n            if (usageCount === 1) {\n                this.onStyleAdded(style);\n            }\n        }\n    }\n    removeStyles(styles) {\n        for (const style of styles) {\n            const usageCount = this.changeUsageCount(style, -1);\n            if (usageCount <= 0) {\n                this.onStyleRemoved(style);\n            }\n        }\n    }\n    ngOnDestroy() {\n        const styleNodesInDOM = this.styleNodesInDOM;\n        if (styleNodesInDOM) {\n            styleNodesInDOM.forEach((node) => node.remove());\n            styleNodesInDOM.clear();\n        }\n        for (const style of this.getAllStyles()) {\n            this.onStyleRemoved(style);\n        }\n        this.resetHostNodes();\n    }\n    addHost(hostNode) {\n        this.hostNodes.add(hostNode);\n        for (const style of this.getAllStyles()) {\n            this.addStyleToHost(hostNode, style);\n        }\n    }\n    removeHost(hostNode) {\n        this.hostNodes.delete(hostNode);\n    }\n    getAllStyles() {\n        return this.styleRef.keys();\n    }\n    onStyleAdded(style) {\n        for (const host of this.hostNodes) {\n            this.addStyleToHost(host, style);\n        }\n    }\n    onStyleRemoved(style) {\n        const styleRef = this.styleRef;\n        styleRef.get(style)?.elements?.forEach((node) => node.remove());\n        styleRef.delete(style);\n    }\n    collectServerRenderedStyles() {\n        const styles = this.doc.head?.querySelectorAll(`style[${APP_ID_ATTRIBUTE_NAME}=\"${this.appId}\"]`);\n        if (styles?.length) {\n            const styleMap = new Map();\n            styles.forEach((style) => {\n                if (style.textContent != null) {\n                    styleMap.set(style.textContent, style);\n                }\n            });\n            return styleMap;\n        }\n        return null;\n    }\n    changeUsageCount(style, delta) {\n        const map = this.styleRef;\n        if (map.has(style)) {\n            const styleRefValue = map.get(style);\n            styleRefValue.usage += delta;\n            return styleRefValue.usage;\n        }\n        map.set(style, { usage: delta, elements: [] });\n        return delta;\n    }\n    getStyleElement(host, style) {\n        const styleNodesInDOM = this.styleNodesInDOM;\n        const styleEl = styleNodesInDOM?.get(style);\n        if (styleEl?.parentNode === host) {\n            // `styleNodesInDOM` cannot be undefined due to the above `styleNodesInDOM?.get`.\n            styleNodesInDOM.delete(style);\n            styleEl.removeAttribute(APP_ID_ATTRIBUTE_NAME);\n            if (typeof ngDevMode === 'undefined' || ngDevMode) {\n                // This attribute is solely used for debugging purposes.\n                styleEl.setAttribute('ng-style-reused', '');\n            }\n            return styleEl;\n        }\n        else {\n            const styleEl = this.doc.createElement('style');\n            if (this.nonce) {\n                styleEl.setAttribute('nonce', this.nonce);\n            }\n            styleEl.textContent = style;\n            if (this.platformIsServer) {\n                styleEl.setAttribute(APP_ID_ATTRIBUTE_NAME, this.appId);\n            }\n            host.appendChild(styleEl);\n            return styleEl;\n        }\n    }\n    addStyleToHost(host, style) {\n        const styleEl = this.getStyleElement(host, style);\n        const styleRef = this.styleRef;\n        const styleElRef = styleRef.get(style)?.elements;\n        if (styleElRef) {\n            styleElRef.push(styleEl);\n        }\n        else {\n            styleRef.set(style, { elements: [styleEl], usage: 1 });\n        }\n    }\n    resetHostNodes() {\n        const hostNodes = this.hostNodes;\n        hostNodes.clear();\n        // Re-add the head element back since this is the default host.\n        hostNodes.add(this.doc.head);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: SharedStylesHost, deps: [{ token: DOCUMENT }, { token: APP_ID }, { token: CSP_NONCE, optional: true }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: SharedStylesHost }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: SharedStylesHost, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: Document, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [APP_ID]\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [CSP_NONCE]\n                }, {\n                    type: Optional\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [PLATFORM_ID]\n                }] }] });\n\nconst NAMESPACE_URIS = {\n    'svg': 'http://www.w3.org/2000/svg',\n    'xhtml': 'http://www.w3.org/1999/xhtml',\n    'xlink': 'http://www.w3.org/1999/xlink',\n    'xml': 'http://www.w3.org/XML/1998/namespace',\n    'xmlns': 'http://www.w3.org/2000/xmlns/',\n    'math': 'http://www.w3.org/1998/Math/MathML',\n};\nconst COMPONENT_REGEX = /%COMP%/g;\nconst COMPONENT_VARIABLE = '%COMP%';\nconst HOST_ATTR = `_nghost-${COMPONENT_VARIABLE}`;\nconst CONTENT_ATTR = `_ngcontent-${COMPONENT_VARIABLE}`;\n/**\n * The default value for the `REMOVE_STYLES_ON_COMPONENT_DESTROY` DI token.\n */\nconst REMOVE_STYLES_ON_COMPONENT_DESTROY_DEFAULT = true;\n/**\n * A DI token that indicates whether styles\n * of destroyed components should be removed from DOM.\n *\n * By default, the value is set to `true`.\n * @publicApi\n */\nconst REMOVE_STYLES_ON_COMPONENT_DESTROY = new InjectionToken(ngDevMode ? 'RemoveStylesOnCompDestroy' : '', {\n    providedIn: 'root',\n    factory: () => REMOVE_STYLES_ON_COMPONENT_DESTROY_DEFAULT,\n});\nfunction shimContentAttribute(componentShortId) {\n    return CONTENT_ATTR.replace(COMPONENT_REGEX, componentShortId);\n}\nfunction shimHostAttribute(componentShortId) {\n    return HOST_ATTR.replace(COMPONENT_REGEX, componentShortId);\n}\nfunction shimStylesContent(compId, styles) {\n    return styles.map((s) => s.replace(COMPONENT_REGEX, compId));\n}\nclass DomRendererFactory2 {\n    constructor(eventManager, sharedStylesHost, appId, removeStylesOnCompDestroy, doc, platformId, ngZone, nonce = null) {\n        this.eventManager = eventManager;\n        this.sharedStylesHost = sharedStylesHost;\n        this.appId = appId;\n        this.removeStylesOnCompDestroy = removeStylesOnCompDestroy;\n        this.doc = doc;\n        this.platformId = platformId;\n        this.ngZone = ngZone;\n        this.nonce = nonce;\n        this.rendererByCompId = new Map();\n        this.platformIsServer = isPlatformServer(platformId);\n        this.defaultRenderer = new DefaultDomRenderer2(eventManager, doc, ngZone, this.platformIsServer);\n    }\n    createRenderer(element, type) {\n        if (!element || !type) {\n            return this.defaultRenderer;\n        }\n        if (this.platformIsServer && type.encapsulation === ViewEncapsulation.ShadowDom) {\n            // Domino does not support shadow DOM.\n            type = { ...type, encapsulation: ViewEncapsulation.Emulated };\n        }\n        const renderer = this.getOrCreateRenderer(element, type);\n        // Renderers have different logic due to different encapsulation behaviours.\n        // Ex: for emulated, an attribute is added to the element.\n        if (renderer instanceof EmulatedEncapsulationDomRenderer2) {\n            renderer.applyToHost(element);\n        }\n        else if (renderer instanceof NoneEncapsulationDomRenderer) {\n            renderer.applyStyles();\n        }\n        return renderer;\n    }\n    getOrCreateRenderer(element, type) {\n        const rendererByCompId = this.rendererByCompId;\n        let renderer = rendererByCompId.get(type.id);\n        if (!renderer) {\n            const doc = this.doc;\n            const ngZone = this.ngZone;\n            const eventManager = this.eventManager;\n            const sharedStylesHost = this.sharedStylesHost;\n            const removeStylesOnCompDestroy = this.removeStylesOnCompDestroy;\n            const platformIsServer = this.platformIsServer;\n            switch (type.encapsulation) {\n                case ViewEncapsulation.Emulated:\n                    renderer = new EmulatedEncapsulationDomRenderer2(eventManager, sharedStylesHost, type, this.appId, removeStylesOnCompDestroy, doc, ngZone, platformIsServer);\n                    break;\n                case ViewEncapsulation.ShadowDom:\n                    return new ShadowDomRenderer(eventManager, sharedStylesHost, element, type, doc, ngZone, this.nonce, platformIsServer);\n                default:\n                    renderer = new NoneEncapsulationDomRenderer(eventManager, sharedStylesHost, type, removeStylesOnCompDestroy, doc, ngZone, platformIsServer);\n                    break;\n            }\n            rendererByCompId.set(type.id, renderer);\n        }\n        return renderer;\n    }\n    ngOnDestroy() {\n        this.rendererByCompId.clear();\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomRendererFactory2, deps: [{ token: EventManager }, { token: SharedStylesHost }, { token: APP_ID }, { token: REMOVE_STYLES_ON_COMPONENT_DESTROY }, { token: DOCUMENT }, { token: PLATFORM_ID }, { token: i0.NgZone }, { token: CSP_NONCE }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomRendererFactory2 }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomRendererFactory2, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: EventManager }, { type: SharedStylesHost }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [APP_ID]\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [REMOVE_STYLES_ON_COMPONENT_DESTROY]\n                }] }, { type: Document, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: Object, decorators: [{\n                    type: Inject,\n                    args: [PLATFORM_ID]\n                }] }, { type: i0.NgZone }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [CSP_NONCE]\n                }] }] });\nclass DefaultDomRenderer2 {\n    constructor(eventManager, doc, ngZone, platformIsServer) {\n        this.eventManager = eventManager;\n        this.doc = doc;\n        this.ngZone = ngZone;\n        this.platformIsServer = platformIsServer;\n        this.data = Object.create(null);\n        /**\n         * By default this renderer throws when encountering synthetic properties\n         * This can be disabled for example by the AsyncAnimationRendererFactory\n         */\n        this.throwOnSyntheticProps = true;\n        this.destroyNode = null;\n    }\n    destroy() { }\n    createElement(name, namespace) {\n        if (namespace) {\n            // TODO: `|| namespace` was added in\n            // https://github.com/angular/angular/commit/2b9cc8503d48173492c29f5a271b61126104fbdb to\n            // support how Ivy passed around the namespace URI rather than short name at the time. It did\n            // not, however extend the support to other parts of the system (setAttribute, setAttribute,\n            // and the ServerRenderer). We should decide what exactly the semantics for dealing with\n            // namespaces should be and make it consistent.\n            // Related issues:\n            // https://github.com/angular/angular/issues/44028\n            // https://github.com/angular/angular/issues/44883\n            return this.doc.createElementNS(NAMESPACE_URIS[namespace] || namespace, name);\n        }\n        return this.doc.createElement(name);\n    }\n    createComment(value) {\n        return this.doc.createComment(value);\n    }\n    createText(value) {\n        return this.doc.createTextNode(value);\n    }\n    appendChild(parent, newChild) {\n        const targetParent = isTemplateNode(parent) ? parent.content : parent;\n        targetParent.appendChild(newChild);\n    }\n    insertBefore(parent, newChild, refChild) {\n        if (parent) {\n            const targetParent = isTemplateNode(parent) ? parent.content : parent;\n            targetParent.insertBefore(newChild, refChild);\n        }\n    }\n    removeChild(_parent, oldChild) {\n        oldChild.remove();\n    }\n    selectRootElement(selectorOrNode, preserveContent) {\n        let el = typeof selectorOrNode === 'string' ? this.doc.querySelector(selectorOrNode) : selectorOrNode;\n        if (!el) {\n            throw new ɵRuntimeError(-5104 /* RuntimeErrorCode.ROOT_NODE_NOT_FOUND */, (typeof ngDevMode === 'undefined' || ngDevMode) &&\n                `The selector \"${selectorOrNode}\" did not match any elements`);\n        }\n        if (!preserveContent) {\n            el.textContent = '';\n        }\n        return el;\n    }\n    parentNode(node) {\n        return node.parentNode;\n    }\n    nextSibling(node) {\n        return node.nextSibling;\n    }\n    setAttribute(el, name, value, namespace) {\n        if (namespace) {\n            name = namespace + ':' + name;\n            const namespaceUri = NAMESPACE_URIS[namespace];\n            if (namespaceUri) {\n                el.setAttributeNS(namespaceUri, name, value);\n            }\n            else {\n                el.setAttribute(name, value);\n            }\n        }\n        else {\n            el.setAttribute(name, value);\n        }\n    }\n    removeAttribute(el, name, namespace) {\n        if (namespace) {\n            const namespaceUri = NAMESPACE_URIS[namespace];\n            if (namespaceUri) {\n                el.removeAttributeNS(namespaceUri, name);\n            }\n            else {\n                el.removeAttribute(`${namespace}:${name}`);\n            }\n        }\n        else {\n            el.removeAttribute(name);\n        }\n    }\n    addClass(el, name) {\n        el.classList.add(name);\n    }\n    removeClass(el, name) {\n        el.classList.remove(name);\n    }\n    setStyle(el, style, value, flags) {\n        if (flags & (RendererStyleFlags2.DashCase | RendererStyleFlags2.Important)) {\n            el.style.setProperty(style, value, flags & RendererStyleFlags2.Important ? 'important' : '');\n        }\n        else {\n            el.style[style] = value;\n        }\n    }\n    removeStyle(el, style, flags) {\n        if (flags & RendererStyleFlags2.DashCase) {\n            // removeProperty has no effect when used on camelCased properties.\n            el.style.removeProperty(style);\n        }\n        else {\n            el.style[style] = '';\n        }\n    }\n    setProperty(el, name, value) {\n        if (el == null) {\n            return;\n        }\n        (typeof ngDevMode === 'undefined' || ngDevMode) &&\n            this.throwOnSyntheticProps &&\n            checkNoSyntheticProp(name, 'property');\n        el[name] = value;\n    }\n    setValue(node, value) {\n        node.nodeValue = value;\n    }\n    listen(target, event, callback) {\n        (typeof ngDevMode === 'undefined' || ngDevMode) &&\n            this.throwOnSyntheticProps &&\n            checkNoSyntheticProp(event, 'listener');\n        if (typeof target === 'string') {\n            target = ɵgetDOM().getGlobalEventTarget(this.doc, target);\n            if (!target) {\n                throw new Error(`Unsupported event target ${target} for event ${event}`);\n            }\n        }\n        return this.eventManager.addEventListener(target, event, this.decoratePreventDefault(callback));\n    }\n    decoratePreventDefault(eventHandler) {\n        // `DebugNode.triggerEventHandler` needs to know if the listener was created with\n        // decoratePreventDefault or is a listener added outside the Angular context so it can handle\n        // the two differently. In the first case, the special '__ngUnwrap__' token is passed to the\n        // unwrap the listener (see below).\n        return (event) => {\n            // Ivy uses '__ngUnwrap__' as a special token that allows us to unwrap the function\n            // so that it can be invoked programmatically by `DebugNode.triggerEventHandler`. The\n            // debug_node can inspect the listener toString contents for the existence of this special\n            // token. Because the token is a string literal, it is ensured to not be modified by compiled\n            // code.\n            if (event === '__ngUnwrap__') {\n                return eventHandler;\n            }\n            // Run the event handler inside the ngZone because event handlers are not patched\n            // by Zone on the server. This is required only for tests.\n            const allowDefaultBehavior = this.platformIsServer\n                ? this.ngZone.runGuarded(() => eventHandler(event))\n                : eventHandler(event);\n            if (allowDefaultBehavior === false) {\n                event.preventDefault();\n            }\n            return undefined;\n        };\n    }\n}\nconst AT_CHARCODE = (() => '@'.charCodeAt(0))();\nfunction checkNoSyntheticProp(name, nameKind) {\n    if (name.charCodeAt(0) === AT_CHARCODE) {\n        throw new ɵRuntimeError(5105 /* RuntimeErrorCode.UNEXPECTED_SYNTHETIC_PROPERTY */, `Unexpected synthetic ${nameKind} ${name} found. Please make sure that:\n  - Either \\`BrowserAnimationsModule\\` or \\`NoopAnimationsModule\\` are imported in your application.\n  - There is corresponding configuration for the animation named \\`${name}\\` defined in the \\`animations\\` field of the \\`@Component\\` decorator (see https://angular.io/api/core/Component#animations).`);\n    }\n}\nfunction isTemplateNode(node) {\n    return node.tagName === 'TEMPLATE' && node.content !== undefined;\n}\nclass ShadowDomRenderer extends DefaultDomRenderer2 {\n    constructor(eventManager, sharedStylesHost, hostEl, component, doc, ngZone, nonce, platformIsServer) {\n        super(eventManager, doc, ngZone, platformIsServer);\n        this.sharedStylesHost = sharedStylesHost;\n        this.hostEl = hostEl;\n        this.shadowRoot = hostEl.attachShadow({ mode: 'open' });\n        this.sharedStylesHost.addHost(this.shadowRoot);\n        const styles = shimStylesContent(component.id, component.styles);\n        for (const style of styles) {\n            const styleEl = document.createElement('style');\n            if (nonce) {\n                styleEl.setAttribute('nonce', nonce);\n            }\n            styleEl.textContent = style;\n            this.shadowRoot.appendChild(styleEl);\n        }\n    }\n    nodeOrShadowRoot(node) {\n        return node === this.hostEl ? this.shadowRoot : node;\n    }\n    appendChild(parent, newChild) {\n        return super.appendChild(this.nodeOrShadowRoot(parent), newChild);\n    }\n    insertBefore(parent, newChild, refChild) {\n        return super.insertBefore(this.nodeOrShadowRoot(parent), newChild, refChild);\n    }\n    removeChild(_parent, oldChild) {\n        return super.removeChild(null, oldChild);\n    }\n    parentNode(node) {\n        return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(node)));\n    }\n    destroy() {\n        this.sharedStylesHost.removeHost(this.shadowRoot);\n    }\n}\nclass NoneEncapsulationDomRenderer extends DefaultDomRenderer2 {\n    constructor(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, compId) {\n        super(eventManager, doc, ngZone, platformIsServer);\n        this.sharedStylesHost = sharedStylesHost;\n        this.removeStylesOnCompDestroy = removeStylesOnCompDestroy;\n        this.styles = compId ? shimStylesContent(compId, component.styles) : component.styles;\n    }\n    applyStyles() {\n        this.sharedStylesHost.addStyles(this.styles);\n    }\n    destroy() {\n        if (!this.removeStylesOnCompDestroy) {\n            return;\n        }\n        this.sharedStylesHost.removeStyles(this.styles);\n    }\n}\nclass EmulatedEncapsulationDomRenderer2 extends NoneEncapsulationDomRenderer {\n    constructor(eventManager, sharedStylesHost, component, appId, removeStylesOnCompDestroy, doc, ngZone, platformIsServer) {\n        const compId = appId + '-' + component.id;\n        super(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, compId);\n        this.contentAttr = shimContentAttribute(compId);\n        this.hostAttr = shimHostAttribute(compId);\n    }\n    applyToHost(element) {\n        this.applyStyles();\n        this.setAttribute(element, this.hostAttr, '');\n    }\n    createElement(parent, name) {\n        const el = super.createElement(parent, name);\n        super.setAttribute(el, this.contentAttr, '');\n        return el;\n    }\n}\n\nclass DomEventsPlugin extends EventManagerPlugin {\n    constructor(doc) {\n        super(doc);\n    }\n    // This plugin should come last in the list of plugins, because it accepts all\n    // events.\n    supports(eventName) {\n        return true;\n    }\n    addEventListener(element, eventName, handler) {\n        element.addEventListener(eventName, handler, false);\n        return () => this.removeEventListener(element, eventName, handler);\n    }\n    removeEventListener(target, eventName, callback) {\n        return target.removeEventListener(eventName, callback);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomEventsPlugin, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomEventsPlugin }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomEventsPlugin, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }] });\n\n/**\n * Defines supported modifiers for key events.\n */\nconst MODIFIER_KEYS = ['alt', 'control', 'meta', 'shift'];\n// The following values are here for cross-browser compatibility and to match the W3C standard\n// cf https://www.w3.org/TR/DOM-Level-3-Events-key/\nconst _keyMap = {\n    '\\b': 'Backspace',\n    '\\t': 'Tab',\n    '\\x7F': 'Delete',\n    '\\x1B': 'Escape',\n    'Del': 'Delete',\n    'Esc': 'Escape',\n    'Left': 'ArrowLeft',\n    'Right': 'ArrowRight',\n    'Up': 'ArrowUp',\n    'Down': 'ArrowDown',\n    'Menu': 'ContextMenu',\n    'Scroll': 'ScrollLock',\n    'Win': 'OS',\n};\n/**\n * Retrieves modifiers from key-event objects.\n */\nconst MODIFIER_KEY_GETTERS = {\n    'alt': (event) => event.altKey,\n    'control': (event) => event.ctrlKey,\n    'meta': (event) => event.metaKey,\n    'shift': (event) => event.shiftKey,\n};\n/**\n * A browser plug-in that provides support for handling of key events in Angular.\n */\nclass KeyEventsPlugin extends EventManagerPlugin {\n    /**\n     * Initializes an instance of the browser plug-in.\n     * @param doc The document in which key events will be detected.\n     */\n    constructor(doc) {\n        super(doc);\n    }\n    /**\n     * Reports whether a named key event is supported.\n     * @param eventName The event name to query.\n     * @return True if the named key event is supported.\n     */\n    supports(eventName) {\n        return KeyEventsPlugin.parseEventName(eventName) != null;\n    }\n    /**\n     * Registers a handler for a specific element and key event.\n     * @param element The HTML element to receive event notifications.\n     * @param eventName The name of the key event to listen for.\n     * @param handler A function to call when the notification occurs. Receives the\n     * event object as an argument.\n     * @returns The key event that was registered.\n     */\n    addEventListener(element, eventName, handler) {\n        const parsedEvent = KeyEventsPlugin.parseEventName(eventName);\n        const outsideHandler = KeyEventsPlugin.eventCallback(parsedEvent['fullKey'], handler, this.manager.getZone());\n        return this.manager.getZone().runOutsideAngular(() => {\n            return ɵgetDOM().onAndCancel(element, parsedEvent['domEventName'], outsideHandler);\n        });\n    }\n    /**\n     * Parses the user provided full keyboard event definition and normalizes it for\n     * later internal use. It ensures the string is all lowercase, converts special\n     * characters to a standard spelling, and orders all the values consistently.\n     *\n     * @param eventName The name of the key event to listen for.\n     * @returns an object with the full, normalized string, and the dom event name\n     * or null in the case when the event doesn't match a keyboard event.\n     */\n    static parseEventName(eventName) {\n        const parts = eventName.toLowerCase().split('.');\n        const domEventName = parts.shift();\n        if (parts.length === 0 || !(domEventName === 'keydown' || domEventName === 'keyup')) {\n            return null;\n        }\n        const key = KeyEventsPlugin._normalizeKey(parts.pop());\n        let fullKey = '';\n        let codeIX = parts.indexOf('code');\n        if (codeIX > -1) {\n            parts.splice(codeIX, 1);\n            fullKey = 'code.';\n        }\n        MODIFIER_KEYS.forEach((modifierName) => {\n            const index = parts.indexOf(modifierName);\n            if (index > -1) {\n                parts.splice(index, 1);\n                fullKey += modifierName + '.';\n            }\n        });\n        fullKey += key;\n        if (parts.length != 0 || key.length === 0) {\n            // returning null instead of throwing to let another plugin process the event\n            return null;\n        }\n        // NOTE: Please don't rewrite this as so, as it will break JSCompiler property renaming.\n        //       The code must remain in the `result['domEventName']` form.\n        // return {domEventName, fullKey};\n        const result = {};\n        result['domEventName'] = domEventName;\n        result['fullKey'] = fullKey;\n        return result;\n    }\n    /**\n     * Determines whether the actual keys pressed match the configured key code string.\n     * The `fullKeyCode` event is normalized in the `parseEventName` method when the\n     * event is attached to the DOM during the `addEventListener` call. This is unseen\n     * by the end user and is normalized for internal consistency and parsing.\n     *\n     * @param event The keyboard event.\n     * @param fullKeyCode The normalized user defined expected key event string\n     * @returns boolean.\n     */\n    static matchEventFullKeyCode(event, fullKeyCode) {\n        let keycode = _keyMap[event.key] || event.key;\n        let key = '';\n        if (fullKeyCode.indexOf('code.') > -1) {\n            keycode = event.code;\n            key = 'code.';\n        }\n        // the keycode could be unidentified so we have to check here\n        if (keycode == null || !keycode)\n            return false;\n        keycode = keycode.toLowerCase();\n        if (keycode === ' ') {\n            keycode = 'space'; // for readability\n        }\n        else if (keycode === '.') {\n            keycode = 'dot'; // because '.' is used as a separator in event names\n        }\n        MODIFIER_KEYS.forEach((modifierName) => {\n            if (modifierName !== keycode) {\n                const modifierGetter = MODIFIER_KEY_GETTERS[modifierName];\n                if (modifierGetter(event)) {\n                    key += modifierName + '.';\n                }\n            }\n        });\n        key += keycode;\n        return key === fullKeyCode;\n    }\n    /**\n     * Configures a handler callback for a key event.\n     * @param fullKey The event name that combines all simultaneous keystrokes.\n     * @param handler The function that responds to the key event.\n     * @param zone The zone in which the event occurred.\n     * @returns A callback function.\n     */\n    static eventCallback(fullKey, handler, zone) {\n        return (event) => {\n            if (KeyEventsPlugin.matchEventFullKeyCode(event, fullKey)) {\n                zone.runGuarded(() => handler(event));\n            }\n        };\n    }\n    /** @internal */\n    static _normalizeKey(keyName) {\n        return keyName === 'esc' ? 'escape' : keyName;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: KeyEventsPlugin, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: KeyEventsPlugin }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: KeyEventsPlugin, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }] });\n\n/**\n * Bootstraps an instance of an Angular application and renders a standalone component as the\n * application's root component. More information about standalone components can be found in [this\n * guide](guide/components/importing).\n *\n * @usageNotes\n * The root component passed into this function *must* be a standalone one (should have the\n * `standalone: true` flag in the `@Component` decorator config).\n *\n * ```typescript\n * @Component({\n *   standalone: true,\n *   template: 'Hello world!'\n * })\n * class RootComponent {}\n *\n * const appRef: ApplicationRef = await bootstrapApplication(RootComponent);\n * ```\n *\n * You can add the list of providers that should be available in the application injector by\n * specifying the `providers` field in an object passed as the second argument:\n *\n * ```typescript\n * await bootstrapApplication(RootComponent, {\n *   providers: [\n *     {provide: BACKEND_URL, useValue: 'https://yourdomain.com/api'}\n *   ]\n * });\n * ```\n *\n * The `importProvidersFrom` helper method can be used to collect all providers from any\n * existing NgModule (and transitively from all NgModules that it imports):\n *\n * ```typescript\n * await bootstrapApplication(RootComponent, {\n *   providers: [\n *     importProvidersFrom(SomeNgModule)\n *   ]\n * });\n * ```\n *\n * Note: the `bootstrapApplication` method doesn't include [Testability](api/core/Testability) by\n * default. You can add [Testability](api/core/Testability) by getting the list of necessary\n * providers using `provideProtractorTestingSupport()` function and adding them into the `providers`\n * array, for example:\n *\n * ```typescript\n * import {provideProtractorTestingSupport} from '@angular/platform-browser';\n *\n * await bootstrapApplication(RootComponent, {providers: [provideProtractorTestingSupport()]});\n * ```\n *\n * @param rootComponent A reference to a standalone component that should be rendered.\n * @param options Extra configuration for the bootstrap operation, see `ApplicationConfig` for\n *     additional info.\n * @returns A promise that returns an `ApplicationRef` instance once resolved.\n *\n * @publicApi\n */\nfunction bootstrapApplication(rootComponent, options) {\n    return ɵinternalCreateApplication({ rootComponent, ...createProvidersConfig(options) });\n}\n/**\n * Create an instance of an Angular application without bootstrapping any components. This is useful\n * for the situation where one wants to decouple application environment creation (a platform and\n * associated injectors) from rendering components on a screen. Components can be subsequently\n * bootstrapped on the returned `ApplicationRef`.\n *\n * @param options Extra configuration for the application environment, see `ApplicationConfig` for\n *     additional info.\n * @returns A promise that returns an `ApplicationRef` instance once resolved.\n *\n * @publicApi\n */\nfunction createApplication(options) {\n    return ɵinternalCreateApplication(createProvidersConfig(options));\n}\nfunction createProvidersConfig(options) {\n    return {\n        appProviders: [...BROWSER_MODULE_PROVIDERS, ...(options?.providers ?? [])],\n        platformProviders: INTERNAL_BROWSER_PLATFORM_PROVIDERS,\n    };\n}\n/**\n * Returns a set of providers required to setup [Testability](api/core/Testability) for an\n * application bootstrapped using the `bootstrapApplication` function. The set of providers is\n * needed to support testing an application with Protractor (which relies on the Testability APIs\n * to be present).\n *\n * @returns An array of providers required to setup Testability for an application and make it\n *     available for testing using Protractor.\n *\n * @publicApi\n */\nfunction provideProtractorTestingSupport() {\n    // Return a copy to prevent changes to the original array in case any in-place\n    // alterations are performed to the `provideProtractorTestingSupport` call results in app\n    // code.\n    return [...TESTABILITY_PROVIDERS];\n}\nfunction initDomAdapter() {\n    BrowserDomAdapter.makeCurrent();\n}\nfunction errorHandler() {\n    return new ErrorHandler();\n}\nfunction _document() {\n    // Tell ivy about the global document\n    ɵsetDocument(document);\n    return document;\n}\nconst INTERNAL_BROWSER_PLATFORM_PROVIDERS = [\n    { provide: PLATFORM_ID, useValue: ɵPLATFORM_BROWSER_ID },\n    { provide: PLATFORM_INITIALIZER, useValue: initDomAdapter, multi: true },\n    { provide: DOCUMENT, useFactory: _document, deps: [] },\n];\n/**\n * A factory function that returns a `PlatformRef` instance associated with browser service\n * providers.\n *\n * @publicApi\n */\nconst platformBrowser = createPlatformFactory(platformCore, 'browser', INTERNAL_BROWSER_PLATFORM_PROVIDERS);\n/**\n * Internal marker to signal whether providers from the `BrowserModule` are already present in DI.\n * This is needed to avoid loading `BrowserModule` providers twice. We can't rely on the\n * `BrowserModule` presence itself, since the standalone-based bootstrap just imports\n * `BrowserModule` providers without referencing the module itself.\n */\nconst BROWSER_MODULE_PROVIDERS_MARKER = new InjectionToken(typeof ngDevMode === 'undefined' || ngDevMode ? 'BrowserModule Providers Marker' : '');\nconst TESTABILITY_PROVIDERS = [\n    {\n        provide: ɵTESTABILITY_GETTER,\n        useClass: BrowserGetTestability,\n        deps: [],\n    },\n    {\n        provide: ɵTESTABILITY,\n        useClass: Testability,\n        deps: [NgZone, TestabilityRegistry, ɵTESTABILITY_GETTER],\n    },\n    {\n        provide: Testability, // Also provide as `Testability` for backwards-compatibility.\n        useClass: Testability,\n        deps: [NgZone, TestabilityRegistry, ɵTESTABILITY_GETTER],\n    },\n];\nconst BROWSER_MODULE_PROVIDERS = [\n    { provide: ɵINJECTOR_SCOPE, useValue: 'root' },\n    { provide: ErrorHandler, useFactory: errorHandler, deps: [] },\n    {\n        provide: EVENT_MANAGER_PLUGINS,\n        useClass: DomEventsPlugin,\n        multi: true,\n        deps: [DOCUMENT, NgZone, PLATFORM_ID],\n    },\n    { provide: EVENT_MANAGER_PLUGINS, useClass: KeyEventsPlugin, multi: true, deps: [DOCUMENT] },\n    DomRendererFactory2,\n    SharedStylesHost,\n    EventManager,\n    { provide: RendererFactory2, useExisting: DomRendererFactory2 },\n    { provide: XhrFactory, useClass: BrowserXhr, deps: [] },\n    typeof ngDevMode === 'undefined' || ngDevMode\n        ? { provide: BROWSER_MODULE_PROVIDERS_MARKER, useValue: true }\n        : [],\n];\n/**\n * Exports required infrastructure for all Angular apps.\n * Included by default in all Angular apps created with the CLI\n * `new` command.\n * Re-exports `CommonModule` and `ApplicationModule`, making their\n * exports and providers available to all apps.\n *\n * @publicApi\n */\nclass BrowserModule {\n    constructor(providersAlreadyPresent) {\n        if ((typeof ngDevMode === 'undefined' || ngDevMode) && providersAlreadyPresent) {\n            throw new ɵRuntimeError(5100 /* RuntimeErrorCode.BROWSER_MODULE_ALREADY_LOADED */, `Providers from the \\`BrowserModule\\` have already been loaded. If you need access ` +\n                `to common directives such as NgIf and NgFor, import the \\`CommonModule\\` instead.`);\n        }\n    }\n    /**\n     * Configures a browser-based app to transition from a server-rendered app, if\n     * one is present on the page.\n     *\n     * @param params An object containing an identifier for the app to transition.\n     * The ID must match between the client and server versions of the app.\n     * @returns The reconfigured `BrowserModule` to import into the app's root `AppModule`.\n     *\n     * @deprecated Use {@link APP_ID} instead to set the application ID.\n     */\n    static withServerTransition(params) {\n        return {\n            ngModule: BrowserModule,\n            providers: [{ provide: APP_ID, useValue: params.appId }],\n        };\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: BrowserModule, deps: [{ token: BROWSER_MODULE_PROVIDERS_MARKER, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"18.2.13\", ngImport: i0, type: BrowserModule, exports: [CommonModule, ApplicationModule] }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: BrowserModule, providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS], imports: [CommonModule, ApplicationModule] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: BrowserModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS],\n                    exports: [CommonModule, ApplicationModule],\n                }]\n        }], ctorParameters: () => [{ type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: SkipSelf\n                }, {\n                    type: Inject,\n                    args: [BROWSER_MODULE_PROVIDERS_MARKER]\n                }] }] });\n\n/**\n * A service for managing HTML `<meta>` tags.\n *\n * Properties of the `MetaDefinition` object match the attributes of the\n * HTML `<meta>` tag. These tags define document metadata that is important for\n * things like configuring a Content Security Policy, defining browser compatibility\n * and security settings, setting HTTP Headers, defining rich content for social sharing,\n * and Search Engine Optimization (SEO).\n *\n * To identify specific `<meta>` tags in a document, use an attribute selection\n * string in the format `\"tag_attribute='value string'\"`.\n * For example, an `attrSelector` value of `\"name='description'\"` matches a tag\n * whose `name` attribute has the value `\"description\"`.\n * Selectors are used with the `querySelector()` Document method,\n * in the format `meta[{attrSelector}]`.\n *\n * @see [HTML meta tag](https://developer.mozilla.org/docs/Web/HTML/Element/meta)\n * @see [Document.querySelector()](https://developer.mozilla.org/docs/Web/API/Document/querySelector)\n *\n *\n * @publicApi\n */\nclass Meta {\n    constructor(_doc) {\n        this._doc = _doc;\n        this._dom = ɵgetDOM();\n    }\n    /**\n     * Retrieves or creates a specific `<meta>` tag element in the current HTML document.\n     * In searching for an existing tag, Angular attempts to match the `name` or `property` attribute\n     * values in the provided tag definition, and verifies that all other attribute values are equal.\n     * If an existing element is found, it is returned and is not modified in any way.\n     * @param tag The definition of a `<meta>` element to match or create.\n     * @param forceCreation True to create a new element without checking whether one already exists.\n     * @returns The existing element with the same attributes and values if found,\n     * the new element if no match is found, or `null` if the tag parameter is not defined.\n     */\n    addTag(tag, forceCreation = false) {\n        if (!tag)\n            return null;\n        return this._getOrCreateElement(tag, forceCreation);\n    }\n    /**\n     * Retrieves or creates a set of `<meta>` tag elements in the current HTML document.\n     * In searching for an existing tag, Angular attempts to match the `name` or `property` attribute\n     * values in the provided tag definition, and verifies that all other attribute values are equal.\n     * @param tags An array of tag definitions to match or create.\n     * @param forceCreation True to create new elements without checking whether they already exist.\n     * @returns The matching elements if found, or the new elements.\n     */\n    addTags(tags, forceCreation = false) {\n        if (!tags)\n            return [];\n        return tags.reduce((result, tag) => {\n            if (tag) {\n                result.push(this._getOrCreateElement(tag, forceCreation));\n            }\n            return result;\n        }, []);\n    }\n    /**\n     * Retrieves a `<meta>` tag element in the current HTML document.\n     * @param attrSelector The tag attribute and value to match against, in the format\n     * `\"tag_attribute='value string'\"`.\n     * @returns The matching element, if any.\n     */\n    getTag(attrSelector) {\n        if (!attrSelector)\n            return null;\n        return this._doc.querySelector(`meta[${attrSelector}]`) || null;\n    }\n    /**\n     * Retrieves a set of `<meta>` tag elements in the current HTML document.\n     * @param attrSelector The tag attribute and value to match against, in the format\n     * `\"tag_attribute='value string'\"`.\n     * @returns The matching elements, if any.\n     */\n    getTags(attrSelector) {\n        if (!attrSelector)\n            return [];\n        const list /*NodeList*/ = this._doc.querySelectorAll(`meta[${attrSelector}]`);\n        return list ? [].slice.call(list) : [];\n    }\n    /**\n     * Modifies an existing `<meta>` tag element in the current HTML document.\n     * @param tag The tag description with which to replace the existing tag content.\n     * @param selector A tag attribute and value to match against, to identify\n     * an existing tag. A string in the format `\"tag_attribute=`value string`\"`.\n     * If not supplied, matches a tag with the same `name` or `property` attribute value as the\n     * replacement tag.\n     * @return The modified element.\n     */\n    updateTag(tag, selector) {\n        if (!tag)\n            return null;\n        selector = selector || this._parseSelector(tag);\n        const meta = this.getTag(selector);\n        if (meta) {\n            return this._setMetaElementAttributes(tag, meta);\n        }\n        return this._getOrCreateElement(tag, true);\n    }\n    /**\n     * Removes an existing `<meta>` tag element from the current HTML document.\n     * @param attrSelector A tag attribute and value to match against, to identify\n     * an existing tag. A string in the format `\"tag_attribute=`value string`\"`.\n     */\n    removeTag(attrSelector) {\n        this.removeTagElement(this.getTag(attrSelector));\n    }\n    /**\n     * Removes an existing `<meta>` tag element from the current HTML document.\n     * @param meta The tag definition to match against to identify an existing tag.\n     */\n    removeTagElement(meta) {\n        if (meta) {\n            this._dom.remove(meta);\n        }\n    }\n    _getOrCreateElement(meta, forceCreation = false) {\n        if (!forceCreation) {\n            const selector = this._parseSelector(meta);\n            // It's allowed to have multiple elements with the same name so it's not enough to\n            // just check that element with the same name already present on the page. We also need to\n            // check if element has tag attributes\n            const elem = this.getTags(selector).filter((elem) => this._containsAttributes(meta, elem))[0];\n            if (elem !== undefined)\n                return elem;\n        }\n        const element = this._dom.createElement('meta');\n        this._setMetaElementAttributes(meta, element);\n        const head = this._doc.getElementsByTagName('head')[0];\n        head.appendChild(element);\n        return element;\n    }\n    _setMetaElementAttributes(tag, el) {\n        Object.keys(tag).forEach((prop) => el.setAttribute(this._getMetaKeyMap(prop), tag[prop]));\n        return el;\n    }\n    _parseSelector(tag) {\n        const attr = tag.name ? 'name' : 'property';\n        return `${attr}=\"${tag[attr]}\"`;\n    }\n    _containsAttributes(tag, elem) {\n        return Object.keys(tag).every((key) => elem.getAttribute(this._getMetaKeyMap(key)) === tag[key]);\n    }\n    _getMetaKeyMap(prop) {\n        return META_KEYS_MAP[prop] || prop;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: Meta, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: Meta, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: Meta, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: () => [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }] });\n/**\n * Mapping for MetaDefinition properties with their correct meta attribute names\n */\nconst META_KEYS_MAP = {\n    httpEquiv: 'http-equiv',\n};\n\n/**\n * A service that can be used to get and set the title of a current HTML document.\n *\n * Since an Angular application can't be bootstrapped on the entire HTML document (`<html>` tag)\n * it is not possible to bind to the `text` property of the `HTMLTitleElement` elements\n * (representing the `<title>` tag). Instead, this service can be used to set and get the current\n * title value.\n *\n * @publicApi\n */\nclass Title {\n    constructor(_doc) {\n        this._doc = _doc;\n    }\n    /**\n     * Get the title of the current HTML document.\n     */\n    getTitle() {\n        return this._doc.title;\n    }\n    /**\n     * Set the title of the current HTML document.\n     * @param newTitle\n     */\n    setTitle(newTitle) {\n        this._doc.title = newTitle || '';\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: Title, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: Title, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: Title, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: () => [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }] });\n\n/**\n * Exports the value under a given `name` in the global property `ng`. For example `ng.probe` if\n * `name` is `'probe'`.\n * @param name Name under which it will be exported. Keep in mind this will be a property of the\n * global `ng` object.\n * @param value The value to export.\n */\nfunction exportNgVar(name, value) {\n    if (typeof COMPILED === 'undefined' || !COMPILED) {\n        // Note: we can't export `ng` when using closure enhanced optimization as:\n        // - closure declares globals itself for minified names, which sometimes clobber our `ng` global\n        // - we can't declare a closure extern as the namespace `ng` is already used within Google\n        //   for typings for angularJS (via `goog.provide('ng....')`).\n        const ng = (ɵglobal['ng'] = ɵglobal['ng'] || {});\n        ng[name] = value;\n    }\n}\n\nclass ChangeDetectionPerfRecord {\n    constructor(msPerTick, numTicks) {\n        this.msPerTick = msPerTick;\n        this.numTicks = numTicks;\n    }\n}\n/**\n * Entry point for all Angular profiling-related debug tools. This object\n * corresponds to the `ng.profiler` in the dev console.\n */\nclass AngularProfiler {\n    constructor(ref) {\n        this.appRef = ref.injector.get(ApplicationRef);\n    }\n    // tslint:disable:no-console\n    /**\n     * Exercises change detection in a loop and then prints the average amount of\n     * time in milliseconds how long a single round of change detection takes for\n     * the current state of the UI. It runs a minimum of 5 rounds for a minimum\n     * of 500 milliseconds.\n     *\n     * Optionally, a user may pass a `config` parameter containing a map of\n     * options. Supported options are:\n     *\n     * `record` (boolean) - causes the profiler to record a CPU profile while\n     * it exercises the change detector. Example:\n     *\n     * ```\n     * ng.profiler.timeChangeDetection({record: true})\n     * ```\n     */\n    timeChangeDetection(config) {\n        const record = config && config['record'];\n        const profileName = 'Change Detection';\n        // Profiler is not available in Android browsers without dev tools opened\n        if (record && 'profile' in console && typeof console.profile === 'function') {\n            console.profile(profileName);\n        }\n        const start = performance.now();\n        let numTicks = 0;\n        while (numTicks < 5 || performance.now() - start < 500) {\n            this.appRef.tick();\n            numTicks++;\n        }\n        const end = performance.now();\n        if (record && 'profileEnd' in console && typeof console.profileEnd === 'function') {\n            console.profileEnd(profileName);\n        }\n        const msPerTick = (end - start) / numTicks;\n        console.log(`ran ${numTicks} change detection cycles`);\n        console.log(`${msPerTick.toFixed(2)} ms per check`);\n        return new ChangeDetectionPerfRecord(msPerTick, numTicks);\n    }\n}\n\nconst PROFILER_GLOBAL_NAME = 'profiler';\n/**\n * Enabled Angular debug tools that are accessible via your browser's\n * developer console.\n *\n * Usage:\n *\n * 1. Open developer console (e.g. in Chrome Ctrl + Shift + j)\n * 1. Type `ng.` (usually the console will show auto-complete suggestion)\n * 1. Try the change detection profiler `ng.profiler.timeChangeDetection()`\n *    then hit Enter.\n *\n * @publicApi\n */\nfunction enableDebugTools(ref) {\n    exportNgVar(PROFILER_GLOBAL_NAME, new AngularProfiler(ref));\n    return ref;\n}\n/**\n * Disables Angular tools.\n *\n * @publicApi\n */\nfunction disableDebugTools() {\n    exportNgVar(PROFILER_GLOBAL_NAME, null);\n}\n\n/**\n * Predicates for use with {@link DebugElement}'s query functions.\n *\n * @publicApi\n */\nclass By {\n    /**\n     * Match all nodes.\n     *\n     * @usageNotes\n     * ### Example\n     *\n     * {@example platform-browser/dom/debug/ts/by/by.ts region='by_all'}\n     */\n    static all() {\n        return () => true;\n    }\n    /**\n     * Match elements by the given CSS selector.\n     *\n     * @usageNotes\n     * ### Example\n     *\n     * {@example platform-browser/dom/debug/ts/by/by.ts region='by_css'}\n     */\n    static css(selector) {\n        return (debugElement) => {\n            return debugElement.nativeElement != null\n                ? elementMatches(debugElement.nativeElement, selector)\n                : false;\n        };\n    }\n    /**\n     * Match nodes that have the given directive present.\n     *\n     * @usageNotes\n     * ### Example\n     *\n     * {@example platform-browser/dom/debug/ts/by/by.ts region='by_directive'}\n     */\n    static directive(type) {\n        return (debugNode) => debugNode.providerTokens.indexOf(type) !== -1;\n    }\n}\nfunction elementMatches(n, selector) {\n    if (ɵgetDOM().isElementNode(n)) {\n        return ((n.matches && n.matches(selector)) ||\n            (n.msMatchesSelector && n.msMatchesSelector(selector)) ||\n            (n.webkitMatchesSelector && n.webkitMatchesSelector(selector)));\n    }\n    return false;\n}\n\n/**\n * Supported HammerJS recognizer event names.\n */\nconst EVENT_NAMES = {\n    // pan\n    'pan': true,\n    'panstart': true,\n    'panmove': true,\n    'panend': true,\n    'pancancel': true,\n    'panleft': true,\n    'panright': true,\n    'panup': true,\n    'pandown': true,\n    // pinch\n    'pinch': true,\n    'pinchstart': true,\n    'pinchmove': true,\n    'pinchend': true,\n    'pinchcancel': true,\n    'pinchin': true,\n    'pinchout': true,\n    // press\n    'press': true,\n    'pressup': true,\n    // rotate\n    'rotate': true,\n    'rotatestart': true,\n    'rotatemove': true,\n    'rotateend': true,\n    'rotatecancel': true,\n    // swipe\n    'swipe': true,\n    'swipeleft': true,\n    'swiperight': true,\n    'swipeup': true,\n    'swipedown': true,\n    // tap\n    'tap': true,\n    'doubletap': true,\n};\n/**\n * DI token for providing [HammerJS](https://hammerjs.github.io/) support to Angular.\n * @see {@link HammerGestureConfig}\n *\n * @ngModule HammerModule\n * @publicApi\n */\nconst HAMMER_GESTURE_CONFIG = new InjectionToken('HammerGestureConfig');\n/**\n * Injection token used to provide a HammerLoader to Angular.\n *\n * @see {@link HammerLoader}\n *\n * @publicApi\n */\nconst HAMMER_LOADER = new InjectionToken('HammerLoader');\n/**\n * An injectable [HammerJS Manager](https://hammerjs.github.io/api/#hammermanager)\n * for gesture recognition. Configures specific event recognition.\n * @publicApi\n */\nclass HammerGestureConfig {\n    constructor() {\n        /**\n         * A set of supported event names for gestures to be used in Angular.\n         * Angular supports all built-in recognizers, as listed in\n         * [HammerJS documentation](https://hammerjs.github.io/).\n         */\n        this.events = [];\n        /**\n         * Maps gesture event names to a set of configuration options\n         * that specify overrides to the default values for specific properties.\n         *\n         * The key is a supported event name to be configured,\n         * and the options object contains a set of properties, with override values\n         * to be applied to the named recognizer event.\n         * For example, to disable recognition of the rotate event, specify\n         *  `{\"rotate\": {\"enable\": false}}`.\n         *\n         * Properties that are not present take the HammerJS default values.\n         * For information about which properties are supported for which events,\n         * and their allowed and default values, see\n         * [HammerJS documentation](https://hammerjs.github.io/).\n         *\n         */\n        this.overrides = {};\n    }\n    /**\n     * Creates a [HammerJS Manager](https://hammerjs.github.io/api/#hammermanager)\n     * and attaches it to a given HTML element.\n     * @param element The element that will recognize gestures.\n     * @returns A HammerJS event-manager object.\n     */\n    buildHammer(element) {\n        const mc = new Hammer(element, this.options);\n        mc.get('pinch').set({ enable: true });\n        mc.get('rotate').set({ enable: true });\n        for (const eventName in this.overrides) {\n            mc.get(eventName).set(this.overrides[eventName]);\n        }\n        return mc;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HammerGestureConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HammerGestureConfig }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HammerGestureConfig, decorators: [{\n            type: Injectable\n        }] });\n/**\n * Event plugin that adds Hammer support to an application.\n *\n * @ngModule HammerModule\n */\nclass HammerGesturesPlugin extends EventManagerPlugin {\n    constructor(doc, _config, console, loader) {\n        super(doc);\n        this._config = _config;\n        this.console = console;\n        this.loader = loader;\n        this._loaderPromise = null;\n    }\n    supports(eventName) {\n        if (!EVENT_NAMES.hasOwnProperty(eventName.toLowerCase()) && !this.isCustomEvent(eventName)) {\n            return false;\n        }\n        if (!window.Hammer && !this.loader) {\n            if (typeof ngDevMode === 'undefined' || ngDevMode) {\n                this.console.warn(`The \"${eventName}\" event cannot be bound because Hammer.JS is not ` +\n                    `loaded and no custom loader has been specified.`);\n            }\n            return false;\n        }\n        return true;\n    }\n    addEventListener(element, eventName, handler) {\n        const zone = this.manager.getZone();\n        eventName = eventName.toLowerCase();\n        // If Hammer is not present but a loader is specified, we defer adding the event listener\n        // until Hammer is loaded.\n        if (!window.Hammer && this.loader) {\n            this._loaderPromise = this._loaderPromise || zone.runOutsideAngular(() => this.loader());\n            // This `addEventListener` method returns a function to remove the added listener.\n            // Until Hammer is loaded, the returned function needs to *cancel* the registration rather\n            // than remove anything.\n            let cancelRegistration = false;\n            let deregister = () => {\n                cancelRegistration = true;\n            };\n            zone.runOutsideAngular(() => this._loaderPromise.then(() => {\n                // If Hammer isn't actually loaded when the custom loader resolves, give up.\n                if (!window.Hammer) {\n                    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n                        this.console.warn(`The custom HAMMER_LOADER completed, but Hammer.JS is not present.`);\n                    }\n                    deregister = () => { };\n                    return;\n                }\n                if (!cancelRegistration) {\n                    // Now that Hammer is loaded and the listener is being loaded for real,\n                    // the deregistration function changes from canceling registration to\n                    // removal.\n                    deregister = this.addEventListener(element, eventName, handler);\n                }\n            }).catch(() => {\n                if (typeof ngDevMode === 'undefined' || ngDevMode) {\n                    this.console.warn(`The \"${eventName}\" event cannot be bound because the custom ` +\n                        `Hammer.JS loader failed.`);\n                }\n                deregister = () => { };\n            }));\n            // Return a function that *executes* `deregister` (and not `deregister` itself) so that we\n            // can change the behavior of `deregister` once the listener is added. Using a closure in\n            // this way allows us to avoid any additional data structures to track listener removal.\n            return () => {\n                deregister();\n            };\n        }\n        return zone.runOutsideAngular(() => {\n            // Creating the manager bind events, must be done outside of angular\n            const mc = this._config.buildHammer(element);\n            const callback = function (eventObj) {\n                zone.runGuarded(function () {\n                    handler(eventObj);\n                });\n            };\n            mc.on(eventName, callback);\n            return () => {\n                mc.off(eventName, callback);\n                // destroy mc to prevent memory leak\n                if (typeof mc.destroy === 'function') {\n                    mc.destroy();\n                }\n            };\n        });\n    }\n    isCustomEvent(eventName) {\n        return this._config.events.indexOf(eventName) > -1;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HammerGesturesPlugin, deps: [{ token: DOCUMENT }, { token: HAMMER_GESTURE_CONFIG }, { token: i0.ɵConsole }, { token: HAMMER_LOADER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HammerGesturesPlugin }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HammerGesturesPlugin, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: HammerGestureConfig, decorators: [{\n                    type: Inject,\n                    args: [HAMMER_GESTURE_CONFIG]\n                }] }, { type: i0.ɵConsole }, { type: undefined, decorators: [{\n                    type: Optional\n                }, {\n                    type: Inject,\n                    args: [HAMMER_LOADER]\n                }] }] });\n/**\n * Adds support for HammerJS.\n *\n * Import this module at the root of your application so that Angular can work with\n * HammerJS to detect gesture events.\n *\n * Note that applications still need to include the HammerJS script itself. This module\n * simply sets up the coordination layer between HammerJS and Angular's `EventManager`.\n *\n * @publicApi\n */\nclass HammerModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HammerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"18.2.13\", ngImport: i0, type: HammerModule }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HammerModule, providers: [\n            {\n                provide: EVENT_MANAGER_PLUGINS,\n                useClass: HammerGesturesPlugin,\n                multi: true,\n                deps: [DOCUMENT, HAMMER_GESTURE_CONFIG, ɵConsole, [new Optional(), HAMMER_LOADER]],\n            },\n            { provide: HAMMER_GESTURE_CONFIG, useClass: HammerGestureConfig, deps: [] },\n        ] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HammerModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    providers: [\n                        {\n                            provide: EVENT_MANAGER_PLUGINS,\n                            useClass: HammerGesturesPlugin,\n                            multi: true,\n                            deps: [DOCUMENT, HAMMER_GESTURE_CONFIG, ɵConsole, [new Optional(), HAMMER_LOADER]],\n                        },\n                        { provide: HAMMER_GESTURE_CONFIG, useClass: HammerGestureConfig, deps: [] },\n                    ],\n                }]\n        }] });\n\n/**\n * DomSanitizer helps preventing Cross Site Scripting Security bugs (XSS) by sanitizing\n * values to be safe to use in the different DOM contexts.\n *\n * For example, when binding a URL in an `<a [href]=\"someValue\">` hyperlink, `someValue` will be\n * sanitized so that an attacker cannot inject e.g. a `javascript:` URL that would execute code on\n * the website.\n *\n * In specific situations, it might be necessary to disable sanitization, for example if the\n * application genuinely needs to produce a `javascript:` style link with a dynamic value in it.\n * Users can bypass security by constructing a value with one of the `bypassSecurityTrust...`\n * methods, and then binding to that value from the template.\n *\n * These situations should be very rare, and extraordinary care must be taken to avoid creating a\n * Cross Site Scripting (XSS) security bug!\n *\n * When using `bypassSecurityTrust...`, make sure to call the method as early as possible and as\n * close as possible to the source of the value, to make it easy to verify no security bug is\n * created by its use.\n *\n * It is not required (and not recommended) to bypass security if the value is safe, e.g. a URL that\n * does not start with a suspicious protocol, or an HTML snippet that does not contain dangerous\n * code. The sanitizer leaves safe values intact.\n *\n * @security Calling any of the `bypassSecurityTrust...` APIs disables Angular's built-in\n * sanitization for the value passed in. Carefully check and audit all values and code paths going\n * into this call. Make sure any user data is appropriately escaped for this security context.\n * For more detail, see the [Security Guide](https://g.co/ng/security).\n *\n * @publicApi\n */\nclass DomSanitizer {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomSanitizer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomSanitizer, providedIn: 'root', useExisting: i0.forwardRef(() => DomSanitizerImpl) }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomSanitizer, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root', useExisting: forwardRef(() => DomSanitizerImpl) }]\n        }] });\nclass DomSanitizerImpl extends DomSanitizer {\n    constructor(_doc) {\n        super();\n        this._doc = _doc;\n    }\n    sanitize(ctx, value) {\n        if (value == null)\n            return null;\n        switch (ctx) {\n            case SecurityContext.NONE:\n                return value;\n            case SecurityContext.HTML:\n                if (ɵallowSanitizationBypassAndThrow(value, \"HTML\" /* BypassType.Html */)) {\n                    return ɵunwrapSafeValue(value);\n                }\n                return ɵ_sanitizeHtml(this._doc, String(value)).toString();\n            case SecurityContext.STYLE:\n                if (ɵallowSanitizationBypassAndThrow(value, \"Style\" /* BypassType.Style */)) {\n                    return ɵunwrapSafeValue(value);\n                }\n                return value;\n            case SecurityContext.SCRIPT:\n                if (ɵallowSanitizationBypassAndThrow(value, \"Script\" /* BypassType.Script */)) {\n                    return ɵunwrapSafeValue(value);\n                }\n                throw new ɵRuntimeError(5200 /* RuntimeErrorCode.SANITIZATION_UNSAFE_SCRIPT */, (typeof ngDevMode === 'undefined' || ngDevMode) &&\n                    'unsafe value used in a script context');\n            case SecurityContext.URL:\n                if (ɵallowSanitizationBypassAndThrow(value, \"URL\" /* BypassType.Url */)) {\n                    return ɵunwrapSafeValue(value);\n                }\n                return ɵ_sanitizeUrl(String(value));\n            case SecurityContext.RESOURCE_URL:\n                if (ɵallowSanitizationBypassAndThrow(value, \"ResourceURL\" /* BypassType.ResourceUrl */)) {\n                    return ɵunwrapSafeValue(value);\n                }\n                throw new ɵRuntimeError(5201 /* RuntimeErrorCode.SANITIZATION_UNSAFE_RESOURCE_URL */, (typeof ngDevMode === 'undefined' || ngDevMode) &&\n                    `unsafe value used in a resource URL context (see ${ɵXSS_SECURITY_URL})`);\n            default:\n                throw new ɵRuntimeError(5202 /* RuntimeErrorCode.SANITIZATION_UNEXPECTED_CTX */, (typeof ngDevMode === 'undefined' || ngDevMode) &&\n                    `Unexpected SecurityContext ${ctx} (see ${ɵXSS_SECURITY_URL})`);\n        }\n    }\n    bypassSecurityTrustHtml(value) {\n        return ɵbypassSanitizationTrustHtml(value);\n    }\n    bypassSecurityTrustStyle(value) {\n        return ɵbypassSanitizationTrustStyle(value);\n    }\n    bypassSecurityTrustScript(value) {\n        return ɵbypassSanitizationTrustScript(value);\n    }\n    bypassSecurityTrustUrl(value) {\n        return ɵbypassSanitizationTrustUrl(value);\n    }\n    bypassSecurityTrustResourceUrl(value) {\n        return ɵbypassSanitizationTrustResourceUrl(value);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomSanitizerImpl, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomSanitizerImpl, providedIn: 'root' }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: DomSanitizerImpl, decorators: [{\n            type: Injectable,\n            args: [{ providedIn: 'root' }]\n        }], ctorParameters: () => [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }] });\n\n/**\n * The list of features as an enum to uniquely type each `HydrationFeature`.\n * @see {@link HydrationFeature}\n *\n * @publicApi\n */\nvar HydrationFeatureKind;\n(function (HydrationFeatureKind) {\n    HydrationFeatureKind[HydrationFeatureKind[\"NoHttpTransferCache\"] = 0] = \"NoHttpTransferCache\";\n    HydrationFeatureKind[HydrationFeatureKind[\"HttpTransferCacheOptions\"] = 1] = \"HttpTransferCacheOptions\";\n    HydrationFeatureKind[HydrationFeatureKind[\"I18nSupport\"] = 2] = \"I18nSupport\";\n    HydrationFeatureKind[HydrationFeatureKind[\"EventReplay\"] = 3] = \"EventReplay\";\n})(HydrationFeatureKind || (HydrationFeatureKind = {}));\n/**\n * Helper function to create an object that represents a Hydration feature.\n */\nfunction hydrationFeature(ɵkind, ɵproviders = [], ɵoptions = {}) {\n    return { ɵkind, ɵproviders };\n}\n/**\n * Disables HTTP transfer cache. Effectively causes HTTP requests to be performed twice: once on the\n * server and other one on the browser.\n *\n * @publicApi\n */\nfunction withNoHttpTransferCache() {\n    // This feature has no providers and acts as a flag that turns off\n    // HTTP transfer cache (which otherwise is turned on by default).\n    return hydrationFeature(HydrationFeatureKind.NoHttpTransferCache);\n}\n/**\n * The function accepts an object, which allows to configure cache parameters,\n * such as which headers should be included (no headers are included by default),\n * whether POST requests should be cached or a callback function to determine if a\n * particular request should be cached.\n *\n * @publicApi\n */\nfunction withHttpTransferCacheOptions(options) {\n    // This feature has no providers and acts as a flag to pass options to the HTTP transfer cache.\n    return hydrationFeature(HydrationFeatureKind.HttpTransferCacheOptions, ɵwithHttpTransferCache(options));\n}\n/**\n * Enables support for hydrating i18n blocks.\n *\n * @developerPreview\n * @publicApi\n */\nfunction withI18nSupport() {\n    return hydrationFeature(HydrationFeatureKind.I18nSupport, ɵwithI18nSupport());\n}\n/**\n * Enables support for replaying user events (e.g. `click`s) that happened on a page\n * before hydration logic has completed. Once an application is hydrated, all captured\n * events are replayed and relevant event listeners are executed.\n *\n * @usageNotes\n *\n * Basic example of how you can enable event replay in your application when\n * `bootstrapApplication` function is used:\n * ```\n * bootstrapApplication(AppComponent, {\n *   providers: [provideClientHydration(withEventReplay())]\n * });\n * ```\n * @developerPreview\n * @publicApi\n * @see {@link provideClientHydration}\n */\nfunction withEventReplay() {\n    return hydrationFeature(HydrationFeatureKind.EventReplay, ɵwithEventReplay());\n}\n/**\n * Returns an `ENVIRONMENT_INITIALIZER` token setup with a function\n * that verifies whether compatible ZoneJS was used in an application\n * and logs a warning in a console if it's not the case.\n */\nfunction provideZoneJsCompatibilityDetector() {\n    return [\n        {\n            provide: ENVIRONMENT_INITIALIZER,\n            useValue: () => {\n                const ngZone = inject(NgZone);\n                const isZoneless = inject(ɵZONELESS_ENABLED);\n                // Checking `ngZone instanceof NgZone` would be insufficient here,\n                // because custom implementations might use NgZone as a base class.\n                if (!isZoneless && ngZone.constructor !== NgZone) {\n                    const console = inject(ɵConsole);\n                    const message = ɵformatRuntimeError(-5000 /* RuntimeErrorCode.UNSUPPORTED_ZONEJS_INSTANCE */, 'Angular detected that hydration was enabled for an application ' +\n                        'that uses a custom or a noop Zone.js implementation. ' +\n                        'This is not yet a fully supported configuration.');\n                    // tslint:disable-next-line:no-console\n                    console.warn(message);\n                }\n            },\n            multi: true,\n        },\n    ];\n}\n/**\n * Sets up providers necessary to enable hydration functionality for the application.\n *\n * By default, the function enables the recommended set of features for the optimal\n * performance for most of the applications. It includes the following features:\n *\n * * Reconciling DOM hydration. Learn more about it [here](guide/hydration).\n * * [`HttpClient`](api/common/http/HttpClient) response caching while running on the server and\n * transferring this cache to the client to avoid extra HTTP requests. Learn more about data caching\n * [here](guide/ssr#caching-data-when-using-httpclient).\n *\n * These functions allow you to disable some of the default features or enable new ones:\n *\n * * {@link withNoHttpTransferCache} to disable HTTP transfer cache\n * * {@link withHttpTransferCacheOptions} to configure some HTTP transfer cache options\n * * {@link withI18nSupport} to enable hydration support for i18n blocks\n * * {@link withEventReplay} to enable support for replaying user events\n *\n * @usageNotes\n *\n * Basic example of how you can enable hydration in your application when\n * `bootstrapApplication` function is used:\n * ```\n * bootstrapApplication(AppComponent, {\n *   providers: [provideClientHydration()]\n * });\n * ```\n *\n * Alternatively if you are using NgModules, you would add `provideClientHydration`\n * to your root app module's provider list.\n * ```\n * @NgModule({\n *   declarations: [RootCmp],\n *   bootstrap: [RootCmp],\n *   providers: [provideClientHydration()],\n * })\n * export class AppModule {}\n * ```\n *\n * @see {@link withNoHttpTransferCache}\n * @see {@link withHttpTransferCacheOptions}\n * @see {@link withI18nSupport}\n * @see {@link withEventReplay}\n *\n * @param features Optional features to configure additional router behaviors.\n * @returns A set of providers to enable hydration.\n *\n * @publicApi\n */\nfunction provideClientHydration(...features) {\n    const providers = [];\n    const featuresKind = new Set();\n    const hasHttpTransferCacheOptions = featuresKind.has(HydrationFeatureKind.HttpTransferCacheOptions);\n    for (const { ɵproviders, ɵkind } of features) {\n        featuresKind.add(ɵkind);\n        if (ɵproviders.length) {\n            providers.push(ɵproviders);\n        }\n    }\n    if (typeof ngDevMode !== 'undefined' &&\n        ngDevMode &&\n        featuresKind.has(HydrationFeatureKind.NoHttpTransferCache) &&\n        hasHttpTransferCacheOptions) {\n        // TODO: Make this a runtime error\n        throw new Error('Configuration error: found both withHttpTransferCacheOptions() and withNoHttpTransferCache() in the same call to provideClientHydration(), which is a contradiction.');\n    }\n    return makeEnvironmentProviders([\n        typeof ngDevMode !== 'undefined' && ngDevMode ? provideZoneJsCompatibilityDetector() : [],\n        ɵwithDomHydration(),\n        featuresKind.has(HydrationFeatureKind.NoHttpTransferCache) || hasHttpTransferCacheOptions\n            ? []\n            : ɵwithHttpTransferCache({}),\n        providers,\n    ]);\n}\n\n/**\n * @module\n * @description\n * Entry point for all public APIs of the platform-browser package.\n */\n/**\n * @publicApi\n */\nconst VERSION = new Version('18.2.13');\n\n/**\n * @module\n * @description\n * Entry point for all public APIs of this package.\n */\n// This file only reexports content of the `src` folder. Keep it that way.\n\n// This file is not used to build this module. It is only used during editing\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { BrowserModule, By, DomSanitizer, EVENT_MANAGER_PLUGINS, EventManager, EventManagerPlugin, HAMMER_GESTURE_CONFIG, HAMMER_LOADER, HammerGestureConfig, HammerModule, HydrationFeatureKind, Meta, REMOVE_STYLES_ON_COMPONENT_DESTROY, Title, VERSION, bootstrapApplication, createApplication, disableDebugTools, enableDebugTools, platformBrowser, provideClientHydration, provideProtractorTestingSupport, withEventReplay, withHttpTransferCacheOptions, withI18nSupport, withNoHttpTransferCache, BrowserDomAdapter as ɵBrowserDomAdapter, BrowserGetTestability as ɵBrowserGetTestability, DomEventsPlugin as ɵDomEventsPlugin, DomRendererFactory2 as ɵDomRendererFactory2, DomSanitizerImpl as ɵDomSanitizerImpl, HammerGesturesPlugin as ɵHammerGesturesPlugin, INTERNAL_BROWSER_PLATFORM_PROVIDERS as ɵINTERNAL_BROWSER_PLATFORM_PROVIDERS, KeyEventsPlugin as ɵKeyEventsPlugin, SharedStylesHost as ɵSharedStylesHost, initDomAdapter as ɵinitDomAdapter };\n//# sourceMappingURL=platform-browser.mjs.map\n","import * as angularPlatformBrowser from '@angular/platform-browser';\r\n\r\n// global glue variable for externals\r\nif (window['ng'] == null) window['ng'] = <any>{};\r\n\r\nwindow['ng'].platformBrowser = angularPlatformBrowser;\r\n\r\nexport { angularPlatformBrowser };"],"names":["leafPrototypes","getProto","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","exports","module","__webpack_modules__","Object","getPrototypeOf","obj","t","value","mode","this","__esModule","then","ns","create","r","def","current","indexOf","getOwnPropertyNames","forEach","key","d","definition","o","defineProperty","enumerable","get","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","ng","common","core","http","GenericBrowserDomAdapter","constructor","super","arguments","supportsDOMEvents","BrowserDomAdapter","makeCurrent","onAndCancel","el","evt","listener","addEventListener","removeEventListener","dispatchEvent","remove","node","createElement","tagName","doc","getDefaultDocument","createHtmlDocument","document","implementation","createHTMLDocument","isElementNode","nodeType","Node","ELEMENT_NODE","isShadowRoot","DocumentFragment","getGlobalEventTarget","target","window","body","getBaseHref","href","baseElement","querySelector","getAttribute","URL","baseURI","pathname","resetBaseElement","getUserAgent","navigator","userAgent","getCookie","name","cookie","BrowserGetTestability","addToWindow","registry","elem","findInAncestors","testability","findTestabilityInTree","ngDevMode","getAllTestabilities","getAllRootElements","push","callback","testabilities","count","length","decrement","whenStable","getTestability","host","parentElement","BrowserXhr","build","XMLHttpRequest","minVersion","version","ngImport","type","deps","Injectable","decorators","EVENT_MANAGER_PLUGINS","InjectionToken","EventManager","plugins","_zone","_eventNameToPlugin","Map","plugin","manager","_plugins","slice","reverse","element","eventName","handler","_findPluginFor","getZone","find","supports","set","token","ctorParameters","Inject","args","EventManagerPlugin","_doc","APP_ID_ATTRIBUTE_NAME","SharedStylesHost","appId","nonce","platformId","styleRef","hostNodes","Set","styleNodesInDOM","collectServerRenderedStyles","platformIsServer","isPlatformServer","resetHostNodes","addStyles","styles","style","changeUsageCount","onStyleAdded","removeStyles","onStyleRemoved","ngOnDestroy","clear","getAllStyles","addHost","hostNode","add","addStyleToHost","removeHost","delete","keys","elements","head","querySelectorAll","styleMap","textContent","delta","map","has","styleRefValue","usage","getStyleElement","styleEl","parentNode","removeAttribute","setAttribute","appendChild","styleElRef","DOCUMENT","APP_ID","CSP_NONCE","optional","PLATFORM_ID","Document","Optional","NAMESPACE_URIS","COMPONENT_REGEX","COMPONENT_VARIABLE","HOST_ATTR","CONTENT_ATTR","REMOVE_STYLES_ON_COMPONENT_DESTROY","providedIn","factory","shimStylesContent","compId","s","replace","DomRendererFactory2","eventManager","sharedStylesHost","removeStylesOnCompDestroy","ngZone","rendererByCompId","defaultRenderer","DefaultDomRenderer2","createRenderer","encapsulation","ViewEncapsulation","ShadowDom","Emulated","renderer","getOrCreateRenderer","EmulatedEncapsulationDomRenderer2","applyToHost","NoneEncapsulationDomRenderer","applyStyles","id","ShadowDomRenderer","data","throwOnSyntheticProps","destroyNode","destroy","namespace","createElementNS","createComment","createText","createTextNode","parent","newChild","isTemplateNode","content","insertBefore","refChild","removeChild","_parent","oldChild","selectRootElement","selectorOrNode","preserveContent","nextSibling","namespaceUri","setAttributeNS","removeAttributeNS","addClass","classList","removeClass","setStyle","flags","RendererStyleFlags2","DashCase","Important","setProperty","removeStyle","removeProperty","checkNoSyntheticProp","setValue","nodeValue","listen","event","Error","decoratePreventDefault","eventHandler","runGuarded","preventDefault","AT_CHARCODE","charCodeAt","nameKind","hostEl","component","shadowRoot","attachShadow","nodeOrShadowRoot","componentShortId","contentAttr","hostAttr","shimHostAttribute","DomEventsPlugin","MODIFIER_KEYS","_keyMap","MODIFIER_KEY_GETTERS","altKey","ctrlKey","metaKey","shiftKey","KeyEventsPlugin","parseEventName","parsedEvent","outsideHandler","eventCallback","runOutsideAngular","parts","toLowerCase","split","domEventName","shift","_normalizeKey","pop","fullKey","codeIX","splice","modifierName","index","result","matchEventFullKeyCode","fullKeyCode","keycode","code","modifierGetter","zone","keyName","bootstrapApplication","rootComponent","options","createProvidersConfig","createApplication","appProviders","BROWSER_MODULE_PROVIDERS","providers","platformProviders","INTERNAL_BROWSER_PLATFORM_PROVIDERS","provideProtractorTestingSupport","TESTABILITY_PROVIDERS","initDomAdapter","provide","useValue","PLATFORM_INITIALIZER","multi","useFactory","platformBrowser","createPlatformFactory","platformCore","BROWSER_MODULE_PROVIDERS_MARKER","useClass","Testability","NgZone","TestabilityRegistry","ErrorHandler","RendererFactory2","useExisting","XhrFactory","BrowserModule","providersAlreadyPresent","withServerTransition","params","ngModule","skipSelf","NgModule","CommonModule","ApplicationModule","imports","SkipSelf","Meta","_dom","addTag","tag","forceCreation","_getOrCreateElement","addTags","tags","reduce","getTag","attrSelector","getTags","list","updateTag","selector","_parseSelector","meta","_setMetaElementAttributes","removeTag","removeTagElement","filter","_containsAttributes","getElementsByTagName","_getMetaKeyMap","attr","every","META_KEYS_MAP","httpEquiv","Title","getTitle","title","setTitle","newTitle","exportNgVar","COMPILED","ChangeDetectionPerfRecord","msPerTick","numTicks","AngularProfiler","ref","appRef","injector","ApplicationRef","timeChangeDetection","config","record","profileName","console","profile","start","performance","now","tick","end","profileEnd","log","toFixed","PROFILER_GLOBAL_NAME","enableDebugTools","disableDebugTools","By","all","css","debugElement","nativeElement","n","matches","msMatchesSelector","webkitMatchesSelector","elementMatches","directive","debugNode","providerTokens","EVENT_NAMES","HAMMER_GESTURE_CONFIG","HAMMER_LOADER","HammerGestureConfig","events","overrides","buildHammer","mc","Hammer","enable","HammerGesturesPlugin","_config","loader","_loaderPromise","isCustomEvent","warn","cancelRegistration","deregister","catch","eventObj","on","off","HammerModule","DomSanitizer","DomSanitizerImpl","forwardRef","sanitize","ctx","SecurityContext","NONE","HTML","String","toString","STYLE","SCRIPT","RESOURCE_URL","bypassSecurityTrustHtml","bypassSecurityTrustStyle","bypassSecurityTrustScript","bypassSecurityTrustUrl","bypassSecurityTrustResourceUrl","HydrationFeatureKind","hydrationFeature","withNoHttpTransferCache","NoHttpTransferCache","withHttpTransferCacheOptions","HttpTransferCacheOptions","withI18nSupport","I18nSupport","withEventReplay","EventReplay","provideClientHydration","features","featuresKind","hasHttpTransferCacheOptions","makeEnvironmentProviders","ENVIRONMENT_INITIALIZER","inject","message","VERSION","Version"],"sourceRoot":""}