@absolutejs/absolute 0.18.0 → 0.18.1

package/.cache/angular-linker/2b273ec8888e3cb1d3cc1cfdf3f9c16e.js

@@ -1,2023 +0,0 @@
-/**
- * @license Angular v21.1.5
- * (c) 2010-2026 Google LLC. https://angular.dev/
- * License: MIT
- */
-
-import * as i0 from '@angular/core';
-import { ɵRuntimeError as _RuntimeError, InjectionToken, inject, NgZone, DestroyRef, Injectable, ɵformatRuntimeError as _formatRuntimeError, ɵTracingService as _TracingService, runInInjectionContext, PendingTasks, ɵConsole as _Console, DOCUMENT, Inject, EnvironmentInjector, makeEnvironmentProviders, NgModule } from '@angular/core';
-import { switchMap, finalize, concatMap, filter, map } from 'rxjs/operators';
-import { Observable, from, of } from 'rxjs';
-import { XhrFactory, parseCookieValue } from './_xhr-chunk.mjs';
-import { PlatformLocation } from './_platform_location-chunk.mjs';
-class HttpHeaders {
-  headers;
-  normalizedNames = new Map();
-  lazyInit;
-  lazyUpdate = null;
-  constructor(headers) {
-    if (!headers) {
-      this.headers = new Map();
-    } else if (typeof headers === 'string') {
-      this.lazyInit = () => {
-        this.headers = 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 = new Map();
-      headers.forEach((value, name) => {
-        this.addHeaderEntry(name, value);
-      });
-    } else {
-      this.lazyInit = () => {
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
-          assertValidHeaders(headers);
-        }
-        this.headers = new Map();
-        Object.entries(headers).forEach(([name, values]) => {
-          this.setHeaderEntries(name, values);
-        });
-      };
-    }
-  }
-  has(name) {
-    this.init();
-    return this.headers.has(name.toLowerCase());
-  }
-  get(name) {
-    this.init();
-    const values = this.headers.get(name.toLowerCase());
-    return values && values.length > 0 ? values[0] : null;
-  }
-  keys() {
-    this.init();
-    return Array.from(this.normalizedNames.values());
-  }
-  getAll(name) {
-    this.init();
-    return this.headers.get(name.toLowerCase()) || null;
-  }
-  append(name, value) {
-    return this.clone({
-      name,
-      op: 'a',
-      value
-    });
-  }
-  set(name, value) {
-    return this.clone({
-      name,
-      op: 's',
-      value
-    });
-  }
-  delete(name, value) {
-    return this.clone({
-      name,
-      op: 'd',
-      value
-    });
-  }
-  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 = Boolean(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;
-        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) : undefined) || [];
-        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(value => toDelete.indexOf(value) === -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);
-  }
-  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 HttpContextToken {
-  defaultValue;
-  constructor(defaultValue) {
-    this.defaultValue = defaultValue;
-  }
-}
-class HttpContext {
-  map = new Map();
-  set(token, value) {
-    this.map.set(token, value);
-    return this;
-  }
-  get(token) {
-    if (!this.map.has(token)) {
-      this.map.set(token, token.defaultValue());
-    }
-    return this.map.get(token);
-  }
-  delete(token) {
-    this.map.delete(token);
-    return this;
-  }
-  has(token) {
-    return this.map.has(token);
-  }
-  keys() {
-    return this.map.keys();
-  }
-}
-class HttpUrlEncodingCodec {
-  encodeKey(key) {
-    return standardEncoding(key);
-  }
-  encodeValue(value) {
-    return standardEncoding(value);
-  }
-  decodeKey(key) {
-    return decodeURIComponent(key);
-  }
-  decodeValue(value) {
-    return decodeURIComponent(value);
-  }
-}
-function paramParser(rawParams, codec) {
-  const map = 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 = map.get(key) || [];
-      list.push(val);
-      map.set(key, list);
-    });
-  }
-  return map;
-}
-const STANDARD_ENCODING_REGEX = /%(\d[a-f0-9])/gi;
-const STANDARD_ENCODING_REPLACEMENTS = {
-  '2C': ',',
-  '2F': '/',
-  '3A': ':',
-  '3B': ';',
-  '3D': '=',
-  '3F': '?',
-  '24': '$',
-  '40': '@'
-};
-function standardEncoding(v) {
-  return encodeURIComponent(v).replace(STANDARD_ENCODING_REGEX, (s, t) => STANDARD_ENCODING_REPLACEMENTS[t] ?? s);
-}
-function valueToString(value) {
-  return `${value}`;
-}
-class HttpParams {
-  map;
-  encoder;
-  updates = null;
-  cloneFrom = null;
-  constructor(options = {}) {
-    this.encoder = options.encoder || new HttpUrlEncodingCodec();
-    if (options.fromString) {
-      if (options.fromObject) {
-        throw new _RuntimeError(2805, ngDevMode && 'Cannot specify both fromString and fromObject.');
-      }
-      this.map = paramParser(options.fromString, this.encoder);
-    } else if (options.fromObject) {
-      this.map = 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;
-    }
-  }
-  has(param) {
-    this.init();
-    return this.map.has(param);
-  }
-  get(param) {
-    this.init();
-    const res = this.map.get(param);
-    return res ? res[0] : null;
-  }
-  getAll(param) {
-    this.init();
-    return this.map.get(param) || null;
-  }
-  keys() {
-    this.init();
-    return Array.from(this.map.keys());
-  }
-  append(param, value) {
-    return this.clone({
-      op: 'a',
-      param,
-      value
-    });
-  }
-  appendAll(params) {
-    const updates = [];
-    Object.keys(params).forEach(param => {
-      const value = params[param];
-      if (Array.isArray(value)) {
-        value.forEach(_value => {
-          updates.push({
-            op: 'a',
-            param,
-            value: _value
-          });
-        });
-      } else {
-        updates.push({
-          op: 'a',
-          param,
-          value: value
-        });
-      }
-    });
-    return this.clone(updates);
-  }
-  set(param, value) {
-    return this.clone({
-      op: 's',
-      param,
-      value
-    });
-  }
-  delete(param, value) {
-    return this.clone({
-      op: 'd',
-      param,
-      value
-    });
-  }
-  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 = 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) : undefined) || [];
-            base.push(valueToString(update.value));
-            this.map.set(update.param, base);
-            break;
-          case 'd':
-            if (update.value !== undefined) {
-              const base = this.map.get(update.param) || [];
-              const idx = base.indexOf(valueToString(update.value));
-              if (idx !== -1) {
-                base.splice(idx, 1);
-              }
-              if (base.length > 0) {
-                this.map.set(update.param, base);
-              } else {
-                this.map.delete(update.param);
-              }
-            } else {
-              this.map.delete(update.param);
-              break;
-            }
-        }
-      });
-      this.cloneFrom = this.updates = null;
-    }
-  }
-}
-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 TEXT_CONTENT_TYPE = 'text/plain';
-const JSON_CONTENT_TYPE = 'application/json';
-const ACCEPT_HEADER_VALUE = `${JSON_CONTENT_TYPE}, ${TEXT_CONTENT_TYPE}, */*`;
-class HttpRequest {
-  url;
-  body = null;
-  headers;
-  context;
-  reportProgress = false;
-  withCredentials = false;
-  credentials;
-  keepalive = false;
-  cache;
-  priority;
-  mode;
-  redirect;
-  referrer;
-  integrity;
-  referrerPolicy;
-  responseType = 'json';
-  method;
-  params;
-  urlWithParams;
-  transferCache;
-  timeout;
-  constructor(method, url, third, fourth) {
-    this.url = url;
-    this.method = method.toUpperCase();
-    let options;
-    if (mightHaveBody(this.method) || Boolean(fourth)) {
-      this.body = third !== undefined ? third : null;
-      options = fourth;
-    } else {
-      options = third;
-    }
-    if (options) {
-      this.reportProgress = Boolean(options.reportProgress);
-      this.withCredentials = Boolean(options.withCredentials);
-      this.keepalive = Boolean(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 _RuntimeError(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;
-      }
-      if (options.referrerPolicy) {
-        this.referrerPolicy = options.referrerPolicy;
-      }
-      this.transferCache = options.transferCache;
-    }
-    this.headers ??= new HttpHeaders();
-    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;
-      }
-    }
-  }
-  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();
-  }
-  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 = {}) {
-    const method = update.method || this.method;
-    const url = update.url || this.url;
-    const responseType = update.responseType || this.responseType;
-    const keepalive = update.keepalive ?? 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 referrerPolicy = update.referrerPolicy || this.referrerPolicy;
-    const transferCache = update.transferCache ?? this.transferCache;
-    const timeout = update.timeout ?? this.timeout;
-    const body = update.body !== undefined ? update.body : this.body;
-    const withCredentials = update.withCredentials ?? this.withCredentials;
-    const reportProgress = update.reportProgress ?? this.reportProgress;
-    let headers = update.headers || this.headers;
-    let params = update.params || this.params;
-    const context = update.context ?? this.context;
-    if (update.setHeaders !== undefined) {
-      headers = Object.keys(update.setHeaders).reduce((headers, name) => headers.set(name, update.setHeaders[name]), headers);
-    }
-    if (update.setParams) {
-      params = Object.keys(update.setParams).reduce((params, param) => params.set(param, update.setParams[param]), params);
-    }
-    return new HttpRequest(method, url, body, {
-      cache,
-      context,
-      credentials,
-      headers,
-      integrity,
-      keepalive,
-      mode,
-      params,
-      priority,
-      redirect,
-      referrer,
-      referrerPolicy,
-      reportProgress,
-      responseType,
-      timeout,
-      transferCache,
-      withCredentials
-    });
-  }
-}
-let HttpEventType;
-(function (HttpEventType) {
-  HttpEventType[HttpEventType["Sent"] = 0] = "Sent";
-  HttpEventType[HttpEventType["UploadProgress"] = 1] = "UploadProgress";
-  HttpEventType[HttpEventType["ResponseHeader"] = 2] = "ResponseHeader";
-  HttpEventType[HttpEventType["DownloadProgress"] = 3] = "DownloadProgress";
-  HttpEventType[HttpEventType["Response"] = 4] = "Response";
-  HttpEventType[HttpEventType["User"] = 5] = "User";
-})(HttpEventType || (HttpEventType = {}));
-class HttpResponseBase {
-  headers;
-  status;
-  statusText;
-  url;
-  ok;
-  type;
-  redirected;
-  responseType;
-  constructor(init, defaultStatus = 200, defaultStatusText = 'OK') {
-    this.headers = init.headers || new HttpHeaders();
-    this.status = init.status !== undefined ? init.status : defaultStatus;
-    this.statusText = init.statusText || defaultStatusText;
-    this.url = init.url || null;
-    this.redirected = init.redirected;
-    this.responseType = init.responseType;
-    this.ok = this.status >= 200 && this.status < 300;
-  }
-}
-class HttpHeaderResponse extends HttpResponseBase {
-  constructor(init = {}) {
-    super(init);
-  }
-  type = HttpEventType.ResponseHeader;
-  clone(update = {}) {
-    return new HttpHeaderResponse({
-      headers: update.headers || this.headers,
-      status: update.status !== undefined ? update.status : this.status,
-      statusText: update.statusText || this.statusText,
-      url: update.url || this.url || undefined
-    });
-  }
-}
-class HttpResponse extends HttpResponseBase {
-  body;
-  constructor(init = {}) {
-    super(init);
-    this.body = init.body !== undefined ? init.body : null;
-  }
-  type = HttpEventType.Response;
-  clone(update = {}) {
-    return new HttpResponse({
-      body: update.body !== undefined ? update.body : this.body,
-      headers: update.headers || this.headers,
-      redirected: update.redirected ?? this.redirected,
-      responseType: update.responseType ?? this.responseType,
-      status: update.status !== undefined ? update.status : this.status,
-      statusText: update.statusText || this.statusText,
-      url: update.url || this.url || undefined
-    });
-  }
-}
-class HttpErrorResponse extends HttpResponseBase {
-  name = 'HttpErrorResponse';
-  message;
-  error;
-  ok = false;
-  constructor(init) {
-    super(init, 0, 'Unknown Error');
-    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;
-let HttpStatusCode;
-(function (HttpStatusCode) {
-  HttpStatusCode[HttpStatusCode["Continue"] = 100] = "Continue";
-  HttpStatusCode[HttpStatusCode["SwitchingProtocols"] = 101] = "SwitchingProtocols";
-  HttpStatusCode[HttpStatusCode["Processing"] = 102] = "Processing";
-  HttpStatusCode[HttpStatusCode["EarlyHints"] = 103] = "EarlyHints";
-  HttpStatusCode[HttpStatusCode["Ok"] = 200] = "Ok";
-  HttpStatusCode[HttpStatusCode["Created"] = 201] = "Created";
-  HttpStatusCode[HttpStatusCode["Accepted"] = 202] = "Accepted";
-  HttpStatusCode[HttpStatusCode["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
-  HttpStatusCode[HttpStatusCode["NoContent"] = 204] = "NoContent";
-  HttpStatusCode[HttpStatusCode["ResetContent"] = 205] = "ResetContent";
-  HttpStatusCode[HttpStatusCode["PartialContent"] = 206] = "PartialContent";
-  HttpStatusCode[HttpStatusCode["MultiStatus"] = 207] = "MultiStatus";
-  HttpStatusCode[HttpStatusCode["AlreadyReported"] = 208] = "AlreadyReported";
-  HttpStatusCode[HttpStatusCode["ImUsed"] = 226] = "ImUsed";
-  HttpStatusCode[HttpStatusCode["MultipleChoices"] = 300] = "MultipleChoices";
-  HttpStatusCode[HttpStatusCode["MovedPermanently"] = 301] = "MovedPermanently";
-  HttpStatusCode[HttpStatusCode["Found"] = 302] = "Found";
-  HttpStatusCode[HttpStatusCode["SeeOther"] = 303] = "SeeOther";
-  HttpStatusCode[HttpStatusCode["NotModified"] = 304] = "NotModified";
-  HttpStatusCode[HttpStatusCode["UseProxy"] = 305] = "UseProxy";
-  HttpStatusCode[HttpStatusCode["Unused"] = 306] = "Unused";
-  HttpStatusCode[HttpStatusCode["TemporaryRedirect"] = 307] = "TemporaryRedirect";
-  HttpStatusCode[HttpStatusCode["PermanentRedirect"] = 308] = "PermanentRedirect";
-  HttpStatusCode[HttpStatusCode["BadRequest"] = 400] = "BadRequest";
-  HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
-  HttpStatusCode[HttpStatusCode["PaymentRequired"] = 402] = "PaymentRequired";
-  HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
-  HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
-  HttpStatusCode[HttpStatusCode["MethodNotAllowed"] = 405] = "MethodNotAllowed";
-  HttpStatusCode[HttpStatusCode["NotAcceptable"] = 406] = "NotAcceptable";
-  HttpStatusCode[HttpStatusCode["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
-  HttpStatusCode[HttpStatusCode["RequestTimeout"] = 408] = "RequestTimeout";
-  HttpStatusCode[HttpStatusCode["Conflict"] = 409] = "Conflict";
-  HttpStatusCode[HttpStatusCode["Gone"] = 410] = "Gone";
-  HttpStatusCode[HttpStatusCode["LengthRequired"] = 411] = "LengthRequired";
-  HttpStatusCode[HttpStatusCode["PreconditionFailed"] = 412] = "PreconditionFailed";
-  HttpStatusCode[HttpStatusCode["PayloadTooLarge"] = 413] = "PayloadTooLarge";
-  HttpStatusCode[HttpStatusCode["UriTooLong"] = 414] = "UriTooLong";
-  HttpStatusCode[HttpStatusCode["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
-  HttpStatusCode[HttpStatusCode["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
-  HttpStatusCode[HttpStatusCode["ExpectationFailed"] = 417] = "ExpectationFailed";
-  HttpStatusCode[HttpStatusCode["ImATeapot"] = 418] = "ImATeapot";
-  HttpStatusCode[HttpStatusCode["MisdirectedRequest"] = 421] = "MisdirectedRequest";
-  HttpStatusCode[HttpStatusCode["UnprocessableEntity"] = 422] = "UnprocessableEntity";
-  HttpStatusCode[HttpStatusCode["Locked"] = 423] = "Locked";
-  HttpStatusCode[HttpStatusCode["FailedDependency"] = 424] = "FailedDependency";
-  HttpStatusCode[HttpStatusCode["TooEarly"] = 425] = "TooEarly";
-  HttpStatusCode[HttpStatusCode["UpgradeRequired"] = 426] = "UpgradeRequired";
-  HttpStatusCode[HttpStatusCode["PreconditionRequired"] = 428] = "PreconditionRequired";
-  HttpStatusCode[HttpStatusCode["TooManyRequests"] = 429] = "TooManyRequests";
-  HttpStatusCode[HttpStatusCode["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
-  HttpStatusCode[HttpStatusCode["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
-  HttpStatusCode[HttpStatusCode["InternalServerError"] = 500] = "InternalServerError";
-  HttpStatusCode[HttpStatusCode["NotImplemented"] = 501] = "NotImplemented";
-  HttpStatusCode[HttpStatusCode["BadGateway"] = 502] = "BadGateway";
-  HttpStatusCode[HttpStatusCode["ServiceUnavailable"] = 503] = "ServiceUnavailable";
-  HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
-  HttpStatusCode[HttpStatusCode["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
-  HttpStatusCode[HttpStatusCode["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
-  HttpStatusCode[HttpStatusCode["InsufficientStorage"] = 507] = "InsufficientStorage";
-  HttpStatusCode[HttpStatusCode["LoopDetected"] = 508] = "LoopDetected";
-  HttpStatusCode[HttpStatusCode["NotExtended"] = 510] = "NotExtended";
-  HttpStatusCode[HttpStatusCode["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
-})(HttpStatusCode || (HttpStatusCode = {}));
-const XSSI_PREFIX$1 = /^\)\]\}',?\n/;
-const FETCH_BACKEND = new InjectionToken(typeof ngDevMode === 'undefined' || ngDevMode ? 'FETCH_BACKEND' : '');
-class FetchBackend {
-  fetchImpl = inject(FetchFactory, {
-    optional: true
-  })?.fetch ?? ((...args) => globalThis.fetch(...args));
-  ngZone = inject(NgZone);
-  destroyRef = inject(DestroyRef);
-  handle(request) {
-    return new 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 !== undefined) {
-          clearTimeout(timeoutId);
-        }
-        aborter.abort();
-      };
-    });
-  }
-  async doRequest(request, signal, observer) {
-    const init = this.createRequestInit(request);
-    let response;
-    try {
-      const fetchPromise = this.ngZone.runOutsideAngular(() => this.fetchImpl(request.urlWithParams, {
-        signal,
-        ...init
-      }));
-      silenceSuperfluousUnhandledPromiseRejection(fetchPromise);
-      observer.next({
-        type: HttpEventType.Sent
-      });
-      response = await fetchPromise;
-    } catch (error) {
-      observer.error(new HttpErrorResponse({
-        error,
-        headers: error.headers,
-        status: error.status ?? 0,
-        statusText: error.statusText,
-        url: request.urlWithParams
-      }));
-      return;
-    }
-    const headers = new HttpHeaders(response.headers);
-    const {statusText} = response;
-    const url = response.url || request.urlWithParams;
-    let {status} = response;
-    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;
-      await this.ngZone.runOutsideAngular(async () => {
-        while (true) {
-          if (this.destroyRef.destroyed) {
-            await reader.cancel();
-            canceled = true;
-            break;
-          }
-          const {
-            done,
-            value
-          } = await reader.read();
-          if (done) {
-            break;
-          }
-          chunks.push(value);
-          receivedLength += value.length;
-          if (request.reportProgress) {
-            partialText = request.responseType === 'text' ? (partialText ?? '') + (decoder ??= new TextDecoder()).decode(value, {
-              stream: true
-            }) : undefined;
-            const reportProgress = () => observer.next({
-              loaded: receivedLength,
-              partialText,
-              total: contentLength ? +contentLength : undefined,
-              type: HttpEventType.DownloadProgress
-            });
-            reqZone ? reqZone.run(reportProgress) : reportProgress();
-          }
-        }
-      });
-      if (canceled) {
-        observer.complete();
-        return;
-      }
-      const chunksAll = this.concatChunks(chunks, receivedLength);
-      try {
-        const contentType = response.headers.get(CONTENT_TYPE_HEADER) ?? '';
-        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: response.url || request.urlWithParams
-        }));
-        return;
-      }
-    }
-    if (status === 0) {
-      status = body ? HTTP_STATUS_CODE_OK : 0;
-    }
-    const ok = status >= 200 && status < 300;
-    const {redirected} = response;
-    const responseType = response.type;
-    if (ok) {
-      observer.next(new HttpResponse({
-        body,
-        headers,
-        redirected,
-        responseType,
-        status,
-        statusText,
-        url
-      }));
-      observer.complete();
-    } else {
-      observer.error(new HttpErrorResponse({
-        error: body,
-        headers,
-        redirected,
-        responseType,
-        status,
-        statusText,
-        url
-      }));
-    }
-  }
-  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(),
-      cache: req.cache,
-      credentials,
-      headers,
-      integrity: req.integrity,
-      keepalive: req.keepalive,
-      method: req.method,
-      mode: req.mode,
-      priority: req.priority,
-      redirect: req.redirect,
-      referrer: req.referrer,
-      referrerPolicy: req.referrerPolicy
-    };
-  }
-  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;
-  }
-  static ɵfac = function FetchBackend_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || FetchBackend)();
-  };
-  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
-    factory: FetchBackend.ɵfac,
-    token: FetchBackend
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FetchBackend, [{
-    type: Injectable
-  }], null, null);
-})();
-class FetchFactory {}
-function noop() {}
-function warningOptionsMessage(req) {
-  if (req.credentials && req.withCredentials) {
-    console.warn(_formatRuntimeError(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);
-}
-const XSSI_PREFIX = /^\)\]\}',?\n/;
-function validateXhrCompatibility(req) {
-  const unsupportedOptions = [{
-    errorCode: 2813,
-    property: 'keepalive'
-  }, {
-    errorCode: 2814,
-    property: 'cache'
-  }, {
-    errorCode: 2815,
-    property: 'priority'
-  }, {
-    errorCode: 2816,
-    property: 'mode'
-  }, {
-    errorCode: 2817,
-    property: 'redirect'
-  }, {
-    errorCode: 2818,
-    property: 'credentials'
-  }, {
-    errorCode: 2820,
-    property: 'integrity'
-  }, {
-    errorCode: 2821,
-    property: 'referrer'
-  }, {
-    errorCode: 2823,
-    property: 'referrerPolicy'
-  }];
-  for (const {
-    property,
-    errorCode
-  } of unsupportedOptions) {
-    if (req[property]) {
-      console.warn(_formatRuntimeError(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()\`.`));
-    }
-  }
-}
-class HttpXhrBackend {
-  xhrFactory;
-  tracingService = inject(_TracingService, {
-    optional: true
-  });
-  constructor(xhrFactory) {
-    this.xhrFactory = xhrFactory;
-  }
-  maybePropagateTrace(fn) {
-    return this.tracingService?.propagate ? this.tracingService.propagate(fn) : fn;
-  }
-  handle(req) {
-    if (req.method === 'JSONP') {
-      throw new _RuntimeError(-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;
-    const source = typeof ngServerMode !== 'undefined' && ngServerMode && xhrFactory.ɵloadImpl ? from(xhrFactory.ɵloadImpl()) : of(null);
-    return source.pipe(switchMap(() => new 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 = xhr.responseURL || req.url;
-          headerResponse = new HttpHeaderResponse({
-            headers,
-            status: xhr.status,
-            statusText,
-            url
-          });
-          return headerResponse;
-        };
-        const onLoad = this.maybePropagateTrace(() => {
-          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 || undefined
-            }));
-            observer.complete();
-          } else {
-            observer.error(new HttpErrorResponse({
-              error: body,
-              headers,
-              status,
-              statusText,
-              url: url || undefined
-            }));
-          }
-        });
-        const onError = this.maybePropagateTrace(error => {
-          const {
-            url
-          } = partialFromXhr();
-          const res = new HttpErrorResponse({
-            error,
-            status: xhr.status || 0,
-            statusText: xhr.statusText || 'Unknown Error',
-            url: url || undefined
-          });
-          observer.error(res);
-        });
-        let onTimeout = onError;
-        if (req.timeout) {
-          onTimeout = this.maybePropagateTrace(_ => {
-            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 || undefined
-            });
-            observer.error(res);
-          });
-        }
-        let sentHeaders = false;
-        const onDownProgress = this.maybePropagateTrace(event => {
-          if (!sentHeaders) {
-            observer.next(partialFromXhr());
-            sentHeaders = true;
-          }
-          const progressEvent = {
-            loaded: event.loaded,
-            type: HttpEventType.DownloadProgress
-          };
-          if (event.lengthComputable) {
-            progressEvent.total = event.total;
-          }
-          if (req.responseType === 'text' && Boolean(xhr.responseText)) {
-            progressEvent.partialText = xhr.responseText;
-          }
-          observer.next(progressEvent);
-        });
-        const onUpProgress = this.maybePropagateTrace(event => {
-          const progress = {
-            loaded: event.loaded,
-            type: HttpEventType.UploadProgress
-          };
-          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();
-          }
-        };
-      })));
-  }
-  static ɵfac = function HttpXhrBackend_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HttpXhrBackend)(i0.ɵɵinject(XhrFactory));
-  };
-  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
-    factory: HttpXhrBackend.ɵfac,
-    providedIn: 'root',
-    token: HttpXhrBackend
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpXhrBackend, [{
-    args: [{
-      providedIn: 'root'
-    }],
-    type: Injectable
-  }], () => [{
-    type: XhrFactory
-  }], null);
-})();
-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) => runInInjectionContext(injector, () => interceptorFn(initialRequest, downstreamRequest => chainTailFn(downstreamRequest, finalHandlerFn)));
-}
-const HTTP_INTERCEPTORS = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'HTTP_INTERCEPTORS' : '');
-const HTTP_INTERCEPTOR_FNS = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'HTTP_INTERCEPTOR_FNS' : '', {
-  factory: () => []
-});
-const HTTP_ROOT_INTERCEPTOR_FNS = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'HTTP_ROOT_INTERCEPTOR_FNS' : '');
-const REQUESTS_CONTRIBUTE_TO_STABILITY = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'REQUESTS_CONTRIBUTE_TO_STABILITY' : '', {
-  factory: () => true
-});
-function legacyInterceptorFnFactory() {
-  let chain = null;
-  return (req, handler) => {
-    if (chain === null) {
-      const interceptors = inject(HTTP_INTERCEPTORS, {
-        optional: true
-      }) ?? [];
-      chain = interceptors.reduceRight(adaptLegacyInterceptorToChain, interceptorChainEndFn);
-    }
-    const pendingTasks = inject(PendingTasks);
-    const contributeToStability = inject(REQUESTS_CONTRIBUTE_TO_STABILITY);
-    if (contributeToStability) {
-      const removeTask = pendingTasks.add();
-      return chain(req, handler).pipe(finalize(removeTask));
-    } 
-      return chain(req, handler);
-    
-  };
-}
-class HttpBackend {
-  static ɵfac = function HttpBackend_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HttpBackend)();
-  };
-  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
-    providedIn: 'root',
-    token: HttpBackend,
-    factory: function HttpBackend_Factory(__ngFactoryType__) {
-      let __ngConditionalFactory__ = null;
-      if (__ngFactoryType__) {
-        __ngConditionalFactory__ = new (__ngFactoryType__ || HttpBackend)();
-      } else {
-        __ngConditionalFactory__ = i0.ɵɵinject(HttpXhrBackend);
-      }
-      return __ngConditionalFactory__;
-    }
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpBackend, [{
-    args: [{
-      providedIn: 'root',
-      useExisting: HttpXhrBackend
-    }],
-    type: Injectable
-  }], null, null);
-})();
-let fetchBackendWarningDisplayed = false;
-class HttpInterceptorHandler {
-  backend;
-  injector;
-  chain = null;
-  pendingTasks = inject(PendingTasks);
-  contributeToStability = inject(REQUESTS_CONTRIBUTE_TO_STABILITY);
-  constructor(backend, injector) {
-    this.backend = backend;
-    this.injector = injector;
-    if ((typeof ngDevMode === 'undefined' || ngDevMode) && !fetchBackendWarningDisplayed) {
-      const {isTestingBackend} = this.backend;
-      if (typeof ngServerMode !== 'undefined' && ngServerMode && !(this.backend instanceof FetchBackend) && !isTestingBackend) {
-        fetchBackendWarningDisplayed = true;
-        injector.get(_Console).warn(_formatRuntimeError(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(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(finalize(removeTask));
-    } 
-      return this.chain(initialRequest, downstreamRequest => this.backend.handle(downstreamRequest));
-    
-  }
-  static ɵfac = function HttpInterceptorHandler_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HttpInterceptorHandler)(i0.ɵɵinject(HttpBackend), i0.ɵɵinject(i0.EnvironmentInjector));
-  };
-  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
-    factory: HttpInterceptorHandler.ɵfac,
-    providedIn: 'root',
-    token: HttpInterceptorHandler
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpInterceptorHandler, [{
-    args: [{
-      providedIn: 'root'
-    }],
-    type: Injectable
-  }], () => [{
-    type: HttpBackend
-  }, {
-    type: i0.EnvironmentInjector
-  }], null);
-})();
-class HttpHandler {
-  static ɵfac = function HttpHandler_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HttpHandler)();
-  };
-  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
-    providedIn: 'root',
-    token: HttpHandler,
-    factory: function HttpHandler_Factory(__ngFactoryType__) {
-      let __ngConditionalFactory__ = null;
-      if (__ngFactoryType__) {
-        __ngConditionalFactory__ = new (__ngFactoryType__ || HttpHandler)();
-      } else {
-        __ngConditionalFactory__ = i0.ɵɵinject(HttpInterceptorHandler);
-      }
-      return __ngConditionalFactory__;
-    }
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpHandler, [{
-    args: [{
-      providedIn: 'root',
-      useExisting: HttpInterceptorHandler
-    }],
-    type: Injectable
-  }], null, null);
-})();
-function addBody(options, body) {
-  return {
-    body,
-    cache: options.cache,
-    context: options.context,
-    credentials: options.credentials,
-    headers: options.headers,
-    integrity: options.integrity,
-    keepalive: options.keepalive,
-    mode: options.mode,
-    observe: options.observe,
-    params: options.params,
-    priority: options.priority,
-    redirect: options.redirect,
-    referrer: options.referrer,
-    referrerPolicy: options.referrerPolicy,
-    reportProgress: options.reportProgress,
-    responseType: options.responseType,
-    timeout: options.timeout,
-    transferCache: options.transferCache,
-    withCredentials: options.withCredentials
-  };
-}
-class HttpClient {
-  handler;
-  constructor(handler) {
-    this.handler = handler;
-  }
-  request(first, url, options = {}) {
-    let req;
-    if (first instanceof HttpRequest) {
-      req = first;
-    } else {
-      let headers = undefined;
-      if (options.headers instanceof HttpHeaders) {
-        headers = options.headers;
-      } else {
-        headers = new HttpHeaders(options.headers);
-      }
-      let params = undefined;
-      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 !== undefined ? options.body : null, {
-        cache: options.cache,
-        context: options.context,
-        credentials: options.credentials,
-        headers,
-        integrity: options.integrity,
-        keepalive: options.keepalive,
-        mode: options.mode,
-        params,
-        priority: options.priority,
-        redirect: options.redirect,
-        referrer: options.referrer,
-        referrerPolicy: options.referrerPolicy,
-        reportProgress: options.reportProgress,
-        responseType: options.responseType || 'json',
-        timeout: options.timeout,
-        transferCache: options.transferCache,
-        withCredentials: options.withCredentials
-      });
-    }
-    const events$ = of(req).pipe(concatMap(req => this.handler.handle(req)));
-    if (first instanceof HttpRequest || options.observe === 'events') {
-      return events$;
-    }
-    const res$ = events$.pipe(filter(event => event instanceof HttpResponse));
-    switch (options.observe || 'body') {
-      case 'body':
-        switch (req.responseType) {
-          case 'arraybuffer':
-            return res$.pipe(map(res => {
-              if (res.body !== null && !(res.body instanceof ArrayBuffer)) {
-                throw new _RuntimeError(2806, ngDevMode && 'Response is not an ArrayBuffer.');
-              }
-              return res.body;
-            }));
-          case 'blob':
-            return res$.pipe(map(res => {
-              if (res.body !== null && !(res.body instanceof Blob)) {
-                throw new _RuntimeError(2807, ngDevMode && 'Response is not a Blob.');
-              }
-              return res.body;
-            }));
-          case 'text':
-            return res$.pipe(map(res => {
-              if (res.body !== null && typeof res.body !== 'string') {
-                throw new _RuntimeError(2808, ngDevMode && 'Response is not a string.');
-              }
-              return res.body;
-            }));
-          case 'json':
-          default:
-            return res$.pipe(map(res => res.body));
-        }
-      case 'response':
-        return res$;
-      default:
-        throw new _RuntimeError(2809, ngDevMode && `Unreachable: unhandled observe type ${options.observe}}`);
-    }
-  }
-  delete(url, options = {}) {
-    return this.request('DELETE', url, options);
-  }
-  get(url, options = {}) {
-    return this.request('GET', url, options);
-  }
-  head(url, options = {}) {
-    return this.request('HEAD', url, options);
-  }
-  jsonp(url, callbackParam) {
-    return this.request('JSONP', url, {
-      observe: 'body',
-      params: new HttpParams().append(callbackParam, 'JSONP_CALLBACK'),
-      responseType: 'json'
-    });
-  }
-  options(url, options = {}) {
-    return this.request('OPTIONS', url, options);
-  }
-  patch(url, body, options = {}) {
-    return this.request('PATCH', url, addBody(options, body));
-  }
-  post(url, body, options = {}) {
-    return this.request('POST', url, addBody(options, body));
-  }
-  put(url, body, options = {}) {
-    return this.request('PUT', url, addBody(options, body));
-  }
-  static ɵfac = function HttpClient_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HttpClient)(i0.ɵɵinject(HttpHandler));
-  };
-  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
-    factory: HttpClient.ɵfac,
-    providedIn: 'root',
-    token: HttpClient
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpClient, [{
-    args: [{
-      providedIn: 'root'
-    }],
-    type: Injectable
-  }], () => [{
-    type: HttpHandler
-  }], null);
-})();
-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 {};
-}
-class JsonpClientBackend {
-  callbackMap;
-  document;
-  resolvedPromise = Promise.resolve();
-  constructor(callbackMap, document) {
-    this.callbackMap = callbackMap;
-    this.document = document;
-  }
-  nextCallback() {
-    return `ng_jsonp_callback_${nextRequestId++}`;
-  }
-  handle(req) {
-    if (req.method !== 'JSONP') {
-      throw new _RuntimeError(2810, ngDevMode && JSONP_ERR_WRONG_METHOD);
-    } else if (req.responseType !== 'json') {
-      throw new _RuntimeError(2811, ngDevMode && JSONP_ERR_WRONG_RESPONSE_TYPE);
-    }
-    if (req.headers.keys().length > 0) {
-      throw new _RuntimeError(2812, ngDevMode && JSONP_ERR_HEADERS_NOT_SUPPORTED);
-    }
-    return new 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({
-              error: new Error(JSONP_ERR_NO_CALLBACK),
-              status: 0,
-              statusText: 'JSONP Error',
-              url
-            }));
-            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 ??= this.document.implementation.createHTMLDocument();
-    foreignDocument.adoptNode(script);
-  }
-  static ɵfac = function JsonpClientBackend_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || JsonpClientBackend)(i0.ɵɵinject(JsonpCallbackContext), i0.ɵɵinject(DOCUMENT));
-  };
-  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
-    factory: JsonpClientBackend.ɵfac,
-    token: JsonpClientBackend
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(JsonpClientBackend, [{
-    type: Injectable
-  }], () => [{
-    type: JsonpCallbackContext
-  }, {
-    decorators: [{
-      args: [DOCUMENT],
-      type: Inject
-    }],
-    type: undefined
-  }], null);
-})();
-function jsonpInterceptorFn(req, next) {
-  if (req.method === 'JSONP') {
-    return inject(JsonpClientBackend).handle(req);
-  }
-  return next(req);
-}
-class JsonpInterceptor {
-  injector;
-  constructor(injector) {
-    this.injector = injector;
-  }
-  intercept(initialRequest, next) {
-    return runInInjectionContext(this.injector, () => jsonpInterceptorFn(initialRequest, downstreamRequest => next.handle(downstreamRequest)));
-  }
-  static ɵfac = function JsonpInterceptor_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || JsonpInterceptor)(i0.ɵɵinject(i0.EnvironmentInjector));
-  };
-  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
-    factory: JsonpInterceptor.ɵfac,
-    token: JsonpInterceptor
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(JsonpInterceptor, [{
-    type: Injectable
-  }], () => [{
-    type: i0.EnvironmentInjector
-  }], null);
-})();
-const XSRF_ENABLED = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'XSRF_ENABLED' : '', {
-  factory: () => true
-});
-const XSRF_DEFAULT_COOKIE_NAME = 'XSRF-TOKEN';
-const XSRF_COOKIE_NAME = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'XSRF_COOKIE_NAME' : '', {
-  factory: () => XSRF_DEFAULT_COOKIE_NAME
-});
-const XSRF_DEFAULT_HEADER_NAME = 'X-XSRF-TOKEN';
-const XSRF_HEADER_NAME = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'XSRF_HEADER_NAME' : '', {
-  factory: () => XSRF_DEFAULT_HEADER_NAME
-});
-class HttpXsrfCookieExtractor {
-  cookieName = inject(XSRF_COOKIE_NAME);
-  doc = inject(DOCUMENT);
-  lastCookieString = '';
-  lastToken = null;
-  parseCount = 0;
-  getToken() {
-    if (typeof ngServerMode !== 'undefined' && ngServerMode) {
-      return null;
-    }
-    const cookieString = this.doc.cookie || '';
-    if (cookieString !== this.lastCookieString) {
-      this.parseCount++;
-      this.lastToken = parseCookieValue(cookieString, this.cookieName);
-      this.lastCookieString = cookieString;
-    }
-    return this.lastToken;
-  }
-  static ɵfac = function HttpXsrfCookieExtractor_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HttpXsrfCookieExtractor)();
-  };
-  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
-    factory: HttpXsrfCookieExtractor.ɵfac,
-    providedIn: 'root',
-    token: HttpXsrfCookieExtractor
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpXsrfCookieExtractor, [{
-    args: [{
-      providedIn: 'root'
-    }],
-    type: Injectable
-  }], null, null);
-})();
-class HttpXsrfTokenExtractor {
-  static ɵfac = function HttpXsrfTokenExtractor_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HttpXsrfTokenExtractor)();
-  };
-  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
-    providedIn: 'root',
-    token: HttpXsrfTokenExtractor,
-    factory: function HttpXsrfTokenExtractor_Factory(__ngFactoryType__) {
-      let __ngConditionalFactory__ = null;
-      if (__ngFactoryType__) {
-        __ngConditionalFactory__ = new (__ngFactoryType__ || HttpXsrfTokenExtractor)();
-      } else {
-        __ngConditionalFactory__ = i0.ɵɵinject(HttpXsrfCookieExtractor);
-      }
-      return __ngConditionalFactory__;
-    }
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpXsrfTokenExtractor, [{
-    args: [{
-      providedIn: 'root',
-      useExisting: HttpXsrfCookieExtractor
-    }],
-    type: Injectable
-  }], null, null);
-})();
-function xsrfInterceptorFn(req, next) {
-  if (!inject(XSRF_ENABLED) || req.method === 'GET' || req.method === 'HEAD') {
-    return next(req);
-  }
-  try {
-    const locationHref = inject(PlatformLocation).href;
-    const {
-      origin: locationOrigin
-    } = new URL(locationHref);
-    const {
-      origin: requestOrigin
-    } = new URL(req.url, locationOrigin);
-    if (locationOrigin !== requestOrigin) {
-      return next(req);
-    }
-  } catch {
-    return next(req);
-  }
-  const token = inject(HttpXsrfTokenExtractor).getToken();
-  const headerName = inject(XSRF_HEADER_NAME);
-  if (token != null && !req.headers.has(headerName)) {
-    req = req.clone({
-      headers: req.headers.set(headerName, token)
-    });
-  }
-  return next(req);
-}
-class HttpXsrfInterceptor {
-  injector = inject(EnvironmentInjector);
-  intercept(initialRequest, next) {
-    return runInInjectionContext(this.injector, () => xsrfInterceptorFn(initialRequest, downstreamRequest => next.handle(downstreamRequest)));
-  }
-  static ɵfac = function HttpXsrfInterceptor_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HttpXsrfInterceptor)();
-  };
-  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
-    factory: HttpXsrfInterceptor.ɵfac,
-    token: HttpXsrfInterceptor
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpXsrfInterceptor, [{
-    type: Injectable
-  }], null, null);
-})();
-let HttpFeatureKind;
-(function (HttpFeatureKind) {
-  HttpFeatureKind[HttpFeatureKind["Interceptors"] = 0] = "Interceptors";
-  HttpFeatureKind[HttpFeatureKind["LegacyInterceptors"] = 1] = "LegacyInterceptors";
-  HttpFeatureKind[HttpFeatureKind["CustomXsrfConfiguration"] = 2] = "CustomXsrfConfiguration";
-  HttpFeatureKind[HttpFeatureKind["NoXsrfProtection"] = 3] = "NoXsrfProtection";
-  HttpFeatureKind[HttpFeatureKind["JsonpSupport"] = 4] = "JsonpSupport";
-  HttpFeatureKind[HttpFeatureKind["RequestsMadeViaParent"] = 5] = "RequestsMadeViaParent";
-  HttpFeatureKind[HttpFeatureKind["Fetch"] = 6] = "Fetch";
-})(HttpFeatureKind || (HttpFeatureKind = {}));
-function makeHttpFeature(kind, providers) {
-  return {
-    ɵkind: kind,
-    ɵproviders: providers
-  };
-}
-function provideHttpClient(...features) {
-  if (ngDevMode) {
-    const featureKinds = new Set(features.map(f => f.ɵkind));
-    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, HttpInterceptorHandler, {
-    provide: HttpHandler,
-    useExisting: HttpInterceptorHandler
-  }, {
-    provide: HttpBackend,
-    useFactory: () => inject(FETCH_BACKEND, {
-        optional: true
-      }) ?? inject(HttpXhrBackend)
-  }, {
-    multi: true,
-    provide: HTTP_INTERCEPTOR_FNS,
-    useValue: xsrfInterceptorFn
-  }];
-  for (const feature of features) {
-    providers.push(...feature.ɵproviders);
-  }
-  return makeEnvironmentProviders(providers);
-}
-function withInterceptors(interceptorFns) {
-  return makeHttpFeature(HttpFeatureKind.Interceptors, interceptorFns.map(interceptorFn => ({
-      multi: true,
-      provide: HTTP_INTERCEPTOR_FNS,
-      useValue: interceptorFn
-    })));
-}
-const LEGACY_INTERCEPTOR_FN = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'LEGACY_INTERCEPTOR_FN' : '');
-function withInterceptorsFromDi() {
-  return makeHttpFeature(HttpFeatureKind.LegacyInterceptors, [{
-    provide: LEGACY_INTERCEPTOR_FN,
-    useFactory: legacyInterceptorFnFactory
-  }, {
-    multi: true,
-    provide: HTTP_INTERCEPTOR_FNS,
-    useExisting: LEGACY_INTERCEPTOR_FN
-  }]);
-}
-function withXsrfConfiguration({
-  cookieName,
-  headerName
-}) {
-  const providers = [];
-  if (cookieName !== undefined) {
-    providers.push({
-      provide: XSRF_COOKIE_NAME,
-      useValue: cookieName
-    });
-  }
-  if (headerName !== undefined) {
-    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
-  }, {
-    multi: true,
-    provide: HTTP_INTERCEPTOR_FNS,
-    useValue: jsonpInterceptorFn
-  }]);
-}
-function withRequestsMadeViaParent() {
-  return makeHttpFeature(HttpFeatureKind.RequestsMadeViaParent, [{
-    provide: HttpBackend,
-    useFactory: () => {
-      const handlerFromParent = inject(HttpHandler, {
-        optional: true,
-        skipSelf: 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
-  }]);
-}
-class HttpClientXsrfModule {
-  static disable() {
-    return {
-      ngModule: HttpClientXsrfModule,
-      providers: [withNoXsrfProtection().ɵproviders]
-    };
-  }
-  static withOptions(options = {}) {
-    return {
-      ngModule: HttpClientXsrfModule,
-      providers: withXsrfConfiguration(options).ɵproviders
-    };
-  }
-  static ɵfac = function HttpClientXsrfModule_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HttpClientXsrfModule)();
-  };
-  static ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({
-    type: HttpClientXsrfModule
-  });
-  static ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({
-    providers: [HttpXsrfInterceptor, {
-      multi: true,
-      provide: HTTP_INTERCEPTORS,
-      useExisting: HttpXsrfInterceptor
-    }, {
-      provide: HttpXsrfTokenExtractor,
-      useClass: HttpXsrfCookieExtractor
-    }, withXsrfConfiguration({
-      cookieName: XSRF_DEFAULT_COOKIE_NAME,
-      headerName: XSRF_DEFAULT_HEADER_NAME
-    }).ɵproviders, {
-      provide: XSRF_ENABLED,
-      useValue: true
-    }]
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpClientXsrfModule, [{
-    args: [{
-      providers: [HttpXsrfInterceptor, {
-        multi: true,
-        provide: HTTP_INTERCEPTORS,
-        useExisting: HttpXsrfInterceptor
-      }, {
-        provide: HttpXsrfTokenExtractor,
-        useClass: HttpXsrfCookieExtractor
-      }, withXsrfConfiguration({
-        cookieName: XSRF_DEFAULT_COOKIE_NAME,
-        headerName: XSRF_DEFAULT_HEADER_NAME
-      }).ɵproviders, {
-        provide: XSRF_ENABLED,
-        useValue: true
-      }]
-    }],
-    type: NgModule
-  }], null, null);
-})();
-class HttpClientModule {
-  static ɵfac = function HttpClientModule_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HttpClientModule)();
-  };
-  static ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({
-    type: HttpClientModule
-  });
-  static ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({
-    providers: [provideHttpClient(withInterceptorsFromDi())]
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpClientModule, [{
-    args: [{
-      providers: [provideHttpClient(withInterceptorsFromDi())]
-    }],
-    type: NgModule
-  }], null, null);
-})();
-class HttpClientJsonpModule {
-  static ɵfac = function HttpClientJsonpModule_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HttpClientJsonpModule)();
-  };
-  static ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({
-    type: HttpClientJsonpModule
-  });
-  static ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({
-    providers: [withJsonpSupport().ɵproviders]
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpClientJsonpModule, [{
-    args: [{
-      providers: [withJsonpSupport().ɵproviders]
-    }],
-    type: NgModule
-  }], null, null);
-})();
-export { FetchBackend, HTTP_INTERCEPTORS, HTTP_ROOT_INTERCEPTOR_FNS, HttpBackend, HttpClient, HttpClientJsonpModule, HttpClientModule, HttpClientXsrfModule, HttpContext, HttpContextToken, HttpErrorResponse, HttpEventType, HttpFeatureKind, HttpHandler, HttpHeaderResponse, HttpHeaders, HttpInterceptorHandler, HttpParams, HttpRequest, HttpResponse, HttpResponseBase, HttpStatusCode, HttpUrlEncodingCodec, HttpXhrBackend, HttpXsrfTokenExtractor, JsonpClientBackend, JsonpInterceptor, REQUESTS_CONTRIBUTE_TO_STABILITY, provideHttpClient, withFetch, withInterceptors, withInterceptorsFromDi, withJsonpSupport, withNoXsrfProtection, withRequestsMadeViaParent, withXsrfConfiguration };