@siran/chat-react-hooks 0.1.0

package/dist/index.js

@@ -0,0 +1,1774 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../../node_modules/.bun/react@19.2.3/node_modules/react/cjs/react.development.js
+var require_react_development = __commonJS((exports, module) => {
+  (function() {
+    function defineDeprecationWarning(methodName, info) {
+      Object.defineProperty(Component.prototype, methodName, {
+        get: function() {
+          console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
+        }
+      });
+    }
+    function getIteratorFn(maybeIterable) {
+      if (maybeIterable === null || typeof maybeIterable !== "object")
+        return null;
+      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+      return typeof maybeIterable === "function" ? maybeIterable : null;
+    }
+    function warnNoop(publicInstance, callerName) {
+      publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
+      var warningKey = publicInstance + "." + callerName;
+      didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, publicInstance), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
+    }
+    function Component(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    function ComponentDummy() {}
+    function PureComponent(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    function noop() {}
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+        return testStringCoercion(value);
+      }
+    }
+    function getComponentNameFromType(type) {
+      if (type == null)
+        return null;
+      if (typeof type === "function")
+        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if (typeof type === "string")
+        return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+        case REACT_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if (typeof type === "object")
+        switch (typeof type.tag === "number" && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+          case REACT_PORTAL_TYPE:
+            return "Portal";
+          case REACT_CONTEXT_TYPE:
+            return type.displayName || "Context";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = type !== "" ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, innerType !== null ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
+            try {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {}
+        }
+      return null;
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE)
+        return "<>";
+      if (typeof type === "object" && type !== null && type.$$typeof === REACT_LAZY_TYPE)
+        return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return dispatcher === null ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning)
+          return false;
+      }
+      return config.key !== undefined;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+      componentName = this.props.ref;
+      return componentName !== undefined ? componentName : null;
+    }
+    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+      var refProp = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      (refProp !== undefined ? refProp : null) !== null ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function cloneAndReplaceKey(oldElement, newKey) {
+      newKey = ReactElement(oldElement.type, newKey, oldElement.props, oldElement._owner, oldElement._debugStack, oldElement._debugTask);
+      oldElement._store && (newKey._store.validated = oldElement._store.validated);
+      return newKey;
+    }
+    function validateChildKeys(node) {
+      isValidElement(node) ? node._store && (node._store.validated = 1) : typeof node === "object" && node !== null && node.$$typeof === REACT_LAZY_TYPE && (node._payload.status === "fulfilled" ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    }
+    function isValidElement(object) {
+      return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function escape(key) {
+      var escaperLookup = { "=": "=0", ":": "=2" };
+      return "$" + key.replace(/[=:]/g, function(match) {
+        return escaperLookup[match];
+      });
+    }
+    function getElementKey(element, index) {
+      return typeof element === "object" && element !== null && element.key != null ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
+    }
+    function resolveThenable(thenable) {
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+        default:
+          switch (typeof thenable.status === "string" ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(function(fulfilledValue) {
+            thenable.status === "pending" && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+          }, function(error) {
+            thenable.status === "pending" && (thenable.status = "rejected", thenable.reason = error);
+          })), thenable.status) {
+            case "fulfilled":
+              return thenable.value;
+            case "rejected":
+              throw thenable.reason;
+          }
+      }
+      throw thenable;
+    }
+    function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+      var type = typeof children;
+      if (type === "undefined" || type === "boolean")
+        children = null;
+      var invokeCallback = false;
+      if (children === null)
+        invokeCallback = true;
+      else
+        switch (type) {
+          case "bigint":
+          case "string":
+          case "number":
+            invokeCallback = true;
+            break;
+          case "object":
+            switch (children.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+              case REACT_PORTAL_TYPE:
+                invokeCallback = true;
+                break;
+              case REACT_LAZY_TYPE:
+                return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback);
+            }
+        }
+      if (invokeCallback) {
+        invokeCallback = children;
+        callback = callback(invokeCallback);
+        var childKey = nameSoFar === "" ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
+        isArrayImpl(callback) ? (escapedPrefix = "", childKey != null && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
+          return c;
+        })) : callback != null && (isValidElement(callback) && (callback.key != null && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(callback, escapedPrefix + (callback.key == null || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + childKey), nameSoFar !== "" && invokeCallback != null && isValidElement(invokeCallback) && invokeCallback.key == null && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
+        return 1;
+      }
+      invokeCallback = 0;
+      childKey = nameSoFar === "" ? "." : nameSoFar + ":";
+      if (isArrayImpl(children))
+        for (var i = 0;i < children.length; i++)
+          nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+      else if (i = getIteratorFn(children), typeof i === "function")
+        for (i === children.entries && (didWarnAboutMaps || console.warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = true), children = i.call(children), i = 0;!(nameSoFar = children.next()).done; )
+          nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+      else if (type === "object") {
+        if (typeof children.then === "function")
+          return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback);
+        array = String(children);
+        throw Error("Objects are not valid as a React child (found: " + (array === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead.");
+      }
+      return invokeCallback;
+    }
+    function mapChildren(children, func, context) {
+      if (children == null)
+        return children;
+      var result = [], count = 0;
+      mapIntoArray(children, result, "", "", function(child) {
+        return func.call(context, child, count++);
+      });
+      return result;
+    }
+    function lazyInitializer(payload) {
+      if (payload._status === -1) {
+        var ioInfo = payload._ioInfo;
+        ioInfo != null && (ioInfo.start = ioInfo.end = performance.now());
+        ioInfo = payload._result;
+        var thenable = ioInfo();
+        thenable.then(function(moduleObject) {
+          if (payload._status === 0 || payload._status === -1) {
+            payload._status = 1;
+            payload._result = moduleObject;
+            var _ioInfo = payload._ioInfo;
+            _ioInfo != null && (_ioInfo.end = performance.now());
+            thenable.status === undefined && (thenable.status = "fulfilled", thenable.value = moduleObject);
+          }
+        }, function(error) {
+          if (payload._status === 0 || payload._status === -1) {
+            payload._status = 2;
+            payload._result = error;
+            var _ioInfo2 = payload._ioInfo;
+            _ioInfo2 != null && (_ioInfo2.end = performance.now());
+            thenable.status === undefined && (thenable.status = "rejected", thenable.reason = error);
+          }
+        });
+        ioInfo = payload._ioInfo;
+        if (ioInfo != null) {
+          ioInfo.value = thenable;
+          var displayName = thenable.displayName;
+          typeof displayName === "string" && (ioInfo.name = displayName);
+        }
+        payload._status === -1 && (payload._status = 0, payload._result = thenable);
+      }
+      if (payload._status === 1)
+        return ioInfo = payload._result, ioInfo === undefined && console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`, ioInfo), "default" in ioInfo || console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`, ioInfo), ioInfo.default;
+      throw payload._result;
+    }
+    function resolveDispatcher() {
+      var dispatcher = ReactSharedInternals.H;
+      dispatcher === null && console.error(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`);
+      return dispatcher;
+    }
+    function releaseAsyncTransition() {
+      ReactSharedInternals.asyncTransitions--;
+    }
+    function enqueueTask(task) {
+      if (enqueueTaskImpl === null)
+        try {
+          var requireString = ("require" + Math.random()).slice(0, 7);
+          enqueueTaskImpl = (module && module[requireString]).call(module, "timers").setImmediate;
+        } catch (_err) {
+          enqueueTaskImpl = function(callback) {
+            didWarnAboutMessageChannel === false && (didWarnAboutMessageChannel = true, typeof MessageChannel === "undefined" && console.error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."));
+            var channel = new MessageChannel;
+            channel.port1.onmessage = callback;
+            channel.port2.postMessage(undefined);
+          };
+        }
+      return enqueueTaskImpl(task);
+    }
+    function aggregateErrors(errors) {
+      return 1 < errors.length && typeof AggregateError === "function" ? new AggregateError(errors) : errors[0];
+    }
+    function popActScope(prevActQueue, prevActScopeDepth) {
+      prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
+      actScopeDepth = prevActScopeDepth;
+    }
+    function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+      var queue = ReactSharedInternals.actQueue;
+      if (queue !== null)
+        if (queue.length !== 0)
+          try {
+            flushActQueue(queue);
+            enqueueTask(function() {
+              return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+            });
+            return;
+          } catch (error) {
+            ReactSharedInternals.thrownErrors.push(error);
+          }
+        else
+          ReactSharedInternals.actQueue = null;
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
+    }
+    function flushActQueue(queue) {
+      if (!isFlushing) {
+        isFlushing = true;
+        var i = 0;
+        try {
+          for (;i < queue.length; i++) {
+            var callback = queue[i];
+            do {
+              ReactSharedInternals.didUsePromise = false;
+              var continuation = callback(false);
+              if (continuation !== null) {
+                if (ReactSharedInternals.didUsePromise) {
+                  queue[i] = callback;
+                  queue.splice(0, i);
+                  return;
+                }
+                callback = continuation;
+              } else
+                break;
+            } while (1);
+          }
+          queue.length = 0;
+        } catch (error) {
+          queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
+        } finally {
+          isFlushing = false;
+        }
+      }
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
+      isMounted: function() {
+        return false;
+      },
+      enqueueForceUpdate: function(publicInstance) {
+        warnNoop(publicInstance, "forceUpdate");
+      },
+      enqueueReplaceState: function(publicInstance) {
+        warnNoop(publicInstance, "replaceState");
+      },
+      enqueueSetState: function(publicInstance) {
+        warnNoop(publicInstance, "setState");
+      }
+    }, assign = Object.assign, emptyObject = {};
+    Object.freeze(emptyObject);
+    Component.prototype.isReactComponent = {};
+    Component.prototype.setState = function(partialState, callback) {
+      if (typeof partialState !== "object" && typeof partialState !== "function" && partialState != null)
+        throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
+      this.updater.enqueueSetState(this, partialState, callback, "setState");
+    };
+    Component.prototype.forceUpdate = function(callback) {
+      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+    };
+    var deprecatedAPIs = {
+      isMounted: [
+        "isMounted",
+        "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+      ],
+      replaceState: [
+        "replaceState",
+        "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+      ]
+    };
+    for (fnName in deprecatedAPIs)
+      deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+    ComponentDummy.prototype = Component.prototype;
+    deprecatedAPIs = PureComponent.prototype = new ComponentDummy;
+    deprecatedAPIs.constructor = PureComponent;
+    assign(deprecatedAPIs, Component.prototype);
+    deprecatedAPIs.isPureReactComponent = true;
+    var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = {
+      H: null,
+      A: null,
+      T: null,
+      S: null,
+      actQueue: null,
+      asyncTransitions: 0,
+      isBatchingLegacy: false,
+      didScheduleLegacyUpdate: false,
+      didUsePromise: false,
+      thrownErrors: [],
+      getCurrentStack: null,
+      recentlyCreatedOwnerStacks: 0
+    }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    deprecatedAPIs = {
+      react_stack_bottom_frame: function(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(deprecatedAPIs, UnknownOwner)();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = typeof reportError === "function" ? reportError : function(error) {
+      if (typeof window === "object" && typeof window.ErrorEvent === "function") {
+        var event = new window.ErrorEvent("error", {
+          bubbles: true,
+          cancelable: true,
+          message: typeof error === "object" && error !== null && typeof error.message === "string" ? String(error.message) : String(error),
+          error
+        });
+        if (!window.dispatchEvent(event))
+          return;
+      } else if (typeof process === "object" && typeof process.emit === "function") {
+        process.emit("uncaughtException", error);
+        return;
+      }
+      console.error(error);
+    }, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = typeof queueMicrotask === "function" ? function(callback) {
+      queueMicrotask(function() {
+        return queueMicrotask(callback);
+      });
+    } : enqueueTask;
+    deprecatedAPIs = Object.freeze({
+      __proto__: null,
+      c: function(size) {
+        return resolveDispatcher().useMemoCache(size);
+      }
+    });
+    var fnName = {
+      map: mapChildren,
+      forEach: function(children, forEachFunc, forEachContext) {
+        mapChildren(children, function() {
+          forEachFunc.apply(this, arguments);
+        }, forEachContext);
+      },
+      count: function(children) {
+        var n = 0;
+        mapChildren(children, function() {
+          n++;
+        });
+        return n;
+      },
+      toArray: function(children) {
+        return mapChildren(children, function(child) {
+          return child;
+        }) || [];
+      },
+      only: function(children) {
+        if (!isValidElement(children))
+          throw Error("React.Children.only expected to receive a single React element child.");
+        return children;
+      }
+    };
+    exports.Activity = REACT_ACTIVITY_TYPE;
+    exports.Children = fnName;
+    exports.Component = Component;
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.Profiler = REACT_PROFILER_TYPE;
+    exports.PureComponent = PureComponent;
+    exports.StrictMode = REACT_STRICT_MODE_TYPE;
+    exports.Suspense = REACT_SUSPENSE_TYPE;
+    exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+    exports.__COMPILER_RUNTIME = deprecatedAPIs;
+    exports.act = function(callback) {
+      var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
+      actScopeDepth++;
+      var queue = ReactSharedInternals.actQueue = prevActQueue !== null ? prevActQueue : [], didAwaitActCall = false;
+      try {
+        var result = callback();
+      } catch (error) {
+        ReactSharedInternals.thrownErrors.push(error);
+      }
+      if (0 < ReactSharedInternals.thrownErrors.length)
+        throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+      if (result !== null && typeof result === "object" && typeof result.then === "function") {
+        var thenable = result;
+        queueSeveralMicrotasks(function() {
+          didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
+        });
+        return {
+          then: function(resolve, reject) {
+            didAwaitActCall = true;
+            thenable.then(function(returnValue) {
+              popActScope(prevActQueue, prevActScopeDepth);
+              if (prevActScopeDepth === 0) {
+                try {
+                  flushActQueue(queue), enqueueTask(function() {
+                    return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                  });
+                } catch (error$0) {
+                  ReactSharedInternals.thrownErrors.push(error$0);
+                }
+                if (0 < ReactSharedInternals.thrownErrors.length) {
+                  var _thrownError = aggregateErrors(ReactSharedInternals.thrownErrors);
+                  ReactSharedInternals.thrownErrors.length = 0;
+                  reject(_thrownError);
+                }
+              } else
+                resolve(returnValue);
+            }, function(error) {
+              popActScope(prevActQueue, prevActScopeDepth);
+              0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
+            });
+          }
+        };
+      }
+      var returnValue$jscomp$0 = result;
+      popActScope(prevActQueue, prevActScopeDepth);
+      prevActScopeDepth === 0 && (flushActQueue(queue), queue.length !== 0 && queueSeveralMicrotasks(function() {
+        didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"));
+      }), ReactSharedInternals.actQueue = null);
+      if (0 < ReactSharedInternals.thrownErrors.length)
+        throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+      return {
+        then: function(resolve, reject) {
+          didAwaitActCall = true;
+          prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve, reject);
+          })) : resolve(returnValue$jscomp$0);
+        }
+      };
+    };
+    exports.cache = function(fn) {
+      return function() {
+        return fn.apply(null, arguments);
+      };
+    };
+    exports.cacheSignal = function() {
+      return null;
+    };
+    exports.captureOwnerStack = function() {
+      var getCurrentStack = ReactSharedInternals.getCurrentStack;
+      return getCurrentStack === null ? null : getCurrentStack();
+    };
+    exports.cloneElement = function(element, config, children) {
+      if (element === null || element === undefined)
+        throw Error("The argument must be a React element, but you passed " + element + ".");
+      var props = assign({}, element.props), key = element.key, owner = element._owner;
+      if (config != null) {
+        var JSCompiler_inline_result;
+        a: {
+          if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(config, "ref").get) && JSCompiler_inline_result.isReactWarning) {
+            JSCompiler_inline_result = false;
+            break a;
+          }
+          JSCompiler_inline_result = config.ref !== undefined;
+        }
+        JSCompiler_inline_result && (owner = getOwner());
+        hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
+        for (propName in config)
+          !hasOwnProperty.call(config, propName) || propName === "key" || propName === "__self" || propName === "__source" || propName === "ref" && config.ref === undefined || (props[propName] = config[propName]);
+      }
+      var propName = arguments.length - 2;
+      if (propName === 1)
+        props.children = children;
+      else if (1 < propName) {
+        JSCompiler_inline_result = Array(propName);
+        for (var i = 0;i < propName; i++)
+          JSCompiler_inline_result[i] = arguments[i + 2];
+        props.children = JSCompiler_inline_result;
+      }
+      props = ReactElement(element.type, key, props, owner, element._debugStack, element._debugTask);
+      for (key = 2;key < arguments.length; key++)
+        validateChildKeys(arguments[key]);
+      return props;
+    };
+    exports.createContext = function(defaultValue) {
+      defaultValue = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        _currentValue: defaultValue,
+        _currentValue2: defaultValue,
+        _threadCount: 0,
+        Provider: null,
+        Consumer: null
+      };
+      defaultValue.Provider = defaultValue;
+      defaultValue.Consumer = {
+        $$typeof: REACT_CONSUMER_TYPE,
+        _context: defaultValue
+      };
+      defaultValue._currentRenderer = null;
+      defaultValue._currentRenderer2 = null;
+      return defaultValue;
+    };
+    exports.createElement = function(type, config, children) {
+      for (var i = 2;i < arguments.length; i++)
+        validateChildKeys(arguments[i]);
+      i = {};
+      var key = null;
+      if (config != null)
+        for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = true, console.warn("Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform")), hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key), config)
+          hasOwnProperty.call(config, propName) && propName !== "key" && propName !== "__self" && propName !== "__source" && (i[propName] = config[propName]);
+      var childrenLength = arguments.length - 2;
+      if (childrenLength === 1)
+        i.children = children;
+      else if (1 < childrenLength) {
+        for (var childArray = Array(childrenLength), _i = 0;_i < childrenLength; _i++)
+          childArray[_i] = arguments[_i + 2];
+        Object.freeze && Object.freeze(childArray);
+        i.children = childArray;
+      }
+      if (type && type.defaultProps)
+        for (propName in childrenLength = type.defaultProps, childrenLength)
+          i[propName] === undefined && (i[propName] = childrenLength[propName]);
+      key && defineKeyPropWarningGetter(i, typeof type === "function" ? type.displayName || type.name || "Unknown" : type);
+      var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return ReactElement(type, key, i, getOwner(), propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack, propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+    exports.createRef = function() {
+      var refObject = { current: null };
+      Object.seal(refObject);
+      return refObject;
+    };
+    exports.forwardRef = function(render) {
+      render != null && render.$$typeof === REACT_MEMO_TYPE ? console.error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : typeof render !== "function" ? console.error("forwardRef requires a render function but was given %s.", render === null ? "null" : typeof render) : render.length !== 0 && render.length !== 2 && console.error("forwardRef render functions accept exactly two parameters: props and ref. %s", render.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
+      render != null && render.defaultProps != null && console.error("forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?");
+      var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
+      Object.defineProperty(elementType, "displayName", {
+        enumerable: false,
+        configurable: true,
+        get: function() {
+          return ownName;
+        },
+        set: function(name) {
+          ownName = name;
+          render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
+        }
+      });
+      return elementType;
+    };
+    exports.isValidElement = isValidElement;
+    exports.lazy = function(ctor) {
+      ctor = { _status: -1, _result: ctor };
+      var lazyType = {
+        $$typeof: REACT_LAZY_TYPE,
+        _payload: ctor,
+        _init: lazyInitializer
+      }, ioInfo = {
+        name: "lazy",
+        start: -1,
+        end: -1,
+        value: null,
+        owner: null,
+        debugStack: Error("react-stack-top-frame"),
+        debugTask: console.createTask ? console.createTask("lazy()") : null
+      };
+      ctor._ioInfo = ioInfo;
+      lazyType._debugInfo = [{ awaited: ioInfo }];
+      return lazyType;
+    };
+    exports.memo = function(type, compare) {
+      type == null && console.error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type);
+      compare = {
+        $$typeof: REACT_MEMO_TYPE,
+        type,
+        compare: compare === undefined ? null : compare
+      };
+      var ownName;
+      Object.defineProperty(compare, "displayName", {
+        enumerable: false,
+        configurable: true,
+        get: function() {
+          return ownName;
+        },
+        set: function(name) {
+          ownName = name;
+          type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
+        }
+      });
+      return compare;
+    };
+    exports.startTransition = function(scope) {
+      var prevTransition = ReactSharedInternals.T, currentTransition = {};
+      currentTransition._updatedFibers = new Set;
+      ReactSharedInternals.T = currentTransition;
+      try {
+        var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
+        onStartTransitionFinish !== null && onStartTransitionFinish(currentTransition, returnValue);
+        typeof returnValue === "object" && returnValue !== null && typeof returnValue.then === "function" && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError));
+      } catch (error) {
+        reportGlobalError(error);
+      } finally {
+        prevTransition === null && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table.")), prevTransition !== null && currentTransition.types !== null && (prevTransition.types !== null && prevTransition.types !== currentTransition.types && console.error("We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+      }
+    };
+    exports.unstable_useCacheRefresh = function() {
+      return resolveDispatcher().useCacheRefresh();
+    };
+    exports.use = function(usable) {
+      return resolveDispatcher().use(usable);
+    };
+    exports.useActionState = function(action, initialState, permalink) {
+      return resolveDispatcher().useActionState(action, initialState, permalink);
+    };
+    exports.useCallback = function(callback, deps) {
+      return resolveDispatcher().useCallback(callback, deps);
+    };
+    exports.useContext = function(Context) {
+      var dispatcher = resolveDispatcher();
+      Context.$$typeof === REACT_CONSUMER_TYPE && console.error("Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?");
+      return dispatcher.useContext(Context);
+    };
+    exports.useDebugValue = function(value, formatterFn) {
+      return resolveDispatcher().useDebugValue(value, formatterFn);
+    };
+    exports.useDeferredValue = function(value, initialValue) {
+      return resolveDispatcher().useDeferredValue(value, initialValue);
+    };
+    exports.useEffect = function(create, deps) {
+      create == null && console.warn("React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useEffect(create, deps);
+    };
+    exports.useEffectEvent = function(callback) {
+      return resolveDispatcher().useEffectEvent(callback);
+    };
+    exports.useId = function() {
+      return resolveDispatcher().useId();
+    };
+    exports.useImperativeHandle = function(ref, create, deps) {
+      return resolveDispatcher().useImperativeHandle(ref, create, deps);
+    };
+    exports.useInsertionEffect = function(create, deps) {
+      create == null && console.warn("React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useInsertionEffect(create, deps);
+    };
+    exports.useLayoutEffect = function(create, deps) {
+      create == null && console.warn("React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useLayoutEffect(create, deps);
+    };
+    exports.useMemo = function(create, deps) {
+      return resolveDispatcher().useMemo(create, deps);
+    };
+    exports.useOptimistic = function(passthrough, reducer) {
+      return resolveDispatcher().useOptimistic(passthrough, reducer);
+    };
+    exports.useReducer = function(reducer, initialArg, init) {
+      return resolveDispatcher().useReducer(reducer, initialArg, init);
+    };
+    exports.useRef = function(initialValue) {
+      return resolveDispatcher().useRef(initialValue);
+    };
+    exports.useState = function(initialState) {
+      return resolveDispatcher().useState(initialState);
+    };
+    exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
+      return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    };
+    exports.useTransition = function() {
+      return resolveDispatcher().useTransition();
+    };
+    exports.version = "19.2.3";
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })();
+});
+
+// ../../node_modules/.bun/react@19.2.3/node_modules/react/index.js
+var require_react = __commonJS((exports, module) => {
+  var react_development = __toESM(require_react_development());
+  if (false) {} else {
+    module.exports = react_development;
+  }
+});
+
+// ../../node_modules/.bun/react@19.2.3/node_modules/react/cjs/react-jsx-dev-runtime.development.js
+var require_react_jsx_dev_runtime_development = __commonJS((exports) => {
+  var React = __toESM(require_react());
+  (function() {
+    function getComponentNameFromType(type) {
+      if (type == null)
+        return null;
+      if (typeof type === "function")
+        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if (typeof type === "string")
+        return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+        case REACT_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if (typeof type === "object")
+        switch (typeof type.tag === "number" && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+          case REACT_PORTAL_TYPE:
+            return "Portal";
+          case REACT_CONTEXT_TYPE:
+            return type.displayName || "Context";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = type !== "" ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, innerType !== null ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
+            try {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {}
+        }
+      return null;
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+        return testStringCoercion(value);
+      }
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE)
+        return "<>";
+      if (typeof type === "object" && type !== null && type.$$typeof === REACT_LAZY_TYPE)
+        return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return dispatcher === null ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning)
+          return false;
+      }
+      return config.key !== undefined;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+      componentName = this.props.ref;
+      return componentName !== undefined ? componentName : null;
+    }
+    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+      var refProp = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      (refProp !== undefined ? refProp : null) !== null ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+      var children = config.children;
+      if (children !== undefined)
+        if (isStaticChildren)
+          if (isArrayImpl(children)) {
+            for (isStaticChildren = 0;isStaticChildren < children.length; isStaticChildren++)
+              validateChildKeys(children[isStaticChildren]);
+            Object.freeze && Object.freeze(children);
+          } else
+            console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+        else
+          validateChildKeys(children);
+      if (hasOwnProperty.call(config, "key")) {
+        children = getComponentNameFromType(type);
+        var keys = Object.keys(config).filter(function(k) {
+          return k !== "key";
+        });
+        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = true);
+      }
+      children = null;
+      maybeKey !== undefined && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+      hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+      if ("key" in config) {
+        maybeKey = {};
+        for (var propName in config)
+          propName !== "key" && (maybeKey[propName] = config[propName]);
+      } else
+        maybeKey = config;
+      children && defineKeyPropWarningGetter(maybeKey, typeof type === "function" ? type.displayName || type.name || "Unknown" : type);
+      return ReactElement(type, children, maybeKey, getOwner(), debugStack, debugTask);
+    }
+    function validateChildKeys(node) {
+      isValidElement(node) ? node._store && (node._store.validated = 1) : typeof node === "object" && node !== null && node.$$typeof === REACT_LAZY_TYPE && (node._payload.status === "fulfilled" ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    }
+    function isValidElement(object) {
+      return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    React = {
+      react_stack_bottom_frame: function(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(React, UnknownOwner)();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutKeySpread = {};
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.jsxDEV = function(type, config, maybeKey, isStaticChildren) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(type, config, maybeKey, isStaticChildren, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+  })();
+});
+
+// ../../node_modules/.bun/react@19.2.3/node_modules/react/jsx-dev-runtime.js
+var require_jsx_dev_runtime = __commonJS((exports, module) => {
+  var react_jsx_dev_runtime_development = __toESM(require_react_jsx_dev_runtime_development());
+  if (false) {} else {
+    module.exports = react_jsx_dev_runtime_development;
+  }
+});
+
+// src/ChatContext.tsx
+var import_react = __toESM(require_react(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+var ChatContext = import_react.createContext(null);
+function ChatProvider({ client, children }) {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ChatContext.Provider, {
+    value: client,
+    children
+  }, undefined, false, undefined, this);
+}
+function useChat() {
+  const client = import_react.useContext(ChatContext);
+  if (!client) {
+    throw new Error("useChat must be used within a ChatProvider");
+  }
+  return client;
+}
+// src/hooks/useConversations.ts
+var import_react2 = __toESM(require_react(), 1);
+function useConversations(input, options) {
+  const chat = useChat();
+  const [state, setState] = import_react2.useState({
+    data: null,
+    loading: false,
+    error: null
+  });
+  const inputKey = input ? JSON.stringify(input) : null;
+  const autoLoad = options?.autoLoad;
+  const lastConversationsRef = import_react2.useRef([]);
+  const storeConversations = import_react2.useSyncExternalStore((onStoreChange) => chat.store.subscribe(onStoreChange), () => {
+    const conversations2 = chat.store.conversations();
+    const hasChanged = conversations2.length !== lastConversationsRef.current.length || conversations2.some((conv, idx) => {
+      const prevConv = lastConversationsRef.current[idx];
+      return !prevConv || prevConv.id !== conv.id || prevConv.lastMessageAt?.getTime() !== conv.lastMessageAt?.getTime();
+    });
+    if (!hasChanged) {
+      return lastConversationsRef.current;
+    }
+    lastConversationsRef.current = conversations2;
+    return conversations2;
+  });
+  const loadConversations = import_react2.useCallback(async () => {
+    if (!input) {
+      setState((prev) => ({ ...prev, loading: false }));
+      return;
+    }
+    if (!input.userId) {
+      setState((prev) => ({ ...prev, loading: false }));
+      return;
+    }
+    setState((prev) => ({ ...prev, loading: true, error: null }));
+    try {
+      const result = await chat.getConversations(input);
+      if (result.ok) {
+        setState({
+          data: result.value,
+          loading: false,
+          error: null
+        });
+      } else {
+        setState({
+          data: null,
+          loading: false,
+          error: new Error(result.message || "Erreur lors du chargement des conversations")
+        });
+      }
+    } catch (error) {
+      setState({
+        data: null,
+        loading: false,
+        error: error instanceof Error ? error : new Error("Erreur inconnue")
+      });
+    }
+  }, [chat, inputKey]);
+  import_react2.useEffect(() => {
+    if (autoLoad !== false && inputKey) {
+      loadConversations();
+    }
+  }, [loadConversations, autoLoad, inputKey]);
+  const conversations = storeConversations.length > 0 ? storeConversations : state.data || [];
+  return {
+    conversations,
+    loading: state.loading,
+    error: state.error,
+    refetch: loadConversations
+  };
+}
+// src/hooks/useConversationsWithLastMessages.ts
+var import_react3 = __toESM(require_react(), 1);
+function useConversationsWithLastMessages(input, options) {
+  const chat = useChat();
+  const [state, setState] = import_react3.useState({
+    data: null,
+    loading: false,
+    error: null
+  });
+  const inputKey = input ? JSON.stringify(input) : null;
+  const autoLoad = options?.autoLoad;
+  const lastResultRef = import_react3.useRef([]);
+  const storeData = import_react3.useSyncExternalStore((onStoreChange) => chat.store.subscribe(onStoreChange), () => {
+    const conversations = chat.store.conversations();
+    const result = conversations.map((conversation) => ({
+      conversation,
+      lastMessage: chat.store.lastMessage(conversation.id)
+    }));
+    const hasChanged = result.length !== lastResultRef.current.length || result.some((item, idx) => {
+      const prev = lastResultRef.current[idx];
+      if (!prev)
+        return true;
+      if (prev.conversation.id !== item.conversation.id || prev.conversation.lastMessageAt?.getTime() !== item.conversation.lastMessageAt?.getTime()) {
+        return true;
+      }
+      if (prev.lastMessage?.id !== item.lastMessage?.id || prev.lastMessage?.status !== item.lastMessage?.status || prev.lastMessage?.content !== item.lastMessage?.content) {
+        return true;
+      }
+      return false;
+    });
+    if (!hasChanged) {
+      return lastResultRef.current;
+    }
+    lastResultRef.current = result;
+    return result;
+  });
+  const loadConversations = import_react3.useCallback(async () => {
+    if (!input?.userId) {
+      setState((prev) => ({ ...prev, loading: false }));
+      return;
+    }
+    setState((prev) => ({ ...prev, loading: true, error: null }));
+    try {
+      const result = await chat.getConversations(input);
+      if (result.ok) {
+        setState({
+          data: null,
+          loading: false,
+          error: null
+        });
+      } else {
+        setState({
+          data: null,
+          loading: false,
+          error: new Error(result.message || "Erreur lors du chargement des conversations")
+        });
+      }
+    } catch (error) {
+      setState({
+        data: null,
+        loading: false,
+        error: error instanceof Error ? error : new Error("Erreur inconnue")
+      });
+    }
+  }, [chat, inputKey]);
+  import_react3.useEffect(() => {
+    if (autoLoad !== false && inputKey) {
+      loadConversations();
+    }
+  }, [loadConversations, autoLoad, inputKey]);
+  return {
+    conversationsWithLastMessages: storeData,
+    loading: state.loading,
+    error: state.error,
+    refetch: loadConversations
+  };
+}
+// src/hooks/useConversation.ts
+var import_react4 = __toESM(require_react(), 1);
+function useConversation(conversationId) {
+  const chat = useChat();
+  const lastValueRef = import_react4.useRef(undefined);
+  const lastIdRef = import_react4.useRef(undefined);
+  return import_react4.useSyncExternalStore((onStoreChange) => chat.store.subscribe(onStoreChange), () => {
+    if (!conversationId) {
+      const value = undefined;
+      if (lastIdRef.current !== undefined) {
+        lastIdRef.current = undefined;
+        lastValueRef.current = value;
+      }
+      return value;
+    }
+    if (lastIdRef.current !== conversationId) {
+      const conversations2 = chat.store.conversations();
+      const found2 = conversations2.find((conv) => conv.id === conversationId);
+      lastIdRef.current = conversationId;
+      lastValueRef.current = found2;
+      return found2;
+    }
+    const conversations = chat.store.conversations();
+    const found = conversations.find((conv) => conv.id === conversationId);
+    if (found === lastValueRef.current) {
+      return lastValueRef.current;
+    }
+    lastValueRef.current = found;
+    return found;
+  });
+}
+// src/hooks/useMessages.ts
+var import_react6 = __toESM(require_react(), 1);
+
+// src/hooks/useChatStore.ts
+var import_react5 = __toESM(require_react(), 1);
+function useChatStore() {
+  const chat = useChat();
+  return import_react5.useSyncExternalStore((onStoreChange) => {
+    return chat.store.subscribe(onStoreChange);
+  }, () => {
+    return chat.store.getSnapshot();
+  });
+}
+
+// src/hooks/useMessages.ts
+function useMessages(conversationId, userId, input, options) {
+  const chat = useChat();
+  const store = useChatStore();
+  const [state, setState] = import_react6.useState({
+    data: null,
+    loading: false,
+    error: null
+  });
+  const inputKey = input ? JSON.stringify(input) : null;
+  const autoLoad = options?.autoLoad;
+  const loadMessages = import_react6.useCallback(async () => {
+    setState((prev) => ({ ...prev, loading: true, error: null }));
+    try {
+      const result = await chat.getMessages({
+        conversationId,
+        userId,
+        options: input?.options
+      });
+      if (result.ok) {
+        setState({
+          data: result.value,
+          loading: false,
+          error: null
+        });
+      } else {
+        setState({
+          data: null,
+          loading: false,
+          error: new Error(result.message || "Erreur lors du chargement des messages")
+        });
+      }
+    } catch (error) {
+      setState({
+        data: null,
+        loading: false,
+        error: error instanceof Error ? error : new Error("Erreur inconnue")
+      });
+    }
+  }, [chat, conversationId, userId, inputKey]);
+  import_react6.useEffect(() => {
+    if (autoLoad !== false) {
+      loadMessages();
+    }
+  }, [loadMessages, autoLoad]);
+  const storeMessages = store.messages[conversationId] || [];
+  const messages = storeMessages.length > 0 ? storeMessages : state.data || [];
+  return {
+    messages,
+    loading: state.loading,
+    error: state.error,
+    refetch: loadMessages
+  };
+}
+// src/hooks/useMessage.ts
+var import_react7 = __toESM(require_react(), 1);
+function useMessage(messageId) {
+  const store = useChatStore();
+  return import_react7.useMemo(() => {
+    if (!messageId)
+      return;
+    for (const conversationId in store.messages) {
+      const messages = store.messages[conversationId];
+      if (!messages)
+        continue;
+      const found = messages.find((msg) => msg.id === messageId);
+      if (found) {
+        return found;
+      }
+    }
+    return;
+  }, [store.messages, messageId]);
+}
+// src/hooks/useLastMessage.ts
+var import_react8 = __toESM(require_react(), 1);
+function useLastMessage(conversationId) {
+  const chat = useChat();
+  const lastValueRef = import_react8.useRef(undefined);
+  const lastIdRef = import_react8.useRef(undefined);
+  return import_react8.useSyncExternalStore((onStoreChange) => chat.store.subscribe(onStoreChange), () => {
+    if (!conversationId) {
+      if (lastIdRef.current !== undefined) {
+        lastIdRef.current = undefined;
+        lastValueRef.current = undefined;
+      }
+      return;
+    }
+    const msg = chat.store.lastMessage(conversationId);
+    const cached = lastValueRef.current;
+    if (lastIdRef.current !== conversationId) {
+      lastIdRef.current = conversationId;
+      lastValueRef.current = msg ? { ...msg } : undefined;
+      return lastValueRef.current;
+    }
+    if (!msg && !cached) {
+      return;
+    }
+    if (!msg || !cached) {
+      lastValueRef.current = msg ? { ...msg } : undefined;
+      return lastValueRef.current;
+    }
+    if (msg.id === cached.id && msg.status === cached.status && msg.content === cached.content && msg.type === cached.type) {
+      return cached;
+    }
+    lastValueRef.current = { ...msg };
+    return lastValueRef.current;
+  });
+}
+// src/hooks/useTyping.ts
+function useTyping(conversationId) {
+  const store = useChatStore();
+  return store.typing[conversationId] || [];
+}
+// src/hooks/usePresence.ts
+function usePresence(userId) {
+  const store = useChatStore();
+  return store.presence[userId];
+}
+// src/hooks/useMessagesPagination.ts
+var import_react9 = __toESM(require_react(), 1);
+var MESSAGES_PER_PAGE = 50;
+var defaultPagination = {
+  loading: false,
+  loadingMore: false,
+  hasMore: true,
+  error: null
+};
+function useMessagesPagination({
+  conversationId,
+  userId,
+  autoLoad = true
+}) {
+  const chat = useChat();
+  const lastPaginationRef = import_react9.useRef(undefined);
+  const lastConversationIdRefPagination = import_react9.useRef(undefined);
+  const hasLoadedRef = import_react9.useRef(false);
+  const prevConversationIdRef = import_react9.useRef(undefined);
+  const messagesCache = import_react9.useRef(null);
+  const emptyArray = import_react9.useRef([]);
+  const messages = import_react9.useSyncExternalStore((onStoreChange) => chat.store.subscribe(onStoreChange), () => {
+    if (!conversationId) {
+      return emptyArray.current;
+    }
+    const storeMessages = chat.store.messages(conversationId);
+    if (!storeMessages || storeMessages.length === 0) {
+      return emptyArray.current;
+    }
+    if (messagesCache.current?.conversationId !== conversationId) {
+      messagesCache.current = {
+        conversationId,
+        messages: storeMessages
+      };
+      return storeMessages;
+    }
+    if (messagesCache.current.messages !== storeMessages) {
+      messagesCache.current = {
+        conversationId,
+        messages: storeMessages
+      };
+      return storeMessages;
+    }
+    return messagesCache.current.messages;
+  });
+  const pagination = import_react9.useSyncExternalStore((onStoreChange) => chat.store.subscribe(onStoreChange), () => {
+    if (!conversationId) {
+      return;
+    }
+    const pag = chat.store.pagination(conversationId);
+    if (lastConversationIdRefPagination.current !== conversationId) {
+      lastConversationIdRefPagination.current = conversationId;
+      lastPaginationRef.current = pag;
+      return pag;
+    }
+    if (pag === lastPaginationRef.current) {
+      return lastPaginationRef.current;
+    }
+    if (pag && lastPaginationRef.current && pag.loading === lastPaginationRef.current.loading && pag.loadingMore === lastPaginationRef.current.loadingMore && pag.hasMore === lastPaginationRef.current.hasMore && pag.error === lastPaginationRef.current.error) {
+      return lastPaginationRef.current;
+    }
+    lastPaginationRef.current = pag;
+    return pag;
+  });
+  import_react9.useEffect(() => {
+    if (prevConversationIdRef.current !== conversationId) {
+      hasLoadedRef.current = false;
+      prevConversationIdRef.current = conversationId;
+    }
+    if (autoLoad && conversationId && !pagination?.loading && !hasLoadedRef.current && pagination?.hasMore !== false && !pagination?.error) {
+      hasLoadedRef.current = true;
+      chat.getMessages({
+        conversationId,
+        userId,
+        options: { limit: MESSAGES_PER_PAGE }
+      });
+    }
+  }, [autoLoad, conversationId, userId, pagination?.loading, pagination?.hasMore, pagination?.error, chat]);
+  const loadMoreMessages = import_react9.useCallback(() => {
+    if (!conversationId || pagination?.loadingMore || !pagination?.hasMore || messages.length === 0 || pagination?.loading) {
+      return;
+    }
+    const oldestMessage = messages[messages.length - 1];
+    if (!oldestMessage) {
+      return;
+    }
+    chat.getMessages({
+      conversationId,
+      userId,
+      options: {
+        limit: MESSAGES_PER_PAGE,
+        before: oldestMessage.sentAt
+      }
+    });
+  }, [conversationId, userId, messages, pagination, chat]);
+  const paginationState = pagination ?? defaultPagination;
+  return {
+    messages,
+    loading: paginationState.loading,
+    error: paginationState.error ? new Error(paginationState.error) : null,
+    loadingMore: paginationState.loadingMore,
+    hasMoreMessages: paginationState.hasMore,
+    loadMoreMessages
+  };
+}
+// src/hooks/useSendMessage.ts
+var import_react10 = __toESM(require_react(), 1);
+function useSendMessage() {
+  const chat = useChat();
+  const [state, setState] = import_react10.useState({
+    loading: false,
+    error: null
+  });
+  const sendMessage = import_react10.useCallback(async (input) => {
+    setState({ loading: true, error: null });
+    try {
+      const result = await chat.sendMessage(input);
+      if (result.ok) {
+        setState({ loading: false, error: null });
+      } else {
+        const error = new Error(result.message || "Erreur lors de l'envoi du message");
+        setState({ loading: false, error });
+      }
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error("Erreur inconnue");
+      setState({ loading: false, error: err });
+      return {
+        ok: false,
+        error: "SEND_ERROR",
+        message: err.message
+      };
+    }
+  }, [chat]);
+  return {
+    sendMessage,
+    loading: state.loading,
+    error: state.error
+  };
+}
+// src/hooks/useCreateConversation.ts
+var import_react11 = __toESM(require_react(), 1);
+function useCreateConversation() {
+  const chat = useChat();
+  const [state, setState] = import_react11.useState({
+    loading: false,
+    error: null
+  });
+  const createConversation = import_react11.useCallback(async (input) => {
+    setState({ loading: true, error: null });
+    try {
+      const result = await chat.createConversation(input);
+      if (result.ok) {
+        setState({ loading: false, error: null });
+      } else {
+        const error = new Error(result.message || "Erreur lors de la création de la conversation");
+        setState({ loading: false, error });
+      }
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error("Erreur inconnue");
+      setState({ loading: false, error: err });
+      return {
+        ok: false,
+        error: "CREATE_ERROR",
+        message: err.message
+      };
+    }
+  }, [chat]);
+  return {
+    createConversation,
+    loading: state.loading,
+    error: state.error
+  };
+}
+// src/hooks/useEditMessage.ts
+var import_react12 = __toESM(require_react(), 1);
+function useEditMessage() {
+  const chat = useChat();
+  const [state, setState] = import_react12.useState({
+    loading: false,
+    error: null
+  });
+  const editMessage = import_react12.useCallback(async (input) => {
+    setState({ loading: true, error: null });
+    try {
+      const result = await chat.editMessage(input);
+      if (result.ok) {
+        setState({ loading: false, error: null });
+      } else {
+        const error = new Error(result.message || "Erreur lors de l'édition du message");
+        setState({ loading: false, error });
+      }
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error("Erreur inconnue");
+      setState({ loading: false, error: err });
+      return {
+        ok: false,
+        error: "UPDATE_ERROR",
+        message: err.message
+      };
+    }
+  }, [chat]);
+  return {
+    editMessage,
+    loading: state.loading,
+    error: state.error
+  };
+}
+// src/hooks/useDeleteMessage.ts
+var import_react13 = __toESM(require_react(), 1);
+function useDeleteMessage() {
+  const chat = useChat();
+  const [state, setState] = import_react13.useState({
+    loading: false,
+    error: null
+  });
+  const deleteMessage = import_react13.useCallback(async (input) => {
+    setState({ loading: true, error: null });
+    try {
+      const result = await chat.deleteMessage(input);
+      if (result.ok) {
+        setState({ loading: false, error: null });
+      } else {
+        const error = new Error(result.message || "Erreur lors de la suppression du message");
+        setState({ loading: false, error });
+      }
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error("Erreur inconnue");
+      setState({ loading: false, error: err });
+      return {
+        ok: false,
+        error: "DELETE_ERROR",
+        message: err.message
+      };
+    }
+  }, [chat]);
+  return {
+    deleteMessage,
+    loading: state.loading,
+    error: state.error
+  };
+}
+// src/hooks/useMarkMessageAsRead.ts
+var import_react14 = __toESM(require_react(), 1);
+function useMarkMessageAsRead() {
+  const chat = useChat();
+  const [state, setState] = import_react14.useState({
+    loading: false,
+    error: null
+  });
+  const markAsRead = import_react14.useCallback(async (input) => {
+    setState({ loading: true, error: null });
+    try {
+      const result = await chat.markMessageAsRead(input);
+      if (result.ok) {
+        setState({ loading: false, error: null });
+      } else {
+        const error = new Error(result.message || "Erreur lors du marquage du message comme lu");
+        setState({ loading: false, error });
+      }
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error("Erreur inconnue");
+      setState({ loading: false, error: err });
+      return {
+        ok: false,
+        error: "UPDATE_ERROR",
+        message: err.message
+      };
+    }
+  }, [chat]);
+  return {
+    markAsRead,
+    loading: state.loading,
+    error: state.error
+  };
+}
+// src/hooks/useSubscribeToConversation.ts
+var import_react15 = __toESM(require_react(), 1);
+function useSubscribeToConversation(conversationId, options = {}) {
+  const { enabled = true, userId } = options;
+  const chat = useChat();
+  import_react15.useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+    const unsubscribe = chat.subscribeToConversation(conversationId, userId, { markAsRead: true });
+    return unsubscribe;
+  }, [chat, conversationId, enabled, userId]);
+}
+// src/hooks/useSubscribeToUser.ts
+var import_react16 = __toESM(require_react(), 1);
+function useSubscribeToUser(userId, enabled = true) {
+  const chat = useChat();
+  import_react16.useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+    const unsubscribe = chat.subscribeToUser(userId);
+    return unsubscribe;
+  }, [chat, userId, enabled]);
+}
+// src/hooks/useTrackPresence.ts
+var import_react17 = __toESM(require_react(), 1);
+function useTrackPresence(userId, enabled = true) {
+  const chat = useChat();
+  import_react17.useEffect(() => {
+    if (!enabled || !userId) {
+      return;
+    }
+    const untrack = chat.trackPresence(userId);
+    return untrack;
+  }, [chat, userId, enabled]);
+}
+// src/hooks/useSubscribeToAllConversations.ts
+var import_react18 = __toESM(require_react(), 1);
+function useSubscribeToAllConversations({
+  userId,
+  enabled = true
+}) {
+  const chat = useChat();
+  const unsubscribeFunctionsRef = import_react18.useRef([]);
+  const hasSubscribedRef = import_react18.useRef(false);
+  import_react18.useEffect(() => {
+    if (!enabled || !userId) {
+      return;
+    }
+    if (hasSubscribedRef.current) {
+      return;
+    }
+    chat.getConversations({ userId }).then((result) => {
+      if (!result.ok) {
+        return;
+      }
+      const conversations = result.value;
+      conversations.forEach((conversation) => {
+        const unsubscribe = chat.subscribeToConversation(conversation.id, userId);
+        unsubscribeFunctionsRef.current.push(unsubscribe);
+      });
+      hasSubscribedRef.current = true;
+    }).catch((error) => {
+      console.error("[useSubscribeToAllConversations] Error:", error);
+    });
+    return () => {
+      unsubscribeFunctionsRef.current.forEach((unsubscribe) => unsubscribe());
+      unsubscribeFunctionsRef.current = [];
+      hasSubscribedRef.current = false;
+    };
+  }, [chat, userId, enabled]);
+}
+export {
+  useTyping,
+  useTrackPresence,
+  useSubscribeToUser,
+  useSubscribeToConversation,
+  useSubscribeToAllConversations,
+  useSendMessage,
+  usePresence,
+  useMessagesPagination,
+  useMessages,
+  useMessage,
+  useMarkMessageAsRead,
+  useLastMessage,
+  useEditMessage,
+  useDeleteMessage,
+  useCreateConversation,
+  useConversationsWithLastMessages,
+  useConversations,
+  useConversation,
+  useChat,
+  ChatProvider
+};