{"version":3,"file":"scripts/@angular/common/angular-common-http-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.core\"","webpack://baas-static-web/external var \"rxjs\"","webpack://baas-static-web/external var \"rxjs.operators\"","webpack://baas-static-web/external var \"ng.common\"","webpack://baas-static-web/./node_modules/@angular/common/fesm2022/http.mjs","webpack://baas-static-web/./src/@angular/common/angular-common-http.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.core;","const __WEBPACK_NAMESPACE_OBJECT__ = rxjs;","const __WEBPACK_NAMESPACE_OBJECT__ = rxjs.operators;","const __WEBPACK_NAMESPACE_OBJECT__ = ng.common;","/**\n * @license Angular v18.2.13\n * (c) 2010-2024 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport * as i0 from '@angular/core';\nimport { Injectable, inject, NgZone, runInInjectionContext, InjectionToken, ɵPendingTasks, PLATFORM_ID, ɵConsole, ɵformatRuntimeError, Inject, ɵRuntimeError, makeEnvironmentProviders, NgModule, TransferState, makeStateKey, ɵperformanceMarkFeature, APP_BOOTSTRAP_LISTENER, ApplicationRef, ɵwhenStable, ɵtruncateMiddle } from '@angular/core';\nimport { of, Observable, from } from 'rxjs';\nimport { concatMap, filter, map, finalize, switchMap, tap } from 'rxjs/operators';\nimport * as i1 from '@angular/common';\nimport { isPlatformServer, DOCUMENT, ɵparseCookieValue } from '@angular/common';\n\n/**\n * Transforms an `HttpRequest` into a stream of `HttpEvent`s, one of which will likely be a\n * `HttpResponse`.\n *\n * `HttpHandler` is injectable. When injected, the handler instance dispatches requests to the\n * first interceptor in the chain, which dispatches to the second, etc, eventually reaching the\n * `HttpBackend`.\n *\n * In an `HttpInterceptor`, the `HttpHandler` parameter is the next interceptor in the chain.\n *\n * @publicApi\n */\nclass HttpHandler {\n}\n/**\n * A final `HttpHandler` which will dispatch the request via browser HTTP APIs to a backend.\n *\n * Interceptors sit between the `HttpClient` interface and the `HttpBackend`.\n *\n * When injected, `HttpBackend` dispatches requests directly to the backend, without going\n * through the interceptor chain.\n *\n * @publicApi\n */\nclass HttpBackend {\n}\n\n/**\n * Represents the header configuration options for an HTTP request.\n * Instances are immutable. Modifying methods return a cloned\n * instance with the change. The original object is never changed.\n *\n * @publicApi\n */\nclass HttpHeaders {\n    /**  Constructs a new HTTP header object with the given values.*/\n    constructor(headers) {\n        /**\n         * Internal map of lowercased header names to the normalized\n         * form of the name (the form seen first).\n         */\n        this.normalizedNames = new Map();\n        /**\n         * Queued updates to be materialized the next initialization.\n         */\n        this.lazyUpdate = null;\n        if (!headers) {\n            this.headers = new Map();\n        }\n        else if (typeof headers === 'string') {\n            this.lazyInit = () => {\n                this.headers = new Map();\n                headers.split('\\n').forEach((line) => {\n                    const index = line.indexOf(':');\n                    if (index > 0) {\n                        const name = line.slice(0, index);\n                        const key = name.toLowerCase();\n                        const value = line.slice(index + 1).trim();\n                        this.maybeSetNormalizedName(name, key);\n                        if (this.headers.has(key)) {\n                            this.headers.get(key).push(value);\n                        }\n                        else {\n                            this.headers.set(key, [value]);\n                        }\n                    }\n                });\n            };\n        }\n        else if (typeof Headers !== 'undefined' && headers instanceof Headers) {\n            this.headers = new Map();\n            headers.forEach((values, name) => {\n                this.setHeaderEntries(name, values);\n            });\n        }\n        else {\n            this.lazyInit = () => {\n                if (typeof ngDevMode === 'undefined' || ngDevMode) {\n                    assertValidHeaders(headers);\n                }\n                this.headers = new Map();\n                Object.entries(headers).forEach(([name, values]) => {\n                    this.setHeaderEntries(name, values);\n                });\n            };\n        }\n    }\n    /**\n     * Checks for existence of a given header.\n     *\n     * @param name The header name to check for existence.\n     *\n     * @returns True if the header exists, false otherwise.\n     */\n    has(name) {\n        this.init();\n        return this.headers.has(name.toLowerCase());\n    }\n    /**\n     * Retrieves the first value of a given header.\n     *\n     * @param name The header name.\n     *\n     * @returns The value string if the header exists, null otherwise\n     */\n    get(name) {\n        this.init();\n        const values = this.headers.get(name.toLowerCase());\n        return values && values.length > 0 ? values[0] : null;\n    }\n    /**\n     * Retrieves the names of the headers.\n     *\n     * @returns A list of header names.\n     */\n    keys() {\n        this.init();\n        return Array.from(this.normalizedNames.values());\n    }\n    /**\n     * Retrieves a list of values for a given header.\n     *\n     * @param name The header name from which to retrieve values.\n     *\n     * @returns A string of values if the header exists, null otherwise.\n     */\n    getAll(name) {\n        this.init();\n        return this.headers.get(name.toLowerCase()) || null;\n    }\n    /**\n     * Appends a new value to the existing set of values for a header\n     * and returns them in a clone of the original instance.\n     *\n     * @param name The header name for which to append the values.\n     * @param value The value to append.\n     *\n     * @returns A clone of the HTTP headers object with the value appended to the given header.\n     */\n    append(name, value) {\n        return this.clone({ name, value, op: 'a' });\n    }\n    /**\n     * Sets or modifies a value for a given header in a clone of the original instance.\n     * If the header already exists, its value is replaced with the given value\n     * in the returned object.\n     *\n     * @param name The header name.\n     * @param value The value or values to set or override for the given header.\n     *\n     * @returns A clone of the HTTP headers object with the newly set header value.\n     */\n    set(name, value) {\n        return this.clone({ name, value, op: 's' });\n    }\n    /**\n     * Deletes values for a given header in a clone of the original instance.\n     *\n     * @param name The header name.\n     * @param value The value or values to delete for the given header.\n     *\n     * @returns A clone of the HTTP headers object with the given value deleted.\n     */\n    delete(name, value) {\n        return this.clone({ name, value, op: 'd' });\n    }\n    maybeSetNormalizedName(name, lcName) {\n        if (!this.normalizedNames.has(lcName)) {\n            this.normalizedNames.set(lcName, name);\n        }\n    }\n    init() {\n        if (!!this.lazyInit) {\n            if (this.lazyInit instanceof HttpHeaders) {\n                this.copyFrom(this.lazyInit);\n            }\n            else {\n                this.lazyInit();\n            }\n            this.lazyInit = null;\n            if (!!this.lazyUpdate) {\n                this.lazyUpdate.forEach((update) => this.applyUpdate(update));\n                this.lazyUpdate = null;\n            }\n        }\n    }\n    copyFrom(other) {\n        other.init();\n        Array.from(other.headers.keys()).forEach((key) => {\n            this.headers.set(key, other.headers.get(key));\n            this.normalizedNames.set(key, other.normalizedNames.get(key));\n        });\n    }\n    clone(update) {\n        const clone = new HttpHeaders();\n        clone.lazyInit = !!this.lazyInit && this.lazyInit instanceof HttpHeaders ? this.lazyInit : this;\n        clone.lazyUpdate = (this.lazyUpdate || []).concat([update]);\n        return clone;\n    }\n    applyUpdate(update) {\n        const key = update.name.toLowerCase();\n        switch (update.op) {\n            case 'a':\n            case 's':\n                let value = update.value;\n                if (typeof value === 'string') {\n                    value = [value];\n                }\n                if (value.length === 0) {\n                    return;\n                }\n                this.maybeSetNormalizedName(update.name, key);\n                const base = (update.op === 'a' ? this.headers.get(key) : undefined) || [];\n                base.push(...value);\n                this.headers.set(key, base);\n                break;\n            case 'd':\n                const toDelete = update.value;\n                if (!toDelete) {\n                    this.headers.delete(key);\n                    this.normalizedNames.delete(key);\n                }\n                else {\n                    let existing = this.headers.get(key);\n                    if (!existing) {\n                        return;\n                    }\n                    existing = existing.filter((value) => toDelete.indexOf(value) === -1);\n                    if (existing.length === 0) {\n                        this.headers.delete(key);\n                        this.normalizedNames.delete(key);\n                    }\n                    else {\n                        this.headers.set(key, existing);\n                    }\n                }\n                break;\n        }\n    }\n    setHeaderEntries(name, values) {\n        const headerValues = (Array.isArray(values) ? values : [values]).map((value) => value.toString());\n        const key = name.toLowerCase();\n        this.headers.set(key, headerValues);\n        this.maybeSetNormalizedName(name, key);\n    }\n    /**\n     * @internal\n     */\n    forEach(fn) {\n        this.init();\n        Array.from(this.normalizedNames.keys()).forEach((key) => fn(this.normalizedNames.get(key), this.headers.get(key)));\n    }\n}\n/**\n * Verifies that the headers object has the right shape: the values\n * must be either strings, numbers or arrays. Throws an error if an invalid\n * header value is present.\n */\nfunction assertValidHeaders(headers) {\n    for (const [key, value] of Object.entries(headers)) {\n        if (!(typeof value === 'string' || typeof value === 'number') && !Array.isArray(value)) {\n            throw new Error(`Unexpected value of the \\`${key}\\` header provided. ` +\n                `Expecting either a string, a number or an array, but got: \\`${value}\\`.`);\n        }\n    }\n}\n\n/**\n * Provides encoding and decoding of URL parameter and query-string values.\n *\n * Serializes and parses URL parameter keys and values to encode and decode them.\n * If you pass URL query parameters without encoding,\n * the query parameters can be misinterpreted at the receiving end.\n *\n *\n * @publicApi\n */\nclass HttpUrlEncodingCodec {\n    /**\n     * Encodes a key name for a URL parameter or query-string.\n     * @param key The key name.\n     * @returns The encoded key name.\n     */\n    encodeKey(key) {\n        return standardEncoding(key);\n    }\n    /**\n     * Encodes the value of a URL parameter or query-string.\n     * @param value The value.\n     * @returns The encoded value.\n     */\n    encodeValue(value) {\n        return standardEncoding(value);\n    }\n    /**\n     * Decodes an encoded URL parameter or query-string key.\n     * @param key The encoded key name.\n     * @returns The decoded key name.\n     */\n    decodeKey(key) {\n        return decodeURIComponent(key);\n    }\n    /**\n     * Decodes an encoded URL parameter or query-string value.\n     * @param value The encoded value.\n     * @returns The decoded value.\n     */\n    decodeValue(value) {\n        return decodeURIComponent(value);\n    }\n}\nfunction paramParser(rawParams, codec) {\n    const map = new Map();\n    if (rawParams.length > 0) {\n        // The `window.location.search` can be used while creating an instance of the `HttpParams` class\n        // (e.g. `new HttpParams({ fromString: window.location.search })`). The `window.location.search`\n        // may start with the `?` char, so we strip it if it's present.\n        const params = rawParams.replace(/^\\?/, '').split('&');\n        params.forEach((param) => {\n            const eqIdx = param.indexOf('=');\n            const [key, val] = eqIdx == -1\n                ? [codec.decodeKey(param), '']\n                : [codec.decodeKey(param.slice(0, eqIdx)), codec.decodeValue(param.slice(eqIdx + 1))];\n            const list = map.get(key) || [];\n            list.push(val);\n            map.set(key, list);\n        });\n    }\n    return map;\n}\n/**\n * Encode input string with standard encodeURIComponent and then un-encode specific characters.\n */\nconst STANDARD_ENCODING_REGEX = /%(\\d[a-f0-9])/gi;\nconst STANDARD_ENCODING_REPLACEMENTS = {\n    '40': '@',\n    '3A': ':',\n    '24': '$',\n    '2C': ',',\n    '3B': ';',\n    '3D': '=',\n    '3F': '?',\n    '2F': '/',\n};\nfunction standardEncoding(v) {\n    return encodeURIComponent(v).replace(STANDARD_ENCODING_REGEX, (s, t) => STANDARD_ENCODING_REPLACEMENTS[t] ?? s);\n}\nfunction valueToString(value) {\n    return `${value}`;\n}\n/**\n * An HTTP request/response body that represents serialized parameters,\n * per the MIME type `application/x-www-form-urlencoded`.\n *\n * This class is immutable; all mutation operations return a new instance.\n *\n * @publicApi\n */\nclass HttpParams {\n    constructor(options = {}) {\n        this.updates = null;\n        this.cloneFrom = null;\n        this.encoder = options.encoder || new HttpUrlEncodingCodec();\n        if (!!options.fromString) {\n            if (!!options.fromObject) {\n                throw new Error(`Cannot specify both fromString and fromObject.`);\n            }\n            this.map = paramParser(options.fromString, this.encoder);\n        }\n        else if (!!options.fromObject) {\n            this.map = new Map();\n            Object.keys(options.fromObject).forEach((key) => {\n                const value = options.fromObject[key];\n                // convert the values to strings\n                const values = Array.isArray(value) ? value.map(valueToString) : [valueToString(value)];\n                this.map.set(key, values);\n            });\n        }\n        else {\n            this.map = null;\n        }\n    }\n    /**\n     * Reports whether the body includes one or more values for a given parameter.\n     * @param param The parameter name.\n     * @returns True if the parameter has one or more values,\n     * false if it has no value or is not present.\n     */\n    has(param) {\n        this.init();\n        return this.map.has(param);\n    }\n    /**\n     * Retrieves the first value for a parameter.\n     * @param param The parameter name.\n     * @returns The first value of the given parameter,\n     * or `null` if the parameter is not present.\n     */\n    get(param) {\n        this.init();\n        const res = this.map.get(param);\n        return !!res ? res[0] : null;\n    }\n    /**\n     * Retrieves all values for a  parameter.\n     * @param param The parameter name.\n     * @returns All values in a string array,\n     * or `null` if the parameter not present.\n     */\n    getAll(param) {\n        this.init();\n        return this.map.get(param) || null;\n    }\n    /**\n     * Retrieves all the parameters for this body.\n     * @returns The parameter names in a string array.\n     */\n    keys() {\n        this.init();\n        return Array.from(this.map.keys());\n    }\n    /**\n     * Appends a new value to existing values for a parameter.\n     * @param param The parameter name.\n     * @param value The new value to add.\n     * @return A new body with the appended value.\n     */\n    append(param, value) {\n        return this.clone({ param, value, op: 'a' });\n    }\n    /**\n     * Constructs a new body with appended values for the given parameter name.\n     * @param params parameters and values\n     * @return A new body with the new value.\n     */\n    appendAll(params) {\n        const updates = [];\n        Object.keys(params).forEach((param) => {\n            const value = params[param];\n            if (Array.isArray(value)) {\n                value.forEach((_value) => {\n                    updates.push({ param, value: _value, op: 'a' });\n                });\n            }\n            else {\n                updates.push({ param, value: value, op: 'a' });\n            }\n        });\n        return this.clone(updates);\n    }\n    /**\n     * Replaces the value for a parameter.\n     * @param param The parameter name.\n     * @param value The new value.\n     * @return A new body with the new value.\n     */\n    set(param, value) {\n        return this.clone({ param, value, op: 's' });\n    }\n    /**\n     * Removes a given value or all values from a parameter.\n     * @param param The parameter name.\n     * @param value The value to remove, if provided.\n     * @return A new body with the given value removed, or with all values\n     * removed if no value is specified.\n     */\n    delete(param, value) {\n        return this.clone({ param, value, op: 'd' });\n    }\n    /**\n     * Serializes the body to an encoded string, where key-value pairs (separated by `=`) are\n     * separated by `&`s.\n     */\n    toString() {\n        this.init();\n        return (this.keys()\n            .map((key) => {\n            const eKey = this.encoder.encodeKey(key);\n            // `a: ['1']` produces `'a=1'`\n            // `b: []` produces `''`\n            // `c: ['1', '2']` produces `'c=1&c=2'`\n            return this.map.get(key)\n                .map((value) => eKey + '=' + this.encoder.encodeValue(value))\n                .join('&');\n        })\n            // filter out empty values because `b: []` produces `''`\n            // which results in `a=1&&c=1&c=2` instead of `a=1&c=1&c=2` if we don't\n            .filter((param) => param !== '')\n            .join('&'));\n    }\n    clone(update) {\n        const clone = new HttpParams({ encoder: this.encoder });\n        clone.cloneFrom = this.cloneFrom || this;\n        clone.updates = (this.updates || []).concat(update);\n        return clone;\n    }\n    init() {\n        if (this.map === null) {\n            this.map = new Map();\n        }\n        if (this.cloneFrom !== null) {\n            this.cloneFrom.init();\n            this.cloneFrom.keys().forEach((key) => this.map.set(key, this.cloneFrom.map.get(key)));\n            this.updates.forEach((update) => {\n                switch (update.op) {\n                    case 'a':\n                    case 's':\n                        const base = (update.op === 'a' ? this.map.get(update.param) : undefined) || [];\n                        base.push(valueToString(update.value));\n                        this.map.set(update.param, base);\n                        break;\n                    case 'd':\n                        if (update.value !== undefined) {\n                            let base = this.map.get(update.param) || [];\n                            const idx = base.indexOf(valueToString(update.value));\n                            if (idx !== -1) {\n                                base.splice(idx, 1);\n                            }\n                            if (base.length > 0) {\n                                this.map.set(update.param, base);\n                            }\n                            else {\n                                this.map.delete(update.param);\n                            }\n                        }\n                        else {\n                            this.map.delete(update.param);\n                            break;\n                        }\n                }\n            });\n            this.cloneFrom = this.updates = null;\n        }\n    }\n}\n\n/**\n * A token used to manipulate and access values stored in `HttpContext`.\n *\n * @publicApi\n */\nclass HttpContextToken {\n    constructor(defaultValue) {\n        this.defaultValue = defaultValue;\n    }\n}\n/**\n * Http context stores arbitrary user defined values and ensures type safety without\n * actually knowing the types. It is backed by a `Map` and guarantees that keys do not clash.\n *\n * This context is mutable and is shared between cloned requests unless explicitly specified.\n *\n * @usageNotes\n *\n * ### Usage Example\n *\n * ```typescript\n * // inside cache.interceptors.ts\n * export const IS_CACHE_ENABLED = new HttpContextToken<boolean>(() => false);\n *\n * export class CacheInterceptor implements HttpInterceptor {\n *\n *   intercept(req: HttpRequest<any>, delegate: HttpHandler): Observable<HttpEvent<any>> {\n *     if (req.context.get(IS_CACHE_ENABLED) === true) {\n *       return ...;\n *     }\n *     return delegate.handle(req);\n *   }\n * }\n *\n * // inside a service\n *\n * this.httpClient.get('/api/weather', {\n *   context: new HttpContext().set(IS_CACHE_ENABLED, true)\n * }).subscribe(...);\n * ```\n *\n * @publicApi\n */\nclass HttpContext {\n    constructor() {\n        this.map = new Map();\n    }\n    /**\n     * Store a value in the context. If a value is already present it will be overwritten.\n     *\n     * @param token The reference to an instance of `HttpContextToken`.\n     * @param value The value to store.\n     *\n     * @returns A reference to itself for easy chaining.\n     */\n    set(token, value) {\n        this.map.set(token, value);\n        return this;\n    }\n    /**\n     * Retrieve the value associated with the given token.\n     *\n     * @param token The reference to an instance of `HttpContextToken`.\n     *\n     * @returns The stored value or default if one is defined.\n     */\n    get(token) {\n        if (!this.map.has(token)) {\n            this.map.set(token, token.defaultValue());\n        }\n        return this.map.get(token);\n    }\n    /**\n     * Delete the value associated with the given token.\n     *\n     * @param token The reference to an instance of `HttpContextToken`.\n     *\n     * @returns A reference to itself for easy chaining.\n     */\n    delete(token) {\n        this.map.delete(token);\n        return this;\n    }\n    /**\n     * Checks for existence of a given token.\n     *\n     * @param token The reference to an instance of `HttpContextToken`.\n     *\n     * @returns True if the token exists, false otherwise.\n     */\n    has(token) {\n        return this.map.has(token);\n    }\n    /**\n     * @returns a list of tokens currently stored in the context.\n     */\n    keys() {\n        return this.map.keys();\n    }\n}\n\n/**\n * Determine whether the given HTTP method may include a body.\n */\nfunction mightHaveBody(method) {\n    switch (method) {\n        case 'DELETE':\n        case 'GET':\n        case 'HEAD':\n        case 'OPTIONS':\n        case 'JSONP':\n            return false;\n        default:\n            return true;\n    }\n}\n/**\n * Safely assert whether the given value is an ArrayBuffer.\n *\n * In some execution environments ArrayBuffer is not defined.\n */\nfunction isArrayBuffer(value) {\n    return typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer;\n}\n/**\n * Safely assert whether the given value is a Blob.\n *\n * In some execution environments Blob is not defined.\n */\nfunction isBlob(value) {\n    return typeof Blob !== 'undefined' && value instanceof Blob;\n}\n/**\n * Safely assert whether the given value is a FormData instance.\n *\n * In some execution environments FormData is not defined.\n */\nfunction isFormData(value) {\n    return typeof FormData !== 'undefined' && value instanceof FormData;\n}\n/**\n * Safely assert whether the given value is a URLSearchParams instance.\n *\n * In some execution environments URLSearchParams is not defined.\n */\nfunction isUrlSearchParams(value) {\n    return typeof URLSearchParams !== 'undefined' && value instanceof URLSearchParams;\n}\n/**\n * An outgoing HTTP request with an optional typed body.\n *\n * `HttpRequest` represents an outgoing request, including URL, method,\n * headers, body, and other request configuration options. Instances should be\n * assumed to be immutable. To modify a `HttpRequest`, the `clone`\n * method should be used.\n *\n * @publicApi\n */\nclass HttpRequest {\n    constructor(method, url, third, fourth) {\n        this.url = url;\n        /**\n         * The request body, or `null` if one isn't set.\n         *\n         * Bodies are not enforced to be immutable, as they can include a reference to any\n         * user-defined data type. However, interceptors should take care to preserve\n         * idempotence by treating them as such.\n         */\n        this.body = null;\n        /**\n         * Whether this request should be made in a way that exposes progress events.\n         *\n         * Progress events are expensive (change detection runs on each event) and so\n         * they should only be requested if the consumer intends to monitor them.\n         *\n         * Note: The `FetchBackend` doesn't support progress report on uploads.\n         */\n        this.reportProgress = false;\n        /**\n         * Whether this request should be sent with outgoing credentials (cookies).\n         */\n        this.withCredentials = false;\n        /**\n         * The expected response type of the server.\n         *\n         * This is used to parse the response appropriately before returning it to\n         * the requestee.\n         */\n        this.responseType = 'json';\n        this.method = method.toUpperCase();\n        // Next, need to figure out which argument holds the HttpRequestInit\n        // options, if any.\n        let options;\n        // Check whether a body argument is expected. The only valid way to omit\n        // the body argument is to use a known no-body method like GET.\n        if (mightHaveBody(this.method) || !!fourth) {\n            // Body is the third argument, options are the fourth.\n            this.body = third !== undefined ? third : null;\n            options = fourth;\n        }\n        else {\n            // No body required, options are the third argument. The body stays null.\n            options = third;\n        }\n        // If options have been passed, interpret them.\n        if (options) {\n            // Normalize reportProgress and withCredentials.\n            this.reportProgress = !!options.reportProgress;\n            this.withCredentials = !!options.withCredentials;\n            // Override default response type of 'json' if one is provided.\n            if (!!options.responseType) {\n                this.responseType = options.responseType;\n            }\n            // Override headers if they're provided.\n            if (!!options.headers) {\n                this.headers = options.headers;\n            }\n            if (!!options.context) {\n                this.context = options.context;\n            }\n            if (!!options.params) {\n                this.params = options.params;\n            }\n            // We do want to assign transferCache even if it's falsy (false is valid value)\n            this.transferCache = options.transferCache;\n        }\n        // If no headers have been passed in, construct a new HttpHeaders instance.\n        this.headers ??= new HttpHeaders();\n        // If no context have been passed in, construct a new HttpContext instance.\n        this.context ??= new HttpContext();\n        // If no parameters have been passed in, construct a new HttpUrlEncodedParams instance.\n        if (!this.params) {\n            this.params = new HttpParams();\n            this.urlWithParams = url;\n        }\n        else {\n            // Encode the parameters to a string in preparation for inclusion in the URL.\n            const params = this.params.toString();\n            if (params.length === 0) {\n                // No parameters, the visible URL is just the URL given at creation time.\n                this.urlWithParams = url;\n            }\n            else {\n                // Does the URL already have query parameters? Look for '?'.\n                const qIdx = url.indexOf('?');\n                // There are 3 cases to handle:\n                // 1) No existing parameters -> append '?' followed by params.\n                // 2) '?' exists and is followed by existing query string ->\n                //    append '&' followed by params.\n                // 3) '?' exists at the end of the url -> append params directly.\n                // This basically amounts to determining the character, if any, with\n                // which to join the URL and parameters.\n                const sep = qIdx === -1 ? '?' : qIdx < url.length - 1 ? '&' : '';\n                this.urlWithParams = url + sep + params;\n            }\n        }\n    }\n    /**\n     * Transform the free-form body into a serialized format suitable for\n     * transmission to the server.\n     */\n    serializeBody() {\n        // If no body is present, no need to serialize it.\n        if (this.body === null) {\n            return null;\n        }\n        // Check whether the body is already in a serialized form. If so,\n        // it can just be returned directly.\n        if (typeof this.body === 'string' ||\n            isArrayBuffer(this.body) ||\n            isBlob(this.body) ||\n            isFormData(this.body) ||\n            isUrlSearchParams(this.body)) {\n            return this.body;\n        }\n        // Check whether the body is an instance of HttpUrlEncodedParams.\n        if (this.body instanceof HttpParams) {\n            return this.body.toString();\n        }\n        // Check whether the body is an object or array, and serialize with JSON if so.\n        if (typeof this.body === 'object' ||\n            typeof this.body === 'boolean' ||\n            Array.isArray(this.body)) {\n            return JSON.stringify(this.body);\n        }\n        // Fall back on toString() for everything else.\n        return this.body.toString();\n    }\n    /**\n     * Examine the body and attempt to infer an appropriate MIME type\n     * for it.\n     *\n     * If no such type can be inferred, this method will return `null`.\n     */\n    detectContentTypeHeader() {\n        // An empty body has no content type.\n        if (this.body === null) {\n            return null;\n        }\n        // FormData bodies rely on the browser's content type assignment.\n        if (isFormData(this.body)) {\n            return null;\n        }\n        // Blobs usually have their own content type. If it doesn't, then\n        // no type can be inferred.\n        if (isBlob(this.body)) {\n            return this.body.type || null;\n        }\n        // Array buffers have unknown contents and thus no type can be inferred.\n        if (isArrayBuffer(this.body)) {\n            return null;\n        }\n        // Technically, strings could be a form of JSON data, but it's safe enough\n        // to assume they're plain strings.\n        if (typeof this.body === 'string') {\n            return 'text/plain';\n        }\n        // `HttpUrlEncodedParams` has its own content-type.\n        if (this.body instanceof HttpParams) {\n            return 'application/x-www-form-urlencoded;charset=UTF-8';\n        }\n        // Arrays, objects, boolean and numbers will be encoded as JSON.\n        if (typeof this.body === 'object' ||\n            typeof this.body === 'number' ||\n            typeof this.body === 'boolean') {\n            return 'application/json';\n        }\n        // No type could be inferred.\n        return null;\n    }\n    clone(update = {}) {\n        // For method, url, and responseType, take the current value unless\n        // it is overridden in the update hash.\n        const method = update.method || this.method;\n        const url = update.url || this.url;\n        const responseType = update.responseType || this.responseType;\n        // Carefully handle the transferCache to differentiate between\n        // `false` and `undefined` in the update args.\n        const transferCache = update.transferCache ?? this.transferCache;\n        // The body is somewhat special - a `null` value in update.body means\n        // whatever current body is present is being overridden with an empty\n        // body, whereas an `undefined` value in update.body implies no\n        // override.\n        const body = update.body !== undefined ? update.body : this.body;\n        // Carefully handle the boolean options to differentiate between\n        // `false` and `undefined` in the update args.\n        const withCredentials = update.withCredentials ?? this.withCredentials;\n        const reportProgress = update.reportProgress ?? this.reportProgress;\n        // Headers and params may be appended to if `setHeaders` or\n        // `setParams` are used.\n        let headers = update.headers || this.headers;\n        let params = update.params || this.params;\n        // Pass on context if needed\n        const context = update.context ?? this.context;\n        // Check whether the caller has asked to add headers.\n        if (update.setHeaders !== undefined) {\n            // Set every requested header.\n            headers = Object.keys(update.setHeaders).reduce((headers, name) => headers.set(name, update.setHeaders[name]), headers);\n        }\n        // Check whether the caller has asked to set params.\n        if (update.setParams) {\n            // Set every requested param.\n            params = Object.keys(update.setParams).reduce((params, param) => params.set(param, update.setParams[param]), params);\n        }\n        // Finally, construct the new HttpRequest using the pieces from above.\n        return new HttpRequest(method, url, body, {\n            params,\n            headers,\n            context,\n            reportProgress,\n            responseType,\n            withCredentials,\n            transferCache,\n        });\n    }\n}\n\n/**\n * Type enumeration for the different kinds of `HttpEvent`.\n *\n * @publicApi\n */\nvar HttpEventType;\n(function (HttpEventType) {\n    /**\n     * The request was sent out over the wire.\n     */\n    HttpEventType[HttpEventType[\"Sent\"] = 0] = \"Sent\";\n    /**\n     * An upload progress event was received.\n     *\n     * Note: The `FetchBackend` doesn't support progress report on uploads.\n     */\n    HttpEventType[HttpEventType[\"UploadProgress\"] = 1] = \"UploadProgress\";\n    /**\n     * The response status code and headers were received.\n     */\n    HttpEventType[HttpEventType[\"ResponseHeader\"] = 2] = \"ResponseHeader\";\n    /**\n     * A download progress event was received.\n     */\n    HttpEventType[HttpEventType[\"DownloadProgress\"] = 3] = \"DownloadProgress\";\n    /**\n     * The full response including the body was received.\n     */\n    HttpEventType[HttpEventType[\"Response\"] = 4] = \"Response\";\n    /**\n     * A custom event from an interceptor or a backend.\n     */\n    HttpEventType[HttpEventType[\"User\"] = 5] = \"User\";\n})(HttpEventType || (HttpEventType = {}));\n/**\n * Base class for both `HttpResponse` and `HttpHeaderResponse`.\n *\n * @publicApi\n */\nclass HttpResponseBase {\n    /**\n     * Super-constructor for all responses.\n     *\n     * The single parameter accepted is an initialization hash. Any properties\n     * of the response passed there will override the default values.\n     */\n    constructor(init, defaultStatus = 200, defaultStatusText = 'OK') {\n        // If the hash has values passed, use them to initialize the response.\n        // Otherwise use the default values.\n        this.headers = init.headers || new HttpHeaders();\n        this.status = init.status !== undefined ? init.status : defaultStatus;\n        this.statusText = init.statusText || defaultStatusText;\n        this.url = init.url || null;\n        // Cache the ok value to avoid defining a getter.\n        this.ok = this.status >= 200 && this.status < 300;\n    }\n}\n/**\n * A partial HTTP response which only includes the status and header data,\n * but no response body.\n *\n * `HttpHeaderResponse` is a `HttpEvent` available on the response\n * event stream, only when progress events are requested.\n *\n * @publicApi\n */\nclass HttpHeaderResponse extends HttpResponseBase {\n    /**\n     * Create a new `HttpHeaderResponse` with the given parameters.\n     */\n    constructor(init = {}) {\n        super(init);\n        this.type = HttpEventType.ResponseHeader;\n    }\n    /**\n     * Copy this `HttpHeaderResponse`, overriding its contents with the\n     * given parameter hash.\n     */\n    clone(update = {}) {\n        // Perform a straightforward initialization of the new HttpHeaderResponse,\n        // overriding the current parameters with new ones if given.\n        return new HttpHeaderResponse({\n            headers: update.headers || this.headers,\n            status: update.status !== undefined ? update.status : this.status,\n            statusText: update.statusText || this.statusText,\n            url: update.url || this.url || undefined,\n        });\n    }\n}\n/**\n * A full HTTP response, including a typed response body (which may be `null`\n * if one was not returned).\n *\n * `HttpResponse` is a `HttpEvent` available on the response event\n * stream.\n *\n * @publicApi\n */\nclass HttpResponse extends HttpResponseBase {\n    /**\n     * Construct a new `HttpResponse`.\n     */\n    constructor(init = {}) {\n        super(init);\n        this.type = HttpEventType.Response;\n        this.body = init.body !== undefined ? init.body : null;\n    }\n    clone(update = {}) {\n        return new HttpResponse({\n            body: update.body !== undefined ? update.body : this.body,\n            headers: update.headers || this.headers,\n            status: update.status !== undefined ? update.status : this.status,\n            statusText: update.statusText || this.statusText,\n            url: update.url || this.url || undefined,\n        });\n    }\n}\n/**\n * A response that represents an error or failure, either from a\n * non-successful HTTP status, an error while executing the request,\n * or some other failure which occurred during the parsing of the response.\n *\n * Any error returned on the `Observable` response stream will be\n * wrapped in an `HttpErrorResponse` to provide additional context about\n * the state of the HTTP layer when the error occurred. The error property\n * will contain either a wrapped Error object or the error response returned\n * from the server.\n *\n * @publicApi\n */\nclass HttpErrorResponse extends HttpResponseBase {\n    constructor(init) {\n        // Initialize with a default status of 0 / Unknown Error.\n        super(init, 0, 'Unknown Error');\n        this.name = 'HttpErrorResponse';\n        /**\n         * Errors are never okay, even when the status code is in the 2xx success range.\n         */\n        this.ok = false;\n        // If the response was successful, then this was a parse error. Otherwise, it was\n        // a protocol-level failure of some sort. Either the request failed in transit\n        // or the server returned an unsuccessful status code.\n        if (this.status >= 200 && this.status < 300) {\n            this.message = `Http failure during parsing for ${init.url || '(unknown url)'}`;\n        }\n        else {\n            this.message = `Http failure response for ${init.url || '(unknown url)'}: ${init.status} ${init.statusText}`;\n        }\n        this.error = init.error || null;\n    }\n}\n/**\n * We use these constant to prevent pulling the whole HttpStatusCode enum\n * Those are the only ones referenced directly by the framework\n */\nconst HTTP_STATUS_CODE_OK = 200;\nconst HTTP_STATUS_CODE_NO_CONTENT = 204;\n/**\n * Http status codes.\n * As per https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml\n * @publicApi\n */\nvar HttpStatusCode;\n(function (HttpStatusCode) {\n    HttpStatusCode[HttpStatusCode[\"Continue\"] = 100] = \"Continue\";\n    HttpStatusCode[HttpStatusCode[\"SwitchingProtocols\"] = 101] = \"SwitchingProtocols\";\n    HttpStatusCode[HttpStatusCode[\"Processing\"] = 102] = \"Processing\";\n    HttpStatusCode[HttpStatusCode[\"EarlyHints\"] = 103] = \"EarlyHints\";\n    HttpStatusCode[HttpStatusCode[\"Ok\"] = 200] = \"Ok\";\n    HttpStatusCode[HttpStatusCode[\"Created\"] = 201] = \"Created\";\n    HttpStatusCode[HttpStatusCode[\"Accepted\"] = 202] = \"Accepted\";\n    HttpStatusCode[HttpStatusCode[\"NonAuthoritativeInformation\"] = 203] = \"NonAuthoritativeInformation\";\n    HttpStatusCode[HttpStatusCode[\"NoContent\"] = 204] = \"NoContent\";\n    HttpStatusCode[HttpStatusCode[\"ResetContent\"] = 205] = \"ResetContent\";\n    HttpStatusCode[HttpStatusCode[\"PartialContent\"] = 206] = \"PartialContent\";\n    HttpStatusCode[HttpStatusCode[\"MultiStatus\"] = 207] = \"MultiStatus\";\n    HttpStatusCode[HttpStatusCode[\"AlreadyReported\"] = 208] = \"AlreadyReported\";\n    HttpStatusCode[HttpStatusCode[\"ImUsed\"] = 226] = \"ImUsed\";\n    HttpStatusCode[HttpStatusCode[\"MultipleChoices\"] = 300] = \"MultipleChoices\";\n    HttpStatusCode[HttpStatusCode[\"MovedPermanently\"] = 301] = \"MovedPermanently\";\n    HttpStatusCode[HttpStatusCode[\"Found\"] = 302] = \"Found\";\n    HttpStatusCode[HttpStatusCode[\"SeeOther\"] = 303] = \"SeeOther\";\n    HttpStatusCode[HttpStatusCode[\"NotModified\"] = 304] = \"NotModified\";\n    HttpStatusCode[HttpStatusCode[\"UseProxy\"] = 305] = \"UseProxy\";\n    HttpStatusCode[HttpStatusCode[\"Unused\"] = 306] = \"Unused\";\n    HttpStatusCode[HttpStatusCode[\"TemporaryRedirect\"] = 307] = \"TemporaryRedirect\";\n    HttpStatusCode[HttpStatusCode[\"PermanentRedirect\"] = 308] = \"PermanentRedirect\";\n    HttpStatusCode[HttpStatusCode[\"BadRequest\"] = 400] = \"BadRequest\";\n    HttpStatusCode[HttpStatusCode[\"Unauthorized\"] = 401] = \"Unauthorized\";\n    HttpStatusCode[HttpStatusCode[\"PaymentRequired\"] = 402] = \"PaymentRequired\";\n    HttpStatusCode[HttpStatusCode[\"Forbidden\"] = 403] = \"Forbidden\";\n    HttpStatusCode[HttpStatusCode[\"NotFound\"] = 404] = \"NotFound\";\n    HttpStatusCode[HttpStatusCode[\"MethodNotAllowed\"] = 405] = \"MethodNotAllowed\";\n    HttpStatusCode[HttpStatusCode[\"NotAcceptable\"] = 406] = \"NotAcceptable\";\n    HttpStatusCode[HttpStatusCode[\"ProxyAuthenticationRequired\"] = 407] = \"ProxyAuthenticationRequired\";\n    HttpStatusCode[HttpStatusCode[\"RequestTimeout\"] = 408] = \"RequestTimeout\";\n    HttpStatusCode[HttpStatusCode[\"Conflict\"] = 409] = \"Conflict\";\n    HttpStatusCode[HttpStatusCode[\"Gone\"] = 410] = \"Gone\";\n    HttpStatusCode[HttpStatusCode[\"LengthRequired\"] = 411] = \"LengthRequired\";\n    HttpStatusCode[HttpStatusCode[\"PreconditionFailed\"] = 412] = \"PreconditionFailed\";\n    HttpStatusCode[HttpStatusCode[\"PayloadTooLarge\"] = 413] = \"PayloadTooLarge\";\n    HttpStatusCode[HttpStatusCode[\"UriTooLong\"] = 414] = \"UriTooLong\";\n    HttpStatusCode[HttpStatusCode[\"UnsupportedMediaType\"] = 415] = \"UnsupportedMediaType\";\n    HttpStatusCode[HttpStatusCode[\"RangeNotSatisfiable\"] = 416] = \"RangeNotSatisfiable\";\n    HttpStatusCode[HttpStatusCode[\"ExpectationFailed\"] = 417] = \"ExpectationFailed\";\n    HttpStatusCode[HttpStatusCode[\"ImATeapot\"] = 418] = \"ImATeapot\";\n    HttpStatusCode[HttpStatusCode[\"MisdirectedRequest\"] = 421] = \"MisdirectedRequest\";\n    HttpStatusCode[HttpStatusCode[\"UnprocessableEntity\"] = 422] = \"UnprocessableEntity\";\n    HttpStatusCode[HttpStatusCode[\"Locked\"] = 423] = \"Locked\";\n    HttpStatusCode[HttpStatusCode[\"FailedDependency\"] = 424] = \"FailedDependency\";\n    HttpStatusCode[HttpStatusCode[\"TooEarly\"] = 425] = \"TooEarly\";\n    HttpStatusCode[HttpStatusCode[\"UpgradeRequired\"] = 426] = \"UpgradeRequired\";\n    HttpStatusCode[HttpStatusCode[\"PreconditionRequired\"] = 428] = \"PreconditionRequired\";\n    HttpStatusCode[HttpStatusCode[\"TooManyRequests\"] = 429] = \"TooManyRequests\";\n    HttpStatusCode[HttpStatusCode[\"RequestHeaderFieldsTooLarge\"] = 431] = \"RequestHeaderFieldsTooLarge\";\n    HttpStatusCode[HttpStatusCode[\"UnavailableForLegalReasons\"] = 451] = \"UnavailableForLegalReasons\";\n    HttpStatusCode[HttpStatusCode[\"InternalServerError\"] = 500] = \"InternalServerError\";\n    HttpStatusCode[HttpStatusCode[\"NotImplemented\"] = 501] = \"NotImplemented\";\n    HttpStatusCode[HttpStatusCode[\"BadGateway\"] = 502] = \"BadGateway\";\n    HttpStatusCode[HttpStatusCode[\"ServiceUnavailable\"] = 503] = \"ServiceUnavailable\";\n    HttpStatusCode[HttpStatusCode[\"GatewayTimeout\"] = 504] = \"GatewayTimeout\";\n    HttpStatusCode[HttpStatusCode[\"HttpVersionNotSupported\"] = 505] = \"HttpVersionNotSupported\";\n    HttpStatusCode[HttpStatusCode[\"VariantAlsoNegotiates\"] = 506] = \"VariantAlsoNegotiates\";\n    HttpStatusCode[HttpStatusCode[\"InsufficientStorage\"] = 507] = \"InsufficientStorage\";\n    HttpStatusCode[HttpStatusCode[\"LoopDetected\"] = 508] = \"LoopDetected\";\n    HttpStatusCode[HttpStatusCode[\"NotExtended\"] = 510] = \"NotExtended\";\n    HttpStatusCode[HttpStatusCode[\"NetworkAuthenticationRequired\"] = 511] = \"NetworkAuthenticationRequired\";\n})(HttpStatusCode || (HttpStatusCode = {}));\n\n/**\n * Constructs an instance of `HttpRequestOptions<T>` from a source `HttpMethodOptions` and\n * the given `body`. This function clones the object and adds the body.\n *\n * Note that the `responseType` *options* value is a String that identifies the\n * single data type of the response.\n * A single overload version of the method handles each response type.\n * The value of `responseType` cannot be a union, as the combined signature could imply.\n *\n */\nfunction addBody(options, body) {\n    return {\n        body,\n        headers: options.headers,\n        context: options.context,\n        observe: options.observe,\n        params: options.params,\n        reportProgress: options.reportProgress,\n        responseType: options.responseType,\n        withCredentials: options.withCredentials,\n        transferCache: options.transferCache,\n    };\n}\n/**\n * Performs HTTP requests.\n * This service is available as an injectable class, with methods to perform HTTP requests.\n * Each request method has multiple signatures, and the return type varies based on\n * the signature that is called (mainly the values of `observe` and `responseType`).\n *\n * Note that the `responseType` *options* value is a String that identifies the\n * single data type of the response.\n * A single overload version of the method handles each response type.\n * The value of `responseType` cannot be a union, as the combined signature could imply.\n\n * TODO(adev): review\n * @usageNotes\n *\n * ### HTTP Request Example\n *\n * ```\n *  // GET heroes whose name contains search term\n * searchHeroes(term: string): observable<Hero[]>{\n *\n *  const params = new HttpParams({fromString: 'name=term'});\n *    return this.httpClient.request('GET', this.heroesUrl, {responseType:'json', params});\n * }\n * ```\n *\n * Alternatively, the parameter string can be used without invoking HttpParams\n * by directly joining to the URL.\n * ```\n * this.httpClient.request('GET', this.heroesUrl + '?' + 'name=term', {responseType:'json'});\n * ```\n *\n *\n * ### JSONP Example\n * ```\n * requestJsonp(url, callback = 'callback') {\n *  return this.httpClient.jsonp(this.heroesURL, callback);\n * }\n * ```\n *\n * ### PATCH Example\n * ```\n * // PATCH one of the heroes' name\n * patchHero (id: number, heroName: string): Observable<{}> {\n * const url = `${this.heroesUrl}/${id}`;   // PATCH api/heroes/42\n *  return this.httpClient.patch(url, {name: heroName}, httpOptions)\n *    .pipe(catchError(this.handleError('patchHero')));\n * }\n * ```\n *\n * @see [HTTP Guide](guide/http)\n * @see [HTTP Request](api/common/http/HttpRequest)\n *\n * @publicApi\n */\nclass HttpClient {\n    constructor(handler) {\n        this.handler = handler;\n    }\n    /**\n     * Constructs an observable for a generic HTTP request that, when subscribed,\n     * fires the request through the chain of registered interceptors and on to the\n     * server.\n     *\n     * You can pass an `HttpRequest` directly as the only parameter. In this case,\n     * the call returns an observable of the raw `HttpEvent` stream.\n     *\n     * Alternatively you can pass an HTTP method as the first parameter,\n     * a URL string as the second, and an options hash containing the request body as the third.\n     * See `addBody()`. In this case, the specified `responseType` and `observe` options determine the\n     * type of returned observable.\n     *   * The `responseType` value determines how a successful response body is parsed.\n     *   * If `responseType` is the default `json`, you can pass a type interface for the resulting\n     * object as a type parameter to the call.\n     *\n     * The `observe` value determines the return type, according to what you are interested in\n     * observing.\n     *   * An `observe` value of events returns an observable of the raw `HttpEvent` stream, including\n     * progress events by default.\n     *   * An `observe` value of response returns an observable of `HttpResponse<T>`,\n     * where the `T` parameter depends on the `responseType` and any optionally provided type\n     * parameter.\n     *   * An `observe` value of body returns an observable of `<T>` with the same `T` body type.\n     *\n     */\n    request(first, url, options = {}) {\n        let req;\n        // First, check whether the primary argument is an instance of `HttpRequest`.\n        if (first instanceof HttpRequest) {\n            // It is. The other arguments must be undefined (per the signatures) and can be\n            // ignored.\n            req = first;\n        }\n        else {\n            // It's a string, so it represents a URL. Construct a request based on it,\n            // and incorporate the remaining arguments (assuming `GET` unless a method is\n            // provided.\n            // Figure out the headers.\n            let headers = undefined;\n            if (options.headers instanceof HttpHeaders) {\n                headers = options.headers;\n            }\n            else {\n                headers = new HttpHeaders(options.headers);\n            }\n            // Sort out parameters.\n            let params = undefined;\n            if (!!options.params) {\n                if (options.params instanceof HttpParams) {\n                    params = options.params;\n                }\n                else {\n                    params = new HttpParams({ fromObject: options.params });\n                }\n            }\n            // Construct the request.\n            req = new HttpRequest(first, url, options.body !== undefined ? options.body : null, {\n                headers,\n                context: options.context,\n                params,\n                reportProgress: options.reportProgress,\n                // By default, JSON is assumed to be returned for all calls.\n                responseType: options.responseType || 'json',\n                withCredentials: options.withCredentials,\n                transferCache: options.transferCache,\n            });\n        }\n        // Start with an Observable.of() the initial request, and run the handler (which\n        // includes all interceptors) inside a concatMap(). This way, the handler runs\n        // inside an Observable chain, which causes interceptors to be re-run on every\n        // subscription (this also makes retries re-run the handler, including interceptors).\n        const events$ = of(req).pipe(concatMap((req) => this.handler.handle(req)));\n        // If coming via the API signature which accepts a previously constructed HttpRequest,\n        // the only option is to get the event stream. Otherwise, return the event stream if\n        // that is what was requested.\n        if (first instanceof HttpRequest || options.observe === 'events') {\n            return events$;\n        }\n        // The requested stream contains either the full response or the body. In either\n        // case, the first step is to filter the event stream to extract a stream of\n        // responses(s).\n        const res$ = (events$.pipe(filter((event) => event instanceof HttpResponse)));\n        // Decide which stream to return.\n        switch (options.observe || 'body') {\n            case 'body':\n                // The requested stream is the body. Map the response stream to the response\n                // body. This could be done more simply, but a misbehaving interceptor might\n                // transform the response body into a different format and ignore the requested\n                // responseType. Guard against this by validating that the response is of the\n                // requested type.\n                switch (req.responseType) {\n                    case 'arraybuffer':\n                        return res$.pipe(map((res) => {\n                            // Validate that the body is an ArrayBuffer.\n                            if (res.body !== null && !(res.body instanceof ArrayBuffer)) {\n                                throw new Error('Response is not an ArrayBuffer.');\n                            }\n                            return res.body;\n                        }));\n                    case 'blob':\n                        return res$.pipe(map((res) => {\n                            // Validate that the body is a Blob.\n                            if (res.body !== null && !(res.body instanceof Blob)) {\n                                throw new Error('Response is not a Blob.');\n                            }\n                            return res.body;\n                        }));\n                    case 'text':\n                        return res$.pipe(map((res) => {\n                            // Validate that the body is a string.\n                            if (res.body !== null && typeof res.body !== 'string') {\n                                throw new Error('Response is not a string.');\n                            }\n                            return res.body;\n                        }));\n                    case 'json':\n                    default:\n                        // No validation needed for JSON responses, as they can be of any type.\n                        return res$.pipe(map((res) => res.body));\n                }\n            case 'response':\n                // The response stream was requested directly, so return it.\n                return res$;\n            default:\n                // Guard against new future observe types being added.\n                throw new Error(`Unreachable: unhandled observe type ${options.observe}}`);\n        }\n    }\n    /**\n     * Constructs an observable that, when subscribed, causes the configured\n     * `DELETE` request to execute on the server. See the individual overloads for\n     * details on the return type.\n     *\n     * @param url     The endpoint URL.\n     * @param options The HTTP options to send with the request.\n     *\n     */\n    delete(url, options = {}) {\n        return this.request('DELETE', url, options);\n    }\n    /**\n     * Constructs an observable that, when subscribed, causes the configured\n     * `GET` request to execute on the server. See the individual overloads for\n     * details on the return type.\n     */\n    get(url, options = {}) {\n        return this.request('GET', url, options);\n    }\n    /**\n     * Constructs an observable that, when subscribed, causes the configured\n     * `HEAD` request to execute on the server. The `HEAD` method returns\n     * meta information about the resource without transferring the\n     * resource itself. See the individual overloads for\n     * details on the return type.\n     */\n    head(url, options = {}) {\n        return this.request('HEAD', url, options);\n    }\n    /**\n     * Constructs an `Observable` that, when subscribed, causes a request with the special method\n     * `JSONP` to be dispatched via the interceptor pipeline.\n     * The [JSONP pattern](https://en.wikipedia.org/wiki/JSONP) works around limitations of certain\n     * API endpoints that don't support newer,\n     * and preferable [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) protocol.\n     * JSONP treats the endpoint API as a JavaScript file and tricks the browser to process the\n     * requests even if the API endpoint is not located on the same domain (origin) as the client-side\n     * application making the request.\n     * The endpoint API must support JSONP callback for JSONP requests to work.\n     * The resource API returns the JSON response wrapped in a callback function.\n     * You can pass the callback function name as one of the query parameters.\n     * Note that JSONP requests can only be used with `GET` requests.\n     *\n     * @param url The resource URL.\n     * @param callbackParam The callback function name.\n     *\n     */\n    jsonp(url, callbackParam) {\n        return this.request('JSONP', url, {\n            params: new HttpParams().append(callbackParam, 'JSONP_CALLBACK'),\n            observe: 'body',\n            responseType: 'json',\n        });\n    }\n    /**\n     * Constructs an `Observable` that, when subscribed, causes the configured\n     * `OPTIONS` request to execute on the server. This method allows the client\n     * to determine the supported HTTP methods and other capabilities of an endpoint,\n     * without implying a resource action. See the individual overloads for\n     * details on the return type.\n     */\n    options(url, options = {}) {\n        return this.request('OPTIONS', url, options);\n    }\n    /**\n     * Constructs an observable that, when subscribed, causes the configured\n     * `PATCH` request to execute on the server. See the individual overloads for\n     * details on the return type.\n     */\n    patch(url, body, options = {}) {\n        return this.request('PATCH', url, addBody(options, body));\n    }\n    /**\n     * Constructs an observable that, when subscribed, causes the configured\n     * `POST` request to execute on the server. The server responds with the location of\n     * the replaced resource. See the individual overloads for\n     * details on the return type.\n     */\n    post(url, body, options = {}) {\n        return this.request('POST', url, addBody(options, body));\n    }\n    /**\n     * Constructs an observable that, when subscribed, causes the configured\n     * `PUT` request to execute on the server. The `PUT` method replaces an existing resource\n     * with a new set of values.\n     * See the individual overloads for details on the return type.\n     */\n    put(url, body, options = {}) {\n        return this.request('PUT', url, addBody(options, body));\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClient, deps: [{ token: HttpHandler }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClient }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClient, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: HttpHandler }] });\n\nconst XSSI_PREFIX$1 = /^\\)\\]\\}',?\\n/;\nconst REQUEST_URL_HEADER = `X-Request-URL`;\n/**\n * Determine an appropriate URL for the response, by checking either\n * response url or the X-Request-URL header.\n */\nfunction getResponseUrl$1(response) {\n    if (response.url) {\n        return response.url;\n    }\n    // stored as lowercase in the map\n    const xRequestUrl = REQUEST_URL_HEADER.toLocaleLowerCase();\n    return response.headers.get(xRequestUrl);\n}\n/**\n * Uses `fetch` to send requests to a backend server.\n *\n * This `FetchBackend` requires the support of the\n * [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) which is available on all\n * supported browsers and on Node.js v18 or later.\n *\n * @see {@link HttpHandler}\n *\n * @publicApi\n */\nclass FetchBackend {\n    constructor() {\n        // We use an arrow function to always reference the current global implementation of `fetch`.\n        // This is helpful for cases when the global `fetch` implementation is modified by external code,\n        // see https://github.com/angular/angular/issues/57527.\n        this.fetchImpl = inject(FetchFactory, { optional: true })?.fetch ?? ((...args) => globalThis.fetch(...args));\n        this.ngZone = inject(NgZone);\n    }\n    handle(request) {\n        return new Observable((observer) => {\n            const aborter = new AbortController();\n            this.doRequest(request, aborter.signal, observer).then(noop, (error) => observer.error(new HttpErrorResponse({ error })));\n            return () => aborter.abort();\n        });\n    }\n    async doRequest(request, signal, observer) {\n        const init = this.createRequestInit(request);\n        let response;\n        try {\n            // Run fetch outside of Angular zone.\n            // This is due to Node.js fetch implementation (Undici) which uses a number of setTimeouts to check if\n            // the response should eventually timeout which causes extra CD cycles every 500ms\n            const fetchPromise = this.ngZone.runOutsideAngular(() => this.fetchImpl(request.urlWithParams, { signal, ...init }));\n            // Make sure Zone.js doesn't trigger false-positive unhandled promise\n            // error in case the Promise is rejected synchronously. See function\n            // description for additional information.\n            silenceSuperfluousUnhandledPromiseRejection(fetchPromise);\n            // Send the `Sent` event before awaiting the response.\n            observer.next({ type: HttpEventType.Sent });\n            response = await fetchPromise;\n        }\n        catch (error) {\n            observer.error(new HttpErrorResponse({\n                error,\n                status: error.status ?? 0,\n                statusText: error.statusText,\n                url: request.urlWithParams,\n                headers: error.headers,\n            }));\n            return;\n        }\n        const headers = new HttpHeaders(response.headers);\n        const statusText = response.statusText;\n        const url = getResponseUrl$1(response) ?? request.urlWithParams;\n        let status = response.status;\n        let body = null;\n        if (request.reportProgress) {\n            observer.next(new HttpHeaderResponse({ headers, status, statusText, url }));\n        }\n        if (response.body) {\n            // Read Progress\n            const contentLength = response.headers.get('content-length');\n            const chunks = [];\n            const reader = response.body.getReader();\n            let receivedLength = 0;\n            let decoder;\n            let partialText;\n            // We have to check whether the Zone is defined in the global scope because this may be called\n            // when the zone is nooped.\n            const reqZone = typeof Zone !== 'undefined' && Zone.current;\n            // Perform response processing outside of Angular zone to\n            // ensure no excessive change detection runs are executed\n            // Here calling the async ReadableStreamDefaultReader.read() is responsible for triggering CD\n            await this.ngZone.runOutsideAngular(async () => {\n                while (true) {\n                    const { done, value } = await reader.read();\n                    if (done) {\n                        break;\n                    }\n                    chunks.push(value);\n                    receivedLength += value.length;\n                    if (request.reportProgress) {\n                        partialText =\n                            request.responseType === 'text'\n                                ? (partialText ?? '') +\n                                    (decoder ??= new TextDecoder()).decode(value, { stream: true })\n                                : undefined;\n                        const reportProgress = () => observer.next({\n                            type: HttpEventType.DownloadProgress,\n                            total: contentLength ? +contentLength : undefined,\n                            loaded: receivedLength,\n                            partialText,\n                        });\n                        reqZone ? reqZone.run(reportProgress) : reportProgress();\n                    }\n                }\n            });\n            // Combine all chunks.\n            const chunksAll = this.concatChunks(chunks, receivedLength);\n            try {\n                const contentType = response.headers.get('Content-Type') ?? '';\n                body = this.parseBody(request, chunksAll, contentType);\n            }\n            catch (error) {\n                // Body loading or parsing failed\n                observer.error(new HttpErrorResponse({\n                    error,\n                    headers: new HttpHeaders(response.headers),\n                    status: response.status,\n                    statusText: response.statusText,\n                    url: getResponseUrl$1(response) ?? request.urlWithParams,\n                }));\n                return;\n            }\n        }\n        // Same behavior as the XhrBackend\n        if (status === 0) {\n            status = body ? HTTP_STATUS_CODE_OK : 0;\n        }\n        // ok determines whether the response will be transmitted on the event or\n        // error channel. Unsuccessful status codes (not 2xx) will always be errors,\n        // but a successful status code can still result in an error if the user\n        // asked for JSON data and the body cannot be parsed as such.\n        const ok = status >= 200 && status < 300;\n        if (ok) {\n            observer.next(new HttpResponse({\n                body,\n                headers,\n                status,\n                statusText,\n                url,\n            }));\n            // The full body has been received and delivered, no further events\n            // are possible. This request is complete.\n            observer.complete();\n        }\n        else {\n            observer.error(new HttpErrorResponse({\n                error: body,\n                headers,\n                status,\n                statusText,\n                url,\n            }));\n        }\n    }\n    parseBody(request, binContent, contentType) {\n        switch (request.responseType) {\n            case 'json':\n                // stripping the XSSI when present\n                const text = new TextDecoder().decode(binContent).replace(XSSI_PREFIX$1, '');\n                return text === '' ? null : JSON.parse(text);\n            case 'text':\n                return new TextDecoder().decode(binContent);\n            case 'blob':\n                return new Blob([binContent], { type: contentType });\n            case 'arraybuffer':\n                return binContent.buffer;\n        }\n    }\n    createRequestInit(req) {\n        // We could share some of this logic with the XhrBackend\n        const headers = {};\n        const credentials = req.withCredentials ? 'include' : undefined;\n        // Setting all the requested headers.\n        req.headers.forEach((name, values) => (headers[name] = values.join(',')));\n        // Add an Accept header if one isn't present already.\n        if (!req.headers.has('Accept')) {\n            headers['Accept'] = 'application/json, text/plain, */*';\n        }\n        // Auto-detect the Content-Type header if one isn't present already.\n        if (!req.headers.has('Content-Type')) {\n            const detectedType = req.detectContentTypeHeader();\n            // Sometimes Content-Type detection fails.\n            if (detectedType !== null) {\n                headers['Content-Type'] = detectedType;\n            }\n        }\n        return {\n            body: req.serializeBody(),\n            method: req.method,\n            headers,\n            credentials,\n        };\n    }\n    concatChunks(chunks, totalLength) {\n        const chunksAll = new Uint8Array(totalLength);\n        let position = 0;\n        for (const chunk of chunks) {\n            chunksAll.set(chunk, position);\n            position += chunk.length;\n        }\n        return chunksAll;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: FetchBackend, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: FetchBackend }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: FetchBackend, decorators: [{\n            type: Injectable\n        }] });\n/**\n * Abstract class to provide a mocked implementation of `fetch()`\n */\nclass FetchFactory {\n}\nfunction noop() { }\n/**\n * Zone.js treats a rejected promise that has not yet been awaited\n * as an unhandled error. This function adds a noop `.then` to make\n * sure that Zone.js doesn't throw an error if the Promise is rejected\n * synchronously.\n */\nfunction silenceSuperfluousUnhandledPromiseRejection(promise) {\n    promise.then(noop, noop);\n}\n\nfunction interceptorChainEndFn(req, finalHandlerFn) {\n    return finalHandlerFn(req);\n}\n/**\n * Constructs a `ChainedInterceptorFn` which adapts a legacy `HttpInterceptor` to the\n * `ChainedInterceptorFn` interface.\n */\nfunction adaptLegacyInterceptorToChain(chainTailFn, interceptor) {\n    return (initialRequest, finalHandlerFn) => interceptor.intercept(initialRequest, {\n        handle: (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn),\n    });\n}\n/**\n * Constructs a `ChainedInterceptorFn` which wraps and invokes a functional interceptor in the given\n * injector.\n */\nfunction chainedInterceptorFn(chainTailFn, interceptorFn, injector) {\n    return (initialRequest, finalHandlerFn) => runInInjectionContext(injector, () => interceptorFn(initialRequest, (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn)));\n}\n/**\n * A multi-provider token that represents the array of registered\n * `HttpInterceptor` objects.\n *\n * @publicApi\n */\nconst HTTP_INTERCEPTORS = new InjectionToken(ngDevMode ? 'HTTP_INTERCEPTORS' : '');\n/**\n * A multi-provided token of `HttpInterceptorFn`s.\n */\nconst HTTP_INTERCEPTOR_FNS = new InjectionToken(ngDevMode ? 'HTTP_INTERCEPTOR_FNS' : '');\n/**\n * A multi-provided token of `HttpInterceptorFn`s that are only set in root.\n */\nconst HTTP_ROOT_INTERCEPTOR_FNS = new InjectionToken(ngDevMode ? 'HTTP_ROOT_INTERCEPTOR_FNS' : '');\n// TODO(atscott): We need a larger discussion about stability and what should contribute to stability.\n// Should the whole interceptor chain contribute to stability or just the backend request #55075?\n// Should HttpClient contribute to stability automatically at all?\nconst REQUESTS_CONTRIBUTE_TO_STABILITY = new InjectionToken(ngDevMode ? 'REQUESTS_CONTRIBUTE_TO_STABILITY' : '', { providedIn: 'root', factory: () => true });\n/**\n * Creates an `HttpInterceptorFn` which lazily initializes an interceptor chain from the legacy\n * class-based interceptors and runs the request through it.\n */\nfunction legacyInterceptorFnFactory() {\n    let chain = null;\n    return (req, handler) => {\n        if (chain === null) {\n            const interceptors = inject(HTTP_INTERCEPTORS, { optional: true }) ?? [];\n            // Note: interceptors are wrapped right-to-left so that final execution order is\n            // left-to-right. That is, if `interceptors` is the array `[a, b, c]`, we want to\n            // produce a chain that is conceptually `c(b(a(end)))`, which we build from the inside\n            // out.\n            chain = interceptors.reduceRight(adaptLegacyInterceptorToChain, interceptorChainEndFn);\n        }\n        const pendingTasks = inject(ɵPendingTasks);\n        const contributeToStability = inject(REQUESTS_CONTRIBUTE_TO_STABILITY);\n        if (contributeToStability) {\n            const taskId = pendingTasks.add();\n            return chain(req, handler).pipe(finalize(() => pendingTasks.remove(taskId)));\n        }\n        else {\n            return chain(req, handler);\n        }\n    };\n}\nlet fetchBackendWarningDisplayed = false;\n/** Internal function to reset the flag in tests */\nfunction resetFetchBackendWarningFlag() {\n    fetchBackendWarningDisplayed = false;\n}\nclass HttpInterceptorHandler extends HttpHandler {\n    constructor(backend, injector) {\n        super();\n        this.backend = backend;\n        this.injector = injector;\n        this.chain = null;\n        this.pendingTasks = inject(ɵPendingTasks);\n        this.contributeToStability = inject(REQUESTS_CONTRIBUTE_TO_STABILITY);\n        // We strongly recommend using fetch backend for HTTP calls when SSR is used\n        // for an application. The logic below checks if that's the case and produces\n        // a warning otherwise.\n        if ((typeof ngDevMode === 'undefined' || ngDevMode) && !fetchBackendWarningDisplayed) {\n            const isServer = isPlatformServer(injector.get(PLATFORM_ID));\n            if (isServer && !(this.backend instanceof FetchBackend)) {\n                fetchBackendWarningDisplayed = true;\n                injector\n                    .get(ɵConsole)\n                    .warn(ɵformatRuntimeError(2801 /* RuntimeErrorCode.NOT_USING_FETCH_BACKEND_IN_SSR */, 'Angular detected that `HttpClient` is not configured ' +\n                    \"to use `fetch` APIs. It's strongly recommended to \" +\n                    'enable `fetch` for applications that use Server-Side Rendering ' +\n                    'for better performance and compatibility. ' +\n                    'To enable `fetch`, add the `withFetch()` to the `provideHttpClient()` ' +\n                    'call at the root of the application.'));\n            }\n        }\n    }\n    handle(initialRequest) {\n        if (this.chain === null) {\n            const dedupedInterceptorFns = Array.from(new Set([\n                ...this.injector.get(HTTP_INTERCEPTOR_FNS),\n                ...this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, []),\n            ]));\n            // Note: interceptors are wrapped right-to-left so that final execution order is\n            // left-to-right. That is, if `dedupedInterceptorFns` is the array `[a, b, c]`, we want to\n            // produce a chain that is conceptually `c(b(a(end)))`, which we build from the inside\n            // out.\n            this.chain = dedupedInterceptorFns.reduceRight((nextSequencedFn, interceptorFn) => chainedInterceptorFn(nextSequencedFn, interceptorFn, this.injector), interceptorChainEndFn);\n        }\n        if (this.contributeToStability) {\n            const taskId = this.pendingTasks.add();\n            return this.chain(initialRequest, (downstreamRequest) => this.backend.handle(downstreamRequest)).pipe(finalize(() => this.pendingTasks.remove(taskId)));\n        }\n        else {\n            return this.chain(initialRequest, (downstreamRequest) => this.backend.handle(downstreamRequest));\n        }\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpInterceptorHandler, deps: [{ token: HttpBackend }, { token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpInterceptorHandler }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpInterceptorHandler, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: HttpBackend }, { type: i0.EnvironmentInjector }] });\n\n// Every request made through JSONP needs a callback name that's unique across the\n// whole page. Each request is assigned an id and the callback name is constructed\n// from that. The next id to be assigned is tracked in a global variable here that\n// is shared among all applications on the page.\nlet nextRequestId = 0;\n/**\n * When a pending <script> is unsubscribed we'll move it to this document, so it won't be\n * executed.\n */\nlet foreignDocument;\n// Error text given when a JSONP script is injected, but doesn't invoke the callback\n// passed in its URL.\nconst JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';\n// Error text given when a request is passed to the JsonpClientBackend that doesn't\n// have a request method JSONP.\nconst JSONP_ERR_WRONG_METHOD = 'JSONP requests must use JSONP request method.';\nconst JSONP_ERR_WRONG_RESPONSE_TYPE = 'JSONP requests must use Json response type.';\n// Error text given when a request is passed to the JsonpClientBackend that has\n// headers set\nconst JSONP_ERR_HEADERS_NOT_SUPPORTED = 'JSONP requests do not support headers.';\n/**\n * DI token/abstract type representing a map of JSONP callbacks.\n *\n * In the browser, this should always be the `window` object.\n *\n *\n */\nclass JsonpCallbackContext {\n}\n/**\n * Factory function that determines where to store JSONP callbacks.\n *\n * Ordinarily JSONP callbacks are stored on the `window` object, but this may not exist\n * in test environments. In that case, callbacks are stored on an anonymous object instead.\n *\n *\n */\nfunction jsonpCallbackContext() {\n    if (typeof window === 'object') {\n        return window;\n    }\n    return {};\n}\n/**\n * Processes an `HttpRequest` with the JSONP method,\n * by performing JSONP style requests.\n * @see {@link HttpHandler}\n * @see {@link HttpXhrBackend}\n *\n * @publicApi\n */\nclass JsonpClientBackend {\n    constructor(callbackMap, document) {\n        this.callbackMap = callbackMap;\n        this.document = document;\n        /**\n         * A resolved promise that can be used to schedule microtasks in the event handlers.\n         */\n        this.resolvedPromise = Promise.resolve();\n    }\n    /**\n     * Get the name of the next callback method, by incrementing the global `nextRequestId`.\n     */\n    nextCallback() {\n        return `ng_jsonp_callback_${nextRequestId++}`;\n    }\n    /**\n     * Processes a JSONP request and returns an event stream of the results.\n     * @param req The request object.\n     * @returns An observable of the response events.\n     *\n     */\n    handle(req) {\n        // Firstly, check both the method and response type. If either doesn't match\n        // then the request was improperly routed here and cannot be handled.\n        if (req.method !== 'JSONP') {\n            throw new Error(JSONP_ERR_WRONG_METHOD);\n        }\n        else if (req.responseType !== 'json') {\n            throw new Error(JSONP_ERR_WRONG_RESPONSE_TYPE);\n        }\n        // Check the request headers. JSONP doesn't support headers and\n        // cannot set any that were supplied.\n        if (req.headers.keys().length > 0) {\n            throw new Error(JSONP_ERR_HEADERS_NOT_SUPPORTED);\n        }\n        // Everything else happens inside the Observable boundary.\n        return new Observable((observer) => {\n            // The first step to make a request is to generate the callback name, and replace the\n            // callback placeholder in the URL with the name. Care has to be taken here to ensure\n            // a trailing &, if matched, gets inserted back into the URL in the correct place.\n            const callback = this.nextCallback();\n            const url = req.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/, `=${callback}$1`);\n            // Construct the <script> tag and point it at the URL.\n            const node = this.document.createElement('script');\n            node.src = url;\n            // A JSONP request requires waiting for multiple callbacks. These variables\n            // are closed over and track state across those callbacks.\n            // The response object, if one has been received, or null otherwise.\n            let body = null;\n            // Whether the response callback has been called.\n            let finished = false;\n            // Set the response callback in this.callbackMap (which will be the window\n            // object in the browser. The script being loaded via the <script> tag will\n            // eventually call this callback.\n            this.callbackMap[callback] = (data) => {\n                // Data has been received from the JSONP script. Firstly, delete this callback.\n                delete this.callbackMap[callback];\n                // Set state to indicate data was received.\n                body = data;\n                finished = true;\n            };\n            // cleanup() is a utility closure that removes the <script> from the page and\n            // the response callback from the window. This logic is used in both the\n            // success, error, and cancellation paths, so it's extracted out for convenience.\n            const cleanup = () => {\n                node.removeEventListener('load', onLoad);\n                node.removeEventListener('error', onError);\n                // Remove the <script> tag if it's still on the page.\n                node.remove();\n                // Remove the response callback from the callbackMap (window object in the\n                // browser).\n                delete this.callbackMap[callback];\n            };\n            // onLoad() is the success callback which runs after the response callback\n            // if the JSONP script loads successfully. The event itself is unimportant.\n            // If something went wrong, onLoad() may run without the response callback\n            // having been invoked.\n            const onLoad = (event) => {\n                // We wrap it in an extra Promise, to ensure the microtask\n                // is scheduled after the loaded endpoint has executed any potential microtask itself,\n                // which is not guaranteed in Internet Explorer and EdgeHTML. See issue #39496\n                this.resolvedPromise.then(() => {\n                    // Cleanup the page.\n                    cleanup();\n                    // Check whether the response callback has run.\n                    if (!finished) {\n                        // It hasn't, something went wrong with the request. Return an error via\n                        // the Observable error path. All JSONP errors have status 0.\n                        observer.error(new HttpErrorResponse({\n                            url,\n                            status: 0,\n                            statusText: 'JSONP Error',\n                            error: new Error(JSONP_ERR_NO_CALLBACK),\n                        }));\n                        return;\n                    }\n                    // Success. body either contains the response body or null if none was\n                    // returned.\n                    observer.next(new HttpResponse({\n                        body,\n                        status: HTTP_STATUS_CODE_OK,\n                        statusText: 'OK',\n                        url,\n                    }));\n                    // Complete the stream, the response is over.\n                    observer.complete();\n                });\n            };\n            // onError() is the error callback, which runs if the script returned generates\n            // a Javascript error. It emits the error via the Observable error channel as\n            // a HttpErrorResponse.\n            const onError = (error) => {\n                cleanup();\n                // Wrap the error in a HttpErrorResponse.\n                observer.error(new HttpErrorResponse({\n                    error,\n                    status: 0,\n                    statusText: 'JSONP Error',\n                    url,\n                }));\n            };\n            // Subscribe to both the success (load) and error events on the <script> tag,\n            // and add it to the page.\n            node.addEventListener('load', onLoad);\n            node.addEventListener('error', onError);\n            this.document.body.appendChild(node);\n            // The request has now been successfully sent.\n            observer.next({ type: HttpEventType.Sent });\n            // Cancellation handler.\n            return () => {\n                if (!finished) {\n                    this.removeListeners(node);\n                }\n                // And finally, clean up the page.\n                cleanup();\n            };\n        });\n    }\n    removeListeners(script) {\n        // Issue #34818\n        // Changing <script>'s ownerDocument will prevent it from execution.\n        // https://html.spec.whatwg.org/multipage/scripting.html#execute-the-script-block\n        foreignDocument ??= this.document.implementation.createHTMLDocument();\n        foreignDocument.adoptNode(script);\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: JsonpClientBackend, deps: [{ token: JsonpCallbackContext }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: JsonpClientBackend }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: JsonpClientBackend, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: JsonpCallbackContext }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }] });\n/**\n * Identifies requests with the method JSONP and shifts them to the `JsonpClientBackend`.\n */\nfunction jsonpInterceptorFn(req, next) {\n    if (req.method === 'JSONP') {\n        return inject(JsonpClientBackend).handle(req);\n    }\n    // Fall through for normal HTTP requests.\n    return next(req);\n}\n/**\n * Identifies requests with the method JSONP and\n * shifts them to the `JsonpClientBackend`.\n *\n * @see {@link HttpInterceptor}\n *\n * @publicApi\n */\nclass JsonpInterceptor {\n    constructor(injector) {\n        this.injector = injector;\n    }\n    /**\n     * Identifies and handles a given JSONP request.\n     * @param initialRequest The outgoing request object to handle.\n     * @param next The next interceptor in the chain, or the backend\n     * if no interceptors remain in the chain.\n     * @returns An observable of the event stream.\n     */\n    intercept(initialRequest, next) {\n        return runInInjectionContext(this.injector, () => jsonpInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: JsonpInterceptor, deps: [{ token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: JsonpInterceptor }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: JsonpInterceptor, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: i0.EnvironmentInjector }] });\n\nconst XSSI_PREFIX = /^\\)\\]\\}',?\\n/;\n/**\n * Determine an appropriate URL for the response, by checking either\n * XMLHttpRequest.responseURL or the X-Request-URL header.\n */\nfunction getResponseUrl(xhr) {\n    if ('responseURL' in xhr && xhr.responseURL) {\n        return xhr.responseURL;\n    }\n    if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {\n        return xhr.getResponseHeader('X-Request-URL');\n    }\n    return null;\n}\n/**\n * Uses `XMLHttpRequest` to send requests to a backend server.\n * @see {@link HttpHandler}\n * @see {@link JsonpClientBackend}\n *\n * @publicApi\n */\nclass HttpXhrBackend {\n    constructor(xhrFactory) {\n        this.xhrFactory = xhrFactory;\n    }\n    /**\n     * Processes a request and returns a stream of response events.\n     * @param req The request object.\n     * @returns An observable of the response events.\n     */\n    handle(req) {\n        // Quick check to give a better error message when a user attempts to use\n        // HttpClient.jsonp() without installing the HttpClientJsonpModule\n        if (req.method === 'JSONP') {\n            throw new ɵRuntimeError(-2800 /* RuntimeErrorCode.MISSING_JSONP_MODULE */, (typeof ngDevMode === 'undefined' || ngDevMode) &&\n                `Cannot make a JSONP request without JSONP support. To fix the problem, either add the \\`withJsonpSupport()\\` call (if \\`provideHttpClient()\\` is used) or import the \\`HttpClientJsonpModule\\` in the root NgModule.`);\n        }\n        // Check whether this factory has a special function to load an XHR implementation\n        // for various non-browser environments. We currently limit it to only `ServerXhr`\n        // class, which needs to load an XHR implementation.\n        const xhrFactory = this.xhrFactory;\n        const source = xhrFactory.ɵloadImpl\n            ? from(xhrFactory.ɵloadImpl())\n            : of(null);\n        return source.pipe(switchMap(() => {\n            // Everything happens on Observable subscription.\n            return new Observable((observer) => {\n                // Start by setting up the XHR object with request method, URL, and withCredentials\n                // flag.\n                const xhr = xhrFactory.build();\n                xhr.open(req.method, req.urlWithParams);\n                if (req.withCredentials) {\n                    xhr.withCredentials = true;\n                }\n                // Add all the requested headers.\n                req.headers.forEach((name, values) => xhr.setRequestHeader(name, values.join(',')));\n                // Add an Accept header if one isn't present already.\n                if (!req.headers.has('Accept')) {\n                    xhr.setRequestHeader('Accept', 'application/json, text/plain, */*');\n                }\n                // Auto-detect the Content-Type header if one isn't present already.\n                if (!req.headers.has('Content-Type')) {\n                    const detectedType = req.detectContentTypeHeader();\n                    // Sometimes Content-Type detection fails.\n                    if (detectedType !== null) {\n                        xhr.setRequestHeader('Content-Type', detectedType);\n                    }\n                }\n                // Set the responseType if one was requested.\n                if (req.responseType) {\n                    const responseType = req.responseType.toLowerCase();\n                    // JSON responses need to be processed as text. This is because if the server\n                    // returns an XSSI-prefixed JSON response, the browser will fail to parse it,\n                    // xhr.response will be null, and xhr.responseText cannot be accessed to\n                    // retrieve the prefixed JSON data in order to strip the prefix. Thus, all JSON\n                    // is parsed by first requesting text and then applying JSON.parse.\n                    xhr.responseType = (responseType !== 'json' ? responseType : 'text');\n                }\n                // Serialize the request body if one is present. If not, this will be set to null.\n                const reqBody = req.serializeBody();\n                // If progress events are enabled, response headers will be delivered\n                // in two events - the HttpHeaderResponse event and the full HttpResponse\n                // event. However, since response headers don't change in between these\n                // two events, it doesn't make sense to parse them twice. So headerResponse\n                // caches the data extracted from the response whenever it's first parsed,\n                // to ensure parsing isn't duplicated.\n                let headerResponse = null;\n                // partialFromXhr extracts the HttpHeaderResponse from the current XMLHttpRequest\n                // state, and memoizes it into headerResponse.\n                const partialFromXhr = () => {\n                    if (headerResponse !== null) {\n                        return headerResponse;\n                    }\n                    const statusText = xhr.statusText || 'OK';\n                    // Parse headers from XMLHttpRequest - this step is lazy.\n                    const headers = new HttpHeaders(xhr.getAllResponseHeaders());\n                    // Read the response URL from the XMLHttpResponse instance and fall back on the\n                    // request URL.\n                    const url = getResponseUrl(xhr) || req.url;\n                    // Construct the HttpHeaderResponse and memoize it.\n                    headerResponse = new HttpHeaderResponse({ headers, status: xhr.status, statusText, url });\n                    return headerResponse;\n                };\n                // Next, a few closures are defined for the various events which XMLHttpRequest can\n                // emit. This allows them to be unregistered as event listeners later.\n                // First up is the load event, which represents a response being fully available.\n                const onLoad = () => {\n                    // Read response state from the memoized partial data.\n                    let { headers, status, statusText, url } = partialFromXhr();\n                    // The body will be read out if present.\n                    let body = null;\n                    if (status !== HTTP_STATUS_CODE_NO_CONTENT) {\n                        // Use XMLHttpRequest.response if set, responseText otherwise.\n                        body = typeof xhr.response === 'undefined' ? xhr.responseText : xhr.response;\n                    }\n                    // Normalize another potential bug (this one comes from CORS).\n                    if (status === 0) {\n                        status = !!body ? HTTP_STATUS_CODE_OK : 0;\n                    }\n                    // ok determines whether the response will be transmitted on the event or\n                    // error channel. Unsuccessful status codes (not 2xx) will always be errors,\n                    // but a successful status code can still result in an error if the user\n                    // asked for JSON data and the body cannot be parsed as such.\n                    let ok = status >= 200 && status < 300;\n                    // Check whether the body needs to be parsed as JSON (in many cases the browser\n                    // will have done that already).\n                    if (req.responseType === 'json' && typeof body === 'string') {\n                        // Save the original body, before attempting XSSI prefix stripping.\n                        const originalBody = body;\n                        body = body.replace(XSSI_PREFIX, '');\n                        try {\n                            // Attempt the parse. If it fails, a parse error should be delivered to the\n                            // user.\n                            body = body !== '' ? JSON.parse(body) : null;\n                        }\n                        catch (error) {\n                            // Since the JSON.parse failed, it's reasonable to assume this might not have\n                            // been a JSON response. Restore the original body (including any XSSI prefix)\n                            // to deliver a better error response.\n                            body = originalBody;\n                            // If this was an error request to begin with, leave it as a string, it\n                            // probably just isn't JSON. Otherwise, deliver the parsing error to the user.\n                            if (ok) {\n                                // Even though the response status was 2xx, this is still an error.\n                                ok = false;\n                                // The parse error contains the text of the body that failed to parse.\n                                body = { error, text: body };\n                            }\n                        }\n                    }\n                    if (ok) {\n                        // A successful response is delivered on the event stream.\n                        observer.next(new HttpResponse({\n                            body,\n                            headers,\n                            status,\n                            statusText,\n                            url: url || undefined,\n                        }));\n                        // The full body has been received and delivered, no further events\n                        // are possible. This request is complete.\n                        observer.complete();\n                    }\n                    else {\n                        // An unsuccessful request is delivered on the error channel.\n                        observer.error(new HttpErrorResponse({\n                            // The error in this case is the response body (error from the server).\n                            error: body,\n                            headers,\n                            status,\n                            statusText,\n                            url: url || undefined,\n                        }));\n                    }\n                };\n                // The onError callback is called when something goes wrong at the network level.\n                // Connection timeout, DNS error, offline, etc. These are actual errors, and are\n                // transmitted on the error channel.\n                const onError = (error) => {\n                    const { url } = partialFromXhr();\n                    const res = new HttpErrorResponse({\n                        error,\n                        status: xhr.status || 0,\n                        statusText: xhr.statusText || 'Unknown Error',\n                        url: url || undefined,\n                    });\n                    observer.error(res);\n                };\n                // The sentHeaders flag tracks whether the HttpResponseHeaders event\n                // has been sent on the stream. This is necessary to track if progress\n                // is enabled since the event will be sent on only the first download\n                // progress event.\n                let sentHeaders = false;\n                // The download progress event handler, which is only registered if\n                // progress events are enabled.\n                const onDownProgress = (event) => {\n                    // Send the HttpResponseHeaders event if it hasn't been sent already.\n                    if (!sentHeaders) {\n                        observer.next(partialFromXhr());\n                        sentHeaders = true;\n                    }\n                    // Start building the download progress event to deliver on the response\n                    // event stream.\n                    let progressEvent = {\n                        type: HttpEventType.DownloadProgress,\n                        loaded: event.loaded,\n                    };\n                    // Set the total number of bytes in the event if it's available.\n                    if (event.lengthComputable) {\n                        progressEvent.total = event.total;\n                    }\n                    // If the request was for text content and a partial response is\n                    // available on XMLHttpRequest, include it in the progress event\n                    // to allow for streaming reads.\n                    if (req.responseType === 'text' && !!xhr.responseText) {\n                        progressEvent.partialText = xhr.responseText;\n                    }\n                    // Finally, fire the event.\n                    observer.next(progressEvent);\n                };\n                // The upload progress event handler, which is only registered if\n                // progress events are enabled.\n                const onUpProgress = (event) => {\n                    // Upload progress events are simpler. Begin building the progress\n                    // event.\n                    let progress = {\n                        type: HttpEventType.UploadProgress,\n                        loaded: event.loaded,\n                    };\n                    // If the total number of bytes being uploaded is available, include\n                    // it.\n                    if (event.lengthComputable) {\n                        progress.total = event.total;\n                    }\n                    // Send the event.\n                    observer.next(progress);\n                };\n                // By default, register for load and error events.\n                xhr.addEventListener('load', onLoad);\n                xhr.addEventListener('error', onError);\n                xhr.addEventListener('timeout', onError);\n                xhr.addEventListener('abort', onError);\n                // Progress events are only enabled if requested.\n                if (req.reportProgress) {\n                    // Download progress is always enabled if requested.\n                    xhr.addEventListener('progress', onDownProgress);\n                    // Upload progress depends on whether there is a body to upload.\n                    if (reqBody !== null && xhr.upload) {\n                        xhr.upload.addEventListener('progress', onUpProgress);\n                    }\n                }\n                // Fire the request, and notify the event stream that it was fired.\n                xhr.send(reqBody);\n                observer.next({ type: HttpEventType.Sent });\n                // This is the return from the Observable function, which is the\n                // request cancellation handler.\n                return () => {\n                    // On a cancellation, remove all registered event listeners.\n                    xhr.removeEventListener('error', onError);\n                    xhr.removeEventListener('abort', onError);\n                    xhr.removeEventListener('load', onLoad);\n                    xhr.removeEventListener('timeout', onError);\n                    if (req.reportProgress) {\n                        xhr.removeEventListener('progress', onDownProgress);\n                        if (reqBody !== null && xhr.upload) {\n                            xhr.upload.removeEventListener('progress', onUpProgress);\n                        }\n                    }\n                    // Finally, abort the in-flight request.\n                    if (xhr.readyState !== xhr.DONE) {\n                        xhr.abort();\n                    }\n                };\n            });\n        }));\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpXhrBackend, deps: [{ token: i1.XhrFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpXhrBackend }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpXhrBackend, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: i1.XhrFactory }] });\n\nconst XSRF_ENABLED = new InjectionToken(ngDevMode ? 'XSRF_ENABLED' : '');\nconst XSRF_DEFAULT_COOKIE_NAME = 'XSRF-TOKEN';\nconst XSRF_COOKIE_NAME = new InjectionToken(ngDevMode ? 'XSRF_COOKIE_NAME' : '', {\n    providedIn: 'root',\n    factory: () => XSRF_DEFAULT_COOKIE_NAME,\n});\nconst XSRF_DEFAULT_HEADER_NAME = 'X-XSRF-TOKEN';\nconst XSRF_HEADER_NAME = new InjectionToken(ngDevMode ? 'XSRF_HEADER_NAME' : '', {\n    providedIn: 'root',\n    factory: () => XSRF_DEFAULT_HEADER_NAME,\n});\n/**\n * Retrieves the current XSRF token to use with the next outgoing request.\n *\n * @publicApi\n */\nclass HttpXsrfTokenExtractor {\n}\n/**\n * `HttpXsrfTokenExtractor` which retrieves the token from a cookie.\n */\nclass HttpXsrfCookieExtractor {\n    constructor(doc, platform, cookieName) {\n        this.doc = doc;\n        this.platform = platform;\n        this.cookieName = cookieName;\n        this.lastCookieString = '';\n        this.lastToken = null;\n        /**\n         * @internal for testing\n         */\n        this.parseCount = 0;\n    }\n    getToken() {\n        if (this.platform === 'server') {\n            return null;\n        }\n        const cookieString = this.doc.cookie || '';\n        if (cookieString !== this.lastCookieString) {\n            this.parseCount++;\n            this.lastToken = ɵparseCookieValue(cookieString, this.cookieName);\n            this.lastCookieString = cookieString;\n        }\n        return this.lastToken;\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpXsrfCookieExtractor, deps: [{ token: DOCUMENT }, { token: PLATFORM_ID }, { token: XSRF_COOKIE_NAME }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpXsrfCookieExtractor }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpXsrfCookieExtractor, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: undefined, decorators: [{\n                    type: Inject,\n                    args: [DOCUMENT]\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [PLATFORM_ID]\n                }] }, { type: undefined, decorators: [{\n                    type: Inject,\n                    args: [XSRF_COOKIE_NAME]\n                }] }] });\nfunction xsrfInterceptorFn(req, next) {\n    const lcUrl = req.url.toLowerCase();\n    // Skip both non-mutating requests and absolute URLs.\n    // Non-mutating requests don't require a token, and absolute URLs require special handling\n    // anyway as the cookie set\n    // on our origin is not the same as the token expected by another origin.\n    if (!inject(XSRF_ENABLED) ||\n        req.method === 'GET' ||\n        req.method === 'HEAD' ||\n        lcUrl.startsWith('http://') ||\n        lcUrl.startsWith('https://')) {\n        return next(req);\n    }\n    const token = inject(HttpXsrfTokenExtractor).getToken();\n    const headerName = inject(XSRF_HEADER_NAME);\n    // Be careful not to overwrite an existing header of the same name.\n    if (token != null && !req.headers.has(headerName)) {\n        req = req.clone({ headers: req.headers.set(headerName, token) });\n    }\n    return next(req);\n}\n/**\n * `HttpInterceptor` which adds an XSRF token to eligible outgoing requests.\n */\nclass HttpXsrfInterceptor {\n    constructor(injector) {\n        this.injector = injector;\n    }\n    intercept(initialRequest, next) {\n        return runInInjectionContext(this.injector, () => xsrfInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpXsrfInterceptor, deps: [{ token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Injectable }); }\n    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpXsrfInterceptor }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpXsrfInterceptor, decorators: [{\n            type: Injectable\n        }], ctorParameters: () => [{ type: i0.EnvironmentInjector }] });\n\n/**\n * Identifies a particular kind of `HttpFeature`.\n *\n * @publicApi\n */\nvar HttpFeatureKind;\n(function (HttpFeatureKind) {\n    HttpFeatureKind[HttpFeatureKind[\"Interceptors\"] = 0] = \"Interceptors\";\n    HttpFeatureKind[HttpFeatureKind[\"LegacyInterceptors\"] = 1] = \"LegacyInterceptors\";\n    HttpFeatureKind[HttpFeatureKind[\"CustomXsrfConfiguration\"] = 2] = \"CustomXsrfConfiguration\";\n    HttpFeatureKind[HttpFeatureKind[\"NoXsrfProtection\"] = 3] = \"NoXsrfProtection\";\n    HttpFeatureKind[HttpFeatureKind[\"JsonpSupport\"] = 4] = \"JsonpSupport\";\n    HttpFeatureKind[HttpFeatureKind[\"RequestsMadeViaParent\"] = 5] = \"RequestsMadeViaParent\";\n    HttpFeatureKind[HttpFeatureKind[\"Fetch\"] = 6] = \"Fetch\";\n})(HttpFeatureKind || (HttpFeatureKind = {}));\nfunction makeHttpFeature(kind, providers) {\n    return {\n        ɵkind: kind,\n        ɵproviders: providers,\n    };\n}\n/**\n * Configures Angular's `HttpClient` service to be available for injection.\n *\n * By default, `HttpClient` will be configured for injection with its default options for XSRF\n * protection of outgoing requests. Additional configuration options can be provided by passing\n * feature functions to `provideHttpClient`. For example, HTTP interceptors can be added using the\n * `withInterceptors(...)` feature.\n *\n * <div class=\"alert is-helpful\">\n *\n * It's strongly recommended to enable\n * [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) for applications that use\n * Server-Side Rendering for better performance and compatibility. To enable `fetch`, add\n * `withFetch()` feature to the `provideHttpClient()` call at the root of the application:\n *\n * ```\n * provideHttpClient(withFetch());\n * ```\n *\n * </div>\n *\n * @see {@link withInterceptors}\n * @see {@link withInterceptorsFromDi}\n * @see {@link withXsrfConfiguration}\n * @see {@link withNoXsrfProtection}\n * @see {@link withJsonpSupport}\n * @see {@link withRequestsMadeViaParent}\n * @see {@link withFetch}\n */\nfunction provideHttpClient(...features) {\n    if (ngDevMode) {\n        const featureKinds = new Set(features.map((f) => f.ɵkind));\n        if (featureKinds.has(HttpFeatureKind.NoXsrfProtection) &&\n            featureKinds.has(HttpFeatureKind.CustomXsrfConfiguration)) {\n            throw new Error(ngDevMode\n                ? `Configuration error: found both withXsrfConfiguration() and withNoXsrfProtection() in the same call to provideHttpClient(), which is a contradiction.`\n                : '');\n        }\n    }\n    const providers = [\n        HttpClient,\n        HttpXhrBackend,\n        HttpInterceptorHandler,\n        { provide: HttpHandler, useExisting: HttpInterceptorHandler },\n        {\n            provide: HttpBackend,\n            useFactory: () => {\n                return inject(FetchBackend, { optional: true }) ?? inject(HttpXhrBackend);\n            },\n        },\n        {\n            provide: HTTP_INTERCEPTOR_FNS,\n            useValue: xsrfInterceptorFn,\n            multi: true,\n        },\n        { provide: XSRF_ENABLED, useValue: true },\n        { provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor },\n    ];\n    for (const feature of features) {\n        providers.push(...feature.ɵproviders);\n    }\n    return makeEnvironmentProviders(providers);\n}\n/**\n * Adds one or more functional-style HTTP interceptors to the configuration of the `HttpClient`\n * instance.\n *\n * @see {@link HttpInterceptorFn}\n * @see {@link provideHttpClient}\n * @publicApi\n */\nfunction withInterceptors(interceptorFns) {\n    return makeHttpFeature(HttpFeatureKind.Interceptors, interceptorFns.map((interceptorFn) => {\n        return {\n            provide: HTTP_INTERCEPTOR_FNS,\n            useValue: interceptorFn,\n            multi: true,\n        };\n    }));\n}\nconst LEGACY_INTERCEPTOR_FN = new InjectionToken(ngDevMode ? 'LEGACY_INTERCEPTOR_FN' : '');\n/**\n * Includes class-based interceptors configured using a multi-provider in the current injector into\n * the configured `HttpClient` instance.\n *\n * Prefer `withInterceptors` and functional interceptors instead, as support for DI-provided\n * interceptors may be phased out in a later release.\n *\n * @see {@link HttpInterceptor}\n * @see {@link HTTP_INTERCEPTORS}\n * @see {@link provideHttpClient}\n */\nfunction withInterceptorsFromDi() {\n    // Note: the legacy interceptor function is provided here via an intermediate token\n    // (`LEGACY_INTERCEPTOR_FN`), using a pattern which guarantees that if these providers are\n    // included multiple times, all of the multi-provider entries will have the same instance of the\n    // interceptor function. That way, the `HttpINterceptorHandler` will dedup them and legacy\n    // interceptors will not run multiple times.\n    return makeHttpFeature(HttpFeatureKind.LegacyInterceptors, [\n        {\n            provide: LEGACY_INTERCEPTOR_FN,\n            useFactory: legacyInterceptorFnFactory,\n        },\n        {\n            provide: HTTP_INTERCEPTOR_FNS,\n            useExisting: LEGACY_INTERCEPTOR_FN,\n            multi: true,\n        },\n    ]);\n}\n/**\n * Customizes the XSRF protection for the configuration of the current `HttpClient` instance.\n *\n * This feature is incompatible with the `withNoXsrfProtection` feature.\n *\n * @see {@link provideHttpClient}\n */\nfunction withXsrfConfiguration({ cookieName, headerName, }) {\n    const providers = [];\n    if (cookieName !== undefined) {\n        providers.push({ provide: XSRF_COOKIE_NAME, useValue: cookieName });\n    }\n    if (headerName !== undefined) {\n        providers.push({ provide: XSRF_HEADER_NAME, useValue: headerName });\n    }\n    return makeHttpFeature(HttpFeatureKind.CustomXsrfConfiguration, providers);\n}\n/**\n * Disables XSRF protection in the configuration of the current `HttpClient` instance.\n *\n * This feature is incompatible with the `withXsrfConfiguration` feature.\n *\n * @see {@link provideHttpClient}\n */\nfunction withNoXsrfProtection() {\n    return makeHttpFeature(HttpFeatureKind.NoXsrfProtection, [\n        {\n            provide: XSRF_ENABLED,\n            useValue: false,\n        },\n    ]);\n}\n/**\n * Add JSONP support to the configuration of the current `HttpClient` instance.\n *\n * @see {@link provideHttpClient}\n */\nfunction withJsonpSupport() {\n    return makeHttpFeature(HttpFeatureKind.JsonpSupport, [\n        JsonpClientBackend,\n        { provide: JsonpCallbackContext, useFactory: jsonpCallbackContext },\n        { provide: HTTP_INTERCEPTOR_FNS, useValue: jsonpInterceptorFn, multi: true },\n    ]);\n}\n/**\n * Configures the current `HttpClient` instance to make requests via the parent injector's\n * `HttpClient` instead of directly.\n *\n * By default, `provideHttpClient` configures `HttpClient` in its injector to be an independent\n * instance. For example, even if `HttpClient` is configured in the parent injector with\n * one or more interceptors, they will not intercept requests made via this instance.\n *\n * With this option enabled, once the request has passed through the current injector's\n * interceptors, it will be delegated to the parent injector's `HttpClient` chain instead of\n * dispatched directly, and interceptors in the parent configuration will be applied to the request.\n *\n * If there are several `HttpClient` instances in the injector hierarchy, it's possible for\n * `withRequestsMadeViaParent` to be used at multiple levels, which will cause the request to\n * \"bubble up\" until either reaching the root level or an `HttpClient` which was not configured with\n * this option.\n *\n * @see {@link provideHttpClient}\n * @developerPreview\n */\nfunction withRequestsMadeViaParent() {\n    return makeHttpFeature(HttpFeatureKind.RequestsMadeViaParent, [\n        {\n            provide: HttpBackend,\n            useFactory: () => {\n                const handlerFromParent = inject(HttpHandler, { skipSelf: true, optional: true });\n                if (ngDevMode && handlerFromParent === null) {\n                    throw new Error('withRequestsMadeViaParent() can only be used when the parent injector also configures HttpClient');\n                }\n                return handlerFromParent;\n            },\n        },\n    ]);\n}\n/**\n * Configures the current `HttpClient` instance to make requests using the fetch API.\n *\n * Note: The Fetch API doesn't support progress report on uploads.\n *\n * @publicApi\n */\nfunction withFetch() {\n    return makeHttpFeature(HttpFeatureKind.Fetch, [\n        FetchBackend,\n        { provide: HttpBackend, useExisting: FetchBackend },\n    ]);\n}\n\n/**\n * Configures XSRF protection support for outgoing requests.\n *\n * For a server that supports a cookie-based XSRF protection system,\n * use directly to configure XSRF protection with the correct\n * cookie and header names.\n *\n * If no names are supplied, the default cookie name is `XSRF-TOKEN`\n * and the default header name is `X-XSRF-TOKEN`.\n *\n * @publicApi\n * @deprecated Use withXsrfConfiguration({cookieName: 'XSRF-TOKEN', headerName: 'X-XSRF-TOKEN'}) as\n *     providers instead or `withNoXsrfProtection` if you want to disabled XSRF protection.\n */\nclass HttpClientXsrfModule {\n    /**\n     * Disable the default XSRF protection.\n     */\n    static disable() {\n        return {\n            ngModule: HttpClientXsrfModule,\n            providers: [withNoXsrfProtection().ɵproviders],\n        };\n    }\n    /**\n     * Configure XSRF protection.\n     * @param options An object that can specify either or both\n     * cookie name or header name.\n     * - Cookie name default is `XSRF-TOKEN`.\n     * - Header name default is `X-XSRF-TOKEN`.\n     *\n     */\n    static withOptions(options = {}) {\n        return {\n            ngModule: HttpClientXsrfModule,\n            providers: withXsrfConfiguration(options).ɵproviders,\n        };\n    }\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientXsrfModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientXsrfModule }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientXsrfModule, providers: [\n            HttpXsrfInterceptor,\n            { provide: HTTP_INTERCEPTORS, useExisting: HttpXsrfInterceptor, multi: true },\n            { provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor },\n            withXsrfConfiguration({\n                cookieName: XSRF_DEFAULT_COOKIE_NAME,\n                headerName: XSRF_DEFAULT_HEADER_NAME,\n            }).ɵproviders,\n            { provide: XSRF_ENABLED, useValue: true },\n        ] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientXsrfModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    providers: [\n                        HttpXsrfInterceptor,\n                        { provide: HTTP_INTERCEPTORS, useExisting: HttpXsrfInterceptor, multi: true },\n                        { provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor },\n                        withXsrfConfiguration({\n                            cookieName: XSRF_DEFAULT_COOKIE_NAME,\n                            headerName: XSRF_DEFAULT_HEADER_NAME,\n                        }).ɵproviders,\n                        { provide: XSRF_ENABLED, useValue: true },\n                    ],\n                }]\n        }] });\n/**\n * Configures the dependency injector for `HttpClient`\n * with supporting services for XSRF. Automatically imported by `HttpClientModule`.\n *\n * You can add interceptors to the chain behind `HttpClient` by binding them to the\n * multiprovider for built-in DI token `HTTP_INTERCEPTORS`.\n *\n * @publicApi\n * @deprecated use `provideHttpClient(withInterceptorsFromDi())` as providers instead\n */\nclass HttpClientModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientModule }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientModule, providers: [provideHttpClient(withInterceptorsFromDi())] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    /**\n                     * Configures the dependency injector where it is imported\n                     * with supporting services for HTTP communications.\n                     */\n                    providers: [provideHttpClient(withInterceptorsFromDi())],\n                }]\n        }] });\n/**\n * Configures the dependency injector for `HttpClient`\n * with supporting services for JSONP.\n * Without this module, Jsonp requests reach the backend\n * with method JSONP, where they are rejected.\n *\n * @publicApi\n * @deprecated `withJsonpSupport()` as providers instead\n */\nclass HttpClientJsonpModule {\n    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientJsonpModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }\n    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"14.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientJsonpModule }); }\n    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientJsonpModule, providers: [withJsonpSupport().ɵproviders] }); }\n}\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"18.2.13\", ngImport: i0, type: HttpClientJsonpModule, decorators: [{\n            type: NgModule,\n            args: [{\n                    providers: [withJsonpSupport().ɵproviders],\n                }]\n        }] });\n\n/**\n * If your application uses different HTTP origins to make API calls (via `HttpClient`) on the server and\n * on the client, the `HTTP_TRANSFER_CACHE_ORIGIN_MAP` token allows you to establish a mapping\n * between those origins, so that `HttpTransferCache` feature can recognize those requests as the same\n * ones and reuse the data cached on the server during hydration on the client.\n *\n * **Important note**: the `HTTP_TRANSFER_CACHE_ORIGIN_MAP` token should *only* be provided in\n * the *server* code of your application (typically in the `app.server.config.ts` script). Angular throws an\n * error if it detects that the token is defined while running on the client.\n *\n * @usageNotes\n *\n * When the same API endpoint is accessed via `http://internal-domain.com:8080` on the server and\n * via `https://external-domain.com` on the client, you can use the following configuration:\n * ```typescript\n * // in app.server.config.ts\n * {\n *     provide: HTTP_TRANSFER_CACHE_ORIGIN_MAP,\n *     useValue: {\n *         'http://internal-domain.com:8080': 'https://external-domain.com'\n *     }\n * }\n * ```\n *\n * @publicApi\n */\nconst HTTP_TRANSFER_CACHE_ORIGIN_MAP = new InjectionToken(ngDevMode ? 'HTTP_TRANSFER_CACHE_ORIGIN_MAP' : '');\n/**\n * Keys within cached response data structure.\n */\nconst BODY = 'b';\nconst HEADERS = 'h';\nconst STATUS = 's';\nconst STATUS_TEXT = 'st';\nconst REQ_URL = 'u';\nconst RESPONSE_TYPE = 'rt';\nconst CACHE_OPTIONS = new InjectionToken(ngDevMode ? 'HTTP_TRANSFER_STATE_CACHE_OPTIONS' : '');\n/**\n * A list of allowed HTTP methods to cache.\n */\nconst ALLOWED_METHODS = ['GET', 'HEAD'];\nfunction transferCacheInterceptorFn(req, next) {\n    const { isCacheActive, ...globalOptions } = inject(CACHE_OPTIONS);\n    const { transferCache: requestOptions, method: requestMethod } = req;\n    // In the following situations we do not want to cache the request\n    if (!isCacheActive ||\n        requestOptions === false ||\n        // POST requests are allowed either globally or at request level\n        (requestMethod === 'POST' && !globalOptions.includePostRequests && !requestOptions) ||\n        (requestMethod !== 'POST' && !ALLOWED_METHODS.includes(requestMethod)) ||\n        // Do not cache request that require authorization when includeRequestsWithAuthHeaders is falsey\n        (!globalOptions.includeRequestsWithAuthHeaders && hasAuthHeaders(req)) ||\n        globalOptions.filter?.(req) === false) {\n        return next(req);\n    }\n    const transferState = inject(TransferState);\n    const originMap = inject(HTTP_TRANSFER_CACHE_ORIGIN_MAP, {\n        optional: true,\n    });\n    const isServer = isPlatformServer(inject(PLATFORM_ID));\n    if (originMap && !isServer) {\n        throw new ɵRuntimeError(2803 /* RuntimeErrorCode.HTTP_ORIGIN_MAP_USED_IN_CLIENT */, ngDevMode &&\n            'Angular detected that the `HTTP_TRANSFER_CACHE_ORIGIN_MAP` token is configured and ' +\n                'present in the client side code. Please ensure that this token is only provided in the ' +\n                'server code of the application.');\n    }\n    const requestUrl = isServer && originMap ? mapRequestOriginUrl(req.url, originMap) : req.url;\n    const storeKey = makeCacheKey(req, requestUrl);\n    const response = transferState.get(storeKey, null);\n    let headersToInclude = globalOptions.includeHeaders;\n    if (typeof requestOptions === 'object' && requestOptions.includeHeaders) {\n        // Request-specific config takes precedence over the global config.\n        headersToInclude = requestOptions.includeHeaders;\n    }\n    if (response) {\n        const { [BODY]: undecodedBody, [RESPONSE_TYPE]: responseType, [HEADERS]: httpHeaders, [STATUS]: status, [STATUS_TEXT]: statusText, [REQ_URL]: url, } = response;\n        // Request found in cache. Respond using it.\n        let body = undecodedBody;\n        switch (responseType) {\n            case 'arraybuffer':\n                body = new TextEncoder().encode(undecodedBody).buffer;\n                break;\n            case 'blob':\n                body = new Blob([undecodedBody]);\n                break;\n        }\n        // We want to warn users accessing a header provided from the cache\n        // That HttpTransferCache alters the headers\n        // The warning will be logged a single time by HttpHeaders instance\n        let headers = new HttpHeaders(httpHeaders);\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            // Append extra logic in dev mode to produce a warning when a header\n            // that was not transferred to the client is accessed in the code via `get`\n            // and `has` calls.\n            headers = appendMissingHeadersDetection(req.url, headers, headersToInclude ?? []);\n        }\n        return of(new HttpResponse({\n            body,\n            headers,\n            status,\n            statusText,\n            url,\n        }));\n    }\n    // Request not found in cache. Make the request and cache it if on the server.\n    return next(req).pipe(tap((event) => {\n        if (event instanceof HttpResponse && isServer) {\n            transferState.set(storeKey, {\n                [BODY]: event.body,\n                [HEADERS]: getFilteredHeaders(event.headers, headersToInclude),\n                [STATUS]: event.status,\n                [STATUS_TEXT]: event.statusText,\n                [REQ_URL]: requestUrl,\n                [RESPONSE_TYPE]: req.responseType,\n            });\n        }\n    }));\n}\n/** @returns true when the requests contains autorization related headers. */\nfunction hasAuthHeaders(req) {\n    return req.headers.has('authorization') || req.headers.has('proxy-authorization');\n}\nfunction getFilteredHeaders(headers, includeHeaders) {\n    if (!includeHeaders) {\n        return {};\n    }\n    const headersMap = {};\n    for (const key of includeHeaders) {\n        const values = headers.getAll(key);\n        if (values !== null) {\n            headersMap[key] = values;\n        }\n    }\n    return headersMap;\n}\nfunction sortAndConcatParams(params) {\n    return [...params.keys()]\n        .sort()\n        .map((k) => `${k}=${params.getAll(k)}`)\n        .join('&');\n}\nfunction makeCacheKey(request, mappedRequestUrl) {\n    // make the params encoded same as a url so it's easy to identify\n    const { params, method, responseType } = request;\n    const encodedParams = sortAndConcatParams(params);\n    let serializedBody = request.serializeBody();\n    if (serializedBody instanceof URLSearchParams) {\n        serializedBody = sortAndConcatParams(serializedBody);\n    }\n    else if (typeof serializedBody !== 'string') {\n        serializedBody = '';\n    }\n    const key = [method, responseType, mappedRequestUrl, serializedBody, encodedParams].join('|');\n    const hash = generateHash(key);\n    return makeStateKey(hash);\n}\n/**\n * A method that returns a hash representation of a string using a variant of DJB2 hash\n * algorithm.\n *\n * This is the same hashing logic that is used to generate component ids.\n */\nfunction generateHash(value) {\n    let hash = 0;\n    for (const char of value) {\n        hash = (Math.imul(31, hash) + char.charCodeAt(0)) << 0;\n    }\n    // Force positive number hash.\n    // 2147483647 = equivalent of Integer.MAX_VALUE.\n    hash += 2147483647 + 1;\n    return hash.toString();\n}\n/**\n * Returns the DI providers needed to enable HTTP transfer cache.\n *\n * By default, when using server rendering, requests are performed twice: once on the server and\n * other one on the browser.\n *\n * When these providers are added, requests performed on the server are cached and reused during the\n * bootstrapping of the application in the browser thus avoiding duplicate requests and reducing\n * load time.\n *\n */\nfunction withHttpTransferCache(cacheOptions) {\n    return [\n        {\n            provide: CACHE_OPTIONS,\n            useFactory: () => {\n                ɵperformanceMarkFeature('NgHttpTransferCache');\n                return { isCacheActive: true, ...cacheOptions };\n            },\n        },\n        {\n            provide: HTTP_ROOT_INTERCEPTOR_FNS,\n            useValue: transferCacheInterceptorFn,\n            multi: true,\n            deps: [TransferState, CACHE_OPTIONS],\n        },\n        {\n            provide: APP_BOOTSTRAP_LISTENER,\n            multi: true,\n            useFactory: () => {\n                const appRef = inject(ApplicationRef);\n                const cacheState = inject(CACHE_OPTIONS);\n                return () => {\n                    ɵwhenStable(appRef).then(() => {\n                        cacheState.isCacheActive = false;\n                    });\n                };\n            },\n        },\n    ];\n}\n/**\n * This function will add a proxy to an HttpHeader to intercept calls to get/has\n * and log a warning if the header entry requested has been removed\n */\nfunction appendMissingHeadersDetection(url, headers, headersToInclude) {\n    const warningProduced = new Set();\n    return new Proxy(headers, {\n        get(target, prop) {\n            const value = Reflect.get(target, prop);\n            const methods = new Set(['get', 'has', 'getAll']);\n            if (typeof value !== 'function' || !methods.has(prop)) {\n                return value;\n            }\n            return (headerName) => {\n                // We log when the key has been removed and a warning hasn't been produced for the header\n                const key = (prop + ':' + headerName).toLowerCase(); // e.g. `get:cache-control`\n                if (!headersToInclude.includes(headerName) && !warningProduced.has(key)) {\n                    warningProduced.add(key);\n                    const truncatedUrl = ɵtruncateMiddle(url);\n                    // TODO: create Error guide for this warning\n                    console.warn(ɵformatRuntimeError(2802 /* RuntimeErrorCode.HEADERS_ALTERED_BY_TRANSFER_CACHE */, `Angular detected that the \\`${headerName}\\` header is accessed, but the value of the header ` +\n                        `was not transferred from the server to the client by the HttpTransferCache. ` +\n                        `To include the value of the \\`${headerName}\\` header for the \\`${truncatedUrl}\\` request, ` +\n                        `use the \\`includeHeaders\\` list. The \\`includeHeaders\\` can be defined either ` +\n                        `on a request level by adding the \\`transferCache\\` parameter, or on an application ` +\n                        `level by adding the \\`httpCacheTransfer.includeHeaders\\` argument to the ` +\n                        `\\`provideClientHydration()\\` call. `));\n                }\n                // invoking the original method\n                return value.apply(target, [headerName]);\n            };\n        },\n    });\n}\nfunction mapRequestOriginUrl(url, originMap) {\n    const origin = new URL(url, 'resolve://').origin;\n    const mappedOrigin = originMap[origin];\n    if (!mappedOrigin) {\n        return url;\n    }\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        verifyMappedOrigin(mappedOrigin);\n    }\n    return url.replace(origin, mappedOrigin);\n}\nfunction verifyMappedOrigin(url) {\n    if (new URL(url, 'resolve://').pathname !== '/') {\n        throw new ɵRuntimeError(2804 /* RuntimeErrorCode.HTTP_ORIGIN_MAP_CONTAINS_PATH */, 'Angular detected a URL with a path segment in the value provided for the ' +\n            `\\`HTTP_TRANSFER_CACHE_ORIGIN_MAP\\` token: ${url}. The map should only contain origins ` +\n            'without any other segments.');\n    }\n}\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 { FetchBackend, HTTP_INTERCEPTORS, HTTP_TRANSFER_CACHE_ORIGIN_MAP, HttpBackend, HttpClient, HttpClientJsonpModule, HttpClientModule, HttpClientXsrfModule, HttpContext, HttpContextToken, HttpErrorResponse, HttpEventType, HttpFeatureKind, HttpHandler, HttpHeaderResponse, HttpHeaders, HttpParams, HttpRequest, HttpResponse, HttpResponseBase, HttpStatusCode, HttpUrlEncodingCodec, HttpXhrBackend, HttpXsrfTokenExtractor, JsonpClientBackend, JsonpInterceptor, provideHttpClient, withFetch, withInterceptors, withInterceptorsFromDi, withJsonpSupport, withNoXsrfProtection, withRequestsMadeViaParent, withXsrfConfiguration, HTTP_ROOT_INTERCEPTOR_FNS as ɵHTTP_ROOT_INTERCEPTOR_FNS, HttpInterceptorHandler as ɵHttpInterceptingHandler, HttpInterceptorHandler as ɵHttpInterceptorHandler, REQUESTS_CONTRIBUTE_TO_STABILITY as ɵREQUESTS_CONTRIBUTE_TO_STABILITY, withHttpTransferCache as ɵwithHttpTransferCache };\n//# sourceMappingURL=http.mjs.map\n","import * as angularCommonHttp from '@angular/common/http';\r\n\r\n// global glue variable for externals\r\nif (window['ng'] == null) window['ng'] = <any>{};\r\nif (window['ng'].common == null) window['ng'].common = <any>{};\r\n\r\nwindow['ng'].common.http = angularCommonHttp;\r\n\r\nexport { angularCommonHttp };"],"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","core","rxjs","operators","common","HttpHandler","HttpBackend","HttpHeaders","constructor","headers","normalizedNames","Map","lazyUpdate","lazyInit","split","line","index","name","slice","toLowerCase","trim","maybeSetNormalizedName","has","push","set","Headers","values","setHeaderEntries","ngDevMode","entries","Array","isArray","Error","assertValidHeaders","init","length","keys","from","getAll","append","clone","op","lcName","copyFrom","update","applyUpdate","other","concat","base","toDelete","existing","filter","delete","headerValues","map","toString","fn","HttpUrlEncodingCodec","encodeKey","standardEncoding","encodeValue","decodeKey","decodeURIComponent","decodeValue","STANDARD_ENCODING_REGEX","STANDARD_ENCODING_REPLACEMENTS","v","encodeURIComponent","replace","s","valueToString","HttpParams","options","updates","cloneFrom","encoder","fromString","fromObject","rawParams","codec","param","eqIdx","val","list","paramParser","res","appendAll","params","_value","eKey","join","idx","splice","HttpContextToken","defaultValue","HttpContext","token","isArrayBuffer","ArrayBuffer","isBlob","Blob","isFormData","FormData","HttpRequest","method","url","third","fourth","body","reportProgress","withCredentials","responseType","toUpperCase","mightHaveBody","context","transferCache","urlWithParams","qIdx","sep","serializeBody","URLSearchParams","JSON","stringify","detectContentTypeHeader","type","setHeaders","reduce","setParams","HttpEventType","HttpResponseBase","defaultStatus","defaultStatusText","status","statusText","ok","HttpHeaderResponse","super","ResponseHeader","HttpResponse","Response","HttpErrorResponse","message","error","HttpStatusCode","addBody","observe","HttpClient","handler","request","first","req","events$","of","pipe","concatMap","handle","res$","event","head","jsonp","callbackParam","patch","post","put","minVersion","version","ngImport","deps","target","Injectable","decorators","ctorParameters","XSSI_PREFIX$1","REQUEST_URL_HEADER","getResponseUrl$1","response","xRequestUrl","toLocaleLowerCase","FetchBackend","fetchImpl","inject","FetchFactory","optional","fetch","args","globalThis","ngZone","NgZone","Observable","observer","aborter","AbortController","doRequest","signal","noop","abort","createRequestInit","fetchPromise","runOutsideAngular","next","Sent","contentLength","chunks","reader","getReader","decoder","partialText","receivedLength","reqZone","Zone","async","done","read","TextDecoder","decode","stream","DownloadProgress","total","loaded","run","chunksAll","concatChunks","contentType","parseBody","complete","binContent","text","parse","buffer","credentials","detectedType","totalLength","Uint8Array","position","chunk","interceptorChainEndFn","finalHandlerFn","adaptLegacyInterceptorToChain","chainTailFn","interceptor","initialRequest","intercept","downstreamRequest","HTTP_INTERCEPTORS","InjectionToken","HTTP_INTERCEPTOR_FNS","HTTP_ROOT_INTERCEPTOR_FNS","REQUESTS_CONTRIBUTE_TO_STABILITY","providedIn","factory","legacyInterceptorFnFactory","chain","interceptors","reduceRight","pendingTasks","taskId","add","finalize","remove","fetchBackendWarningDisplayed","HttpInterceptorHandler","backend","injector","contributeToStability","isPlatformServer","PLATFORM_ID","warn","dedupedInterceptorFns","Set","nextSequencedFn","interceptorFn","runInInjectionContext","chainedInterceptorFn","foreignDocument","nextRequestId","JsonpCallbackContext","jsonpCallbackContext","window","JsonpClientBackend","callbackMap","document","resolvedPromise","Promise","resolve","nextCallback","callback","node","createElement","src","finished","data","cleanup","removeEventListener","onLoad","onError","addEventListener","appendChild","removeListeners","script","implementation","createHTMLDocument","adoptNode","DOCUMENT","jsonpInterceptorFn","Inject","JsonpInterceptor","XSSI_PREFIX","HttpXhrBackend","xhrFactory","switchMap","xhr","build","open","setRequestHeader","reqBody","headerResponse","partialFromXhr","getAllResponseHeaders","responseURL","test","getResponseHeader","getResponseUrl","responseText","originalBody","sentHeaders","onDownProgress","progressEvent","lengthComputable","onUpProgress","progress","UploadProgress","upload","send","readyState","DONE","XSRF_ENABLED","XSRF_DEFAULT_COOKIE_NAME","XSRF_COOKIE_NAME","XSRF_DEFAULT_HEADER_NAME","XSRF_HEADER_NAME","HttpXsrfTokenExtractor","HttpXsrfCookieExtractor","doc","platform","cookieName","lastCookieString","lastToken","parseCount","getToken","cookieString","cookie","xsrfInterceptorFn","lcUrl","startsWith","headerName","HttpXsrfInterceptor","HttpFeatureKind","makeHttpFeature","kind","providers","provideHttpClient","features","featureKinds","f","NoXsrfProtection","CustomXsrfConfiguration","provide","useExisting","useFactory","useValue","multi","useClass","feature","makeEnvironmentProviders","withInterceptors","interceptorFns","Interceptors","LEGACY_INTERCEPTOR_FN","withInterceptorsFromDi","LegacyInterceptors","withXsrfConfiguration","withNoXsrfProtection","withJsonpSupport","JsonpSupport","withRequestsMadeViaParent","RequestsMadeViaParent","handlerFromParent","skipSelf","withFetch","Fetch","HttpClientXsrfModule","disable","ngModule","withOptions","NgModule","HttpClientModule","HttpClientJsonpModule","HTTP_TRANSFER_CACHE_ORIGIN_MAP","BODY","HEADERS","STATUS","STATUS_TEXT","REQ_URL","RESPONSE_TYPE","CACHE_OPTIONS","ALLOWED_METHODS","transferCacheInterceptorFn","isCacheActive","globalOptions","requestOptions","requestMethod","includePostRequests","includes","includeRequestsWithAuthHeaders","hasAuthHeaders","transferState","TransferState","originMap","isServer","requestUrl","origin","URL","mappedOrigin","pathname","verifyMappedOrigin","mapRequestOriginUrl","storeKey","mappedRequestUrl","encodedParams","sortAndConcatParams","serializedBody","hash","char","Math","imul","charCodeAt","generateHash","makeStateKey","makeCacheKey","headersToInclude","includeHeaders","undecodedBody","httpHeaders","TextEncoder","encode","warningProduced","Proxy","Reflect","methods","truncatedUrl","console","apply","appendMissingHeadersDetection","tap","getFilteredHeaders","headersMap","sort","k","withHttpTransferCache","cacheOptions","APP_BOOTSTRAP_LISTENER","appRef","ApplicationRef","cacheState","http"],"sourceRoot":""}