shared-lib-angular 1.0.0

package/.jest-cache/jest-transform-cache-9a3a3745ceefdbbde8dc96f3a11cb645-79ef2876fae7ca75eedb2aa53dc48338/72/module_726ab71b1f0164c527681100a65aad4a

@@ -0,0 +1,2332 @@
+e33f3a0d4383148bd1edc8d2f1e2bec2
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var module_exports = {};
+__export(module_exports, {
+  FetchBackend: () => FetchBackend,
+  HTTP_INTERCEPTORS: () => HTTP_INTERCEPTORS,
+  HTTP_ROOT_INTERCEPTOR_FNS: () => HTTP_ROOT_INTERCEPTOR_FNS,
+  HttpBackend: () => HttpBackend,
+  HttpClient: () => HttpClient,
+  HttpClientJsonpModule: () => HttpClientJsonpModule,
+  HttpClientModule: () => HttpClientModule,
+  HttpClientXsrfModule: () => HttpClientXsrfModule,
+  HttpContext: () => HttpContext,
+  HttpContextToken: () => HttpContextToken,
+  HttpErrorResponse: () => HttpErrorResponse,
+  HttpEventType: () => HttpEventType,
+  HttpFeatureKind: () => HttpFeatureKind,
+  HttpHandler: () => HttpHandler,
+  HttpHeaderResponse: () => HttpHeaderResponse,
+  HttpHeaders: () => HttpHeaders,
+  HttpInterceptorHandler: () => HttpInterceptorHandler,
+  HttpParams: () => HttpParams,
+  HttpRequest: () => HttpRequest,
+  HttpResponse: () => HttpResponse,
+  HttpResponseBase: () => HttpResponseBase,
+  HttpStatusCode: () => HttpStatusCode,
+  HttpUrlEncodingCodec: () => HttpUrlEncodingCodec,
+  HttpXhrBackend: () => HttpXhrBackend,
+  HttpXsrfTokenExtractor: () => HttpXsrfTokenExtractor,
+  JsonpClientBackend: () => JsonpClientBackend,
+  JsonpInterceptor: () => JsonpInterceptor,
+  REQUESTS_CONTRIBUTE_TO_STABILITY: () => REQUESTS_CONTRIBUTE_TO_STABILITY,
+  provideHttpClient: () => provideHttpClient,
+  withFetch: () => withFetch,
+  withInterceptors: () => withInterceptors,
+  withInterceptorsFromDi: () => withInterceptorsFromDi,
+  withJsonpSupport: () => withJsonpSupport,
+  withNoXsrfProtection: () => withNoXsrfProtection,
+  withRequestsMadeViaParent: () => withRequestsMadeViaParent,
+  withXsrfConfiguration: () => withXsrfConfiguration
+});
+module.exports = __toCommonJS(module_exports);
+var i0 = __toESM(require("@angular/core"), 1);
+var import_core = require("@angular/core");
+var import_operators = require("rxjs/operators");
+var import_rxjs = require("rxjs");
+var import_xhr = require("./xhr.mjs");
+/**
+ * @license Angular v20.3.16
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var _a, _b;
+class HttpHandler {
+}
+class HttpBackend {
+}
+class HttpHeaders {
+  /**  Constructs a new HTTP header object with the given values.*/
+  constructor(headers) {
+    /**
+     * Internal map of lowercase header names to values.
+     */
+    __publicField(this, "headers");
+    /**
+     * Internal map of lowercased header names to the normalized
+     * form of the name (the form seen first).
+     */
+    __publicField(this, "normalizedNames", /* @__PURE__ */ new Map());
+    /**
+     * Complete the lazy initialization of this object (needed before reading).
+     */
+    __publicField(this, "lazyInit");
+    /**
+     * Queued updates to be materialized the next initialization.
+     */
+    __publicField(this, "lazyUpdate", null);
+    if (!headers) {
+      this.headers = /* @__PURE__ */ new Map();
+    } else if (typeof headers === "string") {
+      this.lazyInit = () => {
+        this.headers = /* @__PURE__ */ new Map();
+        headers.split("\n").forEach((line) => {
+          const index = line.indexOf(":");
+          if (index > 0) {
+            const name = line.slice(0, index);
+            const value = line.slice(index + 1).trim();
+            this.addHeaderEntry(name, value);
+          }
+        });
+      };
+    } else if (typeof Headers !== "undefined" && headers instanceof Headers) {
+      this.headers = /* @__PURE__ */ new Map();
+      headers.forEach((value, name) => {
+        this.addHeaderEntry(name, value);
+      });
+    } else {
+      this.lazyInit = () => {
+        if (typeof ngDevMode === "undefined" || ngDevMode) {
+          assertValidHeaders(headers);
+        }
+        this.headers = /* @__PURE__ */ new Map();
+        Object.entries(headers).forEach(([name, values]) => {
+          this.setHeaderEntries(name, values);
+        });
+      };
+    }
+  }
+  /**
+   * Checks for existence of a given header.
+   *
+   * @param name The header name to check for existence.
+   *
+   * @returns True if the header exists, false otherwise.
+   */
+  has(name) {
+    this.init();
+    return this.headers.has(name.toLowerCase());
+  }
+  /**
+   * Retrieves the first value of a given header.
+   *
+   * @param name The header name.
+   *
+   * @returns The value string if the header exists, null otherwise
+   */
+  get(name) {
+    this.init();
+    const values = this.headers.get(name.toLowerCase());
+    return values && values.length > 0 ? values[0] : null;
+  }
+  /**
+   * Retrieves the names of the headers.
+   *
+   * @returns A list of header names.
+   */
+  keys() {
+    this.init();
+    return Array.from(this.normalizedNames.values());
+  }
+  /**
+   * Retrieves a list of values for a given header.
+   *
+   * @param name The header name from which to retrieve values.
+   *
+   * @returns A string of values if the header exists, null otherwise.
+   */
+  getAll(name) {
+    this.init();
+    return this.headers.get(name.toLowerCase()) || null;
+  }
+  /**
+   * Appends a new value to the existing set of values for a header
+   * and returns them in a clone of the original instance.
+   *
+   * @param name The header name for which to append the values.
+   * @param value The value to append.
+   *
+   * @returns A clone of the HTTP headers object with the value appended to the given header.
+   */
+  append(name, value) {
+    return this.clone({ name, value, op: "a" });
+  }
+  /**
+   * Sets or modifies a value for a given header in a clone of the original instance.
+   * If the header already exists, its value is replaced with the given value
+   * in the returned object.
+   *
+   * @param name The header name.
+   * @param value The value or values to set or override for the given header.
+   *
+   * @returns A clone of the HTTP headers object with the newly set header value.
+   */
+  set(name, value) {
+    return this.clone({ name, value, op: "s" });
+  }
+  /**
+   * Deletes values for a given header in a clone of the original instance.
+   *
+   * @param name The header name.
+   * @param value The value or values to delete for the given header.
+   *
+   * @returns A clone of the HTTP headers object with the given value deleted.
+   */
+  delete(name, value) {
+    return this.clone({ name, value, op: "d" });
+  }
+  maybeSetNormalizedName(name, lcName) {
+    if (!this.normalizedNames.has(lcName)) {
+      this.normalizedNames.set(lcName, name);
+    }
+  }
+  init() {
+    if (!!this.lazyInit) {
+      if (this.lazyInit instanceof HttpHeaders) {
+        this.copyFrom(this.lazyInit);
+      } else {
+        this.lazyInit();
+      }
+      this.lazyInit = null;
+      if (!!this.lazyUpdate) {
+        this.lazyUpdate.forEach((update) => this.applyUpdate(update));
+        this.lazyUpdate = null;
+      }
+    }
+  }
+  copyFrom(other) {
+    other.init();
+    Array.from(other.headers.keys()).forEach((key) => {
+      this.headers.set(key, other.headers.get(key));
+      this.normalizedNames.set(key, other.normalizedNames.get(key));
+    });
+  }
+  clone(update) {
+    const clone = new HttpHeaders();
+    clone.lazyInit = !!this.lazyInit && this.lazyInit instanceof HttpHeaders ? this.lazyInit : this;
+    clone.lazyUpdate = (this.lazyUpdate || []).concat([update]);
+    return clone;
+  }
+  applyUpdate(update) {
+    const key = update.name.toLowerCase();
+    switch (update.op) {
+      case "a":
+      case "s":
+        let value = update.value;
+        if (typeof value === "string") {
+          value = [value];
+        }
+        if (value.length === 0) {
+          return;
+        }
+        this.maybeSetNormalizedName(update.name, key);
+        const base = (update.op === "a" ? this.headers.get(key) : void 0) || [];
+        base.push(...value);
+        this.headers.set(key, base);
+        break;
+      case "d":
+        const toDelete = update.value;
+        if (!toDelete) {
+          this.headers.delete(key);
+          this.normalizedNames.delete(key);
+        } else {
+          let existing = this.headers.get(key);
+          if (!existing) {
+            return;
+          }
+          existing = existing.filter((value2) => toDelete.indexOf(value2) === -1);
+          if (existing.length === 0) {
+            this.headers.delete(key);
+            this.normalizedNames.delete(key);
+          } else {
+            this.headers.set(key, existing);
+          }
+        }
+        break;
+    }
+  }
+  addHeaderEntry(name, value) {
+    const key = name.toLowerCase();
+    this.maybeSetNormalizedName(name, key);
+    if (this.headers.has(key)) {
+      this.headers.get(key).push(value);
+    } else {
+      this.headers.set(key, [value]);
+    }
+  }
+  setHeaderEntries(name, values) {
+    const headerValues = (Array.isArray(values) ? values : [values]).map((value) => value.toString());
+    const key = name.toLowerCase();
+    this.headers.set(key, headerValues);
+    this.maybeSetNormalizedName(name, key);
+  }
+  /**
+   * @internal
+   */
+  forEach(fn) {
+    this.init();
+    Array.from(this.normalizedNames.keys()).forEach((key) => fn(this.normalizedNames.get(key), this.headers.get(key)));
+  }
+}
+function assertValidHeaders(headers) {
+  for (const [key, value] of Object.entries(headers)) {
+    if (!(typeof value === "string" || typeof value === "number") && !Array.isArray(value)) {
+      throw new Error(`Unexpected value of the \`${key}\` header provided. Expecting either a string, a number or an array, but got: \`${value}\`.`);
+    }
+  }
+}
+class HttpUrlEncodingCodec {
+  /**
+   * Encodes a key name for a URL parameter or query-string.
+   * @param key The key name.
+   * @returns The encoded key name.
+   */
+  encodeKey(key) {
+    return standardEncoding(key);
+  }
+  /**
+   * Encodes the value of a URL parameter or query-string.
+   * @param value The value.
+   * @returns The encoded value.
+   */
+  encodeValue(value) {
+    return standardEncoding(value);
+  }
+  /**
+   * Decodes an encoded URL parameter or query-string key.
+   * @param key The encoded key name.
+   * @returns The decoded key name.
+   */
+  decodeKey(key) {
+    return decodeURIComponent(key);
+  }
+  /**
+   * Decodes an encoded URL parameter or query-string value.
+   * @param value The encoded value.
+   * @returns The decoded value.
+   */
+  decodeValue(value) {
+    return decodeURIComponent(value);
+  }
+}
+function paramParser(rawParams, codec) {
+  const map2 = /* @__PURE__ */ new Map();
+  if (rawParams.length > 0) {
+    const params = rawParams.replace(/^\?/, "").split("&");
+    params.forEach((param) => {
+      const eqIdx = param.indexOf("=");
+      const [key, val] = eqIdx == -1 ? [codec.decodeKey(param), ""] : [codec.decodeKey(param.slice(0, eqIdx)), codec.decodeValue(param.slice(eqIdx + 1))];
+      const list = map2.get(key) || [];
+      list.push(val);
+      map2.set(key, list);
+    });
+  }
+  return map2;
+}
+const STANDARD_ENCODING_REGEX = /%(\d[a-f0-9])/gi;
+const STANDARD_ENCODING_REPLACEMENTS = {
+  "40": "@",
+  "3A": ":",
+  "24": "$",
+  "2C": ",",
+  "3B": ";",
+  "3D": "=",
+  "3F": "?",
+  "2F": "/"
+};
+function standardEncoding(v) {
+  return encodeURIComponent(v).replace(STANDARD_ENCODING_REGEX, (s, t) => {
+    var _a2;
+    return (_a2 = STANDARD_ENCODING_REPLACEMENTS[t]) != null ? _a2 : s;
+  });
+}
+function valueToString(value) {
+  return `${value}`;
+}
+class HttpParams {
+  constructor(options = {}) {
+    __publicField(this, "map");
+    __publicField(this, "encoder");
+    __publicField(this, "updates", null);
+    __publicField(this, "cloneFrom", null);
+    this.encoder = options.encoder || new HttpUrlEncodingCodec();
+    if (options.fromString) {
+      if (options.fromObject) {
+        throw new import_core.\u0275RuntimeError(2805, ngDevMode && "Cannot specify both fromString and fromObject.");
+      }
+      this.map = paramParser(options.fromString, this.encoder);
+    } else if (!!options.fromObject) {
+      this.map = /* @__PURE__ */ new Map();
+      Object.keys(options.fromObject).forEach((key) => {
+        const value = options.fromObject[key];
+        const values = Array.isArray(value) ? value.map(valueToString) : [valueToString(value)];
+        this.map.set(key, values);
+      });
+    } else {
+      this.map = null;
+    }
+  }
+  /**
+   * Reports whether the body includes one or more values for a given parameter.
+   * @param param The parameter name.
+   * @returns True if the parameter has one or more values,
+   * false if it has no value or is not present.
+   */
+  has(param) {
+    this.init();
+    return this.map.has(param);
+  }
+  /**
+   * Retrieves the first value for a parameter.
+   * @param param The parameter name.
+   * @returns The first value of the given parameter,
+   * or `null` if the parameter is not present.
+   */
+  get(param) {
+    this.init();
+    const res = this.map.get(param);
+    return !!res ? res[0] : null;
+  }
+  /**
+   * Retrieves all values for a  parameter.
+   * @param param The parameter name.
+   * @returns All values in a string array,
+   * or `null` if the parameter not present.
+   */
+  getAll(param) {
+    this.init();
+    return this.map.get(param) || null;
+  }
+  /**
+   * Retrieves all the parameters for this body.
+   * @returns The parameter names in a string array.
+   */
+  keys() {
+    this.init();
+    return Array.from(this.map.keys());
+  }
+  /**
+   * Appends a new value to existing values for a parameter.
+   * @param param The parameter name.
+   * @param value The new value to add.
+   * @return A new body with the appended value.
+   */
+  append(param, value) {
+    return this.clone({ param, value, op: "a" });
+  }
+  /**
+   * Constructs a new body with appended values for the given parameter name.
+   * @param params parameters and values
+   * @return A new body with the new value.
+   */
+  appendAll(params) {
+    const updates = [];
+    Object.keys(params).forEach((param) => {
+      const value = params[param];
+      if (Array.isArray(value)) {
+        value.forEach((_value) => {
+          updates.push({ param, value: _value, op: "a" });
+        });
+      } else {
+        updates.push({ param, value, op: "a" });
+      }
+    });
+    return this.clone(updates);
+  }
+  /**
+   * Replaces the value for a parameter.
+   * @param param The parameter name.
+   * @param value The new value.
+   * @return A new body with the new value.
+   */
+  set(param, value) {
+    return this.clone({ param, value, op: "s" });
+  }
+  /**
+   * Removes a given value or all values from a parameter.
+   * @param param The parameter name.
+   * @param value The value to remove, if provided.
+   * @return A new body with the given value removed, or with all values
+   * removed if no value is specified.
+   */
+  delete(param, value) {
+    return this.clone({ param, value, op: "d" });
+  }
+  /**
+   * Serializes the body to an encoded string, where key-value pairs (separated by `=`) are
+   * separated by `&`s.
+   */
+  toString() {
+    this.init();
+    return this.keys().map((key) => {
+      const eKey = this.encoder.encodeKey(key);
+      return this.map.get(key).map((value) => eKey + "=" + this.encoder.encodeValue(value)).join("&");
+    }).filter((param) => param !== "").join("&");
+  }
+  clone(update) {
+    const clone = new HttpParams({ encoder: this.encoder });
+    clone.cloneFrom = this.cloneFrom || this;
+    clone.updates = (this.updates || []).concat(update);
+    return clone;
+  }
+  init() {
+    if (this.map === null) {
+      this.map = /* @__PURE__ */ new Map();
+    }
+    if (this.cloneFrom !== null) {
+      this.cloneFrom.init();
+      this.cloneFrom.keys().forEach((key) => this.map.set(key, this.cloneFrom.map.get(key)));
+      this.updates.forEach((update) => {
+        switch (update.op) {
+          case "a":
+          case "s":
+            const base = (update.op === "a" ? this.map.get(update.param) : void 0) || [];
+            base.push(valueToString(update.value));
+            this.map.set(update.param, base);
+            break;
+          case "d":
+            if (update.value !== void 0) {
+              let base2 = this.map.get(update.param) || [];
+              const idx = base2.indexOf(valueToString(update.value));
+              if (idx !== -1) {
+                base2.splice(idx, 1);
+              }
+              if (base2.length > 0) {
+                this.map.set(update.param, base2);
+              } else {
+                this.map.delete(update.param);
+              }
+            } else {
+              this.map.delete(update.param);
+              break;
+            }
+        }
+      });
+      this.cloneFrom = this.updates = null;
+    }
+  }
+}
+class HttpContextToken {
+  constructor(defaultValue) {
+    __publicField(this, "defaultValue");
+    this.defaultValue = defaultValue;
+  }
+}
+class HttpContext {
+  constructor() {
+    __publicField(this, "map", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Store a value in the context. If a value is already present it will be overwritten.
+   *
+   * @param token The reference to an instance of `HttpContextToken`.
+   * @param value The value to store.
+   *
+   * @returns A reference to itself for easy chaining.
+   */
+  set(token, value) {
+    this.map.set(token, value);
+    return this;
+  }
+  /**
+   * Retrieve the value associated with the given token.
+   *
+   * @param token The reference to an instance of `HttpContextToken`.
+   *
+   * @returns The stored value or default if one is defined.
+   */
+  get(token) {
+    if (!this.map.has(token)) {
+      this.map.set(token, token.defaultValue());
+    }
+    return this.map.get(token);
+  }
+  /**
+   * Delete the value associated with the given token.
+   *
+   * @param token The reference to an instance of `HttpContextToken`.
+   *
+   * @returns A reference to itself for easy chaining.
+   */
+  delete(token) {
+    this.map.delete(token);
+    return this;
+  }
+  /**
+   * Checks for existence of a given token.
+   *
+   * @param token The reference to an instance of `HttpContextToken`.
+   *
+   * @returns True if the token exists, false otherwise.
+   */
+  has(token) {
+    return this.map.has(token);
+  }
+  /**
+   * @returns a list of tokens currently stored in the context.
+   */
+  keys() {
+    return this.map.keys();
+  }
+}
+function mightHaveBody(method) {
+  switch (method) {
+    case "DELETE":
+    case "GET":
+    case "HEAD":
+    case "OPTIONS":
+    case "JSONP":
+      return false;
+    default:
+      return true;
+  }
+}
+function isArrayBuffer(value) {
+  return typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer;
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+function isUrlSearchParams(value) {
+  return typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams;
+}
+const CONTENT_TYPE_HEADER = "Content-Type";
+const ACCEPT_HEADER = "Accept";
+const X_REQUEST_URL_HEADER = "X-Request-URL";
+const TEXT_CONTENT_TYPE = "text/plain";
+const JSON_CONTENT_TYPE = "application/json";
+const ACCEPT_HEADER_VALUE = `${JSON_CONTENT_TYPE}, ${TEXT_CONTENT_TYPE}, */*`;
+class HttpRequest {
+  constructor(method, url, third, fourth) {
+    __publicField(this, "url");
+    /**
+     * The request body, or `null` if one isn't set.
+     *
+     * Bodies are not enforced to be immutable, as they can include a reference to any
+     * user-defined data type. However, interceptors should take care to preserve
+     * idempotence by treating them as such.
+     */
+    __publicField(this, "body", null);
+    /**
+     * Outgoing headers for this request.
+     */
+    __publicField(this, "headers");
+    /**
+     * Shared and mutable context that can be used by interceptors
+     */
+    __publicField(this, "context");
+    /**
+     * Whether this request should be made in a way that exposes progress events.
+     *
+     * Progress events are expensive (change detection runs on each event) and so
+     * they should only be requested if the consumer intends to monitor them.
+     *
+     * Note: The `FetchBackend` doesn't support progress report on uploads.
+     */
+    __publicField(this, "reportProgress", false);
+    /**
+     * Whether this request should be sent with outgoing credentials (cookies).
+     */
+    __publicField(this, "withCredentials", false);
+    /**
+     *  The credentials mode of the request, which determines how cookies and HTTP authentication are handled.
+     *  This can affect whether cookies are sent with the request, and how authentication is handled.
+     */
+    __publicField(this, "credentials");
+    /**
+     * When using the fetch implementation and set to `true`, the browser will not abort the associated request if the page that initiated it is unloaded before the request is complete.
+     */
+    __publicField(this, "keepalive", false);
+    /**
+     * Controls how the request will interact with the browser's HTTP cache.
+     * This affects whether a response is retrieved from the cache, how it is stored, or if it bypasses the cache altogether.
+     */
+    __publicField(this, "cache");
+    /**
+     * Indicates the relative priority of the request. This may be used by the browser to decide the order in which requests are dispatched and resources fetched.
+     */
+    __publicField(this, "priority");
+    /**
+     * The mode of the request, which determines how the request will interact with the browser's security model.
+     * This can affect things like CORS (Cross-Origin Resource Sharing) and same-origin policies.
+     */
+    __publicField(this, "mode");
+    /**
+     * The redirect mode of the request, which determines how redirects are handled.
+     * This can affect whether the request follows redirects automatically, or if it fails when a redirect occurs.
+     */
+    __publicField(this, "redirect");
+    /**
+     * The referrer of the request, which can be used to indicate the origin of the request.
+     * This is useful for security and analytics purposes.
+     * Value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
+     */
+    __publicField(this, "referrer");
+    /**
+     * The integrity metadata of the request, which can be used to ensure the request is made with the expected content.
+     * A cryptographic hash of the resource to be fetched by request
+     */
+    __publicField(this, "integrity");
+    /**
+     * The expected response type of the server.
+     *
+     * This is used to parse the response appropriately before returning it to
+     * the requestee.
+     */
+    __publicField(this, "responseType", "json");
+    /**
+     * The outgoing HTTP request method.
+     */
+    __publicField(this, "method");
+    /**
+     * Outgoing URL parameters.
+     *
+     * To pass a string representation of HTTP parameters in the URL-query-string format,
+     * the `HttpParamsOptions`' `fromString` may be used. For example:
+     *
+     * ```ts
+     * new HttpParams({fromString: 'angular=awesome'})
+     * ```
+     */
+    __publicField(this, "params");
+    /**
+     * The outgoing URL with all URL parameters set.
+     */
+    __publicField(this, "urlWithParams");
+    /**
+     * The HttpTransferCache option for the request
+     */
+    __publicField(this, "transferCache");
+    /**
+     * The timeout for the backend HTTP request in ms.
+     */
+    __publicField(this, "timeout");
+    var _a2, _b2;
+    this.url = url;
+    this.method = method.toUpperCase();
+    let options;
+    if (mightHaveBody(this.method) || !!fourth) {
+      this.body = third !== void 0 ? third : null;
+      options = fourth;
+    } else {
+      options = third;
+    }
+    if (options) {
+      this.reportProgress = !!options.reportProgress;
+      this.withCredentials = !!options.withCredentials;
+      this.keepalive = !!options.keepalive;
+      if (!!options.responseType) {
+        this.responseType = options.responseType;
+      }
+      if (options.headers) {
+        this.headers = options.headers;
+      }
+      if (options.context) {
+        this.context = options.context;
+      }
+      if (options.params) {
+        this.params = options.params;
+      }
+      if (options.priority) {
+        this.priority = options.priority;
+      }
+      if (options.cache) {
+        this.cache = options.cache;
+      }
+      if (options.credentials) {
+        this.credentials = options.credentials;
+      }
+      if (typeof options.timeout === "number") {
+        if (options.timeout < 1 || !Number.isInteger(options.timeout)) {
+          throw new import_core.\u0275RuntimeError(2822, ngDevMode ? "`timeout` must be a positive integer value" : "");
+        }
+        this.timeout = options.timeout;
+      }
+      if (options.mode) {
+        this.mode = options.mode;
+      }
+      if (options.redirect) {
+        this.redirect = options.redirect;
+      }
+      if (options.integrity) {
+        this.integrity = options.integrity;
+      }
+      if (options.referrer) {
+        this.referrer = options.referrer;
+      }
+      this.transferCache = options.transferCache;
+    }
+    (_a2 = this.headers) != null ? _a2 : this.headers = new HttpHeaders();
+    (_b2 = this.context) != null ? _b2 : this.context = new HttpContext();
+    if (!this.params) {
+      this.params = new HttpParams();
+      this.urlWithParams = url;
+    } else {
+      const params = this.params.toString();
+      if (params.length === 0) {
+        this.urlWithParams = url;
+      } else {
+        const qIdx = url.indexOf("?");
+        const sep = qIdx === -1 ? "?" : qIdx < url.length - 1 ? "&" : "";
+        this.urlWithParams = url + sep + params;
+      }
+    }
+  }
+  /**
+   * Transform the free-form body into a serialized format suitable for
+   * transmission to the server.
+   */
+  serializeBody() {
+    if (this.body === null) {
+      return null;
+    }
+    if (typeof this.body === "string" || isArrayBuffer(this.body) || isBlob(this.body) || isFormData(this.body) || isUrlSearchParams(this.body)) {
+      return this.body;
+    }
+    if (this.body instanceof HttpParams) {
+      return this.body.toString();
+    }
+    if (typeof this.body === "object" || typeof this.body === "boolean" || Array.isArray(this.body)) {
+      return JSON.stringify(this.body);
+    }
+    return this.body.toString();
+  }
+  /**
+   * Examine the body and attempt to infer an appropriate MIME type
+   * for it.
+   *
+   * If no such type can be inferred, this method will return `null`.
+   */
+  detectContentTypeHeader() {
+    if (this.body === null) {
+      return null;
+    }
+    if (isFormData(this.body)) {
+      return null;
+    }
+    if (isBlob(this.body)) {
+      return this.body.type || null;
+    }
+    if (isArrayBuffer(this.body)) {
+      return null;
+    }
+    if (typeof this.body === "string") {
+      return TEXT_CONTENT_TYPE;
+    }
+    if (this.body instanceof HttpParams) {
+      return "application/x-www-form-urlencoded;charset=UTF-8";
+    }
+    if (typeof this.body === "object" || typeof this.body === "number" || typeof this.body === "boolean") {
+      return JSON_CONTENT_TYPE;
+    }
+    return null;
+  }
+  clone(update = {}) {
+    var _a2, _b2, _c, _d, _e, _f;
+    const method = update.method || this.method;
+    const url = update.url || this.url;
+    const responseType = update.responseType || this.responseType;
+    const keepalive = (_a2 = update.keepalive) != null ? _a2 : this.keepalive;
+    const priority = update.priority || this.priority;
+    const cache = update.cache || this.cache;
+    const mode = update.mode || this.mode;
+    const redirect = update.redirect || this.redirect;
+    const credentials = update.credentials || this.credentials;
+    const referrer = update.referrer || this.referrer;
+    const integrity = update.integrity || this.integrity;
+    const transferCache = (_b2 = update.transferCache) != null ? _b2 : this.transferCache;
+    const timeout = (_c = update.timeout) != null ? _c : this.timeout;
+    const body = update.body !== void 0 ? update.body : this.body;
+    const withCredentials = (_d = update.withCredentials) != null ? _d : this.withCredentials;
+    const reportProgress = (_e = update.reportProgress) != null ? _e : this.reportProgress;
+    let headers = update.headers || this.headers;
+    let params = update.params || this.params;
+    const context = (_f = update.context) != null ? _f : this.context;
+    if (update.setHeaders !== void 0) {
+      headers = Object.keys(update.setHeaders).reduce((headers2, name) => headers2.set(name, update.setHeaders[name]), headers);
+    }
+    if (update.setParams) {
+      params = Object.keys(update.setParams).reduce((params2, param) => params2.set(param, update.setParams[param]), params);
+    }
+    return new HttpRequest(method, url, body, {
+      params,
+      headers,
+      context,
+      reportProgress,
+      responseType,
+      withCredentials,
+      transferCache,
+      keepalive,
+      cache,
+      priority,
+      timeout,
+      mode,
+      redirect,
+      credentials,
+      referrer,
+      integrity
+    });
+  }
+}
+var HttpEventType;
+(function(HttpEventType2) {
+  HttpEventType2[HttpEventType2["Sent"] = 0] = "Sent";
+  HttpEventType2[HttpEventType2["UploadProgress"] = 1] = "UploadProgress";
+  HttpEventType2[HttpEventType2["ResponseHeader"] = 2] = "ResponseHeader";
+  HttpEventType2[HttpEventType2["DownloadProgress"] = 3] = "DownloadProgress";
+  HttpEventType2[HttpEventType2["Response"] = 4] = "Response";
+  HttpEventType2[HttpEventType2["User"] = 5] = "User";
+})(HttpEventType || (HttpEventType = {}));
+class HttpResponseBase {
+  /**
+   * Super-constructor for all responses.
+   *
+   * The single parameter accepted is an initialization hash. Any properties
+   * of the response passed there will override the default values.
+   */
+  constructor(init, defaultStatus = 200, defaultStatusText = "OK") {
+    /**
+     * All response headers.
+     */
+    __publicField(this, "headers");
+    /**
+     * Response status code.
+     */
+    __publicField(this, "status");
+    /**
+     * Textual description of response status code, defaults to OK.
+     *
+     * Do not depend on this.
+     */
+    __publicField(this, "statusText");
+    /**
+     * URL of the resource retrieved, or null if not available.
+     */
+    __publicField(this, "url");
+    /**
+     * Whether the status code falls in the 2xx range.
+     */
+    __publicField(this, "ok");
+    /**
+     * Type of the response, narrowed to either the full response or the header.
+     */
+    __publicField(this, "type");
+    /**
+     * Indicates whether the HTTP response was redirected during the request.
+     * This property is only available when using the Fetch API using `withFetch()`
+     * When using the default XHR Request this property will be `undefined`
+     */
+    __publicField(this, "redirected");
+    this.headers = init.headers || new HttpHeaders();
+    this.status = init.status !== void 0 ? init.status : defaultStatus;
+    this.statusText = init.statusText || defaultStatusText;
+    this.url = init.url || null;
+    this.redirected = init.redirected;
+    this.ok = this.status >= 200 && this.status < 300;
+  }
+}
+class HttpHeaderResponse extends HttpResponseBase {
+  /**
+   * Create a new `HttpHeaderResponse` with the given parameters.
+   */
+  constructor(init = {}) {
+    super(init);
+    __publicField(this, "type", HttpEventType.ResponseHeader);
+  }
+  /**
+   * Copy this `HttpHeaderResponse`, overriding its contents with the
+   * given parameter hash.
+   */
+  clone(update = {}) {
+    return new HttpHeaderResponse({
+      headers: update.headers || this.headers,
+      status: update.status !== void 0 ? update.status : this.status,
+      statusText: update.statusText || this.statusText,
+      url: update.url || this.url || void 0
+    });
+  }
+}
+class HttpResponse extends HttpResponseBase {
+  /**
+   * Construct a new `HttpResponse`.
+   */
+  constructor(init = {}) {
+    super(init);
+    /**
+     * The response body, or `null` if one was not returned.
+     */
+    __publicField(this, "body");
+    __publicField(this, "type", HttpEventType.Response);
+    this.body = init.body !== void 0 ? init.body : null;
+  }
+  clone(update = {}) {
+    var _a2;
+    return new HttpResponse({
+      body: update.body !== void 0 ? update.body : this.body,
+      headers: update.headers || this.headers,
+      status: update.status !== void 0 ? update.status : this.status,
+      statusText: update.statusText || this.statusText,
+      url: update.url || this.url || void 0,
+      redirected: (_a2 = update.redirected) != null ? _a2 : this.redirected
+    });
+  }
+}
+class HttpErrorResponse extends HttpResponseBase {
+  constructor(init) {
+    super(init, 0, "Unknown Error");
+    __publicField(this, "name", "HttpErrorResponse");
+    __publicField(this, "message");
+    __publicField(this, "error");
+    /**
+     * Errors are never okay, even when the status code is in the 2xx success range.
+     */
+    __publicField(this, "ok", false);
+    if (this.status >= 200 && this.status < 300) {
+      this.message = `Http failure during parsing for ${init.url || "(unknown url)"}`;
+    } else {
+      this.message = `Http failure response for ${init.url || "(unknown url)"}: ${init.status} ${init.statusText}`;
+    }
+    this.error = init.error || null;
+  }
+}
+const HTTP_STATUS_CODE_OK = 200;
+const HTTP_STATUS_CODE_NO_CONTENT = 204;
+var HttpStatusCode;
+(function(HttpStatusCode2) {
+  HttpStatusCode2[HttpStatusCode2["Continue"] = 100] = "Continue";
+  HttpStatusCode2[HttpStatusCode2["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+  HttpStatusCode2[HttpStatusCode2["Processing"] = 102] = "Processing";
+  HttpStatusCode2[HttpStatusCode2["EarlyHints"] = 103] = "EarlyHints";
+  HttpStatusCode2[HttpStatusCode2["Ok"] = 200] = "Ok";
+  HttpStatusCode2[HttpStatusCode2["Created"] = 201] = "Created";
+  HttpStatusCode2[HttpStatusCode2["Accepted"] = 202] = "Accepted";
+  HttpStatusCode2[HttpStatusCode2["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+  HttpStatusCode2[HttpStatusCode2["NoContent"] = 204] = "NoContent";
+  HttpStatusCode2[HttpStatusCode2["ResetContent"] = 205] = "ResetContent";
+  HttpStatusCode2[HttpStatusCode2["PartialContent"] = 206] = "PartialContent";
+  HttpStatusCode2[HttpStatusCode2["MultiStatus"] = 207] = "MultiStatus";
+  HttpStatusCode2[HttpStatusCode2["AlreadyReported"] = 208] = "AlreadyReported";
+  HttpStatusCode2[HttpStatusCode2["ImUsed"] = 226] = "ImUsed";
+  HttpStatusCode2[HttpStatusCode2["MultipleChoices"] = 300] = "MultipleChoices";
+  HttpStatusCode2[HttpStatusCode2["MovedPermanently"] = 301] = "MovedPermanently";
+  HttpStatusCode2[HttpStatusCode2["Found"] = 302] = "Found";
+  HttpStatusCode2[HttpStatusCode2["SeeOther"] = 303] = "SeeOther";
+  HttpStatusCode2[HttpStatusCode2["NotModified"] = 304] = "NotModified";
+  HttpStatusCode2[HttpStatusCode2["UseProxy"] = 305] = "UseProxy";
+  HttpStatusCode2[HttpStatusCode2["Unused"] = 306] = "Unused";
+  HttpStatusCode2[HttpStatusCode2["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+  HttpStatusCode2[HttpStatusCode2["PermanentRedirect"] = 308] = "PermanentRedirect";
+  HttpStatusCode2[HttpStatusCode2["BadRequest"] = 400] = "BadRequest";
+  HttpStatusCode2[HttpStatusCode2["Unauthorized"] = 401] = "Unauthorized";
+  HttpStatusCode2[HttpStatusCode2["PaymentRequired"] = 402] = "PaymentRequired";
+  HttpStatusCode2[HttpStatusCode2["Forbidden"] = 403] = "Forbidden";
+  HttpStatusCode2[HttpStatusCode2["NotFound"] = 404] = "NotFound";
+  HttpStatusCode2[HttpStatusCode2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+  HttpStatusCode2[HttpStatusCode2["NotAcceptable"] = 406] = "NotAcceptable";
+  HttpStatusCode2[HttpStatusCode2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+  HttpStatusCode2[HttpStatusCode2["RequestTimeout"] = 408] = "RequestTimeout";
+  HttpStatusCode2[HttpStatusCode2["Conflict"] = 409] = "Conflict";
+  HttpStatusCode2[HttpStatusCode2["Gone"] = 410] = "Gone";
+  HttpStatusCode2[HttpStatusCode2["LengthRequired"] = 411] = "LengthRequired";
+  HttpStatusCode2[HttpStatusCode2["PreconditionFailed"] = 412] = "PreconditionFailed";
+  HttpStatusCode2[HttpStatusCode2["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+  HttpStatusCode2[HttpStatusCode2["UriTooLong"] = 414] = "UriTooLong";
+  HttpStatusCode2[HttpStatusCode2["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+  HttpStatusCode2[HttpStatusCode2["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+  HttpStatusCode2[HttpStatusCode2["ExpectationFailed"] = 417] = "ExpectationFailed";
+  HttpStatusCode2[HttpStatusCode2["ImATeapot"] = 418] = "ImATeapot";
+  HttpStatusCode2[HttpStatusCode2["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+  HttpStatusCode2[HttpStatusCode2["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+  HttpStatusCode2[HttpStatusCode2["Locked"] = 423] = "Locked";
+  HttpStatusCode2[HttpStatusCode2["FailedDependency"] = 424] = "FailedDependency";
+  HttpStatusCode2[HttpStatusCode2["TooEarly"] = 425] = "TooEarly";
+  HttpStatusCode2[HttpStatusCode2["UpgradeRequired"] = 426] = "UpgradeRequired";
+  HttpStatusCode2[HttpStatusCode2["PreconditionRequired"] = 428] = "PreconditionRequired";
+  HttpStatusCode2[HttpStatusCode2["TooManyRequests"] = 429] = "TooManyRequests";
+  HttpStatusCode2[HttpStatusCode2["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+  HttpStatusCode2[HttpStatusCode2["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+  HttpStatusCode2[HttpStatusCode2["InternalServerError"] = 500] = "InternalServerError";
+  HttpStatusCode2[HttpStatusCode2["NotImplemented"] = 501] = "NotImplemented";
+  HttpStatusCode2[HttpStatusCode2["BadGateway"] = 502] = "BadGateway";
+  HttpStatusCode2[HttpStatusCode2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+  HttpStatusCode2[HttpStatusCode2["GatewayTimeout"] = 504] = "GatewayTimeout";
+  HttpStatusCode2[HttpStatusCode2["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
+  HttpStatusCode2[HttpStatusCode2["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+  HttpStatusCode2[HttpStatusCode2["InsufficientStorage"] = 507] = "InsufficientStorage";
+  HttpStatusCode2[HttpStatusCode2["LoopDetected"] = 508] = "LoopDetected";
+  HttpStatusCode2[HttpStatusCode2["NotExtended"] = 510] = "NotExtended";
+  HttpStatusCode2[HttpStatusCode2["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+})(HttpStatusCode || (HttpStatusCode = {}));
+function addBody(options, body) {
+  return {
+    body,
+    headers: options.headers,
+    context: options.context,
+    observe: options.observe,
+    params: options.params,
+    reportProgress: options.reportProgress,
+    responseType: options.responseType,
+    withCredentials: options.withCredentials,
+    credentials: options.credentials,
+    transferCache: options.transferCache,
+    timeout: options.timeout,
+    keepalive: options.keepalive,
+    priority: options.priority,
+    cache: options.cache,
+    mode: options.mode,
+    redirect: options.redirect,
+    integrity: options.integrity,
+    referrer: options.referrer
+  };
+}
+const _HttpClient = class _HttpClient {
+  constructor(handler) {
+    __publicField(this, "handler");
+    this.handler = handler;
+  }
+  /**
+   * Constructs an observable for a generic HTTP request that, when subscribed,
+   * fires the request through the chain of registered interceptors and on to the
+   * server.
+   *
+   * You can pass an `HttpRequest` directly as the only parameter. In this case,
+   * the call returns an observable of the raw `HttpEvent` stream.
+   *
+   * Alternatively you can pass an HTTP method as the first parameter,
+   * a URL string as the second, and an options hash containing the request body as the third.
+   * See `addBody()`. In this case, the specified `responseType` and `observe` options determine the
+   * type of returned observable.
+   *   * The `responseType` value determines how a successful response body is parsed.
+   *   * If `responseType` is the default `json`, you can pass a type interface for the resulting
+   * object as a type parameter to the call.
+   *
+   * The `observe` value determines the return type, according to what you are interested in
+   * observing.
+   *   * An `observe` value of events returns an observable of the raw `HttpEvent` stream, including
+   * progress events by default.
+   *   * An `observe` value of response returns an observable of `HttpResponse<T>`,
+   * where the `T` parameter depends on the `responseType` and any optionally provided type
+   * parameter.
+   *   * An `observe` value of body returns an observable of `<T>` with the same `T` body type.
+   *
+   */
+  request(first, url, options = {}) {
+    let req;
+    if (first instanceof HttpRequest) {
+      req = first;
+    } else {
+      let headers = void 0;
+      if (options.headers instanceof HttpHeaders) {
+        headers = options.headers;
+      } else {
+        headers = new HttpHeaders(options.headers);
+      }
+      let params = void 0;
+      if (!!options.params) {
+        if (options.params instanceof HttpParams) {
+          params = options.params;
+        } else {
+          params = new HttpParams({ fromObject: options.params });
+        }
+      }
+      req = new HttpRequest(first, url, options.body !== void 0 ? options.body : null, {
+        headers,
+        context: options.context,
+        params,
+        reportProgress: options.reportProgress,
+        // By default, JSON is assumed to be returned for all calls.
+        responseType: options.responseType || "json",
+        withCredentials: options.withCredentials,
+        transferCache: options.transferCache,
+        keepalive: options.keepalive,
+        priority: options.priority,
+        cache: options.cache,
+        mode: options.mode,
+        redirect: options.redirect,
+        credentials: options.credentials,
+        referrer: options.referrer,
+        integrity: options.integrity,
+        timeout: options.timeout
+      });
+    }
+    const events$ = (0, import_rxjs.of)(req).pipe((0, import_operators.concatMap)((req2) => this.handler.handle(req2)));
+    if (first instanceof HttpRequest || options.observe === "events") {
+      return events$;
+    }
+    const res$ = events$.pipe((0, import_operators.filter)((event) => event instanceof HttpResponse));
+    switch (options.observe || "body") {
+      case "body":
+        switch (req.responseType) {
+          case "arraybuffer":
+            return res$.pipe((0, import_operators.map)((res) => {
+              if (res.body !== null && !(res.body instanceof ArrayBuffer)) {
+                throw new import_core.\u0275RuntimeError(2806, ngDevMode && "Response is not an ArrayBuffer.");
+              }
+              return res.body;
+            }));
+          case "blob":
+            return res$.pipe((0, import_operators.map)((res) => {
+              if (res.body !== null && !(res.body instanceof Blob)) {
+                throw new import_core.\u0275RuntimeError(2807, ngDevMode && "Response is not a Blob.");
+              }
+              return res.body;
+            }));
+          case "text":
+            return res$.pipe((0, import_operators.map)((res) => {
+              if (res.body !== null && typeof res.body !== "string") {
+                throw new import_core.\u0275RuntimeError(2808, ngDevMode && "Response is not a string.");
+              }
+              return res.body;
+            }));
+          case "json":
+          default:
+            return res$.pipe((0, import_operators.map)((res) => res.body));
+        }
+      case "response":
+        return res$;
+      default:
+        throw new import_core.\u0275RuntimeError(2809, ngDevMode && `Unreachable: unhandled observe type ${options.observe}}`);
+    }
+  }
+  /**
+   * Constructs an observable that, when subscribed, causes the configured
+   * `DELETE` request to execute on the server. See the individual overloads for
+   * details on the return type.
+   *
+   * @param url     The endpoint URL.
+   * @param options The HTTP options to send with the request.
+   *
+   */
+  delete(url, options = {}) {
+    return this.request("DELETE", url, options);
+  }
+  /**
+   * Constructs an observable that, when subscribed, causes the configured
+   * `GET` request to execute on the server. See the individual overloads for
+   * details on the return type.
+   */
+  get(url, options = {}) {
+    return this.request("GET", url, options);
+  }
+  /**
+   * Constructs an observable that, when subscribed, causes the configured
+   * `HEAD` request to execute on the server. The `HEAD` method returns
+   * meta information about the resource without transferring the
+   * resource itself. See the individual overloads for
+   * details on the return type.
+   */
+  head(url, options = {}) {
+    return this.request("HEAD", url, options);
+  }
+  /**
+   * Constructs an `Observable` that, when subscribed, causes a request with the special method
+   * `JSONP` to be dispatched via the interceptor pipeline.
+   * The [JSONP pattern](https://en.wikipedia.org/wiki/JSONP) works around limitations of certain
+   * API endpoints that don't support newer,
+   * and preferable [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) protocol.
+   * JSONP treats the endpoint API as a JavaScript file and tricks the browser to process the
+   * requests even if the API endpoint is not located on the same domain (origin) as the client-side
+   * application making the request.
+   * The endpoint API must support JSONP callback for JSONP requests to work.
+   * The resource API returns the JSON response wrapped in a callback function.
+   * You can pass the callback function name as one of the query parameters.
+   * Note that JSONP requests can only be used with `GET` requests.
+   *
+   * @param url The resource URL.
+   * @param callbackParam The callback function name.
+   *
+   */
+  jsonp(url, callbackParam) {
+    return this.request("JSONP", url, {
+      params: new HttpParams().append(callbackParam, "JSONP_CALLBACK"),
+      observe: "body",
+      responseType: "json"
+    });
+  }
+  /**
+   * Constructs an `Observable` that, when subscribed, causes the configured
+   * `OPTIONS` request to execute on the server. This method allows the client
+   * to determine the supported HTTP methods and other capabilities of an endpoint,
+   * without implying a resource action. See the individual overloads for
+   * details on the return type.
+   */
+  options(url, options = {}) {
+    return this.request("OPTIONS", url, options);
+  }
+  /**
+   * Constructs an observable that, when subscribed, causes the configured
+   * `PATCH` request to execute on the server. See the individual overloads for
+   * details on the return type.
+   */
+  patch(url, body, options = {}) {
+    return this.request("PATCH", url, addBody(options, body));
+  }
+  /**
+   * Constructs an observable that, when subscribed, causes the configured
+   * `POST` request to execute on the server. The server responds with the location of
+   * the replaced resource. See the individual overloads for
+   * details on the return type.
+   */
+  post(url, body, options = {}) {
+    return this.request("POST", url, addBody(options, body));
+  }
+  /**
+   * Constructs an observable that, when subscribed, causes the configured
+   * `PUT` request to execute on the server. The `PUT` method replaces an existing resource
+   * with a new set of values.
+   * See the individual overloads for details on the return type.
+   */
+  put(url, body, options = {}) {
+    return this.request("PUT", url, addBody(options, body));
+  }
+};
+__publicField(_HttpClient, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpClient, deps: [{ token: HttpHandler }], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_HttpClient, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpClient }));
+let HttpClient = _HttpClient;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: HttpClient, decorators: [{
+  type: import_core.Injectable
+}], ctorParameters: () => [{ type: HttpHandler }] });
+const XSSI_PREFIX$1 = /^\)\]\}',?\n/;
+function getResponseUrl$1(response) {
+  if (response.url) {
+    return response.url;
+  }
+  const xRequestUrl = X_REQUEST_URL_HEADER.toLocaleLowerCase();
+  return response.headers.get(xRequestUrl);
+}
+const FETCH_BACKEND = new import_core.InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "FETCH_BACKEND" : "");
+const _FetchBackend = class _FetchBackend {
+  constructor() {
+    // We use an arrow function to always reference the current global implementation of `fetch`.
+    // This is helpful for cases when the global `fetch` implementation is modified by external code,
+    // see https://github.com/angular/angular/issues/57527.
+    __publicField(this, "fetchImpl", (_b = (_a = (0, import_core.inject)(FetchFactory, { optional: true })) == null ? void 0 : _a.fetch) != null ? _b : ((...args) => globalThis.fetch(...args)));
+    __publicField(this, "ngZone", (0, import_core.inject)(import_core.NgZone));
+    __publicField(this, "destroyRef", (0, import_core.inject)(import_core.DestroyRef));
+  }
+  handle(request) {
+    return new import_rxjs.Observable((observer) => {
+      const aborter = new AbortController();
+      this.doRequest(request, aborter.signal, observer).then(noop, (error) => observer.error(new HttpErrorResponse({ error })));
+      let timeoutId;
+      if (request.timeout) {
+        timeoutId = this.ngZone.runOutsideAngular(() => setTimeout(() => {
+          if (!aborter.signal.aborted) {
+            aborter.abort(new DOMException("signal timed out", "TimeoutError"));
+          }
+        }, request.timeout));
+      }
+      return () => {
+        if (timeoutId !== void 0) {
+          clearTimeout(timeoutId);
+        }
+        aborter.abort();
+      };
+    });
+  }
+  doRequest(request, signal, observer) {
+    return __async(this, null, function* () {
+      var _a2, _b2, _c, _d;
+      const init = this.createRequestInit(request);
+      let response;
+      try {
+        const fetchPromise = this.ngZone.runOutsideAngular(() => this.fetchImpl(request.urlWithParams, __spreadValues({ signal }, init)));
+        silenceSuperfluousUnhandledPromiseRejection(fetchPromise);
+        observer.next({ type: HttpEventType.Sent });
+        response = yield fetchPromise;
+      } catch (error) {
+        observer.error(new HttpErrorResponse({
+          error,
+          status: (_a2 = error.status) != null ? _a2 : 0,
+          statusText: error.statusText,
+          url: request.urlWithParams,
+          headers: error.headers
+        }));
+        return;
+      }
+      const headers = new HttpHeaders(response.headers);
+      const statusText = response.statusText;
+      const url = (_b2 = getResponseUrl$1(response)) != null ? _b2 : request.urlWithParams;
+      let status = response.status;
+      let body = null;
+      if (request.reportProgress) {
+        observer.next(new HttpHeaderResponse({ headers, status, statusText, url }));
+      }
+      if (response.body) {
+        const contentLength = response.headers.get("content-length");
+        const chunks = [];
+        const reader = response.body.getReader();
+        let receivedLength = 0;
+        let decoder;
+        let partialText;
+        const reqZone = typeof Zone !== "undefined" && Zone.current;
+        let canceled = false;
+        yield this.ngZone.runOutsideAngular(() => __async(this, null, function* () {
+          while (true) {
+            if (this.destroyRef.destroyed) {
+              yield reader.cancel();
+              canceled = true;
+              break;
+            }
+            const { done, value } = yield reader.read();
+            if (done) {
+              break;
+            }
+            chunks.push(value);
+            receivedLength += value.length;
+            if (request.reportProgress) {
+              partialText = request.responseType === "text" ? (partialText != null ? partialText : "") + (decoder != null ? decoder : decoder = new TextDecoder()).decode(value, { stream: true }) : void 0;
+              const reportProgress = () => observer.next({
+                type: HttpEventType.DownloadProgress,
+                total: contentLength ? +contentLength : void 0,
+                loaded: receivedLength,
+                partialText
+              });
+              reqZone ? reqZone.run(reportProgress) : reportProgress();
+            }
+          }
+        }));
+        if (canceled) {
+          observer.complete();
+          return;
+        }
+        const chunksAll = this.concatChunks(chunks, receivedLength);
+        try {
+          const contentType = (_c = response.headers.get(CONTENT_TYPE_HEADER)) != null ? _c : "";
+          body = this.parseBody(request, chunksAll, contentType, status);
+        } catch (error) {
+          observer.error(new HttpErrorResponse({
+            error,
+            headers: new HttpHeaders(response.headers),
+            status: response.status,
+            statusText: response.statusText,
+            url: (_d = getResponseUrl$1(response)) != null ? _d : request.urlWithParams
+          }));
+          return;
+        }
+      }
+      if (status === 0) {
+        status = body ? HTTP_STATUS_CODE_OK : 0;
+      }
+      const ok = status >= 200 && status < 300;
+      const redirected = response.redirected;
+      if (ok) {
+        observer.next(new HttpResponse({
+          body,
+          headers,
+          status,
+          statusText,
+          url,
+          redirected
+        }));
+        observer.complete();
+      } else {
+        observer.error(new HttpErrorResponse({
+          error: body,
+          headers,
+          status,
+          statusText,
+          url,
+          redirected
+        }));
+      }
+    });
+  }
+  parseBody(request, binContent, contentType, status) {
+    switch (request.responseType) {
+      case "json":
+        const text = new TextDecoder().decode(binContent).replace(XSSI_PREFIX$1, "");
+        if (text === "") {
+          return null;
+        }
+        try {
+          return JSON.parse(text);
+        } catch (e) {
+          if (status < 200 || status >= 300) {
+            return text;
+          }
+          throw e;
+        }
+      case "text":
+        return new TextDecoder().decode(binContent);
+      case "blob":
+        return new Blob([binContent], { type: contentType });
+      case "arraybuffer":
+        return binContent.buffer;
+    }
+  }
+  createRequestInit(req) {
+    const headers = {};
+    let credentials;
+    credentials = req.credentials;
+    if (req.withCredentials) {
+      (typeof ngDevMode === "undefined" || ngDevMode) && warningOptionsMessage(req);
+      credentials = "include";
+    }
+    req.headers.forEach((name, values) => headers[name] = values.join(","));
+    if (!req.headers.has(ACCEPT_HEADER)) {
+      headers[ACCEPT_HEADER] = ACCEPT_HEADER_VALUE;
+    }
+    if (!req.headers.has(CONTENT_TYPE_HEADER)) {
+      const detectedType = req.detectContentTypeHeader();
+      if (detectedType !== null) {
+        headers[CONTENT_TYPE_HEADER] = detectedType;
+      }
+    }
+    return {
+      body: req.serializeBody(),
+      method: req.method,
+      headers,
+      credentials,
+      keepalive: req.keepalive,
+      cache: req.cache,
+      priority: req.priority,
+      mode: req.mode,
+      redirect: req.redirect,
+      referrer: req.referrer,
+      integrity: req.integrity
+    };
+  }
+  concatChunks(chunks, totalLength) {
+    const chunksAll = new Uint8Array(totalLength);
+    let position = 0;
+    for (const chunk of chunks) {
+      chunksAll.set(chunk, position);
+      position += chunk.length;
+    }
+    return chunksAll;
+  }
+};
+__publicField(_FetchBackend, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _FetchBackend, deps: [], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_FetchBackend, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _FetchBackend }));
+let FetchBackend = _FetchBackend;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: FetchBackend, decorators: [{
+  type: import_core.Injectable
+}] });
+class FetchFactory {
+}
+function noop() {
+}
+function warningOptionsMessage(req) {
+  if (req.credentials && req.withCredentials) {
+    console.warn((0, import_core.\u0275formatRuntimeError)(2819, `Angular detected that a \`HttpClient\` request has both \`withCredentials: true\` and \`credentials: '${req.credentials}'\` options. The \`withCredentials\` option is overriding the explicit \`credentials\` setting to 'include'. Consider removing \`withCredentials\` and using \`credentials: '${req.credentials}'\` directly for clarity.`));
+  }
+}
+function silenceSuperfluousUnhandledPromiseRejection(promise) {
+  promise.then(noop, noop);
+}
+function interceptorChainEndFn(req, finalHandlerFn) {
+  return finalHandlerFn(req);
+}
+function adaptLegacyInterceptorToChain(chainTailFn, interceptor) {
+  return (initialRequest, finalHandlerFn) => interceptor.intercept(initialRequest, {
+    handle: (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn)
+  });
+}
+function chainedInterceptorFn(chainTailFn, interceptorFn, injector) {
+  return (initialRequest, finalHandlerFn) => (0, import_core.runInInjectionContext)(injector, () => interceptorFn(initialRequest, (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn)));
+}
+const HTTP_INTERCEPTORS = new import_core.InjectionToken(ngDevMode ? "HTTP_INTERCEPTORS" : "");
+const HTTP_INTERCEPTOR_FNS = new import_core.InjectionToken(ngDevMode ? "HTTP_INTERCEPTOR_FNS" : "");
+const HTTP_ROOT_INTERCEPTOR_FNS = new import_core.InjectionToken(ngDevMode ? "HTTP_ROOT_INTERCEPTOR_FNS" : "");
+const REQUESTS_CONTRIBUTE_TO_STABILITY = new import_core.InjectionToken(ngDevMode ? "REQUESTS_CONTRIBUTE_TO_STABILITY" : "", { providedIn: "root", factory: () => true });
+function legacyInterceptorFnFactory() {
+  let chain = null;
+  return (req, handler) => {
+    var _a2;
+    if (chain === null) {
+      const interceptors = (_a2 = (0, import_core.inject)(HTTP_INTERCEPTORS, { optional: true })) != null ? _a2 : [];
+      chain = interceptors.reduceRight(adaptLegacyInterceptorToChain, interceptorChainEndFn);
+    }
+    const pendingTasks = (0, import_core.inject)(import_core.PendingTasks);
+    const contributeToStability = (0, import_core.inject)(REQUESTS_CONTRIBUTE_TO_STABILITY);
+    if (contributeToStability) {
+      const removeTask = pendingTasks.add();
+      return chain(req, handler).pipe((0, import_operators.finalize)(removeTask));
+    } else {
+      return chain(req, handler);
+    }
+  };
+}
+let fetchBackendWarningDisplayed = false;
+const _HttpInterceptorHandler = class _HttpInterceptorHandler extends HttpHandler {
+  constructor(backend, injector) {
+    super();
+    __publicField(this, "backend");
+    __publicField(this, "injector");
+    __publicField(this, "chain", null);
+    __publicField(this, "pendingTasks", (0, import_core.inject)(import_core.PendingTasks));
+    __publicField(this, "contributeToStability", (0, import_core.inject)(REQUESTS_CONTRIBUTE_TO_STABILITY));
+    this.backend = backend;
+    this.injector = injector;
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && !fetchBackendWarningDisplayed) {
+      const isTestingBackend = this.backend.isTestingBackend;
+      if (typeof ngServerMode !== "undefined" && ngServerMode && !(this.backend instanceof FetchBackend) && !isTestingBackend) {
+        fetchBackendWarningDisplayed = true;
+        injector.get(import_core.\u0275Console).warn((0, import_core.\u0275formatRuntimeError)(2801, "Angular detected that `HttpClient` is not configured to use `fetch` APIs. It's strongly recommended to enable `fetch` for applications that use Server-Side Rendering for better performance and compatibility. To enable `fetch`, add the `withFetch()` to the `provideHttpClient()` call at the root of the application."));
+      }
+    }
+  }
+  handle(initialRequest) {
+    if (this.chain === null) {
+      const dedupedInterceptorFns = Array.from(/* @__PURE__ */ new Set([
+        ...this.injector.get(HTTP_INTERCEPTOR_FNS),
+        ...this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, [])
+      ]));
+      this.chain = dedupedInterceptorFns.reduceRight((nextSequencedFn, interceptorFn) => chainedInterceptorFn(nextSequencedFn, interceptorFn, this.injector), interceptorChainEndFn);
+    }
+    if (this.contributeToStability) {
+      const removeTask = this.pendingTasks.add();
+      return this.chain(initialRequest, (downstreamRequest) => this.backend.handle(downstreamRequest)).pipe((0, import_operators.finalize)(removeTask));
+    } else {
+      return this.chain(initialRequest, (downstreamRequest) => this.backend.handle(downstreamRequest));
+    }
+  }
+};
+__publicField(_HttpInterceptorHandler, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpInterceptorHandler, deps: [{ token: HttpBackend }, { token: i0.EnvironmentInjector }], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_HttpInterceptorHandler, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpInterceptorHandler }));
+let HttpInterceptorHandler = _HttpInterceptorHandler;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: HttpInterceptorHandler, decorators: [{
+  type: import_core.Injectable
+}], ctorParameters: () => [{ type: HttpBackend }, { type: i0.EnvironmentInjector }] });
+let nextRequestId = 0;
+let foreignDocument;
+const JSONP_ERR_NO_CALLBACK = "JSONP injected script did not invoke callback.";
+const JSONP_ERR_WRONG_METHOD = "JSONP requests must use JSONP request method.";
+const JSONP_ERR_WRONG_RESPONSE_TYPE = "JSONP requests must use Json response type.";
+const JSONP_ERR_HEADERS_NOT_SUPPORTED = "JSONP requests do not support headers.";
+class JsonpCallbackContext {
+}
+function jsonpCallbackContext() {
+  if (typeof window === "object") {
+    return window;
+  }
+  return {};
+}
+const _JsonpClientBackend = class _JsonpClientBackend {
+  constructor(callbackMap, document) {
+    __publicField(this, "callbackMap");
+    __publicField(this, "document");
+    /**
+     * A resolved promise that can be used to schedule microtasks in the event handlers.
+     */
+    __publicField(this, "resolvedPromise", Promise.resolve());
+    this.callbackMap = callbackMap;
+    this.document = document;
+  }
+  /**
+   * Get the name of the next callback method, by incrementing the global `nextRequestId`.
+   */
+  nextCallback() {
+    return `ng_jsonp_callback_${nextRequestId++}`;
+  }
+  /**
+   * Processes a JSONP request and returns an event stream of the results.
+   * @param req The request object.
+   * @returns An observable of the response events.
+   *
+   */
+  handle(req) {
+    if (req.method !== "JSONP") {
+      throw new import_core.\u0275RuntimeError(2810, ngDevMode && JSONP_ERR_WRONG_METHOD);
+    } else if (req.responseType !== "json") {
+      throw new import_core.\u0275RuntimeError(2811, ngDevMode && JSONP_ERR_WRONG_RESPONSE_TYPE);
+    }
+    if (req.headers.keys().length > 0) {
+      throw new import_core.\u0275RuntimeError(2812, ngDevMode && JSONP_ERR_HEADERS_NOT_SUPPORTED);
+    }
+    return new import_rxjs.Observable((observer) => {
+      const callback = this.nextCallback();
+      const url = req.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/, `=${callback}$1`);
+      const node = this.document.createElement("script");
+      node.src = url;
+      let body = null;
+      let finished = false;
+      this.callbackMap[callback] = (data) => {
+        delete this.callbackMap[callback];
+        body = data;
+        finished = true;
+      };
+      const cleanup = () => {
+        node.removeEventListener("load", onLoad);
+        node.removeEventListener("error", onError);
+        node.remove();
+        delete this.callbackMap[callback];
+      };
+      const onLoad = () => {
+        this.resolvedPromise.then(() => {
+          cleanup();
+          if (!finished) {
+            observer.error(new HttpErrorResponse({
+              url,
+              status: 0,
+              statusText: "JSONP Error",
+              error: new Error(JSONP_ERR_NO_CALLBACK)
+            }));
+            return;
+          }
+          observer.next(new HttpResponse({
+            body,
+            status: HTTP_STATUS_CODE_OK,
+            statusText: "OK",
+            url
+          }));
+          observer.complete();
+        });
+      };
+      const onError = (error) => {
+        cleanup();
+        observer.error(new HttpErrorResponse({
+          error,
+          status: 0,
+          statusText: "JSONP Error",
+          url
+        }));
+      };
+      node.addEventListener("load", onLoad);
+      node.addEventListener("error", onError);
+      this.document.body.appendChild(node);
+      observer.next({ type: HttpEventType.Sent });
+      return () => {
+        if (!finished) {
+          this.removeListeners(node);
+        }
+        cleanup();
+      };
+    });
+  }
+  removeListeners(script) {
+    foreignDocument != null ? foreignDocument : foreignDocument = this.document.implementation.createHTMLDocument();
+    foreignDocument.adoptNode(script);
+  }
+};
+__publicField(_JsonpClientBackend, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _JsonpClientBackend, deps: [{ token: JsonpCallbackContext }, { token: import_core.DOCUMENT }], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_JsonpClientBackend, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _JsonpClientBackend }));
+let JsonpClientBackend = _JsonpClientBackend;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: JsonpClientBackend, decorators: [{
+  type: import_core.Injectable
+}], ctorParameters: () => [{ type: JsonpCallbackContext }, { type: void 0, decorators: [{
+  type: import_core.Inject,
+  args: [import_core.DOCUMENT]
+}] }] });
+function jsonpInterceptorFn(req, next) {
+  if (req.method === "JSONP") {
+    return (0, import_core.inject)(JsonpClientBackend).handle(req);
+  }
+  return next(req);
+}
+const _JsonpInterceptor = class _JsonpInterceptor {
+  constructor(injector) {
+    __publicField(this, "injector");
+    this.injector = injector;
+  }
+  /**
+   * Identifies and handles a given JSONP request.
+   * @param initialRequest The outgoing request object to handle.
+   * @param next The next interceptor in the chain, or the backend
+   * if no interceptors remain in the chain.
+   * @returns An observable of the event stream.
+   */
+  intercept(initialRequest, next) {
+    return (0, import_core.runInInjectionContext)(this.injector, () => jsonpInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));
+  }
+};
+__publicField(_JsonpInterceptor, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _JsonpInterceptor, deps: [{ token: i0.EnvironmentInjector }], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_JsonpInterceptor, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _JsonpInterceptor }));
+let JsonpInterceptor = _JsonpInterceptor;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: JsonpInterceptor, decorators: [{
+  type: import_core.Injectable
+}], ctorParameters: () => [{ type: i0.EnvironmentInjector }] });
+const XSSI_PREFIX = /^\)\]\}',?\n/;
+const X_REQUEST_URL_REGEXP = RegExp(`^${X_REQUEST_URL_HEADER}:`, "m");
+function getResponseUrl(xhr) {
+  if ("responseURL" in xhr && xhr.responseURL) {
+    return xhr.responseURL;
+  }
+  if (X_REQUEST_URL_REGEXP.test(xhr.getAllResponseHeaders())) {
+    return xhr.getResponseHeader(X_REQUEST_URL_HEADER);
+  }
+  return null;
+}
+function validateXhrCompatibility(req) {
+  const unsupportedOptions = [
+    {
+      property: "keepalive",
+      errorCode: 2813
+    },
+    {
+      property: "cache",
+      errorCode: 2814
+    },
+    {
+      property: "priority",
+      errorCode: 2815
+    },
+    {
+      property: "mode",
+      errorCode: 2816
+    },
+    {
+      property: "redirect",
+      errorCode: 2817
+    },
+    {
+      property: "credentials",
+      errorCode: 2818
+    },
+    {
+      property: "integrity",
+      errorCode: 2820
+    },
+    {
+      property: "referrer",
+      errorCode: 2821
+    }
+  ];
+  for (const { property, errorCode } of unsupportedOptions) {
+    if (req[property]) {
+      console.warn((0, import_core.\u0275formatRuntimeError)(errorCode, `Angular detected that a \`HttpClient\` request with the \`${property}\` option was sent using XHR, which does not support it. To use the \`${property}\` option, enable Fetch API support by passing \`withFetch()\` as an argument to \`provideHttpClient()\`.`));
+    }
+  }
+}
+const _HttpXhrBackend = class _HttpXhrBackend {
+  constructor(xhrFactory) {
+    __publicField(this, "xhrFactory");
+    this.xhrFactory = xhrFactory;
+  }
+  /**
+   * Processes a request and returns a stream of response events.
+   * @param req The request object.
+   * @returns An observable of the response events.
+   */
+  handle(req) {
+    if (req.method === "JSONP") {
+      throw new import_core.\u0275RuntimeError(-2800, (typeof ngDevMode === "undefined" || ngDevMode) && `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.`);
+    }
+    ngDevMode && validateXhrCompatibility(req);
+    const xhrFactory = this.xhrFactory;
+    const source = (
+      // Note that `ɵloadImpl` is never defined in client bundles and can be
+      // safely dropped whenever we're running in the browser.
+      // This branching is redundant.
+      // The `ngServerMode` guard also enables tree-shaking of the `from()`
+      // function from the common bundle, as it's only used in server code.
+      typeof ngServerMode !== "undefined" && ngServerMode && xhrFactory.\u0275loadImpl ? (0, import_rxjs.from)(xhrFactory.\u0275loadImpl()) : (0, import_rxjs.of)(null)
+    );
+    return source.pipe((0, import_operators.switchMap)(() => {
+      return new import_rxjs.Observable((observer) => {
+        const xhr = xhrFactory.build();
+        xhr.open(req.method, req.urlWithParams);
+        if (req.withCredentials) {
+          xhr.withCredentials = true;
+        }
+        req.headers.forEach((name, values) => xhr.setRequestHeader(name, values.join(",")));
+        if (!req.headers.has(ACCEPT_HEADER)) {
+          xhr.setRequestHeader(ACCEPT_HEADER, ACCEPT_HEADER_VALUE);
+        }
+        if (!req.headers.has(CONTENT_TYPE_HEADER)) {
+          const detectedType = req.detectContentTypeHeader();
+          if (detectedType !== null) {
+            xhr.setRequestHeader(CONTENT_TYPE_HEADER, detectedType);
+          }
+        }
+        if (req.timeout) {
+          xhr.timeout = req.timeout;
+        }
+        if (req.responseType) {
+          const responseType = req.responseType.toLowerCase();
+          xhr.responseType = responseType !== "json" ? responseType : "text";
+        }
+        const reqBody = req.serializeBody();
+        let headerResponse = null;
+        const partialFromXhr = () => {
+          if (headerResponse !== null) {
+            return headerResponse;
+          }
+          const statusText = xhr.statusText || "OK";
+          const headers = new HttpHeaders(xhr.getAllResponseHeaders());
+          const url = getResponseUrl(xhr) || req.url;
+          headerResponse = new HttpHeaderResponse({ headers, status: xhr.status, statusText, url });
+          return headerResponse;
+        };
+        const onLoad = () => {
+          let { headers, status, statusText, url } = partialFromXhr();
+          let body = null;
+          if (status !== HTTP_STATUS_CODE_NO_CONTENT) {
+            body = typeof xhr.response === "undefined" ? xhr.responseText : xhr.response;
+          }
+          if (status === 0) {
+            status = !!body ? HTTP_STATUS_CODE_OK : 0;
+          }
+          let ok = status >= 200 && status < 300;
+          if (req.responseType === "json" && typeof body === "string") {
+            const originalBody = body;
+            body = body.replace(XSSI_PREFIX, "");
+            try {
+              body = body !== "" ? JSON.parse(body) : null;
+            } catch (error) {
+              body = originalBody;
+              if (ok) {
+                ok = false;
+                body = { error, text: body };
+              }
+            }
+          }
+          if (ok) {
+            observer.next(new HttpResponse({
+              body,
+              headers,
+              status,
+              statusText,
+              url: url || void 0
+            }));
+            observer.complete();
+          } else {
+            observer.error(new HttpErrorResponse({
+              // The error in this case is the response body (error from the server).
+              error: body,
+              headers,
+              status,
+              statusText,
+              url: url || void 0
+            }));
+          }
+        };
+        const onError = (error) => {
+          const { url } = partialFromXhr();
+          const res = new HttpErrorResponse({
+            error,
+            status: xhr.status || 0,
+            statusText: xhr.statusText || "Unknown Error",
+            url: url || void 0
+          });
+          observer.error(res);
+        };
+        let onTimeout = onError;
+        if (req.timeout) {
+          onTimeout = (_) => {
+            const { url } = partialFromXhr();
+            const res = new HttpErrorResponse({
+              error: new DOMException("Request timed out", "TimeoutError"),
+              status: xhr.status || 0,
+              statusText: xhr.statusText || "Request timeout",
+              url: url || void 0
+            });
+            observer.error(res);
+          };
+        }
+        let sentHeaders = false;
+        const onDownProgress = (event) => {
+          if (!sentHeaders) {
+            observer.next(partialFromXhr());
+            sentHeaders = true;
+          }
+          let progressEvent = {
+            type: HttpEventType.DownloadProgress,
+            loaded: event.loaded
+          };
+          if (event.lengthComputable) {
+            progressEvent.total = event.total;
+          }
+          if (req.responseType === "text" && !!xhr.responseText) {
+            progressEvent.partialText = xhr.responseText;
+          }
+          observer.next(progressEvent);
+        };
+        const onUpProgress = (event) => {
+          let progress = {
+            type: HttpEventType.UploadProgress,
+            loaded: event.loaded
+          };
+          if (event.lengthComputable) {
+            progress.total = event.total;
+          }
+          observer.next(progress);
+        };
+        xhr.addEventListener("load", onLoad);
+        xhr.addEventListener("error", onError);
+        xhr.addEventListener("timeout", onTimeout);
+        xhr.addEventListener("abort", onError);
+        if (req.reportProgress) {
+          xhr.addEventListener("progress", onDownProgress);
+          if (reqBody !== null && xhr.upload) {
+            xhr.upload.addEventListener("progress", onUpProgress);
+          }
+        }
+        xhr.send(reqBody);
+        observer.next({ type: HttpEventType.Sent });
+        return () => {
+          xhr.removeEventListener("error", onError);
+          xhr.removeEventListener("abort", onError);
+          xhr.removeEventListener("load", onLoad);
+          xhr.removeEventListener("timeout", onTimeout);
+          if (req.reportProgress) {
+            xhr.removeEventListener("progress", onDownProgress);
+            if (reqBody !== null && xhr.upload) {
+              xhr.upload.removeEventListener("progress", onUpProgress);
+            }
+          }
+          if (xhr.readyState !== xhr.DONE) {
+            xhr.abort();
+          }
+        };
+      });
+    }));
+  }
+};
+__publicField(_HttpXhrBackend, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpXhrBackend, deps: [{ token: import_xhr.XhrFactory }], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_HttpXhrBackend, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpXhrBackend }));
+let HttpXhrBackend = _HttpXhrBackend;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: HttpXhrBackend, decorators: [{
+  type: import_core.Injectable
+}], ctorParameters: () => [{ type: import_xhr.XhrFactory }] });
+const XSRF_ENABLED = new import_core.InjectionToken(ngDevMode ? "XSRF_ENABLED" : "");
+const XSRF_DEFAULT_COOKIE_NAME = "XSRF-TOKEN";
+const XSRF_COOKIE_NAME = new import_core.InjectionToken(ngDevMode ? "XSRF_COOKIE_NAME" : "", {
+  providedIn: "root",
+  factory: () => XSRF_DEFAULT_COOKIE_NAME
+});
+const XSRF_DEFAULT_HEADER_NAME = "X-XSRF-TOKEN";
+const XSRF_HEADER_NAME = new import_core.InjectionToken(ngDevMode ? "XSRF_HEADER_NAME" : "", {
+  providedIn: "root",
+  factory: () => XSRF_DEFAULT_HEADER_NAME
+});
+class HttpXsrfTokenExtractor {
+}
+const _HttpXsrfCookieExtractor = class _HttpXsrfCookieExtractor {
+  constructor(doc, cookieName) {
+    __publicField(this, "doc");
+    __publicField(this, "cookieName");
+    __publicField(this, "lastCookieString", "");
+    __publicField(this, "lastToken", null);
+    /**
+     * @internal for testing
+     */
+    __publicField(this, "parseCount", 0);
+    this.doc = doc;
+    this.cookieName = cookieName;
+  }
+  getToken() {
+    if (typeof ngServerMode !== "undefined" && ngServerMode) {
+      return null;
+    }
+    const cookieString = this.doc.cookie || "";
+    if (cookieString !== this.lastCookieString) {
+      this.parseCount++;
+      this.lastToken = (0, import_xhr.parseCookieValue)(cookieString, this.cookieName);
+      this.lastCookieString = cookieString;
+    }
+    return this.lastToken;
+  }
+};
+__publicField(_HttpXsrfCookieExtractor, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpXsrfCookieExtractor, deps: [{ token: import_core.DOCUMENT }, { token: XSRF_COOKIE_NAME }], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_HttpXsrfCookieExtractor, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpXsrfCookieExtractor }));
+let HttpXsrfCookieExtractor = _HttpXsrfCookieExtractor;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: HttpXsrfCookieExtractor, decorators: [{
+  type: import_core.Injectable
+}], ctorParameters: () => [{ type: void 0, decorators: [{
+  type: import_core.Inject,
+  args: [import_core.DOCUMENT]
+}] }, { type: void 0, decorators: [{
+  type: import_core.Inject,
+  args: [XSRF_COOKIE_NAME]
+}] }] });
+const ABSOLUTE_URL_REGEX = /^(?:https?:)?\/\//i;
+function xsrfInterceptorFn(req, next) {
+  if (!(0, import_core.inject)(XSRF_ENABLED) || req.method === "GET" || req.method === "HEAD" || ABSOLUTE_URL_REGEX.test(req.url)) {
+    return next(req);
+  }
+  const token = (0, import_core.inject)(HttpXsrfTokenExtractor).getToken();
+  const headerName = (0, import_core.inject)(XSRF_HEADER_NAME);
+  if (token != null && !req.headers.has(headerName)) {
+    req = req.clone({ headers: req.headers.set(headerName, token) });
+  }
+  return next(req);
+}
+const _HttpXsrfInterceptor = class _HttpXsrfInterceptor {
+  constructor(injector) {
+    __publicField(this, "injector");
+    this.injector = injector;
+  }
+  intercept(initialRequest, next) {
+    return (0, import_core.runInInjectionContext)(this.injector, () => xsrfInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));
+  }
+};
+__publicField(_HttpXsrfInterceptor, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpXsrfInterceptor, deps: [{ token: i0.EnvironmentInjector }], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_HttpXsrfInterceptor, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpXsrfInterceptor }));
+let HttpXsrfInterceptor = _HttpXsrfInterceptor;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: HttpXsrfInterceptor, decorators: [{
+  type: import_core.Injectable
+}], ctorParameters: () => [{ type: i0.EnvironmentInjector }] });
+var HttpFeatureKind;
+(function(HttpFeatureKind2) {
+  HttpFeatureKind2[HttpFeatureKind2["Interceptors"] = 0] = "Interceptors";
+  HttpFeatureKind2[HttpFeatureKind2["LegacyInterceptors"] = 1] = "LegacyInterceptors";
+  HttpFeatureKind2[HttpFeatureKind2["CustomXsrfConfiguration"] = 2] = "CustomXsrfConfiguration";
+  HttpFeatureKind2[HttpFeatureKind2["NoXsrfProtection"] = 3] = "NoXsrfProtection";
+  HttpFeatureKind2[HttpFeatureKind2["JsonpSupport"] = 4] = "JsonpSupport";
+  HttpFeatureKind2[HttpFeatureKind2["RequestsMadeViaParent"] = 5] = "RequestsMadeViaParent";
+  HttpFeatureKind2[HttpFeatureKind2["Fetch"] = 6] = "Fetch";
+})(HttpFeatureKind || (HttpFeatureKind = {}));
+function makeHttpFeature(kind, providers) {
+  return {
+    \u0275kind: kind,
+    \u0275providers: providers
+  };
+}
+function provideHttpClient(...features) {
+  if (ngDevMode) {
+    const featureKinds = new Set(features.map((f) => f.\u0275kind));
+    if (featureKinds.has(HttpFeatureKind.NoXsrfProtection) && featureKinds.has(HttpFeatureKind.CustomXsrfConfiguration)) {
+      throw new Error(ngDevMode ? `Configuration error: found both withXsrfConfiguration() and withNoXsrfProtection() in the same call to provideHttpClient(), which is a contradiction.` : "");
+    }
+  }
+  const providers = [
+    HttpClient,
+    HttpXhrBackend,
+    HttpInterceptorHandler,
+    { provide: HttpHandler, useExisting: HttpInterceptorHandler },
+    {
+      provide: HttpBackend,
+      useFactory: () => {
+        var _a2;
+        return (_a2 = (0, import_core.inject)(FETCH_BACKEND, { optional: true })) != null ? _a2 : (0, import_core.inject)(HttpXhrBackend);
+      }
+    },
+    {
+      provide: HTTP_INTERCEPTOR_FNS,
+      useValue: xsrfInterceptorFn,
+      multi: true
+    },
+    { provide: XSRF_ENABLED, useValue: true },
+    { provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor }
+  ];
+  for (const feature of features) {
+    providers.push(...feature.\u0275providers);
+  }
+  return (0, import_core.makeEnvironmentProviders)(providers);
+}
+function withInterceptors(interceptorFns) {
+  return makeHttpFeature(HttpFeatureKind.Interceptors, interceptorFns.map((interceptorFn) => {
+    return {
+      provide: HTTP_INTERCEPTOR_FNS,
+      useValue: interceptorFn,
+      multi: true
+    };
+  }));
+}
+const LEGACY_INTERCEPTOR_FN = new import_core.InjectionToken(ngDevMode ? "LEGACY_INTERCEPTOR_FN" : "");
+function withInterceptorsFromDi() {
+  return makeHttpFeature(HttpFeatureKind.LegacyInterceptors, [
+    {
+      provide: LEGACY_INTERCEPTOR_FN,
+      useFactory: legacyInterceptorFnFactory
+    },
+    {
+      provide: HTTP_INTERCEPTOR_FNS,
+      useExisting: LEGACY_INTERCEPTOR_FN,
+      multi: true
+    }
+  ]);
+}
+function withXsrfConfiguration({ cookieName, headerName }) {
+  const providers = [];
+  if (cookieName !== void 0) {
+    providers.push({ provide: XSRF_COOKIE_NAME, useValue: cookieName });
+  }
+  if (headerName !== void 0) {
+    providers.push({ provide: XSRF_HEADER_NAME, useValue: headerName });
+  }
+  return makeHttpFeature(HttpFeatureKind.CustomXsrfConfiguration, providers);
+}
+function withNoXsrfProtection() {
+  return makeHttpFeature(HttpFeatureKind.NoXsrfProtection, [
+    {
+      provide: XSRF_ENABLED,
+      useValue: false
+    }
+  ]);
+}
+function withJsonpSupport() {
+  return makeHttpFeature(HttpFeatureKind.JsonpSupport, [
+    JsonpClientBackend,
+    { provide: JsonpCallbackContext, useFactory: jsonpCallbackContext },
+    { provide: HTTP_INTERCEPTOR_FNS, useValue: jsonpInterceptorFn, multi: true }
+  ]);
+}
+function withRequestsMadeViaParent() {
+  return makeHttpFeature(HttpFeatureKind.RequestsMadeViaParent, [
+    {
+      provide: HttpBackend,
+      useFactory: () => {
+        const handlerFromParent = (0, import_core.inject)(HttpHandler, { skipSelf: true, optional: true });
+        if (ngDevMode && handlerFromParent === null) {
+          throw new Error("withRequestsMadeViaParent() can only be used when the parent injector also configures HttpClient");
+        }
+        return handlerFromParent;
+      }
+    }
+  ]);
+}
+function withFetch() {
+  return makeHttpFeature(HttpFeatureKind.Fetch, [
+    FetchBackend,
+    { provide: FETCH_BACKEND, useExisting: FetchBackend },
+    { provide: HttpBackend, useExisting: FetchBackend }
+  ]);
+}
+const _HttpClientXsrfModule = class _HttpClientXsrfModule {
+  /**
+   * Disable the default XSRF protection.
+   */
+  static disable() {
+    return {
+      ngModule: _HttpClientXsrfModule,
+      providers: [withNoXsrfProtection().\u0275providers]
+    };
+  }
+  /**
+   * Configure XSRF protection.
+   * @param options An object that can specify either or both
+   * cookie name or header name.
+   * - Cookie name default is `XSRF-TOKEN`.
+   * - Header name default is `X-XSRF-TOKEN`.
+   *
+   */
+  static withOptions(options = {}) {
+    return {
+      ngModule: _HttpClientXsrfModule,
+      providers: withXsrfConfiguration(options).\u0275providers
+    };
+  }
+};
+__publicField(_HttpClientXsrfModule, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpClientXsrfModule, deps: [], target: i0.\u0275\u0275FactoryTarget.NgModule }));
+__publicField(_HttpClientXsrfModule, "\u0275mod", i0.\u0275\u0275ngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: _HttpClientXsrfModule }));
+__publicField(_HttpClientXsrfModule, "\u0275inj", i0.\u0275\u0275ngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpClientXsrfModule, providers: [
+  HttpXsrfInterceptor,
+  { provide: HTTP_INTERCEPTORS, useExisting: HttpXsrfInterceptor, multi: true },
+  { provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor },
+  withXsrfConfiguration({
+    cookieName: XSRF_DEFAULT_COOKIE_NAME,
+    headerName: XSRF_DEFAULT_HEADER_NAME
+  }).\u0275providers,
+  { provide: XSRF_ENABLED, useValue: true }
+] }));
+let HttpClientXsrfModule = _HttpClientXsrfModule;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: HttpClientXsrfModule, decorators: [{
+  type: import_core.NgModule,
+  args: [{
+    providers: [
+      HttpXsrfInterceptor,
+      { provide: HTTP_INTERCEPTORS, useExisting: HttpXsrfInterceptor, multi: true },
+      { provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor },
+      withXsrfConfiguration({
+        cookieName: XSRF_DEFAULT_COOKIE_NAME,
+        headerName: XSRF_DEFAULT_HEADER_NAME
+      }).\u0275providers,
+      { provide: XSRF_ENABLED, useValue: true }
+    ]
+  }]
+}] });
+const _HttpClientModule = class _HttpClientModule {
+};
+__publicField(_HttpClientModule, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpClientModule, deps: [], target: i0.\u0275\u0275FactoryTarget.NgModule }));
+__publicField(_HttpClientModule, "\u0275mod", i0.\u0275\u0275ngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: _HttpClientModule }));
+__publicField(_HttpClientModule, "\u0275inj", i0.\u0275\u0275ngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpClientModule, providers: [provideHttpClient(withInterceptorsFromDi())] }));
+let HttpClientModule = _HttpClientModule;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: HttpClientModule, decorators: [{
+  type: import_core.NgModule,
+  args: [{
+    /**
+     * Configures the dependency injector where it is imported
+     * with supporting services for HTTP communications.
+     */
+    providers: [provideHttpClient(withInterceptorsFromDi())]
+  }]
+}] });
+const _HttpClientJsonpModule = class _HttpClientJsonpModule {
+};
+__publicField(_HttpClientJsonpModule, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpClientJsonpModule, deps: [], target: i0.\u0275\u0275FactoryTarget.NgModule }));
+__publicField(_HttpClientJsonpModule, "\u0275mod", i0.\u0275\u0275ngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.16", ngImport: i0, type: _HttpClientJsonpModule }));
+__publicField(_HttpClientJsonpModule, "\u0275inj", i0.\u0275\u0275ngDeclareInjector({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HttpClientJsonpModule, providers: [withJsonpSupport().\u0275providers] }));
+let HttpClientJsonpModule = _HttpClientJsonpModule;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: HttpClientJsonpModule, decorators: [{
+  type: import_core.NgModule,
+  args: [{
+    providers: [withJsonpSupport().\u0275providers]
+  }]
+}] });