@nasa-terra/components 0.0.178 → 0.0.181

package/cdn/chunks/chunk.QKKAIJRP.js

@@ -0,0 +1,3451 @@
+import {
+  withDb
+} from "./chunk.EHU3RZOC.js";
+import {
+  BadRequestException,
+  HttpException
+} from "./chunk.SYQOGYTQ.js";
+import {
+  authService
+} from "./chunk.EYYVMPBZ.js";
+import {
+  __objRest,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __privateWrapper,
+  __spreadProps,
+  __spreadValues,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/apis/harmony.api.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// src/lib/api.client.ts
+init_dirname();
+init_buffer();
+init_process();
+async function request(url, { method = "GET", body, headers = {}, signal } = {}) {
+  var _a11, _b2, _c, _d, _e, _f;
+  try {
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0,
+      signal
+    });
+    if (!res.ok) {
+      if (res.status === 401) {
+        authService.logout();
+      }
+      if (!((_a11 = res.headers.get("Content-Type")) == null ? void 0 : _a11.includes("json"))) {
+        const text = await res.text();
+        throw new HttpException({
+          status: res.status,
+          message: text || `HTTP ${res.status}`
+        });
+      }
+      const json = await res.json();
+      throw new HttpException({
+        status: res.status,
+        message: (_e = (_d = (_b2 = json.message) != null ? _b2 : (
+          // most REST clients will pass a error message
+          json.description
+        )) != null ? _d : (
+          // NASA Harmony uses the description field
+          (_c = json.errors) == null ? void 0 : _c[0]
+        )) != null ? _e : (
+          // NASA CMR uses an array of errors
+          `HTTP ${res.status}`
+        )
+      });
+    }
+    if (res.status === 204) {
+      return void 0;
+    }
+    if (!((_f = res.headers.get("Content-Type")) == null ? void 0 : _f.includes("json"))) {
+      throw new HttpException({
+        status: 500,
+        message: `Expected JSON response but got ${res.headers.get("Content-Type")}`
+      });
+    }
+    return res.json();
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "AbortError") {
+      return void 0;
+    }
+    if (err instanceof HttpException && err.status !== 500) {
+      throw err;
+    }
+    console.error(err);
+    console.error(`Failed to fetch ${url}`);
+    throw new HttpException({
+      status: 500,
+      message: `An unknown error occurred when attempting to fetch, please try again later.`,
+      cause: err
+    });
+  }
+}
+var apiClient = {
+  get: (url, options) => request(url, __spreadValues({}, options)),
+  post: (url, body, options) => request(url, __spreadValues({ method: "POST", body }, options)),
+  put: (url, body) => request(url, { method: "PUT", body }),
+  patch: (url, body) => request(url, { method: "PATCH", body }),
+  delete: (url, options) => request(url, __spreadValues({ method: "DELETE" }, options))
+};
+
+// src/apis/harmony.api.ts
+var API_VERSION = "3";
+var Environments = {
+  PROD: "PROD",
+  UAT: "UAT"
+};
+var HARMONY_URLS = {
+  [Environments.PROD]: "https://harmony.earthdata.nasa.gov",
+  [Environments.UAT]: "https://harmony.uat.earthdata.nasa.gov",
+  // for anonymous access, we have to go through our proxy since Harmony doesn't support anonymous requests directly
+  // the proxy will add the necessary authentication to the request on the backend, so we can still use the same HarmonyRequest class to build the request URL with the appropriate parameters
+  // the proxy also adds restrictions on how much data can be requested
+  ANONYMOUS_ACCESS: "https://sjldutoe6c.execute-api.us-east-1.amazonaws.com/default/harmony-proxy"
+};
+var CLOUD_GIOVANNI_URLS = {
+  [Environments.PROD]: "https://api.giovanni.earthdata.nasa.gov",
+  [Environments.UAT]: "https://api.giovanni.uat.earthdata.nasa.gov"
+};
+var FINAL_STATUSES = /* @__PURE__ */ new Set([
+  "successful" /* SUCCESSFUL */,
+  "failed" /* FAILED */,
+  "canceled" /* CANCELED */,
+  "complete_with_errors" /* COMPLETE_WITH_ERRORS */
+]);
+var _request, request_fn, _hasGiovanniServices, hasGiovanniServices_fn, _hasNonGiovanniServices, hasNonGiovanniServices_fn, _getNonGiovanniFormats, getNonGiovanniFormats_fn, _getGiovanniFormats, getGiovanniFormats_fn;
+var HarmonyApi = class {
+  constructor() {
+    __privateAdd(this, _request);
+    __privateAdd(this, _hasGiovanniServices);
+    __privateAdd(this, _hasNonGiovanniServices);
+    __privateAdd(this, _getNonGiovanniFormats);
+    __privateAdd(this, _getGiovanniFormats);
+  }
+  /**
+   * Returns collection capabilities including available services, output formats, subsetting options, etc.
+   * from the Harmony /capabilities endpoint
+   */
+  async getCollectionCapabilities(conceptId, options) {
+    if (!conceptId) {
+      throw new BadRequestException({
+        message: "`collectionConceptId` is required"
+      });
+    }
+    const capabilities = await __privateMethod(this, _request, request_fn).call(this, `capabilities?collectionId=${conceptId}&version=${API_VERSION}`, options);
+    capabilities.variables = this.addConceptIdToVariables(capabilities.variables);
+    capabilities.configuredOutputFormats = this.getOutputFormatOptions(capabilities);
+    return capabilities;
+  }
+  /**
+   * Gets a user's Harmony jobs
+   */
+  async getJobs(params, options) {
+    const queryParams = new URLSearchParams();
+    if (params == null ? void 0 : params.page)
+      queryParams.append("page", params.page.toString());
+    if (params == null ? void 0 : params.limit)
+      queryParams.append("limit", params.limit.toString());
+    if (params == null ? void 0 : params.label)
+      queryParams.append("label", params.label);
+    return __privateMethod(this, _request, request_fn).call(this, `jobs?${queryParams.toString()}`, options);
+  }
+  /**
+   * Create a subset job by sending a GET request to the Harmony OGC API endpoint.
+   * The harmonyRequest.requestUrl contains the full URL with all subset parameters.
+   */
+  async createJob(harmonyRequest, options) {
+    return __privateMethod(this, _request, request_fn).call(this, harmonyRequest.requestUrl, options);
+  }
+  /**
+   * Get the current status of an existing subset job.
+   * Intended for polling until the job reaches a final state.
+   */
+  async getJobStatus(jobId, options) {
+    return __privateMethod(this, _request, request_fn).call(this, `jobs/${jobId}`, options);
+  }
+  /**
+   * Removes one or more labels from one or more Harmony jobs.
+   * After removal, the jobs will no longer match label-based filters.
+   *
+   * @example
+   * await harmonyApi.removeJobLabels({ jobIDs: ['abc', 'def'], labels: ['my-label'] }, { bearerToken })
+   */
+  async removeJobLabels(params, options) {
+    const url = `${HARMONY_URLS[Environments.PROD]}/labels`;
+    return apiClient.delete(url, {
+      body: { jobID: params.jobIDs, label: params.labels },
+      headers: __spreadValues({
+        "Content-Type": "application/json"
+      }, (options == null ? void 0 : options.bearerToken) && {
+        Authorization: `Bearer ${options.bearerToken}`
+      }),
+      signal: options == null ? void 0 : options.signal
+    });
+  }
+  /**
+   * Given a jobId for a running job, send a cancellation request to the Harmony API.
+   * Returns the updated job status after cancellation.
+   */
+  async cancelJob(jobId, options) {
+    return __privateMethod(this, _request, request_fn).call(this, `jobs/${jobId}/cancel`, options);
+  }
+  /**
+   * When a Harmony job finishes, it provides URLs for downloading the results. This method can be used to fetch the results from those URLs, which may require authentication if the data is not public.
+   */
+  async fetchUrl(url, options) {
+    const relativeUrl = url.replace(CLOUD_GIOVANNI_URLS.PROD, "").replace(CLOUD_GIOVANNI_URLS.UAT, "");
+    return __privateMethod(this, _request, request_fn).call(this, relativeUrl, options);
+  }
+  /**
+   * Extracts the variable concept ID from the variable's href and adds it as a property on the variable object.
+   */
+  addConceptIdToVariables(variables) {
+    return variables.map((v) => {
+      const match = v.href.match(/\/concepts\/(V\d+-\w+)$/);
+      if (match) {
+        v.conceptId = match[1];
+      }
+      return v;
+    });
+  }
+  /**
+   * Processes the Harmony capabilities response to generate a list of output format options with user-friendly labels and descriptions.
+   * If Giovanni is the only service available, only return Giovanni-specific formats.
+   * If Giovanni is present with other services, include both Giovanni and non-Giovanni formats, avoiding duplicates.
+   * If Giovanni is not present, return only non-Giovanni formats.
+   */
+  getOutputFormatOptions(capabilities) {
+    const hasNonGiovanniServices = __privateMethod(this, _hasNonGiovanniServices, hasNonGiovanniServices_fn).call(this, capabilities);
+    const hasGiovanniServices = __privateMethod(this, _hasGiovanniServices, hasGiovanniServices_fn).call(this, capabilities);
+    const giovanniFormats = hasGiovanniServices ? __privateMethod(this, _getGiovanniFormats, getGiovanniFormats_fn).call(this, capabilities) : [];
+    if (hasGiovanniServices && !hasNonGiovanniServices) {
+      return giovanniFormats;
+    }
+    const outputFormats = [];
+    const nonGiovanniFormats = __privateMethod(this, _getNonGiovanniFormats, getNonGiovanniFormats_fn).call(this, capabilities);
+    nonGiovanniFormats.forEach((format) => {
+      let label = format;
+      let description = `Download data in ${format} format`;
+      switch (format) {
+        case "application/x-hdf":
+        case "application/octet-stream":
+          label = "HDF-EOS5";
+          description = "Download data in HDF-EOS5 format";
+          break;
+        case "application/x-netcdf4":
+        case "application/netcdf":
+          label = "NetCDF";
+          description = "Download data in NetCDF format";
+          break;
+        case "application/x-netcdf4;profile=opendap_url":
+          label = "OPeNDAP URL (x-netcdf4)";
+          description = "Download data in OPeNDAP URL (x-netcdf4) format";
+          break;
+        case "text/csv":
+          label = "CSV";
+          description = "Download data in CSV format";
+          break;
+        case "image/tiff":
+        case "image/tif":
+          label = "TIFF";
+          description = "Download data in TIFF format";
+          break;
+        case "image/png":
+          label = "PNG";
+          description = "Download data in PNG format";
+          break;
+        case "image/jpg":
+        case "image/jpeg":
+          label = "JPEG";
+          description = "Download data in JPEG format";
+          break;
+        case "application/shapefile+zip":
+          label = "Shapefile+zip";
+          description = "Download data in Shapefile+zip format";
+          break;
+        case "application/x-zarr":
+          label = "ZARR";
+          description = "Download data in ZARR format";
+          break;
+        default:
+          label = format;
+          description = `Download data in ${format} format`;
+      }
+      outputFormats.push({
+        key: format,
+        label,
+        description
+      });
+    });
+    if (hasGiovanniServices && hasNonGiovanniServices) {
+      outputFormats.push(...giovanniFormats);
+    }
+    return outputFormats;
+  }
+};
+_request = new WeakSet();
+request_fn = function(url, options) {
+  let environmentUrl = HARMONY_URLS[Environments.PROD];
+  if (!(options == null ? void 0 : options.bearerToken)) {
+    environmentUrl = HARMONY_URLS.ANONYMOUS_ACCESS;
+  }
+  if (!url.startsWith("http")) {
+    url = `${environmentUrl}/${url}`;
+  }
+  return apiClient.get(url, {
+    signal: options == null ? void 0 : options.signal,
+    headers: __spreadValues({}, (options == null ? void 0 : options.bearerToken) && {
+      Authorization: `Bearer ${options.bearerToken}`
+    })
+  });
+};
+_hasGiovanniServices = new WeakSet();
+hasGiovanniServices_fn = function(capabilities) {
+  var _a11, _b2;
+  return (_b2 = (_a11 = capabilities == null ? void 0 : capabilities.services) == null ? void 0 : _a11.some(
+    (service) => service.name.toLowerCase().includes("giovanni")
+  )) != null ? _b2 : false;
+};
+_hasNonGiovanniServices = new WeakSet();
+hasNonGiovanniServices_fn = function(capabilities) {
+  var _a11, _b2;
+  return (_b2 = (_a11 = capabilities == null ? void 0 : capabilities.services) == null ? void 0 : _a11.some(
+    (service) => !service.name.toLowerCase().includes("giovanni")
+  )) != null ? _b2 : false;
+};
+_getNonGiovanniFormats = new WeakSet();
+getNonGiovanniFormats_fn = function(capabilities) {
+  if (!(capabilities == null ? void 0 : capabilities.services)) {
+    return [];
+  }
+  const nonGiovanniServices = capabilities.services.filter(
+    (service) => !service.name.toLowerCase().includes("giovanni")
+  );
+  const formats = /* @__PURE__ */ new Set();
+  nonGiovanniServices.forEach((service) => {
+    var _a11;
+    (_a11 = service.capabilities.outputFormats) == null ? void 0 : _a11.forEach((format) => {
+      formats.add(format);
+    });
+  });
+  const formatArray = Array.from(formats);
+  if (formatArray.includes("application/netcdf") && formatArray.includes("application/x-netcdf4")) {
+    return formatArray.filter((format) => format !== "application/netcdf");
+  }
+  return formatArray;
+};
+_getGiovanniFormats = new WeakSet();
+getGiovanniFormats_fn = function(capabilities) {
+  const giovanniFormats = [];
+  capabilities.services.forEach((service) => {
+    const serviceName = service.name.toLowerCase();
+    if (serviceName.includes("giovanni-time-series")) {
+      giovanniFormats.push({
+        key: "text/csv",
+        label: "CSV (point-based time series; one file)",
+        description: "Single variable plotted over time",
+        isGiovanniFormat: true
+      });
+    }
+    if (serviceName.includes("giovanni-averaging")) {
+      giovanniFormats.push(
+        {
+          key: "image/tiff",
+          label: "GeoTIFF (time-averaged map; one file)",
+          description: "Time averaged representation as map",
+          isGiovanniFormat: true
+        },
+        {
+          key: "text/csv",
+          label: "CSV (area-averaged time series; one file)",
+          description: "Area averaged data over time",
+          isGiovanniFormat: true
+        }
+      );
+    }
+  });
+  return giovanniFormats.filter(
+    (format, index, formats) => formats.findIndex((existing) => existing.label === format.label) === index
+  );
+};
+var harmonyApi = new HarmonyApi();
+
+// src/lib/thumbnails/thumbnail.service.ts
+init_dirname();
+init_buffer();
+init_process();
+var ThumbnailService = class {
+  async store(harmonyJobId, blob) {
+    await withDb(async (db) => {
+      const record = {
+        harmonyJobId,
+        blob,
+        createdAt: Date.now()
+      };
+      await db.put("thumbnails" /* THUMBNAILS */, record);
+    });
+  }
+  async get(harmonyJobId) {
+    return withDb(async (db) => {
+      const record = await db.get(
+        "thumbnails" /* THUMBNAILS */,
+        harmonyJobId
+      );
+      return record == null ? void 0 : record.blob;
+    });
+  }
+  async delete(harmonyJobId) {
+    await withDb(async (db) => {
+      await db.delete("thumbnails" /* THUMBNAILS */, harmonyJobId);
+    });
+  }
+};
+
+// src/queries/harmony.queries.ts
+init_dirname();
+init_buffer();
+init_process();
+var POLL_INTERVAL_MS = 3e3;
+var PAGE_1_POLL_INTERVAL_MS = 5e3;
+var thumbnailService = new ThumbnailService();
+function isFetchableHarmonyJobId(jobID) {
+  return Boolean(jobID && jobID !== "new");
+}
+function queryHarmonyCapabilities(collectionConceptId, options) {
+  return {
+    queryKey: ["harmony", "capabilities", collectionConceptId],
+    queryFn: async ({ signal }) => {
+      return harmonyApi.getCollectionCapabilities(collectionConceptId, __spreadProps(__spreadValues({}, options), {
+        signal
+      }));
+    },
+    enabled: !!collectionConceptId
+  };
+}
+function queryHarmonyJobs(params, options) {
+  return {
+    queryKey: ["harmony", "jobs", params],
+    queryFn: async ({ signal }) => {
+      const result = await harmonyApi.getJobs(params, __spreadProps(__spreadValues({}, options), {
+        signal
+      }));
+      const enrichedJobs = await Promise.all(
+        result.jobs.map(async (job) => {
+          const blob = await thumbnailService.get(job.jobID);
+          return blob ? __spreadProps(__spreadValues({}, job), { thumbnailBlob: blob }) : job;
+        })
+      );
+      return __spreadProps(__spreadValues({}, result), { jobs: enrichedJobs });
+    },
+    // require a bearer token to run
+    enabled: !!(options == null ? void 0 : options.bearerToken),
+    refetchInterval: () => {
+      if ((params == null ? void 0 : params.page) && params.page !== 1) {
+        return false;
+      }
+      return PAGE_1_POLL_INTERVAL_MS;
+    }
+  };
+}
+function queryHarmonyJobStatus(jobID, options) {
+  return {
+    queryKey: ["harmony", "jobs", jobID],
+    queryFn: async ({ signal }) => {
+      if (!isFetchableHarmonyJobId(jobID))
+        return null;
+      return harmonyApi.getJobStatus(jobID, __spreadProps(__spreadValues({}, options), { signal }));
+    },
+    enabled: isFetchableHarmonyJobId(jobID),
+    // Poll until the job reaches a final state
+    refetchInterval: (query) => {
+      var _a11;
+      const status = (_a11 = query.state.data) == null ? void 0 : _a11.status;
+      if (status && FINAL_STATUSES.has(status)) {
+        return false;
+      }
+      return POLL_INTERVAL_MS;
+    },
+    // Job status changes frequently while running; don't use stale data
+    staleTime: 0,
+    gcTime: 0
+  };
+}
+function queryCreateHarmonySubsetJob() {
+  return {
+    mutationFn: ({ harmonyRequest, options }) => harmonyApi.createJob(harmonyRequest, options)
+  };
+}
+function queryCancelHarmonySubsetJob() {
+  return {
+    mutationFn: ({ jobId, options }) => harmonyApi.cancelJob(jobId, options)
+  };
+}
+function mutationRemoveHarmonyJobLabels() {
+  return {
+    mutationFn: ({ jobIDs, labels, options }) => harmonyApi.removeJobLabels({ jobIDs, labels }, options)
+  };
+}
+
+// src/controllers/query.controller.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@tanstack/query-core/build/modern/index.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@tanstack/query-core/build/modern/focusManager.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@tanstack/query-core/build/modern/subscribable.js
+init_dirname();
+init_buffer();
+init_process();
+var Subscribable = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    this.onSubscribe();
+    return () => {
+      this.listeners.delete(listener);
+      this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+};
+
+// node_modules/@tanstack/query-core/build/modern/focusManager.js
+var _focused, _cleanup, _setup, _a;
+var FocusManager = (_a = class extends Subscribable {
+  constructor() {
+    super();
+    __privateAdd(this, _focused, void 0);
+    __privateAdd(this, _cleanup, void 0);
+    __privateAdd(this, _setup, void 0);
+    __privateSet(this, _setup, (onFocus) => {
+      if (typeof window !== "undefined" && window.addEventListener) {
+        const listener = () => onFocus();
+        window.addEventListener("visibilitychange", listener, false);
+        return () => {
+          window.removeEventListener("visibilitychange", listener);
+        };
+      }
+      return;
+    });
+  }
+  onSubscribe() {
+    if (!__privateGet(this, _cleanup)) {
+      this.setEventListener(__privateGet(this, _setup));
+    }
+  }
+  onUnsubscribe() {
+    var _a11;
+    if (!this.hasListeners()) {
+      (_a11 = __privateGet(this, _cleanup)) == null ? void 0 : _a11.call(this);
+      __privateSet(this, _cleanup, void 0);
+    }
+  }
+  setEventListener(setup) {
+    var _a11;
+    __privateSet(this, _setup, setup);
+    (_a11 = __privateGet(this, _cleanup)) == null ? void 0 : _a11.call(this);
+    __privateSet(this, _cleanup, setup((focused) => {
+      if (typeof focused === "boolean") {
+        this.setFocused(focused);
+      } else {
+        this.onFocus();
+      }
+    }));
+  }
+  setFocused(focused) {
+    const changed = __privateGet(this, _focused) !== focused;
+    if (changed) {
+      __privateSet(this, _focused, focused);
+      this.onFocus();
+    }
+  }
+  onFocus() {
+    const isFocused = this.isFocused();
+    this.listeners.forEach((listener) => {
+      listener(isFocused);
+    });
+  }
+  isFocused() {
+    var _a11;
+    if (typeof __privateGet(this, _focused) === "boolean") {
+      return __privateGet(this, _focused);
+    }
+    return ((_a11 = globalThis.document) == null ? void 0 : _a11.visibilityState) !== "hidden";
+  }
+}, _focused = new WeakMap(), _cleanup = new WeakMap(), _setup = new WeakMap(), _a);
+var focusManager = new FocusManager();
+
+// node_modules/@tanstack/query-core/build/modern/environmentManager.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@tanstack/query-core/build/modern/utils.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@tanstack/query-core/build/modern/timeoutManager.js
+init_dirname();
+init_buffer();
+init_process();
+var defaultTimeoutProvider = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (callback, delay) => setTimeout(callback, delay),
+  clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+  setInterval: (callback, delay) => setInterval(callback, delay),
+  clearInterval: (intervalId) => clearInterval(intervalId)
+};
+var _provider, _providerCalled, _a2;
+var TimeoutManager = (_a2 = class {
+  constructor() {
+    // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+    // type at app boot; and if we leave that type, then any new timer provider
+    // would need to support the default provider's concrete timer ID, which is
+    // infeasible across environments.
+    //
+    // We settle for type safety for the TimeoutProvider type, and accept that
+    // this class is unsafe internally to allow for extension.
+    __privateAdd(this, _provider, defaultTimeoutProvider);
+    __privateAdd(this, _providerCalled, false);
+  }
+  setTimeoutProvider(provider) {
+    if (false) {
+      if (__privateGet(this, _providerCalled) && provider !== __privateGet(this, _provider)) {
+        console.error(
+          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,
+          { previous: __privateGet(this, _provider), provider }
+        );
+      }
+    }
+    __privateSet(this, _provider, provider);
+    if (false) {
+      __privateSet(this, _providerCalled, false);
+    }
+  }
+  setTimeout(callback, delay) {
+    if (false) {
+      __privateSet(this, _providerCalled, true);
+    }
+    return __privateGet(this, _provider).setTimeout(callback, delay);
+  }
+  clearTimeout(timeoutId) {
+    __privateGet(this, _provider).clearTimeout(timeoutId);
+  }
+  setInterval(callback, delay) {
+    if (false) {
+      __privateSet(this, _providerCalled, true);
+    }
+    return __privateGet(this, _provider).setInterval(callback, delay);
+  }
+  clearInterval(intervalId) {
+    __privateGet(this, _provider).clearInterval(intervalId);
+  }
+}, _provider = new WeakMap(), _providerCalled = new WeakMap(), _a2);
+var timeoutManager = new TimeoutManager();
+function systemSetTimeoutZero(callback) {
+  setTimeout(callback, 0);
+}
+
+// node_modules/@tanstack/query-core/build/modern/utils.js
+var isServer = typeof window === "undefined" || "Deno" in globalThis;
+function noop() {
+}
+function functionalUpdate(updater, input) {
+  return typeof updater === "function" ? updater(input) : updater;
+}
+function isValidTimeout(value) {
+  return typeof value === "number" && value >= 0 && value !== Infinity;
+}
+function timeUntilStale(updatedAt, staleTime) {
+  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+}
+function resolveStaleTime(staleTime, query) {
+  return typeof staleTime === "function" ? staleTime(query) : staleTime;
+}
+function resolveEnabled(enabled, query) {
+  return typeof enabled === "function" ? enabled(query) : enabled;
+}
+function matchQuery(filters, query) {
+  const {
+    type = "all",
+    exact,
+    fetchStatus,
+    predicate,
+    queryKey,
+    stale
+  } = filters;
+  if (queryKey) {
+    if (exact) {
+      if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
+        return false;
+      }
+    } else if (!partialMatchKey(query.queryKey, queryKey)) {
+      return false;
+    }
+  }
+  if (type !== "all") {
+    const isActive = query.isActive();
+    if (type === "active" && !isActive) {
+      return false;
+    }
+    if (type === "inactive" && isActive) {
+      return false;
+    }
+  }
+  if (typeof stale === "boolean" && query.isStale() !== stale) {
+    return false;
+  }
+  if (fetchStatus && fetchStatus !== query.state.fetchStatus) {
+    return false;
+  }
+  if (predicate && !predicate(query)) {
+    return false;
+  }
+  return true;
+}
+function matchMutation(filters, mutation) {
+  const { exact, status, predicate, mutationKey } = filters;
+  if (mutationKey) {
+    if (!mutation.options.mutationKey) {
+      return false;
+    }
+    if (exact) {
+      if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) {
+        return false;
+      }
+    } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {
+      return false;
+    }
+  }
+  if (status && mutation.state.status !== status) {
+    return false;
+  }
+  if (predicate && !predicate(mutation)) {
+    return false;
+  }
+  return true;
+}
+function hashQueryKeyByOptions(queryKey, options) {
+  const hashFn = (options == null ? void 0 : options.queryKeyHashFn) || hashKey;
+  return hashFn(queryKey);
+}
+function hashKey(queryKey) {
+  return JSON.stringify(
+    queryKey,
+    (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+      result[key] = val[key];
+      return result;
+    }, {}) : val
+  );
+}
+function partialMatchKey(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    return Object.keys(b).every((key) => partialMatchKey(a[key], b[key]));
+  }
+  return false;
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+function replaceEqualDeep(a, b, depth = 0) {
+  if (a === b) {
+    return a;
+  }
+  if (depth > 500)
+    return b;
+  const array = isPlainArray(a) && isPlainArray(b);
+  if (!array && !(isPlainObject(a) && isPlainObject(b)))
+    return b;
+  const aItems = array ? a : Object.keys(a);
+  const aSize = aItems.length;
+  const bItems = array ? b : Object.keys(b);
+  const bSize = bItems.length;
+  const copy = array ? new Array(bSize) : {};
+  let equalItems = 0;
+  for (let i = 0; i < bSize; i++) {
+    const key = array ? i : bItems[i];
+    const aItem = a[key];
+    const bItem = b[key];
+    if (aItem === bItem) {
+      copy[key] = aItem;
+      if (array ? i < aSize : hasOwn.call(a, key))
+        equalItems++;
+      continue;
+    }
+    if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
+      copy[key] = bItem;
+      continue;
+    }
+    const v = replaceEqualDeep(aItem, bItem, depth + 1);
+    copy[key] = v;
+    if (v === aItem)
+      equalItems++;
+  }
+  return aSize === bSize && equalItems === aSize ? a : copy;
+}
+function shallowEqualObjects(a, b) {
+  if (!b || Object.keys(a).length !== Object.keys(b).length) {
+    return false;
+  }
+  for (const key in a) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPlainArray(value) {
+  return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o)) {
+    return false;
+  }
+  const ctor = o.constructor;
+  if (ctor === void 0) {
+    return true;
+  }
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot)) {
+    return false;
+  }
+  if (!prot.hasOwnProperty("isPrototypeOf")) {
+    return false;
+  }
+  if (Object.getPrototypeOf(o) !== Object.prototype) {
+    return false;
+  }
+  return true;
+}
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+function sleep(timeout) {
+  return new Promise((resolve) => {
+    timeoutManager.setTimeout(resolve, timeout);
+  });
+}
+function replaceData(prevData, data, options) {
+  if (typeof options.structuralSharing === "function") {
+    return options.structuralSharing(prevData, data);
+  } else if (options.structuralSharing !== false) {
+    if (false) {
+      try {
+        return replaceEqualDeep(prevData, data);
+      } catch (error) {
+        console.error(
+          `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}`
+        );
+        throw error;
+      }
+    }
+    return replaceEqualDeep(prevData, data);
+  }
+  return data;
+}
+function addToEnd(items, item, max = 0) {
+  const newItems = [...items, item];
+  return max && newItems.length > max ? newItems.slice(1) : newItems;
+}
+function addToStart(items, item, max = 0) {
+  const newItems = [item, ...items];
+  return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
+}
+var skipToken = /* @__PURE__ */ Symbol();
+function ensureQueryFn(options, fetchOptions) {
+  if (false) {
+    if (options.queryFn === skipToken) {
+      console.error(
+        `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'`
+      );
+    }
+  }
+  if (!options.queryFn && (fetchOptions == null ? void 0 : fetchOptions.initialPromise)) {
+    return () => fetchOptions.initialPromise;
+  }
+  if (!options.queryFn || options.queryFn === skipToken) {
+    return () => Promise.reject(new Error(`Missing queryFn: '${options.queryHash}'`));
+  }
+  return options.queryFn;
+}
+function addConsumeAwareSignal(object, getSignal, onCancelled) {
+  let consumed = false;
+  let signal;
+  Object.defineProperty(object, "signal", {
+    enumerable: true,
+    get: () => {
+      signal != null ? signal : signal = getSignal();
+      if (consumed) {
+        return signal;
+      }
+      consumed = true;
+      if (signal.aborted) {
+        onCancelled();
+      } else {
+        signal.addEventListener("abort", onCancelled, { once: true });
+      }
+      return signal;
+    }
+  });
+  return object;
+}
+
+// node_modules/@tanstack/query-core/build/modern/environmentManager.js
+var environmentManager = /* @__PURE__ */ (() => {
+  let isServerFn = () => isServer;
+  return {
+    /**
+     * Returns whether the current runtime should be treated as a server environment.
+     */
+    isServer() {
+      return isServerFn();
+    },
+    /**
+     * Overrides the server check globally.
+     */
+    setIsServer(isServerValue) {
+      isServerFn = isServerValue;
+    }
+  };
+})();
+
+// node_modules/@tanstack/query-core/build/modern/hydration.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@tanstack/query-core/build/modern/thenable.js
+init_dirname();
+init_buffer();
+init_process();
+function pendingThenable() {
+  let resolve;
+  let reject;
+  const thenable = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  thenable.status = "pending";
+  thenable.catch(() => {
+  });
+  function finalize(data) {
+    Object.assign(thenable, data);
+    delete thenable.resolve;
+    delete thenable.reject;
+  }
+  thenable.resolve = (value) => {
+    finalize({
+      status: "fulfilled",
+      value
+    });
+    resolve(value);
+  };
+  thenable.reject = (reason) => {
+    finalize({
+      status: "rejected",
+      reason
+    });
+    reject(reason);
+  };
+  return thenable;
+}
+function tryResolveSync(promise) {
+  var _a11;
+  let data;
+  (_a11 = promise.then((result) => {
+    data = result;
+    return result;
+  }, noop)) == null ? void 0 : _a11.catch(noop);
+  if (data !== void 0) {
+    return { data };
+  }
+  return void 0;
+}
+
+// node_modules/@tanstack/query-core/build/modern/hydration.js
+function defaultTransformerFn(data) {
+  return data;
+}
+function dehydrateMutation(mutation) {
+  return __spreadValues(__spreadValues({
+    mutationKey: mutation.options.mutationKey,
+    state: mutation.state
+  }, mutation.options.scope && { scope: mutation.options.scope }), mutation.meta && { meta: mutation.meta });
+}
+function dehydrateQuery(query, serializeData, shouldRedactErrors) {
+  const dehydratePromise = () => {
+    var _a11;
+    const promise = (_a11 = query.promise) == null ? void 0 : _a11.then(serializeData).catch((error) => {
+      if (!shouldRedactErrors(error)) {
+        return Promise.reject(error);
+      }
+      if (false) {
+        console.error(
+          `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`
+        );
+      }
+      return Promise.reject(new Error("redacted"));
+    });
+    promise == null ? void 0 : promise.catch(noop);
+    return promise;
+  };
+  return __spreadValues(__spreadValues({
+    dehydratedAt: Date.now(),
+    state: __spreadValues(__spreadValues({}, query.state), query.state.data !== void 0 && {
+      data: serializeData(query.state.data)
+    }),
+    queryKey: query.queryKey,
+    queryHash: query.queryHash
+  }, query.state.status === "pending" && {
+    promise: dehydratePromise()
+  }), query.meta && { meta: query.meta });
+}
+function defaultShouldDehydrateMutation(mutation) {
+  return mutation.state.isPaused;
+}
+function defaultShouldDehydrateQuery(query) {
+  return query.state.status === "success";
+}
+function defaultShouldRedactErrors(_) {
+  return true;
+}
+function dehydrate(client, options = {}) {
+  var _a11, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const filterMutation = (_c = (_b2 = options.shouldDehydrateMutation) != null ? _b2 : (_a11 = client.getDefaultOptions().dehydrate) == null ? void 0 : _a11.shouldDehydrateMutation) != null ? _c : defaultShouldDehydrateMutation;
+  const mutations = client.getMutationCache().getAll().flatMap(
+    (mutation) => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []
+  );
+  const filterQuery = (_f = (_e = options.shouldDehydrateQuery) != null ? _e : (_d = client.getDefaultOptions().dehydrate) == null ? void 0 : _d.shouldDehydrateQuery) != null ? _f : defaultShouldDehydrateQuery;
+  const shouldRedactErrors = (_i = (_h = options.shouldRedactErrors) != null ? _h : (_g = client.getDefaultOptions().dehydrate) == null ? void 0 : _g.shouldRedactErrors) != null ? _i : defaultShouldRedactErrors;
+  const serializeData = (_l = (_k = options.serializeData) != null ? _k : (_j = client.getDefaultOptions().dehydrate) == null ? void 0 : _j.serializeData) != null ? _l : defaultTransformerFn;
+  const queries = client.getQueryCache().getAll().flatMap(
+    (query) => filterQuery(query) ? [dehydrateQuery(query, serializeData, shouldRedactErrors)] : []
+  );
+  return { mutations, queries };
+}
+function hydrate(client, dehydratedState, options) {
+  var _a11, _b2, _c, _d;
+  if (typeof dehydratedState !== "object" || dehydratedState === null) {
+    return;
+  }
+  const mutationCache = client.getMutationCache();
+  const queryCache = client.getQueryCache();
+  const deserializeData = (_d = (_c = (_a11 = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _a11.deserializeData) != null ? _c : (_b2 = client.getDefaultOptions().hydrate) == null ? void 0 : _b2.deserializeData) != null ? _d : defaultTransformerFn;
+  const mutations = dehydratedState.mutations || [];
+  const queries = dehydratedState.queries || [];
+  mutations.forEach((_e) => {
+    var _f = _e, { state } = _f, mutationOptions = __objRest(_f, ["state"]);
+    var _a12, _b3;
+    mutationCache.build(
+      client,
+      __spreadValues(__spreadValues(__spreadValues({}, (_a12 = client.getDefaultOptions().hydrate) == null ? void 0 : _a12.mutations), (_b3 = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _b3.mutations), mutationOptions),
+      state
+    );
+  });
+  queries.forEach(
+    ({ queryKey, state, queryHash, meta, promise, dehydratedAt }) => {
+      var _b3, _c2;
+      const syncData = promise ? tryResolveSync(promise) : void 0;
+      const rawData = state.data === void 0 ? syncData == null ? void 0 : syncData.data : state.data;
+      const data = rawData === void 0 ? rawData : deserializeData(rawData);
+      let query = queryCache.get(queryHash);
+      const existingQueryIsPending = (query == null ? void 0 : query.state.status) === "pending";
+      const existingQueryIsFetching = (query == null ? void 0 : query.state.fetchStatus) === "fetching";
+      if (query) {
+        const hasNewerSyncData = syncData && // We only need this undefined check to handle older dehydration
+        // payloads that might not have dehydratedAt
+        dehydratedAt !== void 0 && dehydratedAt > query.state.dataUpdatedAt;
+        if (state.dataUpdatedAt > query.state.dataUpdatedAt || hasNewerSyncData) {
+          const _a12 = state, { fetchStatus: _ignored } = _a12, serializedState = __objRest(_a12, ["fetchStatus"]);
+          query.setState(__spreadProps(__spreadValues({}, serializedState), {
+            data
+          }));
+        }
+      } else {
+        query = queryCache.build(
+          client,
+          __spreadProps(__spreadValues(__spreadValues({}, (_b3 = client.getDefaultOptions().hydrate) == null ? void 0 : _b3.queries), (_c2 = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _c2.queries), {
+            queryKey,
+            queryHash,
+            meta
+          }),
+          // Reset fetch status to idle to avoid
+          // query being stuck in fetching state upon hydration
+          __spreadProps(__spreadValues({}, state), {
+            data,
+            fetchStatus: "idle",
+            status: data !== void 0 ? "success" : state.status
+          })
+        );
+      }
+      if (promise && !existingQueryIsPending && !existingQueryIsFetching && // Only hydrate if dehydration is newer than any existing data,
+      // this is always true for new queries
+      (dehydratedAt === void 0 || dehydratedAt > query.state.dataUpdatedAt)) {
+        query.fetch(void 0, {
+          // RSC transformed promises are not thenable
+          initialPromise: Promise.resolve(promise).then(deserializeData)
+        }).catch(noop);
+      }
+    }
+  );
+}
+
+// node_modules/@tanstack/query-core/build/modern/queryObserver.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@tanstack/query-core/build/modern/notifyManager.js
+init_dirname();
+init_buffer();
+init_process();
+var defaultScheduler = systemSetTimeoutZero;
+function createNotifyManager() {
+  let queue = [];
+  let transactions = 0;
+  let notifyFn = (callback) => {
+    callback();
+  };
+  let batchNotifyFn = (callback) => {
+    callback();
+  };
+  let scheduleFn = defaultScheduler;
+  const schedule = (callback) => {
+    if (transactions) {
+      queue.push(callback);
+    } else {
+      scheduleFn(() => {
+        notifyFn(callback);
+      });
+    }
+  };
+  const flush = () => {
+    const originalQueue = queue;
+    queue = [];
+    if (originalQueue.length) {
+      scheduleFn(() => {
+        batchNotifyFn(() => {
+          originalQueue.forEach((callback) => {
+            notifyFn(callback);
+          });
+        });
+      });
+    }
+  };
+  return {
+    batch: (callback) => {
+      let result;
+      transactions++;
+      try {
+        result = callback();
+      } finally {
+        transactions--;
+        if (!transactions) {
+          flush();
+        }
+      }
+      return result;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (callback) => {
+      return (...args) => {
+        schedule(() => {
+          callback(...args);
+        });
+      };
+    },
+    schedule,
+    /**
+     * Use this method to set a custom notify function.
+     * This can be used to for example wrap notifications with `React.act` while running tests.
+     */
+    setNotifyFunction: (fn) => {
+      notifyFn = fn;
+    },
+    /**
+     * Use this method to set a custom function to batch notifications together into a single tick.
+     * By default React Query will use the batch function provided by ReactDOM or React Native.
+     */
+    setBatchNotifyFunction: (fn) => {
+      batchNotifyFn = fn;
+    },
+    setScheduler: (fn) => {
+      scheduleFn = fn;
+    }
+  };
+}
+var notifyManager = createNotifyManager();
+
+// node_modules/@tanstack/query-core/build/modern/query.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@tanstack/query-core/build/modern/retryer.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@tanstack/query-core/build/modern/onlineManager.js
+init_dirname();
+init_buffer();
+init_process();
+var _online, _cleanup2, _setup2, _a3;
+var OnlineManager = (_a3 = class extends Subscribable {
+  constructor() {
+    super();
+    __privateAdd(this, _online, true);
+    __privateAdd(this, _cleanup2, void 0);
+    __privateAdd(this, _setup2, void 0);
+    __privateSet(this, _setup2, (onOnline) => {
+      if (typeof window !== "undefined" && window.addEventListener) {
+        const onlineListener = () => onOnline(true);
+        const offlineListener = () => onOnline(false);
+        window.addEventListener("online", onlineListener, false);
+        window.addEventListener("offline", offlineListener, false);
+        return () => {
+          window.removeEventListener("online", onlineListener);
+          window.removeEventListener("offline", offlineListener);
+        };
+      }
+      return;
+    });
+  }
+  onSubscribe() {
+    if (!__privateGet(this, _cleanup2)) {
+      this.setEventListener(__privateGet(this, _setup2));
+    }
+  }
+  onUnsubscribe() {
+    var _a11;
+    if (!this.hasListeners()) {
+      (_a11 = __privateGet(this, _cleanup2)) == null ? void 0 : _a11.call(this);
+      __privateSet(this, _cleanup2, void 0);
+    }
+  }
+  setEventListener(setup) {
+    var _a11;
+    __privateSet(this, _setup2, setup);
+    (_a11 = __privateGet(this, _cleanup2)) == null ? void 0 : _a11.call(this);
+    __privateSet(this, _cleanup2, setup(this.setOnline.bind(this)));
+  }
+  setOnline(online) {
+    const changed = __privateGet(this, _online) !== online;
+    if (changed) {
+      __privateSet(this, _online, online);
+      this.listeners.forEach((listener) => {
+        listener(online);
+      });
+    }
+  }
+  isOnline() {
+    return __privateGet(this, _online);
+  }
+}, _online = new WeakMap(), _cleanup2 = new WeakMap(), _setup2 = new WeakMap(), _a3);
+var onlineManager = new OnlineManager();
+
+// node_modules/@tanstack/query-core/build/modern/retryer.js
+function defaultRetryDelay(failureCount) {
+  return Math.min(1e3 * 2 ** failureCount, 3e4);
+}
+function canFetch(networkMode) {
+  return (networkMode != null ? networkMode : "online") === "online" ? onlineManager.isOnline() : true;
+}
+var CancelledError = class extends Error {
+  constructor(options) {
+    super("CancelledError");
+    this.revert = options == null ? void 0 : options.revert;
+    this.silent = options == null ? void 0 : options.silent;
+  }
+};
+function createRetryer(config) {
+  let isRetryCancelled = false;
+  let failureCount = 0;
+  let continueFn;
+  const thenable = pendingThenable();
+  const isResolved = () => thenable.status !== "pending";
+  const cancel = (cancelOptions) => {
+    var _a11;
+    if (!isResolved()) {
+      const error = new CancelledError(cancelOptions);
+      reject(error);
+      (_a11 = config.onCancel) == null ? void 0 : _a11.call(config, error);
+    }
+  };
+  const cancelRetry = () => {
+    isRetryCancelled = true;
+  };
+  const continueRetry = () => {
+    isRetryCancelled = false;
+  };
+  const canContinue = () => focusManager.isFocused() && (config.networkMode === "always" || onlineManager.isOnline()) && config.canRun();
+  const canStart = () => canFetch(config.networkMode) && config.canRun();
+  const resolve = (value) => {
+    if (!isResolved()) {
+      continueFn == null ? void 0 : continueFn();
+      thenable.resolve(value);
+    }
+  };
+  const reject = (value) => {
+    if (!isResolved()) {
+      continueFn == null ? void 0 : continueFn();
+      thenable.reject(value);
+    }
+  };
+  const pause = () => {
+    return new Promise((continueResolve) => {
+      var _a11;
+      continueFn = (value) => {
+        if (isResolved() || canContinue()) {
+          continueResolve(value);
+        }
+      };
+      (_a11 = config.onPause) == null ? void 0 : _a11.call(config);
+    }).then(() => {
+      var _a11;
+      continueFn = void 0;
+      if (!isResolved()) {
+        (_a11 = config.onContinue) == null ? void 0 : _a11.call(config);
+      }
+    });
+  };
+  const run = () => {
+    if (isResolved()) {
+      return;
+    }
+    let promiseOrValue;
+    const initialPromise = failureCount === 0 ? config.initialPromise : void 0;
+    try {
+      promiseOrValue = initialPromise != null ? initialPromise : config.fn();
+    } catch (error) {
+      promiseOrValue = Promise.reject(error);
+    }
+    Promise.resolve(promiseOrValue).then(resolve).catch((error) => {
+      var _a11, _b2, _c;
+      if (isResolved()) {
+        return;
+      }
+      const retry = (_a11 = config.retry) != null ? _a11 : environmentManager.isServer() ? 0 : 3;
+      const retryDelay = (_b2 = config.retryDelay) != null ? _b2 : defaultRetryDelay;
+      const delay = typeof retryDelay === "function" ? retryDelay(failureCount, error) : retryDelay;
+      const shouldRetry = retry === true || typeof retry === "number" && failureCount < retry || typeof retry === "function" && retry(failureCount, error);
+      if (isRetryCancelled || !shouldRetry) {
+        reject(error);
+        return;
+      }
+      failureCount++;
+      (_c = config.onFail) == null ? void 0 : _c.call(config, failureCount, error);
+      sleep(delay).then(() => {
+        return canContinue() ? void 0 : pause();
+      }).then(() => {
+        if (isRetryCancelled) {
+          reject(error);
+        } else {
+          run();
+        }
+      });
+    });
+  };
+  return {
+    promise: thenable,
+    status: () => thenable.status,
+    cancel,
+    continue: () => {
+      continueFn == null ? void 0 : continueFn();
+      return thenable;
+    },
+    cancelRetry,
+    continueRetry,
+    canStart,
+    start: () => {
+      if (canStart()) {
+        run();
+      } else {
+        pause().then(run);
+      }
+      return thenable;
+    }
+  };
+}
+
+// node_modules/@tanstack/query-core/build/modern/removable.js
+init_dirname();
+init_buffer();
+init_process();
+var _gcTimeout, _a4;
+var Removable = (_a4 = class {
+  constructor() {
+    __privateAdd(this, _gcTimeout, void 0);
+  }
+  destroy() {
+    this.clearGcTimeout();
+  }
+  scheduleGc() {
+    this.clearGcTimeout();
+    if (isValidTimeout(this.gcTime)) {
+      __privateSet(this, _gcTimeout, timeoutManager.setTimeout(() => {
+        this.optionalRemove();
+      }, this.gcTime));
+    }
+  }
+  updateGcTime(newGcTime) {
+    this.gcTime = Math.max(
+      this.gcTime || 0,
+      newGcTime != null ? newGcTime : environmentManager.isServer() ? Infinity : 5 * 60 * 1e3
+    );
+  }
+  clearGcTimeout() {
+    if (__privateGet(this, _gcTimeout)) {
+      timeoutManager.clearTimeout(__privateGet(this, _gcTimeout));
+      __privateSet(this, _gcTimeout, void 0);
+    }
+  }
+}, _gcTimeout = new WeakMap(), _a4);
+
+// node_modules/@tanstack/query-core/build/modern/query.js
+var _initialState, _revertState, _cache, _client, _retryer, _defaultOptions, _abortSignalConsumed, _isInitialPausedFetch, isInitialPausedFetch_fn, _dispatch, dispatch_fn, _a5;
+var Query = (_a5 = class extends Removable {
+  constructor(config) {
+    var _a11;
+    super();
+    __privateAdd(this, _isInitialPausedFetch);
+    __privateAdd(this, _dispatch);
+    __privateAdd(this, _initialState, void 0);
+    __privateAdd(this, _revertState, void 0);
+    __privateAdd(this, _cache, void 0);
+    __privateAdd(this, _client, void 0);
+    __privateAdd(this, _retryer, void 0);
+    __privateAdd(this, _defaultOptions, void 0);
+    __privateAdd(this, _abortSignalConsumed, void 0);
+    __privateSet(this, _abortSignalConsumed, false);
+    __privateSet(this, _defaultOptions, config.defaultOptions);
+    this.setOptions(config.options);
+    this.observers = [];
+    __privateSet(this, _client, config.client);
+    __privateSet(this, _cache, __privateGet(this, _client).getQueryCache());
+    this.queryKey = config.queryKey;
+    this.queryHash = config.queryHash;
+    __privateSet(this, _initialState, getDefaultState(this.options));
+    this.state = (_a11 = config.state) != null ? _a11 : __privateGet(this, _initialState);
+    this.scheduleGc();
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  get promise() {
+    var _a11;
+    return (_a11 = __privateGet(this, _retryer)) == null ? void 0 : _a11.promise;
+  }
+  setOptions(options) {
+    this.options = __spreadValues(__spreadValues({}, __privateGet(this, _defaultOptions)), options);
+    this.updateGcTime(this.options.gcTime);
+    if (this.state && this.state.data === void 0) {
+      const defaultState = getDefaultState(this.options);
+      if (defaultState.data !== void 0) {
+        this.setState(
+          successState(defaultState.data, defaultState.dataUpdatedAt)
+        );
+        __privateSet(this, _initialState, defaultState);
+      }
+    }
+  }
+  optionalRemove() {
+    if (!this.observers.length && this.state.fetchStatus === "idle") {
+      __privateGet(this, _cache).remove(this);
+    }
+  }
+  setData(newData, options) {
+    const data = replaceData(this.state.data, newData, this.options);
+    __privateMethod(this, _dispatch, dispatch_fn).call(this, {
+      data,
+      type: "success",
+      dataUpdatedAt: options == null ? void 0 : options.updatedAt,
+      manual: options == null ? void 0 : options.manual
+    });
+    return data;
+  }
+  setState(state, setStateOptions) {
+    __privateMethod(this, _dispatch, dispatch_fn).call(this, { type: "setState", state, setStateOptions });
+  }
+  cancel(options) {
+    var _a11, _b2;
+    const promise = (_a11 = __privateGet(this, _retryer)) == null ? void 0 : _a11.promise;
+    (_b2 = __privateGet(this, _retryer)) == null ? void 0 : _b2.cancel(options);
+    return promise ? promise.then(noop).catch(noop) : Promise.resolve();
+  }
+  destroy() {
+    super.destroy();
+    this.cancel({ silent: true });
+  }
+  get resetState() {
+    return __privateGet(this, _initialState);
+  }
+  reset() {
+    this.destroy();
+    this.setState(this.resetState);
+  }
+  isActive() {
+    return this.observers.some(
+      (observer) => resolveEnabled(observer.options.enabled, this) !== false
+    );
+  }
+  isDisabled() {
+    if (this.getObserversCount() > 0) {
+      return !this.isActive();
+    }
+    return this.options.queryFn === skipToken || !this.isFetched();
+  }
+  isFetched() {
+    return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
+  }
+  isStatic() {
+    if (this.getObserversCount() > 0) {
+      return this.observers.some(
+        (observer) => resolveStaleTime(observer.options.staleTime, this) === "static"
+      );
+    }
+    return false;
+  }
+  isStale() {
+    if (this.getObserversCount() > 0) {
+      return this.observers.some(
+        (observer) => observer.getCurrentResult().isStale
+      );
+    }
+    return this.state.data === void 0 || this.state.isInvalidated;
+  }
+  isStaleByTime(staleTime = 0) {
+    if (this.state.data === void 0) {
+      return true;
+    }
+    if (staleTime === "static") {
+      return false;
+    }
+    if (this.state.isInvalidated) {
+      return true;
+    }
+    return !timeUntilStale(this.state.dataUpdatedAt, staleTime);
+  }
+  onFocus() {
+    var _a11;
+    const observer = this.observers.find((x) => x.shouldFetchOnWindowFocus());
+    observer == null ? void 0 : observer.refetch({ cancelRefetch: false });
+    (_a11 = __privateGet(this, _retryer)) == null ? void 0 : _a11.continue();
+  }
+  onOnline() {
+    var _a11;
+    const observer = this.observers.find((x) => x.shouldFetchOnReconnect());
+    observer == null ? void 0 : observer.refetch({ cancelRefetch: false });
+    (_a11 = __privateGet(this, _retryer)) == null ? void 0 : _a11.continue();
+  }
+  addObserver(observer) {
+    if (!this.observers.includes(observer)) {
+      this.observers.push(observer);
+      this.clearGcTimeout();
+      __privateGet(this, _cache).notify({ type: "observerAdded", query: this, observer });
+    }
+  }
+  removeObserver(observer) {
+    if (this.observers.includes(observer)) {
+      this.observers = this.observers.filter((x) => x !== observer);
+      if (!this.observers.length) {
+        if (__privateGet(this, _retryer)) {
+          if (__privateGet(this, _abortSignalConsumed) || __privateMethod(this, _isInitialPausedFetch, isInitialPausedFetch_fn).call(this)) {
+            __privateGet(this, _retryer).cancel({ revert: true });
+          } else {
+            __privateGet(this, _retryer).cancelRetry();
+          }
+        }
+        this.scheduleGc();
+      }
+      __privateGet(this, _cache).notify({ type: "observerRemoved", query: this, observer });
+    }
+  }
+  getObserversCount() {
+    return this.observers.length;
+  }
+  invalidate() {
+    if (!this.state.isInvalidated) {
+      __privateMethod(this, _dispatch, dispatch_fn).call(this, { type: "invalidate" });
+    }
+  }
+  async fetch(options, fetchOptions) {
+    var _a11, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    if (this.state.fetchStatus !== "idle" && // If the promise in the retryer is already rejected, we have to definitely
+    // re-start the fetch; there is a chance that the query is still in a
+    // pending state when that happens
+    ((_a11 = __privateGet(this, _retryer)) == null ? void 0 : _a11.status()) !== "rejected") {
+      if (this.state.data !== void 0 && (fetchOptions == null ? void 0 : fetchOptions.cancelRefetch)) {
+        this.cancel({ silent: true });
+      } else if (__privateGet(this, _retryer)) {
+        __privateGet(this, _retryer).continueRetry();
+        return __privateGet(this, _retryer).promise;
+      }
+    }
+    if (options) {
+      this.setOptions(options);
+    }
+    if (!this.options.queryFn) {
+      const observer = this.observers.find((x) => x.options.queryFn);
+      if (observer) {
+        this.setOptions(observer.options);
+      }
+    }
+    if (false) {
+      if (!Array.isArray(this.options.queryKey)) {
+        console.error(
+          `As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']`
+        );
+      }
+    }
+    const abortController = new AbortController();
+    const addSignalProperty = (object) => {
+      Object.defineProperty(object, "signal", {
+        enumerable: true,
+        get: () => {
+          __privateSet(this, _abortSignalConsumed, true);
+          return abortController.signal;
+        }
+      });
+    };
+    const fetchFn = () => {
+      const queryFn = ensureQueryFn(this.options, fetchOptions);
+      const createQueryFnContext = () => {
+        const queryFnContext2 = {
+          client: __privateGet(this, _client),
+          queryKey: this.queryKey,
+          meta: this.meta
+        };
+        addSignalProperty(queryFnContext2);
+        return queryFnContext2;
+      };
+      const queryFnContext = createQueryFnContext();
+      __privateSet(this, _abortSignalConsumed, false);
+      if (this.options.persister) {
+        return this.options.persister(
+          queryFn,
+          queryFnContext,
+          this
+        );
+      }
+      return queryFn(queryFnContext);
+    };
+    const createFetchContext = () => {
+      const context2 = {
+        fetchOptions,
+        options: this.options,
+        queryKey: this.queryKey,
+        client: __privateGet(this, _client),
+        state: this.state,
+        fetchFn
+      };
+      addSignalProperty(context2);
+      return context2;
+    };
+    const context = createFetchContext();
+    (_b2 = this.options.behavior) == null ? void 0 : _b2.onFetch(context, this);
+    __privateSet(this, _revertState, this.state);
+    if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== ((_c = context.fetchOptions) == null ? void 0 : _c.meta)) {
+      __privateMethod(this, _dispatch, dispatch_fn).call(this, { type: "fetch", meta: (_d = context.fetchOptions) == null ? void 0 : _d.meta });
+    }
+    __privateSet(this, _retryer, createRetryer({
+      initialPromise: fetchOptions == null ? void 0 : fetchOptions.initialPromise,
+      fn: context.fetchFn,
+      onCancel: (error) => {
+        if (error instanceof CancelledError && error.revert) {
+          this.setState(__spreadProps(__spreadValues({}, __privateGet(this, _revertState)), {
+            fetchStatus: "idle"
+          }));
+        }
+        abortController.abort();
+      },
+      onFail: (failureCount, error) => {
+        __privateMethod(this, _dispatch, dispatch_fn).call(this, { type: "failed", failureCount, error });
+      },
+      onPause: () => {
+        __privateMethod(this, _dispatch, dispatch_fn).call(this, { type: "pause" });
+      },
+      onContinue: () => {
+        __privateMethod(this, _dispatch, dispatch_fn).call(this, { type: "continue" });
+      },
+      retry: context.options.retry,
+      retryDelay: context.options.retryDelay,
+      networkMode: context.options.networkMode,
+      canRun: () => true
+    }));
+    try {
+      const data = await __privateGet(this, _retryer).start();
+      if (data === void 0) {
+        if (false) {
+          console.error(
+            `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`
+          );
+        }
+        throw new Error(`${this.queryHash} data is undefined`);
+      }
+      this.setData(data);
+      (_f = (_e = __privateGet(this, _cache).config).onSuccess) == null ? void 0 : _f.call(_e, data, this);
+      (_h = (_g = __privateGet(this, _cache).config).onSettled) == null ? void 0 : _h.call(
+        _g,
+        data,
+        this.state.error,
+        this
+      );
+      return data;
+    } catch (error) {
+      if (error instanceof CancelledError) {
+        if (error.silent) {
+          return __privateGet(this, _retryer).promise;
+        } else if (error.revert) {
+          if (this.state.data === void 0) {
+            throw error;
+          }
+          return this.state.data;
+        }
+      }
+      __privateMethod(this, _dispatch, dispatch_fn).call(this, {
+        type: "error",
+        error
+      });
+      (_j = (_i = __privateGet(this, _cache).config).onError) == null ? void 0 : _j.call(
+        _i,
+        error,
+        this
+      );
+      (_l = (_k = __privateGet(this, _cache).config).onSettled) == null ? void 0 : _l.call(
+        _k,
+        this.state.data,
+        error,
+        this
+      );
+      throw error;
+    } finally {
+      this.scheduleGc();
+    }
+  }
+}, _initialState = new WeakMap(), _revertState = new WeakMap(), _cache = new WeakMap(), _client = new WeakMap(), _retryer = new WeakMap(), _defaultOptions = new WeakMap(), _abortSignalConsumed = new WeakMap(), _isInitialPausedFetch = new WeakSet(), isInitialPausedFetch_fn = function() {
+  return this.state.fetchStatus === "paused" && this.state.status === "pending";
+}, _dispatch = new WeakSet(), dispatch_fn = function(action) {
+  const reducer = (state) => {
+    var _a11;
+    switch (action.type) {
+      case "failed":
+        return __spreadProps(__spreadValues({}, state), {
+          fetchFailureCount: action.failureCount,
+          fetchFailureReason: action.error
+        });
+      case "pause":
+        return __spreadProps(__spreadValues({}, state), {
+          fetchStatus: "paused"
+        });
+      case "continue":
+        return __spreadProps(__spreadValues({}, state), {
+          fetchStatus: "fetching"
+        });
+      case "fetch":
+        return __spreadProps(__spreadValues(__spreadValues({}, state), fetchState(state.data, this.options)), {
+          fetchMeta: (_a11 = action.meta) != null ? _a11 : null
+        });
+      case "success":
+        const newState = __spreadValues(__spreadProps(__spreadValues(__spreadValues({}, state), successState(action.data, action.dataUpdatedAt)), {
+          dataUpdateCount: state.dataUpdateCount + 1
+        }), !action.manual && {
+          fetchStatus: "idle",
+          fetchFailureCount: 0,
+          fetchFailureReason: null
+        });
+        __privateSet(this, _revertState, action.manual ? newState : void 0);
+        return newState;
+      case "error":
+        const error = action.error;
+        return __spreadProps(__spreadValues({}, state), {
+          error,
+          errorUpdateCount: state.errorUpdateCount + 1,
+          errorUpdatedAt: Date.now(),
+          fetchFailureCount: state.fetchFailureCount + 1,
+          fetchFailureReason: error,
+          fetchStatus: "idle",
+          status: "error",
+          // flag existing data as invalidated if we get a background error
+          // note that "no data" always means stale so we can set unconditionally here
+          isInvalidated: true
+        });
+      case "invalidate":
+        return __spreadProps(__spreadValues({}, state), {
+          isInvalidated: true
+        });
+      case "setState":
+        return __spreadValues(__spreadValues({}, state), action.state);
+    }
+  };
+  this.state = reducer(this.state);
+  notifyManager.batch(() => {
+    this.observers.forEach((observer) => {
+      observer.onQueryUpdate();
+    });
+    __privateGet(this, _cache).notify({ query: this, type: "updated", action });
+  });
+}, _a5);
+function fetchState(data, options) {
+  return __spreadValues({
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused"
+  }, data === void 0 && {
+    error: null,
+    status: "pending"
+  });
+}
+function successState(data, dataUpdatedAt) {
+  return {
+    data,
+    dataUpdatedAt: dataUpdatedAt != null ? dataUpdatedAt : Date.now(),
+    error: null,
+    isInvalidated: false,
+    status: "success"
+  };
+}
+function getDefaultState(options) {
+  const data = typeof options.initialData === "function" ? options.initialData() : options.initialData;
+  const hasData = data !== void 0;
+  const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
+  return {
+    data,
+    dataUpdateCount: 0,
+    dataUpdatedAt: hasData ? initialDataUpdatedAt != null ? initialDataUpdatedAt : Date.now() : 0,
+    error: null,
+    errorUpdateCount: 0,
+    errorUpdatedAt: 0,
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchMeta: null,
+    isInvalidated: false,
+    status: hasData ? "success" : "pending",
+    fetchStatus: "idle"
+  };
+}
+
+// node_modules/@tanstack/query-core/build/modern/queryObserver.js
+var _client2, _currentQuery, _currentQueryInitialState, _currentResult, _currentResultState, _currentResultOptions, _currentThenable, _selectError, _selectFn, _selectResult, _lastQueryWithDefinedData, _staleTimeoutId, _refetchIntervalId, _currentRefetchInterval, _trackedProps, _executeFetch, executeFetch_fn, _updateStaleTimeout, updateStaleTimeout_fn, _computeRefetchInterval, computeRefetchInterval_fn, _updateRefetchInterval, updateRefetchInterval_fn, _updateTimers, updateTimers_fn, _clearStaleTimeout, clearStaleTimeout_fn, _clearRefetchInterval, clearRefetchInterval_fn, _updateQuery, updateQuery_fn, _notify, notify_fn, _b;
+var QueryObserver = (_b = class extends Subscribable {
+  constructor(client, options) {
+    super();
+    __privateAdd(this, _executeFetch);
+    __privateAdd(this, _updateStaleTimeout);
+    __privateAdd(this, _computeRefetchInterval);
+    __privateAdd(this, _updateRefetchInterval);
+    __privateAdd(this, _updateTimers);
+    __privateAdd(this, _clearStaleTimeout);
+    __privateAdd(this, _clearRefetchInterval);
+    __privateAdd(this, _updateQuery);
+    __privateAdd(this, _notify);
+    __privateAdd(this, _client2, void 0);
+    __privateAdd(this, _currentQuery, void 0);
+    __privateAdd(this, _currentQueryInitialState, void 0);
+    __privateAdd(this, _currentResult, void 0);
+    __privateAdd(this, _currentResultState, void 0);
+    __privateAdd(this, _currentResultOptions, void 0);
+    __privateAdd(this, _currentThenable, void 0);
+    __privateAdd(this, _selectError, void 0);
+    __privateAdd(this, _selectFn, void 0);
+    __privateAdd(this, _selectResult, void 0);
+    // This property keeps track of the last query with defined data.
+    // It will be used to pass the previous data and query to the placeholder function between renders.
+    __privateAdd(this, _lastQueryWithDefinedData, void 0);
+    __privateAdd(this, _staleTimeoutId, void 0);
+    __privateAdd(this, _refetchIntervalId, void 0);
+    __privateAdd(this, _currentRefetchInterval, void 0);
+    __privateAdd(this, _trackedProps, /* @__PURE__ */ new Set());
+    this.options = options;
+    __privateSet(this, _client2, client);
+    __privateSet(this, _selectError, null);
+    __privateSet(this, _currentThenable, pendingThenable());
+    this.bindMethods();
+    this.setOptions(options);
+  }
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    if (this.listeners.size === 1) {
+      __privateGet(this, _currentQuery).addObserver(this);
+      if (shouldFetchOnMount(__privateGet(this, _currentQuery), this.options)) {
+        __privateMethod(this, _executeFetch, executeFetch_fn).call(this);
+      } else {
+        this.updateResult();
+      }
+      __privateMethod(this, _updateTimers, updateTimers_fn).call(this);
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.destroy();
+    }
+  }
+  shouldFetchOnReconnect() {
+    return shouldFetchOn(
+      __privateGet(this, _currentQuery),
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return shouldFetchOn(
+      __privateGet(this, _currentQuery),
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set();
+    __privateMethod(this, _clearStaleTimeout, clearStaleTimeout_fn).call(this);
+    __privateMethod(this, _clearRefetchInterval, clearRefetchInterval_fn).call(this);
+    __privateGet(this, _currentQuery).removeObserver(this);
+  }
+  setOptions(options) {
+    const prevOptions = this.options;
+    const prevQuery = __privateGet(this, _currentQuery);
+    this.options = __privateGet(this, _client2).defaultQueryOptions(options);
+    if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) !== "boolean") {
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    }
+    __privateMethod(this, _updateQuery, updateQuery_fn).call(this);
+    __privateGet(this, _currentQuery).setOptions(this.options);
+    if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {
+      __privateGet(this, _client2).getQueryCache().notify({
+        type: "observerOptionsUpdated",
+        query: __privateGet(this, _currentQuery),
+        observer: this
+      });
+    }
+    const mounted = this.hasListeners();
+    if (mounted && shouldFetchOptionally(
+      __privateGet(this, _currentQuery),
+      prevQuery,
+      this.options,
+      prevOptions
+    )) {
+      __privateMethod(this, _executeFetch, executeFetch_fn).call(this);
+    }
+    this.updateResult();
+    if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveEnabled(prevOptions.enabled, __privateGet(this, _currentQuery)) || resolveStaleTime(this.options.staleTime, __privateGet(this, _currentQuery)) !== resolveStaleTime(prevOptions.staleTime, __privateGet(this, _currentQuery)))) {
+      __privateMethod(this, _updateStaleTimeout, updateStaleTimeout_fn).call(this);
+    }
+    const nextRefetchInterval = __privateMethod(this, _computeRefetchInterval, computeRefetchInterval_fn).call(this);
+    if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveEnabled(prevOptions.enabled, __privateGet(this, _currentQuery)) || nextRefetchInterval !== __privateGet(this, _currentRefetchInterval))) {
+      __privateMethod(this, _updateRefetchInterval, updateRefetchInterval_fn).call(this, nextRefetchInterval);
+    }
+  }
+  getOptimisticResult(options) {
+    const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), options);
+    const result = this.createResult(query, options);
+    if (shouldAssignObserverCurrentProperties(this, result)) {
+      __privateSet(this, _currentResult, result);
+      __privateSet(this, _currentResultOptions, this.options);
+      __privateSet(this, _currentResultState, __privateGet(this, _currentQuery).state);
+    }
+    return result;
+  }
+  getCurrentResult() {
+    return __privateGet(this, _currentResult);
+  }
+  trackResult(result, onPropTracked) {
+    return new Proxy(result, {
+      get: (target, key) => {
+        this.trackProp(key);
+        onPropTracked == null ? void 0 : onPropTracked(key);
+        if (key === "promise") {
+          this.trackProp("data");
+          if (!this.options.experimental_prefetchInRender && __privateGet(this, _currentThenable).status === "pending") {
+            __privateGet(this, _currentThenable).reject(
+              new Error(
+                "experimental_prefetchInRender feature flag is not enabled"
+              )
+            );
+          }
+        }
+        return Reflect.get(target, key);
+      }
+    });
+  }
+  trackProp(key) {
+    __privateGet(this, _trackedProps).add(key);
+  }
+  getCurrentQuery() {
+    return __privateGet(this, _currentQuery);
+  }
+  refetch(_a11 = {}) {
+    var options = __objRest(_a11, []);
+    return this.fetch(__spreadValues({}, options));
+  }
+  fetchOptimistic(options) {
+    const defaultedOptions = __privateGet(this, _client2).defaultQueryOptions(options);
+    const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), defaultedOptions);
+    return query.fetch().then(() => this.createResult(query, defaultedOptions));
+  }
+  fetch(fetchOptions) {
+    var _a11;
+    return __privateMethod(this, _executeFetch, executeFetch_fn).call(this, __spreadProps(__spreadValues({}, fetchOptions), {
+      cancelRefetch: (_a11 = fetchOptions.cancelRefetch) != null ? _a11 : true
+    })).then(() => {
+      this.updateResult();
+      return __privateGet(this, _currentResult);
+    });
+  }
+  createResult(query, options) {
+    var _a11;
+    const prevQuery = __privateGet(this, _currentQuery);
+    const prevOptions = this.options;
+    const prevResult = __privateGet(this, _currentResult);
+    const prevResultState = __privateGet(this, _currentResultState);
+    const prevResultOptions = __privateGet(this, _currentResultOptions);
+    const queryChange = query !== prevQuery;
+    const queryInitialState = queryChange ? query.state : __privateGet(this, _currentQueryInitialState);
+    const { state } = query;
+    let newState = __spreadValues({}, state);
+    let isPlaceholderData = false;
+    let data;
+    if (options._optimisticResults) {
+      const mounted = this.hasListeners();
+      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
+      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
+      if (fetchOnMount || fetchOptionally) {
+        newState = __spreadValues(__spreadValues({}, newState), fetchState(state.data, query.options));
+      }
+      if (options._optimisticResults === "isRestoring") {
+        newState.fetchStatus = "idle";
+      }
+    }
+    let { error, errorUpdatedAt, status } = newState;
+    data = newState.data;
+    let skipSelect = false;
+    if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
+      let placeholderData;
+      if ((prevResult == null ? void 0 : prevResult.isPlaceholderData) && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
+        placeholderData = prevResult.data;
+        skipSelect = true;
+      } else {
+        placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(
+          (_a11 = __privateGet(this, _lastQueryWithDefinedData)) == null ? void 0 : _a11.state.data,
+          __privateGet(this, _lastQueryWithDefinedData)
+        ) : options.placeholderData;
+      }
+      if (placeholderData !== void 0) {
+        status = "success";
+        data = replaceData(
+          prevResult == null ? void 0 : prevResult.data,
+          placeholderData,
+          options
+        );
+        isPlaceholderData = true;
+      }
+    }
+    if (options.select && data !== void 0 && !skipSelect) {
+      if (prevResult && data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === __privateGet(this, _selectFn)) {
+        data = __privateGet(this, _selectResult);
+      } else {
+        try {
+          __privateSet(this, _selectFn, options.select);
+          data = options.select(data);
+          data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);
+          __privateSet(this, _selectResult, data);
+          __privateSet(this, _selectError, null);
+        } catch (selectError) {
+          __privateSet(this, _selectError, selectError);
+        }
+      }
+    }
+    if (__privateGet(this, _selectError)) {
+      error = __privateGet(this, _selectError);
+      data = __privateGet(this, _selectResult);
+      errorUpdatedAt = Date.now();
+      status = "error";
+    }
+    const isFetching = newState.fetchStatus === "fetching";
+    const isPending = status === "pending";
+    const isError = status === "error";
+    const isLoading = isPending && isFetching;
+    const hasData = data !== void 0;
+    const result = {
+      status,
+      fetchStatus: newState.fetchStatus,
+      isPending,
+      isSuccess: status === "success",
+      isError,
+      isInitialLoading: isLoading,
+      isLoading,
+      data,
+      dataUpdatedAt: newState.dataUpdatedAt,
+      error,
+      errorUpdatedAt,
+      failureCount: newState.fetchFailureCount,
+      failureReason: newState.fetchFailureReason,
+      errorUpdateCount: newState.errorUpdateCount,
+      isFetched: query.isFetched(),
+      isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
+      isFetching,
+      isRefetching: isFetching && !isPending,
+      isLoadingError: isError && !hasData,
+      isPaused: newState.fetchStatus === "paused",
+      isPlaceholderData,
+      isRefetchError: isError && hasData,
+      isStale: isStale(query, options),
+      refetch: this.refetch,
+      promise: __privateGet(this, _currentThenable),
+      isEnabled: resolveEnabled(options.enabled, query) !== false
+    };
+    const nextResult = result;
+    if (this.options.experimental_prefetchInRender) {
+      const hasResultData = nextResult.data !== void 0;
+      const isErrorWithoutData = nextResult.status === "error" && !hasResultData;
+      const finalizeThenableIfPossible = (thenable) => {
+        if (isErrorWithoutData) {
+          thenable.reject(nextResult.error);
+        } else if (hasResultData) {
+          thenable.resolve(nextResult.data);
+        }
+      };
+      const recreateThenable = () => {
+        const pending = __privateSet(this, _currentThenable, nextResult.promise = pendingThenable());
+        finalizeThenableIfPossible(pending);
+      };
+      const prevThenable = __privateGet(this, _currentThenable);
+      switch (prevThenable.status) {
+        case "pending":
+          if (query.queryHash === prevQuery.queryHash) {
+            finalizeThenableIfPossible(prevThenable);
+          }
+          break;
+        case "fulfilled":
+          if (isErrorWithoutData || nextResult.data !== prevThenable.value) {
+            recreateThenable();
+          }
+          break;
+        case "rejected":
+          if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) {
+            recreateThenable();
+          }
+          break;
+      }
+    }
+    return nextResult;
+  }
+  updateResult() {
+    const prevResult = __privateGet(this, _currentResult);
+    const nextResult = this.createResult(__privateGet(this, _currentQuery), this.options);
+    __privateSet(this, _currentResultState, __privateGet(this, _currentQuery).state);
+    __privateSet(this, _currentResultOptions, this.options);
+    if (__privateGet(this, _currentResultState).data !== void 0) {
+      __privateSet(this, _lastQueryWithDefinedData, __privateGet(this, _currentQuery));
+    }
+    if (shallowEqualObjects(nextResult, prevResult)) {
+      return;
+    }
+    __privateSet(this, _currentResult, nextResult);
+    const shouldNotifyListeners = () => {
+      if (!prevResult) {
+        return true;
+      }
+      const { notifyOnChangeProps } = this.options;
+      const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
+      if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !__privateGet(this, _trackedProps).size) {
+        return true;
+      }
+      const includedProps = new Set(
+        notifyOnChangePropsValue != null ? notifyOnChangePropsValue : __privateGet(this, _trackedProps)
+      );
+      if (this.options.throwOnError) {
+        includedProps.add("error");
+      }
+      return Object.keys(__privateGet(this, _currentResult)).some((key) => {
+        const typedKey = key;
+        const changed = __privateGet(this, _currentResult)[typedKey] !== prevResult[typedKey];
+        return changed && includedProps.has(typedKey);
+      });
+    };
+    __privateMethod(this, _notify, notify_fn).call(this, { listeners: shouldNotifyListeners() });
+  }
+  onQueryUpdate() {
+    this.updateResult();
+    if (this.hasListeners()) {
+      __privateMethod(this, _updateTimers, updateTimers_fn).call(this);
+    }
+  }
+}, _client2 = new WeakMap(), _currentQuery = new WeakMap(), _currentQueryInitialState = new WeakMap(), _currentResult = new WeakMap(), _currentResultState = new WeakMap(), _currentResultOptions = new WeakMap(), _currentThenable = new WeakMap(), _selectError = new WeakMap(), _selectFn = new WeakMap(), _selectResult = new WeakMap(), _lastQueryWithDefinedData = new WeakMap(), _staleTimeoutId = new WeakMap(), _refetchIntervalId = new WeakMap(), _currentRefetchInterval = new WeakMap(), _trackedProps = new WeakMap(), _executeFetch = new WeakSet(), executeFetch_fn = function(fetchOptions) {
+  __privateMethod(this, _updateQuery, updateQuery_fn).call(this);
+  let promise = __privateGet(this, _currentQuery).fetch(
+    this.options,
+    fetchOptions
+  );
+  if (!(fetchOptions == null ? void 0 : fetchOptions.throwOnError)) {
+    promise = promise.catch(noop);
+  }
+  return promise;
+}, _updateStaleTimeout = new WeakSet(), updateStaleTimeout_fn = function() {
+  __privateMethod(this, _clearStaleTimeout, clearStaleTimeout_fn).call(this);
+  const staleTime = resolveStaleTime(
+    this.options.staleTime,
+    __privateGet(this, _currentQuery)
+  );
+  if (environmentManager.isServer() || __privateGet(this, _currentResult).isStale || !isValidTimeout(staleTime)) {
+    return;
+  }
+  const time = timeUntilStale(__privateGet(this, _currentResult).dataUpdatedAt, staleTime);
+  const timeout = time + 1;
+  __privateSet(this, _staleTimeoutId, timeoutManager.setTimeout(() => {
+    if (!__privateGet(this, _currentResult).isStale) {
+      this.updateResult();
+    }
+  }, timeout));
+}, _computeRefetchInterval = new WeakSet(), computeRefetchInterval_fn = function() {
+  var _a11;
+  return (_a11 = typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(__privateGet(this, _currentQuery)) : this.options.refetchInterval) != null ? _a11 : false;
+}, _updateRefetchInterval = new WeakSet(), updateRefetchInterval_fn = function(nextInterval) {
+  __privateMethod(this, _clearRefetchInterval, clearRefetchInterval_fn).call(this);
+  __privateSet(this, _currentRefetchInterval, nextInterval);
+  if (environmentManager.isServer() || resolveEnabled(this.options.enabled, __privateGet(this, _currentQuery)) === false || !isValidTimeout(__privateGet(this, _currentRefetchInterval)) || __privateGet(this, _currentRefetchInterval) === 0) {
+    return;
+  }
+  __privateSet(this, _refetchIntervalId, timeoutManager.setInterval(() => {
+    if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
+      __privateMethod(this, _executeFetch, executeFetch_fn).call(this);
+    }
+  }, __privateGet(this, _currentRefetchInterval)));
+}, _updateTimers = new WeakSet(), updateTimers_fn = function() {
+  __privateMethod(this, _updateStaleTimeout, updateStaleTimeout_fn).call(this);
+  __privateMethod(this, _updateRefetchInterval, updateRefetchInterval_fn).call(this, __privateMethod(this, _computeRefetchInterval, computeRefetchInterval_fn).call(this));
+}, _clearStaleTimeout = new WeakSet(), clearStaleTimeout_fn = function() {
+  if (__privateGet(this, _staleTimeoutId)) {
+    timeoutManager.clearTimeout(__privateGet(this, _staleTimeoutId));
+    __privateSet(this, _staleTimeoutId, void 0);
+  }
+}, _clearRefetchInterval = new WeakSet(), clearRefetchInterval_fn = function() {
+  if (__privateGet(this, _refetchIntervalId)) {
+    timeoutManager.clearInterval(__privateGet(this, _refetchIntervalId));
+    __privateSet(this, _refetchIntervalId, void 0);
+  }
+}, _updateQuery = new WeakSet(), updateQuery_fn = function() {
+  const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), this.options);
+  if (query === __privateGet(this, _currentQuery)) {
+    return;
+  }
+  const prevQuery = __privateGet(this, _currentQuery);
+  __privateSet(this, _currentQuery, query);
+  __privateSet(this, _currentQueryInitialState, query.state);
+  if (this.hasListeners()) {
+    prevQuery == null ? void 0 : prevQuery.removeObserver(this);
+    query.addObserver(this);
+  }
+}, _notify = new WeakSet(), notify_fn = function(notifyOptions) {
+  notifyManager.batch(() => {
+    if (notifyOptions.listeners) {
+      this.listeners.forEach((listener) => {
+        listener(__privateGet(this, _currentResult));
+      });
+    }
+    __privateGet(this, _client2).getQueryCache().notify({
+      query: __privateGet(this, _currentQuery),
+      type: "observerResultsUpdated"
+    });
+  });
+}, _b);
+function shouldLoadOnMount(query, options) {
+  return resolveEnabled(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false);
+}
+function shouldFetchOnMount(query, options) {
+  return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
+}
+function shouldFetchOn(query, options, field) {
+  if (resolveEnabled(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
+    const value = typeof field === "function" ? field(query) : field;
+    return value === "always" || value !== false && isStale(query, options);
+  }
+  return false;
+}
+function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
+  return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
+}
+function isStale(query, options) {
+  return resolveEnabled(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
+}
+function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
+  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
+    return true;
+  }
+  return false;
+}
+
+// node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js
+init_dirname();
+init_buffer();
+init_process();
+function infiniteQueryBehavior(pages) {
+  return {
+    onFetch: (context, query) => {
+      var _a11, _b2, _c, _d, _e;
+      const options = context.options;
+      const direction = (_c = (_b2 = (_a11 = context.fetchOptions) == null ? void 0 : _a11.meta) == null ? void 0 : _b2.fetchMore) == null ? void 0 : _c.direction;
+      const oldPages = ((_d = context.state.data) == null ? void 0 : _d.pages) || [];
+      const oldPageParams = ((_e = context.state.data) == null ? void 0 : _e.pageParams) || [];
+      let result = { pages: [], pageParams: [] };
+      let currentPage = 0;
+      const fetchFn = async () => {
+        var _a12;
+        let cancelled = false;
+        const addSignalProperty = (object) => {
+          addConsumeAwareSignal(
+            object,
+            () => context.signal,
+            () => cancelled = true
+          );
+        };
+        const queryFn = ensureQueryFn(context.options, context.fetchOptions);
+        const fetchPage = async (data, param, previous) => {
+          if (cancelled) {
+            return Promise.reject();
+          }
+          if (param == null && data.pages.length) {
+            return Promise.resolve(data);
+          }
+          const createQueryFnContext = () => {
+            const queryFnContext2 = {
+              client: context.client,
+              queryKey: context.queryKey,
+              pageParam: param,
+              direction: previous ? "backward" : "forward",
+              meta: context.options.meta
+            };
+            addSignalProperty(queryFnContext2);
+            return queryFnContext2;
+          };
+          const queryFnContext = createQueryFnContext();
+          const page = await queryFn(queryFnContext);
+          const { maxPages } = context.options;
+          const addTo = previous ? addToStart : addToEnd;
+          return {
+            pages: addTo(data.pages, page, maxPages),
+            pageParams: addTo(data.pageParams, param, maxPages)
+          };
+        };
+        if (direction && oldPages.length) {
+          const previous = direction === "backward";
+          const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
+          const oldData = {
+            pages: oldPages,
+            pageParams: oldPageParams
+          };
+          const param = pageParamFn(options, oldData);
+          result = await fetchPage(oldData, param, previous);
+        } else {
+          const remainingPages = pages != null ? pages : oldPages.length;
+          do {
+            const param = currentPage === 0 ? (_a12 = oldPageParams[0]) != null ? _a12 : options.initialPageParam : getNextPageParam(options, result);
+            if (currentPage > 0 && param == null) {
+              break;
+            }
+            result = await fetchPage(result, param);
+            currentPage++;
+          } while (currentPage < remainingPages);
+        }
+        return result;
+      };
+      if (context.options.persister) {
+        context.fetchFn = () => {
+          var _a12, _b3;
+          return (_b3 = (_a12 = context.options).persister) == null ? void 0 : _b3.call(
+            _a12,
+            fetchFn,
+            {
+              client: context.client,
+              queryKey: context.queryKey,
+              meta: context.options.meta,
+              signal: context.signal
+            },
+            query
+          );
+        };
+      } else {
+        context.fetchFn = fetchFn;
+      }
+    }
+  };
+}
+function getNextPageParam(options, { pages, pageParams }) {
+  const lastIndex = pages.length - 1;
+  return pages.length > 0 ? options.getNextPageParam(
+    pages[lastIndex],
+    pages,
+    pageParams[lastIndex],
+    pageParams
+  ) : void 0;
+}
+function getPreviousPageParam(options, { pages, pageParams }) {
+  var _a11;
+  return pages.length > 0 ? (_a11 = options.getPreviousPageParam) == null ? void 0 : _a11.call(options, pages[0], pages, pageParams[0], pageParams) : void 0;
+}
+
+// node_modules/@tanstack/query-core/build/modern/mutationCache.js
+init_dirname();
+init_buffer();
+init_process();
+
+// node_modules/@tanstack/query-core/build/modern/mutation.js
+init_dirname();
+init_buffer();
+init_process();
+var _client3, _observers, _mutationCache, _retryer2, _dispatch2, dispatch_fn2, _a6;
+var Mutation = (_a6 = class extends Removable {
+  constructor(config) {
+    super();
+    __privateAdd(this, _dispatch2);
+    __privateAdd(this, _client3, void 0);
+    __privateAdd(this, _observers, void 0);
+    __privateAdd(this, _mutationCache, void 0);
+    __privateAdd(this, _retryer2, void 0);
+    __privateSet(this, _client3, config.client);
+    this.mutationId = config.mutationId;
+    __privateSet(this, _mutationCache, config.mutationCache);
+    __privateSet(this, _observers, []);
+    this.state = config.state || getDefaultState2();
+    this.setOptions(config.options);
+    this.scheduleGc();
+  }
+  setOptions(options) {
+    this.options = options;
+    this.updateGcTime(this.options.gcTime);
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  addObserver(observer) {
+    if (!__privateGet(this, _observers).includes(observer)) {
+      __privateGet(this, _observers).push(observer);
+      this.clearGcTimeout();
+      __privateGet(this, _mutationCache).notify({
+        type: "observerAdded",
+        mutation: this,
+        observer
+      });
+    }
+  }
+  removeObserver(observer) {
+    __privateSet(this, _observers, __privateGet(this, _observers).filter((x) => x !== observer));
+    this.scheduleGc();
+    __privateGet(this, _mutationCache).notify({
+      type: "observerRemoved",
+      mutation: this,
+      observer
+    });
+  }
+  optionalRemove() {
+    if (!__privateGet(this, _observers).length) {
+      if (this.state.status === "pending") {
+        this.scheduleGc();
+      } else {
+        __privateGet(this, _mutationCache).remove(this);
+      }
+    }
+  }
+  continue() {
+    var _a11, _b2;
+    return (_b2 = (_a11 = __privateGet(this, _retryer2)) == null ? void 0 : _a11.continue()) != null ? _b2 : (
+      // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
+      this.execute(this.state.variables)
+    );
+  }
+  async execute(variables) {
+    var _a11, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
+    const onContinue = () => {
+      __privateMethod(this, _dispatch2, dispatch_fn2).call(this, { type: "continue" });
+    };
+    const mutationFnContext = {
+      client: __privateGet(this, _client3),
+      meta: this.options.meta,
+      mutationKey: this.options.mutationKey
+    };
+    __privateSet(this, _retryer2, createRetryer({
+      fn: () => {
+        if (!this.options.mutationFn) {
+          return Promise.reject(new Error("No mutationFn found"));
+        }
+        return this.options.mutationFn(variables, mutationFnContext);
+      },
+      onFail: (failureCount, error) => {
+        __privateMethod(this, _dispatch2, dispatch_fn2).call(this, { type: "failed", failureCount, error });
+      },
+      onPause: () => {
+        __privateMethod(this, _dispatch2, dispatch_fn2).call(this, { type: "pause" });
+      },
+      onContinue,
+      retry: (_a11 = this.options.retry) != null ? _a11 : 0,
+      retryDelay: this.options.retryDelay,
+      networkMode: this.options.networkMode,
+      canRun: () => __privateGet(this, _mutationCache).canRun(this)
+    }));
+    const restored = this.state.status === "pending";
+    const isPaused = !__privateGet(this, _retryer2).canStart();
+    try {
+      if (restored) {
+        onContinue();
+      } else {
+        __privateMethod(this, _dispatch2, dispatch_fn2).call(this, { type: "pending", variables, isPaused });
+        if (__privateGet(this, _mutationCache).config.onMutate) {
+          await __privateGet(this, _mutationCache).config.onMutate(
+            variables,
+            this,
+            mutationFnContext
+          );
+        }
+        const context = await ((_c = (_b2 = this.options).onMutate) == null ? void 0 : _c.call(
+          _b2,
+          variables,
+          mutationFnContext
+        ));
+        if (context !== this.state.context) {
+          __privateMethod(this, _dispatch2, dispatch_fn2).call(this, {
+            type: "pending",
+            context,
+            variables,
+            isPaused
+          });
+        }
+      }
+      const data = await __privateGet(this, _retryer2).start();
+      await ((_e = (_d = __privateGet(this, _mutationCache).config).onSuccess) == null ? void 0 : _e.call(
+        _d,
+        data,
+        variables,
+        this.state.context,
+        this,
+        mutationFnContext
+      ));
+      await ((_g = (_f = this.options).onSuccess) == null ? void 0 : _g.call(
+        _f,
+        data,
+        variables,
+        this.state.context,
+        mutationFnContext
+      ));
+      await ((_i = (_h = __privateGet(this, _mutationCache).config).onSettled) == null ? void 0 : _i.call(
+        _h,
+        data,
+        null,
+        this.state.variables,
+        this.state.context,
+        this,
+        mutationFnContext
+      ));
+      await ((_k = (_j = this.options).onSettled) == null ? void 0 : _k.call(
+        _j,
+        data,
+        null,
+        variables,
+        this.state.context,
+        mutationFnContext
+      ));
+      __privateMethod(this, _dispatch2, dispatch_fn2).call(this, { type: "success", data });
+      return data;
+    } catch (error) {
+      try {
+        await ((_m = (_l = __privateGet(this, _mutationCache).config).onError) == null ? void 0 : _m.call(
+          _l,
+          error,
+          variables,
+          this.state.context,
+          this,
+          mutationFnContext
+        ));
+      } catch (e) {
+        void Promise.reject(e);
+      }
+      try {
+        await ((_o = (_n = this.options).onError) == null ? void 0 : _o.call(
+          _n,
+          error,
+          variables,
+          this.state.context,
+          mutationFnContext
+        ));
+      } catch (e) {
+        void Promise.reject(e);
+      }
+      try {
+        await ((_q = (_p = __privateGet(this, _mutationCache).config).onSettled) == null ? void 0 : _q.call(
+          _p,
+          void 0,
+          error,
+          this.state.variables,
+          this.state.context,
+          this,
+          mutationFnContext
+        ));
+      } catch (e) {
+        void Promise.reject(e);
+      }
+      try {
+        await ((_s = (_r = this.options).onSettled) == null ? void 0 : _s.call(
+          _r,
+          void 0,
+          error,
+          variables,
+          this.state.context,
+          mutationFnContext
+        ));
+      } catch (e) {
+        void Promise.reject(e);
+      }
+      __privateMethod(this, _dispatch2, dispatch_fn2).call(this, { type: "error", error });
+      throw error;
+    } finally {
+      __privateGet(this, _mutationCache).runNext(this);
+    }
+  }
+}, _client3 = new WeakMap(), _observers = new WeakMap(), _mutationCache = new WeakMap(), _retryer2 = new WeakMap(), _dispatch2 = new WeakSet(), dispatch_fn2 = function(action) {
+  const reducer = (state) => {
+    switch (action.type) {
+      case "failed":
+        return __spreadProps(__spreadValues({}, state), {
+          failureCount: action.failureCount,
+          failureReason: action.error
+        });
+      case "pause":
+        return __spreadProps(__spreadValues({}, state), {
+          isPaused: true
+        });
+      case "continue":
+        return __spreadProps(__spreadValues({}, state), {
+          isPaused: false
+        });
+      case "pending":
+        return __spreadProps(__spreadValues({}, state), {
+          context: action.context,
+          data: void 0,
+          failureCount: 0,
+          failureReason: null,
+          error: null,
+          isPaused: action.isPaused,
+          status: "pending",
+          variables: action.variables,
+          submittedAt: Date.now()
+        });
+      case "success":
+        return __spreadProps(__spreadValues({}, state), {
+          data: action.data,
+          failureCount: 0,
+          failureReason: null,
+          error: null,
+          status: "success",
+          isPaused: false
+        });
+      case "error":
+        return __spreadProps(__spreadValues({}, state), {
+          data: void 0,
+          error: action.error,
+          failureCount: state.failureCount + 1,
+          failureReason: action.error,
+          isPaused: false,
+          status: "error"
+        });
+    }
+  };
+  this.state = reducer(this.state);
+  notifyManager.batch(() => {
+    __privateGet(this, _observers).forEach((observer) => {
+      observer.onMutationUpdate(action);
+    });
+    __privateGet(this, _mutationCache).notify({
+      mutation: this,
+      type: "updated",
+      action
+    });
+  });
+}, _a6);
+function getDefaultState2() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: false,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+
+// node_modules/@tanstack/query-core/build/modern/mutationCache.js
+var _mutations, _scopes, _mutationId, _a7;
+var MutationCache = (_a7 = class extends Subscribable {
+  constructor(config = {}) {
+    super();
+    __privateAdd(this, _mutations, void 0);
+    __privateAdd(this, _scopes, void 0);
+    __privateAdd(this, _mutationId, void 0);
+    this.config = config;
+    __privateSet(this, _mutations, /* @__PURE__ */ new Set());
+    __privateSet(this, _scopes, /* @__PURE__ */ new Map());
+    __privateSet(this, _mutationId, 0);
+  }
+  build(client, options, state) {
+    const mutation = new Mutation({
+      client,
+      mutationCache: this,
+      mutationId: ++__privateWrapper(this, _mutationId)._,
+      options: client.defaultMutationOptions(options),
+      state
+    });
+    this.add(mutation);
+    return mutation;
+  }
+  add(mutation) {
+    __privateGet(this, _mutations).add(mutation);
+    const scope = scopeFor(mutation);
+    if (typeof scope === "string") {
+      const scopedMutations = __privateGet(this, _scopes).get(scope);
+      if (scopedMutations) {
+        scopedMutations.push(mutation);
+      } else {
+        __privateGet(this, _scopes).set(scope, [mutation]);
+      }
+    }
+    this.notify({ type: "added", mutation });
+  }
+  remove(mutation) {
+    if (__privateGet(this, _mutations).delete(mutation)) {
+      const scope = scopeFor(mutation);
+      if (typeof scope === "string") {
+        const scopedMutations = __privateGet(this, _scopes).get(scope);
+        if (scopedMutations) {
+          if (scopedMutations.length > 1) {
+            const index = scopedMutations.indexOf(mutation);
+            if (index !== -1) {
+              scopedMutations.splice(index, 1);
+            }
+          } else if (scopedMutations[0] === mutation) {
+            __privateGet(this, _scopes).delete(scope);
+          }
+        }
+      }
+    }
+    this.notify({ type: "removed", mutation });
+  }
+  canRun(mutation) {
+    const scope = scopeFor(mutation);
+    if (typeof scope === "string") {
+      const mutationsWithSameScope = __privateGet(this, _scopes).get(scope);
+      const firstPendingMutation = mutationsWithSameScope == null ? void 0 : mutationsWithSameScope.find(
+        (m) => m.state.status === "pending"
+      );
+      return !firstPendingMutation || firstPendingMutation === mutation;
+    } else {
+      return true;
+    }
+  }
+  runNext(mutation) {
+    var _a11, _b2;
+    const scope = scopeFor(mutation);
+    if (typeof scope === "string") {
+      const foundMutation = (_a11 = __privateGet(this, _scopes).get(scope)) == null ? void 0 : _a11.find((m) => m !== mutation && m.state.isPaused);
+      return (_b2 = foundMutation == null ? void 0 : foundMutation.continue()) != null ? _b2 : Promise.resolve();
+    } else {
+      return Promise.resolve();
+    }
+  }
+  clear() {
+    notifyManager.batch(() => {
+      __privateGet(this, _mutations).forEach((mutation) => {
+        this.notify({ type: "removed", mutation });
+      });
+      __privateGet(this, _mutations).clear();
+      __privateGet(this, _scopes).clear();
+    });
+  }
+  getAll() {
+    return Array.from(__privateGet(this, _mutations));
+  }
+  find(filters) {
+    const defaultedFilters = __spreadValues({ exact: true }, filters);
+    return this.getAll().find(
+      (mutation) => matchMutation(defaultedFilters, mutation)
+    );
+  }
+  findAll(filters = {}) {
+    return this.getAll().filter((mutation) => matchMutation(filters, mutation));
+  }
+  notify(event) {
+    notifyManager.batch(() => {
+      this.listeners.forEach((listener) => {
+        listener(event);
+      });
+    });
+  }
+  resumePausedMutations() {
+    const pausedMutations = this.getAll().filter((x) => x.state.isPaused);
+    return notifyManager.batch(
+      () => Promise.all(
+        pausedMutations.map((mutation) => mutation.continue().catch(noop))
+      )
+    );
+  }
+}, _mutations = new WeakMap(), _scopes = new WeakMap(), _mutationId = new WeakMap(), _a7);
+function scopeFor(mutation) {
+  var _a11;
+  return (_a11 = mutation.options.scope) == null ? void 0 : _a11.id;
+}
+
+// node_modules/@tanstack/query-core/build/modern/mutationObserver.js
+init_dirname();
+init_buffer();
+init_process();
+var _client4, _currentResult2, _currentMutation, _mutateOptions, _updateResult, updateResult_fn, _notify2, notify_fn2, _a8;
+var MutationObserver = (_a8 = class extends Subscribable {
+  constructor(client, options) {
+    super();
+    __privateAdd(this, _updateResult);
+    __privateAdd(this, _notify2);
+    __privateAdd(this, _client4, void 0);
+    __privateAdd(this, _currentResult2, void 0);
+    __privateAdd(this, _currentMutation, void 0);
+    __privateAdd(this, _mutateOptions, void 0);
+    __privateSet(this, _client4, client);
+    this.setOptions(options);
+    this.bindMethods();
+    __privateMethod(this, _updateResult, updateResult_fn).call(this);
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this);
+    this.reset = this.reset.bind(this);
+  }
+  setOptions(options) {
+    var _a11;
+    const prevOptions = this.options;
+    this.options = __privateGet(this, _client4).defaultMutationOptions(options);
+    if (!shallowEqualObjects(this.options, prevOptions)) {
+      __privateGet(this, _client4).getMutationCache().notify({
+        type: "observerOptionsUpdated",
+        mutation: __privateGet(this, _currentMutation),
+        observer: this
+      });
+    }
+    if ((prevOptions == null ? void 0 : prevOptions.mutationKey) && this.options.mutationKey && hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)) {
+      this.reset();
+    } else if (((_a11 = __privateGet(this, _currentMutation)) == null ? void 0 : _a11.state.status) === "pending") {
+      __privateGet(this, _currentMutation).setOptions(this.options);
+    }
+  }
+  onUnsubscribe() {
+    var _a11;
+    if (!this.hasListeners()) {
+      (_a11 = __privateGet(this, _currentMutation)) == null ? void 0 : _a11.removeObserver(this);
+    }
+  }
+  onMutationUpdate(action) {
+    __privateMethod(this, _updateResult, updateResult_fn).call(this);
+    __privateMethod(this, _notify2, notify_fn2).call(this, action);
+  }
+  getCurrentResult() {
+    return __privateGet(this, _currentResult2);
+  }
+  reset() {
+    var _a11;
+    (_a11 = __privateGet(this, _currentMutation)) == null ? void 0 : _a11.removeObserver(this);
+    __privateSet(this, _currentMutation, void 0);
+    __privateMethod(this, _updateResult, updateResult_fn).call(this);
+    __privateMethod(this, _notify2, notify_fn2).call(this);
+  }
+  mutate(variables, options) {
+    var _a11;
+    __privateSet(this, _mutateOptions, options);
+    (_a11 = __privateGet(this, _currentMutation)) == null ? void 0 : _a11.removeObserver(this);
+    __privateSet(this, _currentMutation, __privateGet(this, _client4).getMutationCache().build(__privateGet(this, _client4), this.options));
+    __privateGet(this, _currentMutation).addObserver(this);
+    return __privateGet(this, _currentMutation).execute(variables);
+  }
+}, _client4 = new WeakMap(), _currentResult2 = new WeakMap(), _currentMutation = new WeakMap(), _mutateOptions = new WeakMap(), _updateResult = new WeakSet(), updateResult_fn = function() {
+  var _a11, _b2;
+  const state = (_b2 = (_a11 = __privateGet(this, _currentMutation)) == null ? void 0 : _a11.state) != null ? _b2 : getDefaultState2();
+  __privateSet(this, _currentResult2, __spreadProps(__spreadValues({}, state), {
+    isPending: state.status === "pending",
+    isSuccess: state.status === "success",
+    isError: state.status === "error",
+    isIdle: state.status === "idle",
+    mutate: this.mutate,
+    reset: this.reset
+  }));
+}, _notify2 = new WeakSet(), notify_fn2 = function(action) {
+  notifyManager.batch(() => {
+    var _a11, _b2, _c, _d, _e, _f, _g, _h;
+    if (__privateGet(this, _mutateOptions) && this.hasListeners()) {
+      const variables = __privateGet(this, _currentResult2).variables;
+      const onMutateResult = __privateGet(this, _currentResult2).context;
+      const context = {
+        client: __privateGet(this, _client4),
+        meta: this.options.meta,
+        mutationKey: this.options.mutationKey
+      };
+      if ((action == null ? void 0 : action.type) === "success") {
+        try {
+          (_b2 = (_a11 = __privateGet(this, _mutateOptions)).onSuccess) == null ? void 0 : _b2.call(
+            _a11,
+            action.data,
+            variables,
+            onMutateResult,
+            context
+          );
+        } catch (e) {
+          void Promise.reject(e);
+        }
+        try {
+          (_d = (_c = __privateGet(this, _mutateOptions)).onSettled) == null ? void 0 : _d.call(
+            _c,
+            action.data,
+            null,
+            variables,
+            onMutateResult,
+            context
+          );
+        } catch (e) {
+          void Promise.reject(e);
+        }
+      } else if ((action == null ? void 0 : action.type) === "error") {
+        try {
+          (_f = (_e = __privateGet(this, _mutateOptions)).onError) == null ? void 0 : _f.call(
+            _e,
+            action.error,
+            variables,
+            onMutateResult,
+            context
+          );
+        } catch (e) {
+          void Promise.reject(e);
+        }
+        try {
+          (_h = (_g = __privateGet(this, _mutateOptions)).onSettled) == null ? void 0 : _h.call(
+            _g,
+            void 0,
+            action.error,
+            variables,
+            onMutateResult,
+            context
+          );
+        } catch (e) {
+          void Promise.reject(e);
+        }
+      }
+    }
+    this.listeners.forEach((listener) => {
+      listener(__privateGet(this, _currentResult2));
+    });
+  });
+}, _a8);
+
+// node_modules/@tanstack/query-core/build/modern/queryCache.js
+init_dirname();
+init_buffer();
+init_process();
+var _queries, _a9;
+var QueryCache = (_a9 = class extends Subscribable {
+  constructor(config = {}) {
+    super();
+    __privateAdd(this, _queries, void 0);
+    this.config = config;
+    __privateSet(this, _queries, /* @__PURE__ */ new Map());
+  }
+  build(client, options, state) {
+    var _a11;
+    const queryKey = options.queryKey;
+    const queryHash = (_a11 = options.queryHash) != null ? _a11 : hashQueryKeyByOptions(queryKey, options);
+    let query = this.get(queryHash);
+    if (!query) {
+      query = new Query({
+        client,
+        queryKey,
+        queryHash,
+        options: client.defaultQueryOptions(options),
+        state,
+        defaultOptions: client.getQueryDefaults(queryKey)
+      });
+      this.add(query);
+    }
+    return query;
+  }
+  add(query) {
+    if (!__privateGet(this, _queries).has(query.queryHash)) {
+      __privateGet(this, _queries).set(query.queryHash, query);
+      this.notify({
+        type: "added",
+        query
+      });
+    }
+  }
+  remove(query) {
+    const queryInMap = __privateGet(this, _queries).get(query.queryHash);
+    if (queryInMap) {
+      query.destroy();
+      if (queryInMap === query) {
+        __privateGet(this, _queries).delete(query.queryHash);
+      }
+      this.notify({ type: "removed", query });
+    }
+  }
+  clear() {
+    notifyManager.batch(() => {
+      this.getAll().forEach((query) => {
+        this.remove(query);
+      });
+    });
+  }
+  get(queryHash) {
+    return __privateGet(this, _queries).get(queryHash);
+  }
+  getAll() {
+    return [...__privateGet(this, _queries).values()];
+  }
+  find(filters) {
+    const defaultedFilters = __spreadValues({ exact: true }, filters);
+    return this.getAll().find(
+      (query) => matchQuery(defaultedFilters, query)
+    );
+  }
+  findAll(filters = {}) {
+    const queries = this.getAll();
+    return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries;
+  }
+  notify(event) {
+    notifyManager.batch(() => {
+      this.listeners.forEach((listener) => {
+        listener(event);
+      });
+    });
+  }
+  onFocus() {
+    notifyManager.batch(() => {
+      this.getAll().forEach((query) => {
+        query.onFocus();
+      });
+    });
+  }
+  onOnline() {
+    notifyManager.batch(() => {
+      this.getAll().forEach((query) => {
+        query.onOnline();
+      });
+    });
+  }
+}, _queries = new WeakMap(), _a9);
+
+// node_modules/@tanstack/query-core/build/modern/queryClient.js
+init_dirname();
+init_buffer();
+init_process();
+var _queryCache, _mutationCache2, _defaultOptions2, _queryDefaults, _mutationDefaults, _mountCount, _unsubscribeFocus, _unsubscribeOnline, _a10;
+var QueryClient = (_a10 = class {
+  constructor(config = {}) {
+    __privateAdd(this, _queryCache, void 0);
+    __privateAdd(this, _mutationCache2, void 0);
+    __privateAdd(this, _defaultOptions2, void 0);
+    __privateAdd(this, _queryDefaults, void 0);
+    __privateAdd(this, _mutationDefaults, void 0);
+    __privateAdd(this, _mountCount, void 0);
+    __privateAdd(this, _unsubscribeFocus, void 0);
+    __privateAdd(this, _unsubscribeOnline, void 0);
+    __privateSet(this, _queryCache, config.queryCache || new QueryCache());
+    __privateSet(this, _mutationCache2, config.mutationCache || new MutationCache());
+    __privateSet(this, _defaultOptions2, config.defaultOptions || {});
+    __privateSet(this, _queryDefaults, /* @__PURE__ */ new Map());
+    __privateSet(this, _mutationDefaults, /* @__PURE__ */ new Map());
+    __privateSet(this, _mountCount, 0);
+  }
+  mount() {
+    __privateWrapper(this, _mountCount)._++;
+    if (__privateGet(this, _mountCount) !== 1)
+      return;
+    __privateSet(this, _unsubscribeFocus, focusManager.subscribe(async (focused) => {
+      if (focused) {
+        await this.resumePausedMutations();
+        __privateGet(this, _queryCache).onFocus();
+      }
+    }));
+    __privateSet(this, _unsubscribeOnline, onlineManager.subscribe(async (online) => {
+      if (online) {
+        await this.resumePausedMutations();
+        __privateGet(this, _queryCache).onOnline();
+      }
+    }));
+  }
+  unmount() {
+    var _a11, _b2;
+    __privateWrapper(this, _mountCount)._--;
+    if (__privateGet(this, _mountCount) !== 0)
+      return;
+    (_a11 = __privateGet(this, _unsubscribeFocus)) == null ? void 0 : _a11.call(this);
+    __privateSet(this, _unsubscribeFocus, void 0);
+    (_b2 = __privateGet(this, _unsubscribeOnline)) == null ? void 0 : _b2.call(this);
+    __privateSet(this, _unsubscribeOnline, void 0);
+  }
+  isFetching(filters) {
+    return __privateGet(this, _queryCache).findAll(__spreadProps(__spreadValues({}, filters), { fetchStatus: "fetching" })).length;
+  }
+  isMutating(filters) {
+    return __privateGet(this, _mutationCache2).findAll(__spreadProps(__spreadValues({}, filters), { status: "pending" })).length;
+  }
+  /**
+   * Imperative (non-reactive) way to retrieve data for a QueryKey.
+   * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
+   *
+   * Hint: Do not use this function inside a component, because it won't receive updates.
+   * Use `useQuery` to create a `QueryObserver` that subscribes to changes.
+   */
+  getQueryData(queryKey) {
+    var _a11;
+    const options = this.defaultQueryOptions({ queryKey });
+    return (_a11 = __privateGet(this, _queryCache).get(options.queryHash)) == null ? void 0 : _a11.state.data;
+  }
+  ensureQueryData(options) {
+    const defaultedOptions = this.defaultQueryOptions(options);
+    const query = __privateGet(this, _queryCache).build(this, defaultedOptions);
+    const cachedData = query.state.data;
+    if (cachedData === void 0) {
+      return this.fetchQuery(options);
+    }
+    if (options.revalidateIfStale && query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))) {
+      void this.prefetchQuery(defaultedOptions);
+    }
+    return Promise.resolve(cachedData);
+  }
+  getQueriesData(filters) {
+    return __privateGet(this, _queryCache).findAll(filters).map(({ queryKey, state }) => {
+      const data = state.data;
+      return [queryKey, data];
+    });
+  }
+  setQueryData(queryKey, updater, options) {
+    const defaultedOptions = this.defaultQueryOptions({ queryKey });
+    const query = __privateGet(this, _queryCache).get(
+      defaultedOptions.queryHash
+    );
+    const prevData = query == null ? void 0 : query.state.data;
+    const data = functionalUpdate(updater, prevData);
+    if (data === void 0) {
+      return void 0;
+    }
+    return __privateGet(this, _queryCache).build(this, defaultedOptions).setData(data, __spreadProps(__spreadValues({}, options), { manual: true }));
+  }
+  setQueriesData(filters, updater, options) {
+    return notifyManager.batch(
+      () => __privateGet(this, _queryCache).findAll(filters).map(({ queryKey }) => [
+        queryKey,
+        this.setQueryData(queryKey, updater, options)
+      ])
+    );
+  }
+  getQueryState(queryKey) {
+    var _a11;
+    const options = this.defaultQueryOptions({ queryKey });
+    return (_a11 = __privateGet(this, _queryCache).get(
+      options.queryHash
+    )) == null ? void 0 : _a11.state;
+  }
+  removeQueries(filters) {
+    const queryCache = __privateGet(this, _queryCache);
+    notifyManager.batch(() => {
+      queryCache.findAll(filters).forEach((query) => {
+        queryCache.remove(query);
+      });
+    });
+  }
+  resetQueries(filters, options) {
+    const queryCache = __privateGet(this, _queryCache);
+    return notifyManager.batch(() => {
+      queryCache.findAll(filters).forEach((query) => {
+        query.reset();
+      });
+      return this.refetchQueries(
+        __spreadValues({
+          type: "active"
+        }, filters),
+        options
+      );
+    });
+  }
+  cancelQueries(filters, cancelOptions = {}) {
+    const defaultedCancelOptions = __spreadValues({ revert: true }, cancelOptions);
+    const promises = notifyManager.batch(
+      () => __privateGet(this, _queryCache).findAll(filters).map((query) => query.cancel(defaultedCancelOptions))
+    );
+    return Promise.all(promises).then(noop).catch(noop);
+  }
+  invalidateQueries(filters, options = {}) {
+    return notifyManager.batch(() => {
+      var _a11, _b2;
+      __privateGet(this, _queryCache).findAll(filters).forEach((query) => {
+        query.invalidate();
+      });
+      if ((filters == null ? void 0 : filters.refetchType) === "none") {
+        return Promise.resolve();
+      }
+      return this.refetchQueries(
+        __spreadProps(__spreadValues({}, filters), {
+          type: (_b2 = (_a11 = filters == null ? void 0 : filters.refetchType) != null ? _a11 : filters == null ? void 0 : filters.type) != null ? _b2 : "active"
+        }),
+        options
+      );
+    });
+  }
+  refetchQueries(filters, options = {}) {
+    var _a11;
+    const fetchOptions = __spreadProps(__spreadValues({}, options), {
+      cancelRefetch: (_a11 = options.cancelRefetch) != null ? _a11 : true
+    });
+    const promises = notifyManager.batch(
+      () => __privateGet(this, _queryCache).findAll(filters).filter((query) => !query.isDisabled() && !query.isStatic()).map((query) => {
+        let promise = query.fetch(void 0, fetchOptions);
+        if (!fetchOptions.throwOnError) {
+          promise = promise.catch(noop);
+        }
+        return query.state.fetchStatus === "paused" ? Promise.resolve() : promise;
+      })
+    );
+    return Promise.all(promises).then(noop);
+  }
+  fetchQuery(options) {
+    const defaultedOptions = this.defaultQueryOptions(options);
+    if (defaultedOptions.retry === void 0) {
+      defaultedOptions.retry = false;
+    }
+    const query = __privateGet(this, _queryCache).build(this, defaultedOptions);
+    return query.isStaleByTime(
+      resolveStaleTime(defaultedOptions.staleTime, query)
+    ) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
+  }
+  prefetchQuery(options) {
+    return this.fetchQuery(options).then(noop).catch(noop);
+  }
+  fetchInfiniteQuery(options) {
+    options.behavior = infiniteQueryBehavior(options.pages);
+    return this.fetchQuery(options);
+  }
+  prefetchInfiniteQuery(options) {
+    return this.fetchInfiniteQuery(options).then(noop).catch(noop);
+  }
+  ensureInfiniteQueryData(options) {
+    options.behavior = infiniteQueryBehavior(options.pages);
+    return this.ensureQueryData(options);
+  }
+  resumePausedMutations() {
+    if (onlineManager.isOnline()) {
+      return __privateGet(this, _mutationCache2).resumePausedMutations();
+    }
+    return Promise.resolve();
+  }
+  getQueryCache() {
+    return __privateGet(this, _queryCache);
+  }
+  getMutationCache() {
+    return __privateGet(this, _mutationCache2);
+  }
+  getDefaultOptions() {
+    return __privateGet(this, _defaultOptions2);
+  }
+  setDefaultOptions(options) {
+    __privateSet(this, _defaultOptions2, options);
+  }
+  setQueryDefaults(queryKey, options) {
+    __privateGet(this, _queryDefaults).set(hashKey(queryKey), {
+      queryKey,
+      defaultOptions: options
+    });
+  }
+  getQueryDefaults(queryKey) {
+    const defaults = [...__privateGet(this, _queryDefaults).values()];
+    const result = {};
+    defaults.forEach((queryDefault) => {
+      if (partialMatchKey(queryKey, queryDefault.queryKey)) {
+        Object.assign(result, queryDefault.defaultOptions);
+      }
+    });
+    return result;
+  }
+  setMutationDefaults(mutationKey, options) {
+    __privateGet(this, _mutationDefaults).set(hashKey(mutationKey), {
+      mutationKey,
+      defaultOptions: options
+    });
+  }
+  getMutationDefaults(mutationKey) {
+    const defaults = [...__privateGet(this, _mutationDefaults).values()];
+    const result = {};
+    defaults.forEach((queryDefault) => {
+      if (partialMatchKey(mutationKey, queryDefault.mutationKey)) {
+        Object.assign(result, queryDefault.defaultOptions);
+      }
+    });
+    return result;
+  }
+  defaultQueryOptions(options) {
+    if (options._defaulted) {
+      return options;
+    }
+    const defaultedOptions = __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, __privateGet(this, _defaultOptions2).queries), this.getQueryDefaults(options.queryKey)), options), {
+      _defaulted: true
+    });
+    if (!defaultedOptions.queryHash) {
+      defaultedOptions.queryHash = hashQueryKeyByOptions(
+        defaultedOptions.queryKey,
+        defaultedOptions
+      );
+    }
+    if (defaultedOptions.refetchOnReconnect === void 0) {
+      defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== "always";
+    }
+    if (defaultedOptions.throwOnError === void 0) {
+      defaultedOptions.throwOnError = !!defaultedOptions.suspense;
+    }
+    if (!defaultedOptions.networkMode && defaultedOptions.persister) {
+      defaultedOptions.networkMode = "offlineFirst";
+    }
+    if (defaultedOptions.queryFn === skipToken) {
+      defaultedOptions.enabled = false;
+    }
+    return defaultedOptions;
+  }
+  defaultMutationOptions(options) {
+    if (options == null ? void 0 : options._defaulted) {
+      return options;
+    }
+    return __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, __privateGet(this, _defaultOptions2).mutations), (options == null ? void 0 : options.mutationKey) && this.getMutationDefaults(options.mutationKey)), options), {
+      _defaulted: true
+    });
+  }
+  clear() {
+    __privateGet(this, _queryCache).clear();
+    __privateGet(this, _mutationCache2).clear();
+  }
+}, _queryCache = new WeakMap(), _mutationCache2 = new WeakMap(), _defaultOptions2 = new WeakMap(), _queryDefaults = new WeakMap(), _mutationDefaults = new WeakMap(), _mountCount = new WeakMap(), _unsubscribeFocus = new WeakMap(), _unsubscribeOnline = new WeakMap(), _a10);
+
+// src/controllers/query.controller.ts
+var QueryController = class {
+  constructor(host, optionsFn, hostPropertyName) {
+    this.host = host;
+    this.optionsFn = optionsFn;
+    this.host.addController(this);
+    this.hostPropertyName = hostPropertyName;
+    if (this.optionsFn) {
+      this.observeQuery(this.optionsFn);
+    }
+  }
+  observeQuery(options, optimistic = true) {
+    const queryClient = this.host.queryClient;
+    const resolvedOptions = typeof options === "function" ? options() : options;
+    const defaultedOptions = queryClient.defaultQueryOptions(resolvedOptions);
+    this.queryObserver = new QueryObserver(queryClient, defaultedOptions);
+    this.result = optimistic ? this.queryObserver.getOptimisticResult(defaultedOptions) : void 0;
+    this.host.requestUpdate();
+  }
+  hostUpdate() {
+    if (!this.optionsFn || !this.queryObserver)
+      return;
+    const defaultedOptions = this.host.queryClient.defaultQueryOptions(
+      this.optionsFn()
+    );
+    this.queryObserver.setOptions(defaultedOptions);
+  }
+  hostConnected() {
+    this.subscribe();
+  }
+  async subscribe() {
+    var _a11;
+    if (!this.queryObserver) {
+      if (this.optionsFn)
+        this.observeQuery(this.optionsFn);
+      if (!this.queryObserver)
+        return;
+    }
+    (_a11 = this.unsubscribe) == null ? void 0 : _a11.call(this);
+    this.unsubscribe = this.queryObserver.subscribe(
+      (result) => {
+        this.result = result;
+        if (this.hostPropertyName) {
+          ;
+          this.host[this.hostPropertyName] = result;
+        }
+        this.host.requestUpdate();
+      }
+    );
+    this.queryObserver.updateResult();
+    this.host.requestUpdate();
+  }
+  hostDisconnected() {
+    var _a11;
+    (_a11 = this.unsubscribe) == null ? void 0 : _a11.call(this);
+    this.unsubscribe = void 0;
+  }
+};
+
+export {
+  apiClient,
+  Environments,
+  HARMONY_URLS,
+  FINAL_STATUSES,
+  ThumbnailService,
+  queryHarmonyCapabilities,
+  queryHarmonyJobs,
+  queryHarmonyJobStatus,
+  queryCreateHarmonySubsetJob,
+  queryCancelHarmonySubsetJob,
+  mutationRemoveHarmonyJobLabels,
+  dehydrate,
+  hydrate,
+  MutationObserver,
+  QueryClient,
+  QueryController
+};