fui-material 2.6.13 → 2.7.1

package/dist/f-ui-kit.es.js

@@ -1,12 +1,22 @@
+import './index.css';var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _focused, _cleanup, _setup, _a, _provider, _providerCalled, _b, _online, _cleanup2, _setup2, _c, _client, _currentQuery, _currentQueryInitialState, _currentResult, _currentResultState, _currentResultOptions, _currentThenable, _selectError, _selectFn, _selectResult, _lastQueryWithDefinedData, _staleTimeoutId, _refetchIntervalId, _currentRefetchInterval, _trackedProps, _QueryObserver_instances, executeFetch_fn, updateStaleTimeout_fn, computeRefetchInterval_fn, updateRefetchInterval_fn, updateTimers_fn, clearStaleTimeout_fn, clearRefetchInterval_fn, updateQuery_fn, notify_fn, _d, _client2, _currentResult2, _currentMutation, _mutateOptions, _MutationObserver_instances, updateResult_fn, notify_fn2, _e;
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
-import React, { forwardRef, useRef, useState, useEffect, useMemo, useCallback, useLayoutEffect, Fragment as Fragment$1, isValidElement, cloneElement, useDeferredValue } from "react";
+import * as React from "react";
+import React__default, { forwardRef, useRef, useState, useEffect, useMemo, useCallback, useLayoutEffect, Fragment as Fragment$1, isValidElement, cloneElement, useDeferredValue, createContext, useContext } from "react";
 import ReactDOM, { createPortal } from "react-dom";
 import JSZip from "jszip";
 import initializeModule from "allorion-exporting-html-to-docx";
 import { renderToStaticMarkup } from "react-dom/server";
 import { initializeModule as initializeModule$1, installFormatCode } from "allorion-exporting-html-to-xlsx";
 import axios from "axios";
-import './index.css';const btn = "_btn_ch6o3_1";
+const btn = "_btn_ch6o3_1";
 const stylesBtn = {
   btn,
   "btn-xs": "_btn-xs_ch6o3_21",
@@ -68,7 +78,7 @@ const defaultStyles = {
   "f-button-file": "_f-button-file_i2hex_1",
   "file-preview-list": "_file-preview-list_i2hex_1"
 };
-const FTrashIcon = React.forwardRef(({
+const FTrashIcon = React__default.forwardRef(({
   color = "primary",
   size = 32,
   st,
@@ -229,8 +239,8 @@ const FButtonFile = ({
         style,
         id,
         onClick: () => {
-          var _a;
-          return (_a = fileRef.current) == null ? void 0 : _a.click();
+          var _a2;
+          return (_a2 = fileRef.current) == null ? void 0 : _a2.click();
         },
         children
       }
@@ -263,7 +273,7 @@ const FButtonFile = ({
 const styles$x = {
   "f-text-field": "_f-text-field_200bb_1"
 };
-const FLoadIcon = React.forwardRef(({
+const FLoadIcon = React__default.forwardRef(({
   size = 30,
   st,
   id,
@@ -752,7 +762,7 @@ const FTableBody = ({
   ...props
 }) => {
   const tableBodyRef = useRef(null);
-  const flatChildren = useMemo(() => React.Children.toArray(children), [children]);
+  const flatChildren = useMemo(() => React__default.Children.toArray(children), [children]);
   const totalRows = flatChildren.length;
   const [startIdx, setStartIdx] = useState(0);
   const [rowHeights, setRowHeights] = useState(Array(flatChildren.length).fill(0));
@@ -783,16 +793,16 @@ const FTableBody = ({
     requestAnimationFrame(updateStartIdx);
   }, [updateStartIdx, virtualizationEnabled]);
   useEffect(() => {
-    var _a;
+    var _a2;
     if (!virtualizationEnabled) return;
     const handleResize = () => requestAnimationFrame(updateStartIdx);
     window.addEventListener("resize", handleResize);
-    (_a = tableWrapperRef == null ? void 0 : tableWrapperRef.current) == null ? void 0 : _a.addEventListener("scroll", handleScroll);
+    (_a2 = tableWrapperRef == null ? void 0 : tableWrapperRef.current) == null ? void 0 : _a2.addEventListener("scroll", handleScroll);
     handleResize();
     return () => {
-      var _a2;
+      var _a3;
       window.removeEventListener("resize", handleResize);
-      (_a2 = tableWrapperRef == null ? void 0 : tableWrapperRef.current) == null ? void 0 : _a2.removeEventListener("scroll", handleScroll);
+      (_a3 = tableWrapperRef == null ? void 0 : tableWrapperRef.current) == null ? void 0 : _a3.removeEventListener("scroll", handleScroll);
     };
   }, [handleScroll, updateStartIdx, virtualizationEnabled]);
   useLayoutEffect(() => {
@@ -832,11 +842,11 @@ const FTableBody = ({
   }
   return /* @__PURE__ */ jsxs("tbody", { ref: tableBodyRef, style: st, ...props, className: `${styles$s["f-table-component__table_body"]} ${props.className || ""}  ${styles$s[textAlignment]}`, children: [
     virtualizationEnabled && rowHeights.some((h) => h > 0) && /* @__PURE__ */ jsx("tr", { style: { height: topOffset } }),
-    visibleItems.map((child, idx) => React.isValidElement(child) ? React.cloneElement(child, { "data-row-index": virtualizationEnabled ? startIdx + idx : idx, key: virtualizationEnabled ? startIdx + idx : idx }) : child),
+    visibleItems.map((child, idx) => React__default.isValidElement(child) ? React__default.cloneElement(child, { "data-row-index": virtualizationEnabled ? startIdx + idx : idx, key: virtualizationEnabled ? startIdx + idx : idx }) : child),
     virtualizationEnabled && rowHeights.some((h) => h > 0) && /* @__PURE__ */ jsx("tr", { style: { height: bottomOffset } })
   ] });
 };
-const FTableBody$1 = React.memo(FTableBody);
+const FTableBody$1 = React__default.memo(FTableBody);
 const FTable = ({
   st,
   children,
@@ -881,10 +891,10 @@ const FTable = ({
           style: { ...st, tableLayout: layout },
           ...props,
           className: `table ${styles$s["f-table-component__table"]} ${styles$s["bordered"]} ${styles$s["bordered-half"]} ${props.className || ""}`,
-          children: React.Children.map(children, (child) => {
-            if (React.isValidElement(child) && child.type === FTableHead) {
+          children: React__default.Children.map(children, (child) => {
+            if (React__default.isValidElement(child) && child.type === FTableHead) {
               const headProps = child.props;
-              return React.cloneElement(
+              return React__default.cloneElement(
                 child,
                 {
                   ...headProps,
@@ -892,9 +902,9 @@ const FTable = ({
                 }
               );
             }
-            if (React.isValidElement(child) && child.type === FTableBody$1) {
+            if (React__default.isValidElement(child) && child.type === FTableBody$1) {
               const headProps = child.props;
-              return React.cloneElement(
+              return React__default.cloneElement(
                 child,
                 {
                   ...headProps,
@@ -1080,7 +1090,7 @@ const FDialog = ({
     document.body
   );
 };
-const FCloseIcon = React.forwardRef(({
+const FCloseIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -1425,7 +1435,7 @@ const styles$k = {
   "progress-dot": "_progress-dot_f7bma_172",
   active: active$3
 };
-const FArrowIcon = React.forwardRef(({
+const FArrowIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -1967,7 +1977,7 @@ const FSelect = forwardRef(
     );
   }
 );
-const FSelectItem = React.forwardRef(({
+const FSelectItem = React__default.forwardRef(({
   st,
   children,
   ...props
@@ -2741,7 +2751,7 @@ const FDropdown = forwardRef(({
     setIsOpen(false);
   };
   const renderChildren = () => {
-    return React.Children.map(children, (child) => {
+    return React__default.Children.map(children, (child) => {
       if (isValidElement(child) && child.type && child.type.displayName === "FDropdownItem") {
         return cloneElement(child, {
           onClick: handleItemClick(child)
@@ -3153,15 +3163,15 @@ const FMenuLinks = ({
   disabled: disabled2 = [],
   title: title2
 }) => {
-  const enhancedChildren = React.Children.map(children, (child, index) => {
-    if (!React.isValidElement(child)) return child;
+  const enhancedChildren = React__default.Children.map(children, (child, index) => {
+    if (!React__default.isValidElement(child)) return child;
     const isDisabled = disabled2.includes(index);
     const childClass = [
       child.props.className,
       styles$8.link,
       isDisabled && styles$8.disabled
     ].filter(Boolean).join(" ");
-    return React.cloneElement(child, {
+    return React__default.cloneElement(child, {
       className: childClass,
       ...isDisabled && { onClick: (e) => e.preventDefault() }
     });
@@ -3318,43 +3328,43 @@ const FTooltip = ({
   };
   if (!disableHoverListener) {
     childProps.onMouseEnter = (e) => {
-      var _a, _b;
+      var _a2, _b2;
       handleOpen();
-      (_b = (_a = children.props).onMouseEnter) == null ? void 0 : _b.call(_a, e);
+      (_b2 = (_a2 = children.props).onMouseEnter) == null ? void 0 : _b2.call(_a2, e);
     };
     childProps.onMouseLeave = (e) => {
-      var _a, _b;
+      var _a2, _b2;
       handleClose();
-      (_b = (_a = children.props).onMouseLeave) == null ? void 0 : _b.call(_a, e);
+      (_b2 = (_a2 = children.props).onMouseLeave) == null ? void 0 : _b2.call(_a2, e);
     };
   }
   if (!disableFocusListener) {
     childProps.onFocus = (e) => {
-      var _a, _b;
+      var _a2, _b2;
       handleOpen();
-      (_b = (_a = children.props).onFocus) == null ? void 0 : _b.call(_a, e);
+      (_b2 = (_a2 = children.props).onFocus) == null ? void 0 : _b2.call(_a2, e);
     };
     childProps.onBlur = (e) => {
-      var _a, _b;
+      var _a2, _b2;
       handleClose();
-      (_b = (_a = children.props).onBlur) == null ? void 0 : _b.call(_a, e);
+      (_b2 = (_a2 = children.props).onBlur) == null ? void 0 : _b2.call(_a2, e);
     };
   }
   if (!disableTouchListener) {
     childProps.onTouchStart = (e) => {
-      var _a, _b;
+      var _a2, _b2;
       handleOpen();
-      (_b = (_a = children.props).onTouchStart) == null ? void 0 : _b.call(_a, e);
+      (_b2 = (_a2 = children.props).onTouchStart) == null ? void 0 : _b2.call(_a2, e);
     };
     childProps.onTouchEnd = (e) => {
-      var _a, _b;
+      var _a2, _b2;
       handleClose();
-      (_b = (_a = children.props).onTouchEnd) == null ? void 0 : _b.call(_a, e);
+      (_b2 = (_a2 = children.props).onTouchEnd) == null ? void 0 : _b2.call(_a2, e);
     };
   }
   let wrappedChild;
   const childPropsTyped = children.props;
-  if (allowTooltipOnDisabled && React.isValidElement(children) && (childPropsTyped.disabled || childPropsTyped["aria-disabled"])) {
+  if (allowTooltipOnDisabled && React__default.isValidElement(children) && (childPropsTyped.disabled || childPropsTyped["aria-disabled"])) {
     wrappedChild = /* @__PURE__ */ jsx(
       "span",
       {
@@ -3450,8 +3460,8 @@ const FSearchableSelect = forwardRef(
   }, ref) => {
     const options = useMemo(() => {
       const results = [];
-      React.Children.forEach(children, (child) => {
-        if (React.isValidElement(child)) {
+      React__default.Children.forEach(children, (child) => {
+        if (React__default.isValidElement(child)) {
           const element = child;
           const { value: childValue, children: childLabel } = element.props;
           const valStr = childValue !== void 0 ? String(childValue) : "";
@@ -3530,11 +3540,11 @@ const FSearchableSelect = forwardRef(
       setHighlightedIndex(0);
     };
     const handleClear = (e) => {
-      var _a;
+      var _a2;
       e.stopPropagation();
       triggerChange("");
       setSearchQuery("");
-      (_a = visibleInputRef.current) == null ? void 0 : _a.focus();
+      (_a2 = visibleInputRef.current) == null ? void 0 : _a2.focus();
     };
     useEffect(() => {
       const handleClickOutside = (event) => {
@@ -3553,7 +3563,7 @@ const FSearchableSelect = forwardRef(
       return () => document.removeEventListener("mousedown", handleClickOutside);
     }, [restProps.value, options]);
     const handleKeyDown = (e) => {
-      var _a;
+      var _a2;
       if (restOnKeyDown) restOnKeyDown(e);
       if (e.key === "ArrowDown") {
         e.preventDefault();
@@ -3572,7 +3582,7 @@ const FSearchableSelect = forwardRef(
         }
       } else if (e.key === "Escape") {
         setIsOpen(false);
-        (_a = visibleInputRef.current) == null ? void 0 : _a.blur();
+        (_a2 = visibleInputRef.current) == null ? void 0 : _a2.blur();
       }
     };
     const baseStyle = {
@@ -3726,7 +3736,7 @@ const FSearchableSelect = forwardRef(
   }
 );
 FSearchableSelect.displayName = "FSearchableSelect";
-const FPlusIcon = React.forwardRef(({
+const FPlusIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -3760,7 +3770,7 @@ const FPlusIcon = React.forwardRef(({
   );
 });
 FPlusIcon.displayName = "FPlusIcon";
-const FCheckIcon = React.forwardRef(({
+const FCheckIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -3794,7 +3804,7 @@ const FCheckIcon = React.forwardRef(({
   );
 });
 FCheckIcon.displayName = "FCheckIcon";
-const FListIcon = React.forwardRef(({
+const FListIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -3834,7 +3844,7 @@ const FListIcon = React.forwardRef(({
   );
 });
 FListIcon.displayName = "FListIcon";
-const FPenIcon = React.forwardRef(({
+const FPenIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -3866,7 +3876,7 @@ const FPenIcon = React.forwardRef(({
   );
 });
 FPenIcon.displayName = "FPenIcon";
-const FUploadIcon = React.forwardRef(({
+const FUploadIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -3896,7 +3906,7 @@ const FUploadIcon = React.forwardRef(({
   );
 });
 FUploadIcon.displayName = "FUploadIcon";
-const FDownloadIcon = React.forwardRef(({
+const FDownloadIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -3926,7 +3936,7 @@ const FDownloadIcon = React.forwardRef(({
   );
 });
 FDownloadIcon.displayName = "FDownloadIcon";
-const FCopyAddIcon = React.forwardRef(({
+const FCopyAddIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -3956,7 +3966,7 @@ const FCopyAddIcon = React.forwardRef(({
   );
 });
 FCopyAddIcon.displayName = "FCopyAddIcon";
-const FUnlinkIcon = React.forwardRef(({
+const FUnlinkIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -3994,7 +4004,7 @@ const FUnlinkIcon = React.forwardRef(({
   );
 });
 FUnlinkIcon.displayName = "FUnlinkIcon";
-const FFilterIcon = React.forwardRef(({
+const FFilterIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -4024,7 +4034,7 @@ const FFilterIcon = React.forwardRef(({
   );
 });
 FFilterIcon.displayName = "FFilterIcon";
-const FDocumentIcon = React.forwardRef(({
+const FDocumentIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -4078,7 +4088,7 @@ const FDocumentIcon = React.forwardRef(({
   );
 });
 FDocumentIcon.displayName = "FDocumentIcon";
-const FReloadIcon = React.forwardRef(({
+const FReloadIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -4108,7 +4118,7 @@ const FReloadIcon = React.forwardRef(({
   );
 });
 FReloadIcon.displayName = "FReloadIcon";
-const FMinusIcon = React.forwardRef(({
+const FMinusIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -4138,7 +4148,7 @@ const FMinusIcon = React.forwardRef(({
   );
 });
 FMinusIcon.displayName = "FMinusIcon";
-const FInfoCircleIcon = React.forwardRef(({
+const FInfoCircleIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -4168,7 +4178,7 @@ const FInfoCircleIcon = React.forwardRef(({
   );
 });
 FInfoCircleIcon.displayName = "FInfoCircleIcon";
-const FSafeIcon = React.forwardRef(({
+const FSafeIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -4198,7 +4208,7 @@ const FSafeIcon = React.forwardRef(({
   );
 });
 FSafeIcon.displayName = "FSafeIcon";
-const FArrowRightCircleIcon = React.forwardRef(({
+const FArrowRightCircleIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -4225,7 +4235,7 @@ const FArrowRightCircleIcon = React.forwardRef(({
   );
 });
 FArrowRightCircleIcon.displayName = "FArrowRightCircleIcon";
-const FArrowLeftCircleIcon = React.forwardRef(({
+const FArrowLeftCircleIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -4252,7 +4262,7 @@ const FArrowLeftCircleIcon = React.forwardRef(({
   );
 });
 FArrowLeftCircleIcon.displayName = "FArrowLeftCircleIcon";
-const FArrowUpCircleIcon = React.forwardRef(({
+const FArrowUpCircleIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -4279,7 +4289,7 @@ const FArrowUpCircleIcon = React.forwardRef(({
   );
 });
 FArrowUpCircleIcon.displayName = "FArrowUpCircleIcon";
-const FArrowDownCircleIcon = React.forwardRef(({
+const FArrowDownCircleIcon = React__default.forwardRef(({
   color = "primary",
   size = 30,
   st,
@@ -7623,10 +7633,10 @@ const fNotification = ({
       return blockNotification2;
     };
     const removeEmptyNotificationBlock = () => {
-      var _a;
+      var _a2;
       const blockNotification2 = document.querySelector("#block-notification");
       if (blockNotification2 && blockNotification2.children.length === 0) {
-        (_a = blockNotification2.parentNode) == null ? void 0 : _a.removeChild(blockNotification2);
+        (_a2 = blockNotification2.parentNode) == null ? void 0 : _a2.removeChild(blockNotification2);
       }
     };
     const blockNotification = getOrCreateNotificationBlock();
@@ -7740,8 +7750,8 @@ const fDownloadFileFromBase64 = (base64String, fileName) => {
   }
 };
 const getMimeTypeFromFileName = (fileName) => {
-  var _a;
-  const extension = (_a = fileName.split(".").pop()) == null ? void 0 : _a.toLowerCase();
+  var _a2;
+  const extension = (_a2 = fileName.split(".").pop()) == null ? void 0 : _a2.toLowerCase();
   if (!extension) return void 0;
   const mimeTypes = {
     txt: "text/plain",
@@ -7894,7 +7904,7 @@ const useFApi = ({ doNotUseState = false, defaultState = null, getValueByPath =
   const [loading, setLoading] = useState(false);
   const [error2, setError] = useState(null);
   const execute = async (config) => {
-    var _a, _b, _c;
+    var _a2, _b2, _c2;
     setLoading(true);
     setError(null);
     try {
@@ -7918,11 +7928,11 @@ const useFApi = ({ doNotUseState = false, defaultState = null, getValueByPath =
       }
     } catch (error22) {
       const err = error22;
-      const errorMessage = ((_b = (_a = err.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || err.message || "Неизвестная ошибка";
+      const errorMessage = ((_b2 = (_a2 = err.response) == null ? void 0 : _a2.data) == null ? void 0 : _b2.message) || err.message || "Неизвестная ошибка";
       fNotification({
         variant: "error",
         title: "Ошибка",
-        body: `- Произошла ошибка ${(_c = err.response) == null ? void 0 : _c.status}
+        body: `- Произошла ошибка ${(_c2 = err.response) == null ? void 0 : _c2.status}
 - ${errorMessage}`,
         timeSecClose: 5
       });
@@ -7939,6 +7949,1547 @@ const useFApi = ({ doNotUseState = false, defaultState = null, getValueByPath =
   };
   return { data, loading, error: error2, execute, reset };
 };
+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() {
+  }
+};
+var FocusManager = (_a = class extends Subscribable {
+  constructor() {
+    super();
+    __privateAdd(this, _focused);
+    __privateAdd(this, _cleanup);
+    __privateAdd(this, _setup);
+    __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 _a2;
+    if (!this.hasListeners()) {
+      (_a2 = __privateGet(this, _cleanup)) == null ? void 0 : _a2.call(this);
+      __privateSet(this, _cleanup, void 0);
+    }
+  }
+  setEventListener(setup) {
+    var _a2;
+    __privateSet(this, _setup, setup);
+    (_a2 = __privateGet(this, _cleanup)) == null ? void 0 : _a2.call(this);
+    __privateSet(this, _cleanup, setup((focused2) => {
+      if (typeof focused2 === "boolean") {
+        this.setFocused(focused2);
+      } else {
+        this.onFocus();
+      }
+    }));
+  }
+  setFocused(focused2) {
+    const changed = __privateGet(this, _focused) !== focused2;
+    if (changed) {
+      __privateSet(this, _focused, focused2);
+      this.onFocus();
+    }
+  }
+  onFocus() {
+    const isFocused = this.isFocused();
+    this.listeners.forEach((listener) => {
+      listener(isFocused);
+    });
+  }
+  isFocused() {
+    var _a2;
+    if (typeof __privateGet(this, _focused) === "boolean") {
+      return __privateGet(this, _focused);
+    }
+    return ((_a2 = globalThis.document) == null ? void 0 : _a2.visibilityState) !== "hidden";
+  }
+}, _focused = new WeakMap(), _cleanup = new WeakMap(), _setup = new WeakMap(), _a);
+var focusManager = new FocusManager();
+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 TimeoutManager = (_b = 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 (process.env.NODE_ENV !== "production") {
+      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 (process.env.NODE_ENV !== "production") {
+      __privateSet(this, _providerCalled, false);
+    }
+  }
+  setTimeout(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      __privateSet(this, _providerCalled, true);
+    }
+    return __privateGet(this, _provider).setTimeout(callback, delay);
+  }
+  clearTimeout(timeoutId) {
+    __privateGet(this, _provider).clearTimeout(timeoutId);
+  }
+  setInterval(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      __privateSet(this, _providerCalled, true);
+    }
+    return __privateGet(this, _provider).setInterval(callback, delay);
+  }
+  clearInterval(intervalId) {
+    __privateGet(this, _provider).clearInterval(intervalId);
+  }
+}, _provider = new WeakMap(), _providerCalled = new WeakMap(), _b);
+var timeoutManager = new TimeoutManager();
+function systemSetTimeoutZero(callback) {
+  setTimeout(callback, 0);
+}
+var isServer = typeof window === "undefined" || "Deno" in globalThis;
+function noop() {
+}
+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 resolveQueryBoolean(option, query) {
+  return typeof option === "function" ? option(query) : option;
+}
+function hashKey(queryKey) {
+  return JSON.stringify(
+    queryKey,
+    (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+      result[key] = val[key];
+      return result;
+    }, {}) : val
+  );
+}
+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 replaceData(prevData, data, options) {
+  if (typeof options.structuralSharing === "function") {
+    return options.structuralSharing(prevData, data);
+  } else if (options.structuralSharing !== false) {
+    if (process.env.NODE_ENV !== "production") {
+      try {
+        return replaceEqualDeep(prevData, data);
+      } catch (error2) {
+        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}]: ${error2}`
+        );
+        throw error2;
+      }
+    }
+    return replaceEqualDeep(prevData, data);
+  }
+  return data;
+}
+function shouldThrowError(throwOnError, params) {
+  if (typeof throwOnError === "function") {
+    return throwOnError(...params);
+  }
+  return !!throwOnError;
+}
+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;
+    }
+  };
+})();
+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;
+}
+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();
+var OnlineManager = (_c = class extends Subscribable {
+  constructor() {
+    super();
+    __privateAdd(this, _online, true);
+    __privateAdd(this, _cleanup2);
+    __privateAdd(this, _setup2);
+    __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 _a2;
+    if (!this.hasListeners()) {
+      (_a2 = __privateGet(this, _cleanup2)) == null ? void 0 : _a2.call(this);
+      __privateSet(this, _cleanup2, void 0);
+    }
+  }
+  setEventListener(setup) {
+    var _a2;
+    __privateSet(this, _setup2, setup);
+    (_a2 = __privateGet(this, _cleanup2)) == null ? void 0 : _a2.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(), _c);
+var onlineManager = new OnlineManager();
+function canFetch(networkMode) {
+  return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
+}
+function fetchState(data, options) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
+    ...data === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+var QueryObserver = (_d = class extends Subscribable {
+  constructor(client, options) {
+    super();
+    __privateAdd(this, _QueryObserver_instances);
+    __privateAdd(this, _client);
+    __privateAdd(this, _currentQuery);
+    __privateAdd(this, _currentQueryInitialState);
+    __privateAdd(this, _currentResult);
+    __privateAdd(this, _currentResultState);
+    __privateAdd(this, _currentResultOptions);
+    __privateAdd(this, _currentThenable);
+    __privateAdd(this, _selectError);
+    __privateAdd(this, _selectFn);
+    __privateAdd(this, _selectResult);
+    // 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);
+    __privateAdd(this, _staleTimeoutId);
+    __privateAdd(this, _refetchIntervalId);
+    __privateAdd(this, _currentRefetchInterval);
+    __privateAdd(this, _trackedProps, /* @__PURE__ */ new Set());
+    this.options = options;
+    __privateSet(this, _client, 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, _QueryObserver_instances, executeFetch_fn).call(this);
+      } else {
+        this.updateResult();
+      }
+      __privateMethod(this, _QueryObserver_instances, 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, _QueryObserver_instances, clearStaleTimeout_fn).call(this);
+    __privateMethod(this, _QueryObserver_instances, clearRefetchInterval_fn).call(this);
+    __privateGet(this, _currentQuery).removeObserver(this);
+  }
+  setOptions(options) {
+    const prevOptions = this.options;
+    const prevQuery = __privateGet(this, _currentQuery);
+    this.options = __privateGet(this, _client).defaultQueryOptions(options);
+    if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveQueryBoolean(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, _QueryObserver_instances, updateQuery_fn).call(this);
+    __privateGet(this, _currentQuery).setOptions(this.options);
+    if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {
+      __privateGet(this, _client).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, _QueryObserver_instances, executeFetch_fn).call(this);
+    }
+    this.updateResult();
+    if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveQueryBoolean(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveQueryBoolean(prevOptions.enabled, __privateGet(this, _currentQuery)) || resolveStaleTime(this.options.staleTime, __privateGet(this, _currentQuery)) !== resolveStaleTime(prevOptions.staleTime, __privateGet(this, _currentQuery)))) {
+      __privateMethod(this, _QueryObserver_instances, updateStaleTimeout_fn).call(this);
+    }
+    const nextRefetchInterval = __privateMethod(this, _QueryObserver_instances, computeRefetchInterval_fn).call(this);
+    if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveQueryBoolean(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveQueryBoolean(prevOptions.enabled, __privateGet(this, _currentQuery)) || nextRefetchInterval !== __privateGet(this, _currentRefetchInterval))) {
+      __privateMethod(this, _QueryObserver_instances, updateRefetchInterval_fn).call(this, nextRefetchInterval);
+    }
+  }
+  getOptimisticResult(options) {
+    const query = __privateGet(this, _client).getQueryCache().build(__privateGet(this, _client), 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({ ...options } = {}) {
+    return this.fetch({
+      ...options
+    });
+  }
+  fetchOptimistic(options) {
+    const defaultedOptions = __privateGet(this, _client).defaultQueryOptions(options);
+    const query = __privateGet(this, _client).getQueryCache().build(__privateGet(this, _client), defaultedOptions);
+    return query.fetch().then(() => this.createResult(query, defaultedOptions));
+  }
+  fetch(fetchOptions) {
+    return __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this, {
+      ...fetchOptions,
+      cancelRefetch: fetchOptions.cancelRefetch ?? true
+    }).then(() => {
+      this.updateResult();
+      return __privateGet(this, _currentResult);
+    });
+  }
+  createResult(query, options) {
+    var _a2;
+    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 = { ...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 = {
+          ...newState,
+          ...fetchState(state.data, query.options)
+        };
+      }
+      if (options._optimisticResults === "isRestoring") {
+        newState.fetchStatus = "idle";
+      }
+    }
+    let { error: error2, 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(
+          (_a2 = __privateGet(this, _lastQueryWithDefinedData)) == null ? void 0 : _a2.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)) {
+      error2 = __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: error2,
+      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: resolveQueryBoolean(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 ?? __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, _QueryObserver_instances, notify_fn).call(this, { listeners: shouldNotifyListeners() });
+  }
+  onQueryUpdate() {
+    this.updateResult();
+    if (this.hasListeners()) {
+      __privateMethod(this, _QueryObserver_instances, updateTimers_fn).call(this);
+    }
+  }
+}, _client = 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(), _QueryObserver_instances = new WeakSet(), executeFetch_fn = function(fetchOptions) {
+  __privateMethod(this, _QueryObserver_instances, 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_fn = function() {
+  __privateMethod(this, _QueryObserver_instances, 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_fn = function() {
+  return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(__privateGet(this, _currentQuery)) : this.options.refetchInterval) ?? false;
+}, updateRefetchInterval_fn = function(nextInterval) {
+  __privateMethod(this, _QueryObserver_instances, clearRefetchInterval_fn).call(this);
+  __privateSet(this, _currentRefetchInterval, nextInterval);
+  if (environmentManager.isServer() || resolveQueryBoolean(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, _QueryObserver_instances, executeFetch_fn).call(this);
+    }
+  }, __privateGet(this, _currentRefetchInterval)));
+}, updateTimers_fn = function() {
+  __privateMethod(this, _QueryObserver_instances, updateStaleTimeout_fn).call(this);
+  __privateMethod(this, _QueryObserver_instances, updateRefetchInterval_fn).call(this, __privateMethod(this, _QueryObserver_instances, computeRefetchInterval_fn).call(this));
+}, clearStaleTimeout_fn = function() {
+  if (__privateGet(this, _staleTimeoutId) !== void 0) {
+    timeoutManager.clearTimeout(__privateGet(this, _staleTimeoutId));
+    __privateSet(this, _staleTimeoutId, void 0);
+  }
+}, clearRefetchInterval_fn = function() {
+  if (__privateGet(this, _refetchIntervalId) !== void 0) {
+    timeoutManager.clearInterval(__privateGet(this, _refetchIntervalId));
+    __privateSet(this, _refetchIntervalId, void 0);
+  }
+}, updateQuery_fn = function() {
+  const query = __privateGet(this, _client).getQueryCache().build(__privateGet(this, _client), 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_fn = function(notifyOptions) {
+  notifyManager.batch(() => {
+    if (notifyOptions.listeners) {
+      this.listeners.forEach((listener) => {
+        listener(__privateGet(this, _currentResult));
+      });
+    }
+    __privateGet(this, _client).getQueryCache().notify({
+      query: __privateGet(this, _currentQuery),
+      type: "observerResultsUpdated"
+    });
+  });
+}, _d);
+function shouldLoadOnMount(query, options) {
+  return resolveQueryBoolean(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && resolveQueryBoolean(options.retryOnMount, query) === 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 (resolveQueryBoolean(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 || resolveQueryBoolean(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
+}
+function isStale(query, options) {
+  return resolveQueryBoolean(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
+}
+function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
+  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
+    return true;
+  }
+  return false;
+}
+function getDefaultState() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: false,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+var MutationObserver = (_e = class extends Subscribable {
+  constructor(client, options) {
+    super();
+    __privateAdd(this, _MutationObserver_instances);
+    __privateAdd(this, _client2);
+    __privateAdd(this, _currentResult2);
+    __privateAdd(this, _currentMutation);
+    __privateAdd(this, _mutateOptions);
+    __privateSet(this, _client2, client);
+    this.setOptions(options);
+    this.bindMethods();
+    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this);
+    this.reset = this.reset.bind(this);
+  }
+  setOptions(options) {
+    var _a2;
+    const prevOptions = this.options;
+    this.options = __privateGet(this, _client2).defaultMutationOptions(options);
+    if (!shallowEqualObjects(this.options, prevOptions)) {
+      __privateGet(this, _client2).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 (((_a2 = __privateGet(this, _currentMutation)) == null ? void 0 : _a2.state.status) === "pending") {
+      __privateGet(this, _currentMutation).setOptions(this.options);
+    }
+  }
+  onUnsubscribe() {
+    var _a2;
+    if (!this.hasListeners()) {
+      (_a2 = __privateGet(this, _currentMutation)) == null ? void 0 : _a2.removeObserver(this);
+    }
+  }
+  onMutationUpdate(action) {
+    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+    __privateMethod(this, _MutationObserver_instances, notify_fn2).call(this, action);
+  }
+  getCurrentResult() {
+    return __privateGet(this, _currentResult2);
+  }
+  reset() {
+    var _a2;
+    (_a2 = __privateGet(this, _currentMutation)) == null ? void 0 : _a2.removeObserver(this);
+    __privateSet(this, _currentMutation, void 0);
+    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+    __privateMethod(this, _MutationObserver_instances, notify_fn2).call(this);
+  }
+  mutate(variables, options) {
+    var _a2;
+    __privateSet(this, _mutateOptions, options);
+    (_a2 = __privateGet(this, _currentMutation)) == null ? void 0 : _a2.removeObserver(this);
+    __privateSet(this, _currentMutation, __privateGet(this, _client2).getMutationCache().build(__privateGet(this, _client2), this.options));
+    __privateGet(this, _currentMutation).addObserver(this);
+    return __privateGet(this, _currentMutation).execute(variables);
+  }
+}, _client2 = new WeakMap(), _currentResult2 = new WeakMap(), _currentMutation = new WeakMap(), _mutateOptions = new WeakMap(), _MutationObserver_instances = new WeakSet(), updateResult_fn = function() {
+  var _a2;
+  const state = ((_a2 = __privateGet(this, _currentMutation)) == null ? void 0 : _a2.state) ?? getDefaultState();
+  __privateSet(this, _currentResult2, {
+    ...state,
+    isPending: state.status === "pending",
+    isSuccess: state.status === "success",
+    isError: state.status === "error",
+    isIdle: state.status === "idle",
+    mutate: this.mutate,
+    reset: this.reset
+  });
+}, notify_fn2 = function(action) {
+  notifyManager.batch(() => {
+    var _a2, _b2, _c2, _d2, _e2, _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, _client2),
+        meta: this.options.meta,
+        mutationKey: this.options.mutationKey
+      };
+      if ((action == null ? void 0 : action.type) === "success") {
+        try {
+          (_b2 = (_a2 = __privateGet(this, _mutateOptions)).onSuccess) == null ? void 0 : _b2.call(
+            _a2,
+            action.data,
+            variables,
+            onMutateResult,
+            context
+          );
+        } catch (e) {
+          void Promise.reject(e);
+        }
+        try {
+          (_d2 = (_c2 = __privateGet(this, _mutateOptions)).onSettled) == null ? void 0 : _d2.call(
+            _c2,
+            action.data,
+            null,
+            variables,
+            onMutateResult,
+            context
+          );
+        } catch (e) {
+          void Promise.reject(e);
+        }
+      } else if ((action == null ? void 0 : action.type) === "error") {
+        try {
+          (_f = (_e2 = __privateGet(this, _mutateOptions)).onError) == null ? void 0 : _f.call(
+            _e2,
+            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));
+    });
+  });
+}, _e);
+var QueryClientContext = React.createContext(
+  void 0
+);
+var useQueryClient = (queryClient) => {
+  const client = React.useContext(QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client;
+};
+var IsRestoringContext = React.createContext(false);
+var useIsRestoring = () => React.useContext(IsRestoringContext);
+function createValue() {
+  let isReset = false;
+  return {
+    clearReset: () => {
+      isReset = false;
+    },
+    reset: () => {
+      isReset = true;
+    },
+    isReset: () => {
+      return isReset;
+    }
+  };
+}
+var QueryErrorResetBoundaryContext = React.createContext(createValue());
+var useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext);
+var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
+  const throwOnError = (query == null ? void 0 : query.state.error) && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError;
+  if (options.suspense || options.experimental_prefetchInRender || throwOnError) {
+    if (!errorResetBoundary.isReset()) {
+      options.retryOnMount = false;
+    }
+  }
+};
+var useClearResetErrorBoundary = (errorResetBoundary) => {
+  React.useEffect(() => {
+    errorResetBoundary.clearReset();
+  }, [errorResetBoundary]);
+};
+var getHasError = ({
+  result,
+  errorResetBoundary,
+  throwOnError,
+  query,
+  suspense
+}) => {
+  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
+};
+var ensureSuspenseTimers = (defaultedOptions) => {
+  if (defaultedOptions.suspense) {
+    const MIN_SUSPENSE_TIME_MS = 1e3;
+    const clamp = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS);
+    const originalStaleTime = defaultedOptions.staleTime;
+    defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp(originalStaleTime(...args)) : clamp(originalStaleTime);
+    if (typeof defaultedOptions.gcTime === "number") {
+      defaultedOptions.gcTime = Math.max(
+        defaultedOptions.gcTime,
+        MIN_SUSPENSE_TIME_MS
+      );
+    }
+  }
+};
+var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+var shouldSuspend = (defaultedOptions, result) => (defaultedOptions == null ? void 0 : defaultedOptions.suspense) && result.isPending;
+var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
+  errorResetBoundary.clearReset();
+});
+function useBaseQuery(options, Observer, queryClient) {
+  var _a2, _b2, _c2, _d2;
+  if (process.env.NODE_ENV !== "production") {
+    if (typeof options !== "object" || Array.isArray(options)) {
+      throw new Error(
+        'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
+      );
+    }
+  }
+  const isRestoring = useIsRestoring();
+  const errorResetBoundary = useQueryErrorResetBoundary();
+  const client = useQueryClient();
+  const defaultedOptions = client.defaultQueryOptions(options);
+  (_b2 = (_a2 = client.getDefaultOptions().queries) == null ? void 0 : _a2._experimental_beforeQuery) == null ? void 0 : _b2.call(
+    _a2,
+    defaultedOptions
+  );
+  const query = client.getQueryCache().get(defaultedOptions.queryHash);
+  if (process.env.NODE_ENV !== "production") {
+    if (!defaultedOptions.queryFn) {
+      console.error(
+        `[${defaultedOptions.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`
+      );
+    }
+  }
+  const subscribed = options.subscribed !== false;
+  defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
+  ensureSuspenseTimers(defaultedOptions);
+  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
+  useClearResetErrorBoundary(errorResetBoundary);
+  const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
+  const [observer] = React.useState(
+    () => new Observer(
+      client,
+      defaultedOptions
+    )
+  );
+  const result = observer.getOptimisticResult(defaultedOptions);
+  const shouldSubscribe = !isRestoring && subscribed;
+  React.useSyncExternalStore(
+    React.useCallback(
+      (onStoreChange) => {
+        const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
+        observer.updateResult();
+        return unsubscribe;
+      },
+      [observer, shouldSubscribe]
+    ),
+    () => observer.getCurrentResult(),
+    () => observer.getCurrentResult()
+  );
+  React.useEffect(() => {
+    observer.setOptions(defaultedOptions);
+  }, [defaultedOptions, observer]);
+  if (shouldSuspend(defaultedOptions, result)) {
+    throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+  }
+  if (getHasError({
+    result,
+    errorResetBoundary,
+    throwOnError: defaultedOptions.throwOnError,
+    query,
+    suspense: defaultedOptions.suspense
+  })) {
+    throw result.error;
+  }
+  (_d2 = (_c2 = client.getDefaultOptions().queries) == null ? void 0 : _c2._experimental_afterQuery) == null ? void 0 : _d2.call(
+    _c2,
+    defaultedOptions,
+    result
+  );
+  if (defaultedOptions.experimental_prefetchInRender && !environmentManager.isServer() && willFetch(result, isRestoring)) {
+    const promise = isNewCacheEntry ? (
+      // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+      fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
+    ) : (
+      // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+      query == null ? void 0 : query.promise
+    );
+    promise == null ? void 0 : promise.catch(noop).finally(() => {
+      observer.updateResult();
+    });
+  }
+  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+function useQuery(options, queryClient) {
+  return useBaseQuery(options, QueryObserver);
+}
+function useMutation(options, queryClient) {
+  const client = useQueryClient();
+  const [observer] = React.useState(
+    () => new MutationObserver(
+      client,
+      options
+    )
+  );
+  React.useEffect(() => {
+    observer.setOptions(options);
+  }, [observer, options]);
+  const result = React.useSyncExternalStore(
+    React.useCallback(
+      (onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)),
+      [observer]
+    ),
+    () => observer.getCurrentResult(),
+    () => observer.getCurrentResult()
+  );
+  const mutate = React.useCallback(
+    (variables, mutateOptions) => {
+      observer.mutate(variables, mutateOptions).catch(noop);
+    },
+    [observer]
+  );
+  if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) {
+    throw result.error;
+  }
+  return { ...result, mutate, mutateAsync: result.mutate };
+}
+const LibraryContext = createContext(null);
+const LibraryProvider = ({
+  children,
+  config
+}) => {
+  return /* @__PURE__ */ jsx(LibraryContext.Provider, { value: config, children });
+};
+const useLibraryContext = () => {
+  const context = useContext(LibraryContext);
+  if (!context) {
+    throw new Error("[UIKit/Lib]: Вы должны обернуть приложение в <LibraryProvider config={{ apiService }}>");
+  }
+  return context;
+};
+const useApiMutation = (url, config, options) => {
+  const { apiService } = useLibraryContext();
+  const queryClient = useQueryClient();
+  const mutation = useMutation({
+    mutationFn: ({ data, urlParams }) => {
+      let finalUrl = url;
+      if (urlParams) {
+        Object.entries(urlParams).forEach(([key, value]) => {
+          finalUrl = finalUrl.replace(new RegExp(`:${key}\\b`, "g"), String(value));
+        });
+      }
+      const isFormData = data instanceof FormData;
+      const requestConfig = {
+        method: "POST",
+        data,
+        ...config
+      };
+      if (isFormData) {
+        requestConfig.headers = {
+          ...requestConfig.headers,
+          "Content-Type": void 0
+        };
+      }
+      return apiService.request(finalUrl, requestConfig);
+    },
+    ...options,
+    onSuccess: (...args) => {
+      var _a2;
+      if (options == null ? void 0 : options.queryKeyToInvalidate) {
+        queryClient.invalidateQueries({ queryKey: options.queryKeyToInvalidate });
+      }
+      (_a2 = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a2.call(options, ...args);
+    }
+  });
+  const customMutate = (data, urlParams, mutateOptions) => {
+    mutation.mutate({ data, urlParams }, mutateOptions);
+  };
+  const customMutateAsync = (data, urlParams, mutateOptions) => {
+    return mutation.mutateAsync({ data, urlParams }, mutateOptions);
+  };
+  useNotificationEffects(
+    { ...options || {} },
+    {
+      isError: mutation.isError,
+      isPending: mutation.isPending,
+      isSuccess: mutation.isSuccess,
+      error: mutation.error ?? null
+    }
+  );
+  return {
+    ...mutation,
+    mutate: customMutate,
+    mutateAsync: customMutateAsync
+  };
+};
+function useNotificationEffects(options, state) {
+  const {
+    onErrorNotification = false,
+    onErrorLog = false,
+    onSuccessNotification = false,
+    notificationTitle = "Ошибка выполнения запроса!",
+    notificationBody = (error2) => (error2 == null ? void 0 : error2.message) || "Неизвестная ошибка",
+    loadingNotificationTitle = "Загрузка",
+    loadingNotificationBody = "Идет загрузка, пожалуйста, подождите...",
+    successNotificationTitle = "Успешно!",
+    successNotificationBody = "Операция выполнена успешно"
+  } = options;
+  const loadingNotificationIdRef = useRef(void 0);
+  useEffect(() => {
+    let isMounted = true;
+    if (state.isPending && !loadingNotificationIdRef.current) {
+      fNotification({
+        variant: "info",
+        title: loadingNotificationTitle,
+        body: loadingNotificationBody
+      }).then((id) => {
+        if (isMounted && state.isPending) {
+          loadingNotificationIdRef.current = id;
+        } else if (id) {
+          fNotificationDelete(id);
+        }
+      });
+    }
+    if (!state.isPending && loadingNotificationIdRef.current) {
+      fNotificationDelete(loadingNotificationIdRef.current);
+      loadingNotificationIdRef.current = void 0;
+    }
+    return () => {
+      isMounted = false;
+      if (loadingNotificationIdRef.current) {
+        fNotificationDelete(loadingNotificationIdRef.current);
+        loadingNotificationIdRef.current = void 0;
+      }
+    };
+  }, [state.isPending, loadingNotificationTitle, loadingNotificationBody]);
+  useEffect(() => {
+    if (state.isError) {
+      if (onErrorNotification) {
+        fNotification({
+          variant: "error",
+          title: notificationTitle,
+          body: notificationBody(state.error ?? null),
+          timeSecClose: 3
+        });
+      }
+      if (onErrorLog && state.error) {
+        console.error(state.error);
+      }
+    }
+  }, [state.isError, state.error, onErrorNotification, onErrorLog, notificationTitle, notificationBody]);
+  useEffect(() => {
+    if (state.isSuccess && onSuccessNotification) {
+      fNotification({
+        variant: "success",
+        title: successNotificationTitle,
+        body: successNotificationBody,
+        timeSecClose: 3
+      });
+    }
+  }, [state.isSuccess, onSuccessNotification, successNotificationTitle, successNotificationBody]);
+}
+const useApiQuery = (queryKey, url, config, options) => {
+  const { apiService } = useLibraryContext();
+  const {
+    onErrorNotification = false,
+    onErrorLog = false,
+    onLoadingLog = false,
+    notificationTitle = "Ошибка выполнения запроса!",
+    notificationBody = (error2) => (error2 == null ? void 0 : error2.message) || "Неизвестная ошибка",
+    loadingNotificationTitle = "Загрузка",
+    loadingNotificationBody = "Идет загрузка, пожалуйста, подождите...",
+    ...restOptions
+  } = options || {};
+  const method = restOptions.method ?? "GET";
+  const lastKeyElement = queryKey.length > 1 ? queryKey[queryKey.length - 1] : void 0;
+  const paramsOrData = typeof lastKeyElement === "object" && lastKeyElement !== null ? lastKeyElement : void 0;
+  const query = useQuery({
+    queryKey,
+    queryFn: ({ signal }) => apiService.request(url, {
+      method,
+      signal,
+      // Автоматическое отмена зависших запросов при смене ключа
+      ...config,
+      ...method === "POST" ? { data: paramsOrData } : { params: paramsOrData }
+    }),
+    ...restOptions
+  });
+  useEffect(() => {
+    if (query.isError) {
+      if (onErrorNotification) {
+        fNotification({
+          variant: "error",
+          title: notificationTitle,
+          body: notificationBody(query.error ?? null),
+          timeSecClose: 3
+        });
+      }
+      if (onErrorLog && query.error) {
+        console.error(query.error);
+      }
+    }
+  }, [query.isError, query.error, onErrorNotification, onErrorLog, notificationTitle, notificationBody]);
+  const loadingNotificationIdRef = useRef(void 0);
+  useEffect(() => {
+    let isMounted = true;
+    const handleLoadingToast = async () => {
+      if (onLoadingLog && query.isLoading && !loadingNotificationIdRef.current) {
+        const id = await fNotification({
+          variant: "info",
+          title: loadingNotificationTitle,
+          body: loadingNotificationBody
+        });
+        if (isMounted) {
+          loadingNotificationIdRef.current = id;
+        } else if (id) {
+          fNotificationDelete(id);
+        }
+      }
+    };
+    handleLoadingToast();
+    if (!query.isLoading && loadingNotificationIdRef.current) {
+      fNotificationDelete(loadingNotificationIdRef.current);
+      loadingNotificationIdRef.current = void 0;
+    }
+    return () => {
+      isMounted = false;
+      if (loadingNotificationIdRef.current) {
+        fNotificationDelete(loadingNotificationIdRef.current);
+        loadingNotificationIdRef.current = void 0;
+      }
+    };
+  }, [query.isLoading, onLoadingLog, loadingNotificationTitle, loadingNotificationBody]);
+  return query;
+};
+function useManualApiQuery(queryKey, url, initialParams, config, options) {
+  const { apiService } = useLibraryContext();
+  const queryClient = useQueryClient();
+  const [params, setParams] = useState(initialParams);
+  const [urlParams, setUrlParams] = useState(options == null ? void 0 : options.urlParams);
+  const [dopUrl, setDopUrl] = useState(void 0);
+  const {
+    onErrorNotification = false,
+    onErrorLog = false,
+    onLoadingLog = false,
+    notificationTitle = "Ошибка выполнения запроса!",
+    notificationBody = (error2) => (error2 == null ? void 0 : error2.message) || "Неизвестная ошибка",
+    ...restOptions
+  } = options || {};
+  const method = restOptions.method ?? "GET";
+  const listQueryKey = [queryKey];
+  if (params) listQueryKey.push(params);
+  if (urlParams) listQueryKey.push(urlParams);
+  const fetcher = useCallback((overrideParams, overrideUrlParams, overrideDopUrl, signal) => {
+    const currentParams = overrideParams !== void 0 ? overrideParams : params;
+    const currentUrlParams = overrideUrlParams !== void 0 ? overrideUrlParams : urlParams;
+    const currentDopUrl = overrideDopUrl !== void 0 ? overrideDopUrl : dopUrl;
+    const targetUrl = currentDopUrl !== void 0 ? url + currentDopUrl : url;
+    return apiService.request(targetUrl, {
+      method,
+      signal,
+      ...config,
+      ...method === "POST" ? {
+        data: currentParams,
+        params: currentUrlParams
+      } : {
+        params: currentUrlParams ? { ...currentParams, ...currentUrlParams } : currentParams
+      }
+    });
+  }, [apiService, params, urlParams, dopUrl, url, method, config]);
+  const query = useQuery({
+    queryKey: listQueryKey,
+    queryFn: ({ signal }) => fetcher(void 0, void 0, void 0, signal),
+    enabled: false,
+    ...restOptions
+  });
+  const handleSideErrors = useCallback((error2) => {
+    if (onErrorNotification) {
+      fNotification({
+        variant: "error",
+        title: notificationTitle,
+        body: notificationBody(error2 ?? null),
+        timeSecClose: 3
+      });
+    }
+    if (onErrorLog) {
+      console.error(error2);
+    }
+  }, [onErrorNotification, notificationTitle, notificationBody, onErrorLog]);
+  useEffect(() => {
+    if (onLoadingLog && query.isFetching) {
+      console.log(`[useManualApiQuery] Loading: ${url}`);
+    }
+  }, [query.isFetching, onLoadingLog, url]);
+  const run = useCallback(async ({
+    newParams,
+    newUrlParams,
+    preserveParams = false,
+    dopUrl: newDopUrl,
+    preserveUrlParams = false
+  } = {}) => {
+    const updatedParams = preserveParams && newParams === void 0 ? params : newParams;
+    const updatedUrlParams = newUrlParams === void 0 ? urlParams : preserveUrlParams ? { ...urlParams, ...newUrlParams } : newUrlParams;
+    const updatedDopUrl = newDopUrl !== void 0 ? newDopUrl : dopUrl;
+    setParams(updatedParams);
+    setUrlParams(updatedUrlParams);
+    if (newDopUrl !== void 0) setDopUrl(newDopUrl);
+    const nextQueryKey = [queryKey];
+    if (updatedParams) nextQueryKey.push(updatedParams);
+    if (updatedUrlParams) nextQueryKey.push(updatedUrlParams);
+    try {
+      const result = await queryClient.fetchQuery({
+        queryKey: nextQueryKey,
+        queryFn: ({ signal }) => fetcher(updatedParams, updatedUrlParams, updatedDopUrl, signal),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        staleTime: restOptions.staleTime
+      });
+      return result;
+    } catch (error2) {
+      handleSideErrors(error2);
+      throw error2;
+    }
+  }, [params, urlParams, dopUrl, queryKey, fetcher, queryClient, restOptions.staleTime, handleSideErrors]);
+  return { ...query, run, params, urlParams };
+}
 const waterError = "_waterError_10t7p_1";
 const scene = "_scene_10t7p_12";
 const waves = "_waves_10t7p_18";
@@ -8110,6 +9661,7 @@ export {
   FUnlinkIcon,
   FUploadIcon,
   FWaterErrorBoundaryPage,
+  LibraryProvider,
   fAlert,
   fBankRound,
   fConfirm,
@@ -8127,6 +9679,9 @@ export {
   fNotification,
   fNotificationDelete,
   fPrompt,
-  useFApi
+  useApiMutation,
+  useApiQuery,
+  useFApi,
+  useManualApiQuery
 };
 //# sourceMappingURL=f-ui-kit.es.js.map