@auxilium/datalynk-client 1.5.2 → 1.6.0

package/dist/chat.cjs

@@ -0,0 +1,2202 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.DatalynkChat = {}));
+})(this, function(exports2) {
+  "use strict";var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
+  function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator["throw"](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  }
+  function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() {
+      if (t[0] & 1) throw t[1];
+      return t[1];
+    }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+      return this;
+    }), g;
+    function verb(n) {
+      return function(v) {
+        return step([n, v]);
+      };
+    }
+    function step(op) {
+      if (f) throw new TypeError("Generator is already executing.");
+      while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+        if (y = 0, t) op = [op[0] & 2, t.value];
+        switch (op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            _.label++;
+            return { value: op[1], done: false };
+          case 5:
+            _.label++;
+            y = op[1];
+            op = [0];
+            continue;
+          case 7:
+            op = _.ops.pop();
+            _.trys.pop();
+            continue;
+          default:
+            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1];
+              t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2];
+              _.ops.push(op);
+              break;
+            }
+            if (t[2]) _.ops.pop();
+            _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [6, e];
+        y = 0;
+      } finally {
+        f = t = 0;
+      }
+      if (op[0] & 5) throw op[1];
+      return { value: op[0] ? op[1] : void 0, done: true };
+    }
+  }
+  function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+      next: function() {
+        if (o && i >= o.length) o = void 0;
+        return { value: o && o[i++], done: !o };
+      }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+  }
+  function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    } catch (error) {
+      e = { error };
+    } finally {
+      try {
+        if (r && !r.done && (m = i["return"])) m.call(i);
+      } finally {
+        if (e) throw e.error;
+      }
+    }
+    return ar;
+  }
+  function __spreadArray(to, from2, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from2.length, ar; i < l; i++) {
+      if (ar || !(i in from2)) {
+        if (!ar) ar = Array.prototype.slice.call(from2, 0, i);
+        ar[i] = from2[i];
+      }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from2));
+  }
+  function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+  }
+  function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+      return this;
+    }, i;
+    function awaitReturn(f) {
+      return function(v) {
+        return Promise.resolve(v).then(f, reject);
+      };
+    }
+    function verb(n, f) {
+      if (g[n]) {
+        i[n] = function(v) {
+          return new Promise(function(a, b) {
+            q.push([n, v, a, b]) > 1 || resume(n, v);
+          });
+        };
+        if (f) i[n] = f(i[n]);
+      }
+    }
+    function resume(n, v) {
+      try {
+        step(g[n](v));
+      } catch (e) {
+        settle(q[0][3], e);
+      }
+    }
+    function step(r) {
+      r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+    }
+    function fulfill(value) {
+      resume("next", value);
+    }
+    function reject(value) {
+      resume("throw", value);
+    }
+    function settle(f, v) {
+      if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+    }
+  }
+  function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+      return this;
+    }, i);
+    function verb(n) {
+      i[n] = o[n] && function(v) {
+        return new Promise(function(resolve, reject) {
+          v = o[n](v), settle(resolve, reject, v.done, v.value);
+        });
+      };
+    }
+    function settle(resolve, reject, d, v) {
+      Promise.resolve(v).then(function(v2) {
+        resolve({ value: v2, done: d });
+      }, reject);
+    }
+  }
+  typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  function isFunction(value) {
+    return typeof value === "function";
+  }
+  function createErrorClass(createImpl) {
+    var _super = function(instance) {
+      Error.call(instance);
+      instance.stack = new Error().stack;
+    };
+    var ctorFunc = createImpl(_super);
+    ctorFunc.prototype = Object.create(Error.prototype);
+    ctorFunc.prototype.constructor = ctorFunc;
+    return ctorFunc;
+  }
+  var UnsubscriptionError = createErrorClass(function(_super) {
+    return function UnsubscriptionErrorImpl(errors) {
+      _super(this);
+      this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+        return i + 1 + ") " + err.toString();
+      }).join("\n  ") : "";
+      this.name = "UnsubscriptionError";
+      this.errors = errors;
+    };
+  });
+  function arrRemove(arr, item) {
+    if (arr) {
+      var index = arr.indexOf(item);
+      0 <= index && arr.splice(index, 1);
+    }
+  }
+  var Subscription = function() {
+    function Subscription2(initialTeardown) {
+      this.initialTeardown = initialTeardown;
+      this.closed = false;
+      this._parentage = null;
+      this._finalizers = null;
+    }
+    Subscription2.prototype.unsubscribe = function() {
+      var e_1, _a, e_2, _b;
+      var errors;
+      if (!this.closed) {
+        this.closed = true;
+        var _parentage = this._parentage;
+        if (_parentage) {
+          this._parentage = null;
+          if (Array.isArray(_parentage)) {
+            try {
+              for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+                var parent_1 = _parentage_1_1.value;
+                parent_1.remove(this);
+              }
+            } catch (e_1_1) {
+              e_1 = { error: e_1_1 };
+            } finally {
+              try {
+                if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+              } finally {
+                if (e_1) throw e_1.error;
+              }
+            }
+          } else {
+            _parentage.remove(this);
+          }
+        }
+        var initialFinalizer = this.initialTeardown;
+        if (isFunction(initialFinalizer)) {
+          try {
+            initialFinalizer();
+          } catch (e) {
+            errors = e instanceof UnsubscriptionError ? e.errors : [e];
+          }
+        }
+        var _finalizers = this._finalizers;
+        if (_finalizers) {
+          this._finalizers = null;
+          try {
+            for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+              var finalizer = _finalizers_1_1.value;
+              try {
+                execFinalizer(finalizer);
+              } catch (err) {
+                errors = errors !== null && errors !== void 0 ? errors : [];
+                if (err instanceof UnsubscriptionError) {
+                  errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+                } else {
+                  errors.push(err);
+                }
+              }
+            }
+          } catch (e_2_1) {
+            e_2 = { error: e_2_1 };
+          } finally {
+            try {
+              if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+            } finally {
+              if (e_2) throw e_2.error;
+            }
+          }
+        }
+        if (errors) {
+          throw new UnsubscriptionError(errors);
+        }
+      }
+    };
+    Subscription2.prototype.add = function(teardown) {
+      var _a;
+      if (teardown && teardown !== this) {
+        if (this.closed) {
+          execFinalizer(teardown);
+        } else {
+          if (teardown instanceof Subscription2) {
+            if (teardown.closed || teardown._hasParent(this)) {
+              return;
+            }
+            teardown._addParent(this);
+          }
+          (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+        }
+      }
+    };
+    Subscription2.prototype._hasParent = function(parent) {
+      var _parentage = this._parentage;
+      return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+    };
+    Subscription2.prototype._addParent = function(parent) {
+      var _parentage = this._parentage;
+      this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+    };
+    Subscription2.prototype._removeParent = function(parent) {
+      var _parentage = this._parentage;
+      if (_parentage === parent) {
+        this._parentage = null;
+      } else if (Array.isArray(_parentage)) {
+        arrRemove(_parentage, parent);
+      }
+    };
+    Subscription2.prototype.remove = function(teardown) {
+      var _finalizers = this._finalizers;
+      _finalizers && arrRemove(_finalizers, teardown);
+      if (teardown instanceof Subscription2) {
+        teardown._removeParent(this);
+      }
+    };
+    Subscription2.EMPTY = function() {
+      var empty = new Subscription2();
+      empty.closed = true;
+      return empty;
+    }();
+    return Subscription2;
+  }();
+  var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+  function isSubscription(value) {
+    return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+  }
+  function execFinalizer(finalizer) {
+    if (isFunction(finalizer)) {
+      finalizer();
+    } else {
+      finalizer.unsubscribe();
+    }
+  }
+  var config = {
+    Promise: void 0
+  };
+  var timeoutProvider = {
+    setTimeout: function(handler, timeout) {
+      var args = [];
+      for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+      }
+      return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+    },
+    clearTimeout: function(handle) {
+      return clearTimeout(handle);
+    },
+    delegate: void 0
+  };
+  function reportUnhandledError(err) {
+    timeoutProvider.setTimeout(function() {
+      {
+        throw err;
+      }
+    });
+  }
+  function noop() {
+  }
+  function errorContext(cb) {
+    {
+      cb();
+    }
+  }
+  var Subscriber = function(_super) {
+    __extends(Subscriber2, _super);
+    function Subscriber2(destination) {
+      var _this = _super.call(this) || this;
+      _this.isStopped = false;
+      if (destination) {
+        _this.destination = destination;
+        if (isSubscription(destination)) {
+          destination.add(_this);
+        }
+      } else {
+        _this.destination = EMPTY_OBSERVER;
+      }
+      return _this;
+    }
+    Subscriber2.create = function(next, error, complete) {
+      return new SafeSubscriber(next, error, complete);
+    };
+    Subscriber2.prototype.next = function(value) {
+      if (this.isStopped) ;
+      else {
+        this._next(value);
+      }
+    };
+    Subscriber2.prototype.error = function(err) {
+      if (this.isStopped) ;
+      else {
+        this.isStopped = true;
+        this._error(err);
+      }
+    };
+    Subscriber2.prototype.complete = function() {
+      if (this.isStopped) ;
+      else {
+        this.isStopped = true;
+        this._complete();
+      }
+    };
+    Subscriber2.prototype.unsubscribe = function() {
+      if (!this.closed) {
+        this.isStopped = true;
+        _super.prototype.unsubscribe.call(this);
+        this.destination = null;
+      }
+    };
+    Subscriber2.prototype._next = function(value) {
+      this.destination.next(value);
+    };
+    Subscriber2.prototype._error = function(err) {
+      try {
+        this.destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    };
+    Subscriber2.prototype._complete = function() {
+      try {
+        this.destination.complete();
+      } finally {
+        this.unsubscribe();
+      }
+    };
+    return Subscriber2;
+  }(Subscription);
+  var ConsumerObserver = function() {
+    function ConsumerObserver2(partialObserver) {
+      this.partialObserver = partialObserver;
+    }
+    ConsumerObserver2.prototype.next = function(value) {
+      var partialObserver = this.partialObserver;
+      if (partialObserver.next) {
+        try {
+          partialObserver.next(value);
+        } catch (error) {
+          handleUnhandledError(error);
+        }
+      }
+    };
+    ConsumerObserver2.prototype.error = function(err) {
+      var partialObserver = this.partialObserver;
+      if (partialObserver.error) {
+        try {
+          partialObserver.error(err);
+        } catch (error) {
+          handleUnhandledError(error);
+        }
+      } else {
+        handleUnhandledError(err);
+      }
+    };
+    ConsumerObserver2.prototype.complete = function() {
+      var partialObserver = this.partialObserver;
+      if (partialObserver.complete) {
+        try {
+          partialObserver.complete();
+        } catch (error) {
+          handleUnhandledError(error);
+        }
+      }
+    };
+    return ConsumerObserver2;
+  }();
+  var SafeSubscriber = function(_super) {
+    __extends(SafeSubscriber2, _super);
+    function SafeSubscriber2(observerOrNext, error, complete) {
+      var _this = _super.call(this) || this;
+      var partialObserver;
+      if (isFunction(observerOrNext) || !observerOrNext) {
+        partialObserver = {
+          next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+          error: error !== null && error !== void 0 ? error : void 0,
+          complete: complete !== null && complete !== void 0 ? complete : void 0
+        };
+      } else {
+        {
+          partialObserver = observerOrNext;
+        }
+      }
+      _this.destination = new ConsumerObserver(partialObserver);
+      return _this;
+    }
+    return SafeSubscriber2;
+  }(Subscriber);
+  function handleUnhandledError(error) {
+    {
+      reportUnhandledError(error);
+    }
+  }
+  function defaultErrorHandler(err) {
+    throw err;
+  }
+  var EMPTY_OBSERVER = {
+    closed: true,
+    next: noop,
+    error: defaultErrorHandler,
+    complete: noop
+  };
+  var observable = function() {
+    return typeof Symbol === "function" && Symbol.observable || "@@observable";
+  }();
+  function identity(x) {
+    return x;
+  }
+  function pipeFromArray(fns) {
+    if (fns.length === 0) {
+      return identity;
+    }
+    if (fns.length === 1) {
+      return fns[0];
+    }
+    return function piped(input) {
+      return fns.reduce(function(prev, fn) {
+        return fn(prev);
+      }, input);
+    };
+  }
+  var Observable = function() {
+    function Observable2(subscribe) {
+      if (subscribe) {
+        this._subscribe = subscribe;
+      }
+    }
+    Observable2.prototype.lift = function(operator) {
+      var observable2 = new Observable2();
+      observable2.source = this;
+      observable2.operator = operator;
+      return observable2;
+    };
+    Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
+      var _this = this;
+      var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+      errorContext(function() {
+        var _a = _this, operator = _a.operator, source = _a.source;
+        subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+      });
+      return subscriber;
+    };
+    Observable2.prototype._trySubscribe = function(sink) {
+      try {
+        return this._subscribe(sink);
+      } catch (err) {
+        sink.error(err);
+      }
+    };
+    Observable2.prototype.forEach = function(next, promiseCtor) {
+      var _this = this;
+      promiseCtor = getPromiseCtor(promiseCtor);
+      return new promiseCtor(function(resolve, reject) {
+        var subscriber = new SafeSubscriber({
+          next: function(value) {
+            try {
+              next(value);
+            } catch (err) {
+              reject(err);
+              subscriber.unsubscribe();
+            }
+          },
+          error: reject,
+          complete: resolve
+        });
+        _this.subscribe(subscriber);
+      });
+    };
+    Observable2.prototype._subscribe = function(subscriber) {
+      var _a;
+      return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+    };
+    Observable2.prototype[observable] = function() {
+      return this;
+    };
+    Observable2.prototype.pipe = function() {
+      var operations = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        operations[_i] = arguments[_i];
+      }
+      return pipeFromArray(operations)(this);
+    };
+    Observable2.prototype.toPromise = function(promiseCtor) {
+      var _this = this;
+      promiseCtor = getPromiseCtor(promiseCtor);
+      return new promiseCtor(function(resolve, reject) {
+        var value;
+        _this.subscribe(function(x) {
+          return value = x;
+        }, function(err) {
+          return reject(err);
+        }, function() {
+          return resolve(value);
+        });
+      });
+    };
+    Observable2.create = function(subscribe) {
+      return new Observable2(subscribe);
+    };
+    return Observable2;
+  }();
+  function getPromiseCtor(promiseCtor) {
+    var _a;
+    return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+  }
+  function isObserver(value) {
+    return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+  }
+  function isSubscriber(value) {
+    return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+  }
+  function hasLift(source) {
+    return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+  }
+  function operate(init) {
+    return function(source) {
+      if (hasLift(source)) {
+        return source.lift(function(liftedSource) {
+          try {
+            return init(liftedSource, this);
+          } catch (err) {
+            this.error(err);
+          }
+        });
+      }
+      throw new TypeError("Unable to lift unknown Observable type");
+    };
+  }
+  function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+    return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+  }
+  var OperatorSubscriber = function(_super) {
+    __extends(OperatorSubscriber2, _super);
+    function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+      var _this = _super.call(this, destination) || this;
+      _this.onFinalize = onFinalize;
+      _this.shouldUnsubscribe = shouldUnsubscribe;
+      _this._next = onNext ? function(value) {
+        try {
+          onNext(value);
+        } catch (err) {
+          destination.error(err);
+        }
+      } : _super.prototype._next;
+      _this._error = onError ? function(err) {
+        try {
+          onError(err);
+        } catch (err2) {
+          destination.error(err2);
+        } finally {
+          this.unsubscribe();
+        }
+      } : _super.prototype._error;
+      _this._complete = onComplete ? function() {
+        try {
+          onComplete();
+        } catch (err) {
+          destination.error(err);
+        } finally {
+          this.unsubscribe();
+        }
+      } : _super.prototype._complete;
+      return _this;
+    }
+    OperatorSubscriber2.prototype.unsubscribe = function() {
+      var _a;
+      if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+        var closed_1 = this.closed;
+        _super.prototype.unsubscribe.call(this);
+        !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+      }
+    };
+    return OperatorSubscriber2;
+  }(Subscriber);
+  var ObjectUnsubscribedError = createErrorClass(function(_super) {
+    return function ObjectUnsubscribedErrorImpl() {
+      _super(this);
+      this.name = "ObjectUnsubscribedError";
+      this.message = "object unsubscribed";
+    };
+  });
+  var Subject = function(_super) {
+    __extends(Subject2, _super);
+    function Subject2() {
+      var _this = _super.call(this) || this;
+      _this.closed = false;
+      _this.currentObservers = null;
+      _this.observers = [];
+      _this.isStopped = false;
+      _this.hasError = false;
+      _this.thrownError = null;
+      return _this;
+    }
+    Subject2.prototype.lift = function(operator) {
+      var subject = new AnonymousSubject(this, this);
+      subject.operator = operator;
+      return subject;
+    };
+    Subject2.prototype._throwIfClosed = function() {
+      if (this.closed) {
+        throw new ObjectUnsubscribedError();
+      }
+    };
+    Subject2.prototype.next = function(value) {
+      var _this = this;
+      errorContext(function() {
+        var e_1, _a;
+        _this._throwIfClosed();
+        if (!_this.isStopped) {
+          if (!_this.currentObservers) {
+            _this.currentObservers = Array.from(_this.observers);
+          }
+          try {
+            for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+              var observer = _c.value;
+              observer.next(value);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+        }
+      });
+    };
+    Subject2.prototype.error = function(err) {
+      var _this = this;
+      errorContext(function() {
+        _this._throwIfClosed();
+        if (!_this.isStopped) {
+          _this.hasError = _this.isStopped = true;
+          _this.thrownError = err;
+          var observers = _this.observers;
+          while (observers.length) {
+            observers.shift().error(err);
+          }
+        }
+      });
+    };
+    Subject2.prototype.complete = function() {
+      var _this = this;
+      errorContext(function() {
+        _this._throwIfClosed();
+        if (!_this.isStopped) {
+          _this.isStopped = true;
+          var observers = _this.observers;
+          while (observers.length) {
+            observers.shift().complete();
+          }
+        }
+      });
+    };
+    Subject2.prototype.unsubscribe = function() {
+      this.isStopped = this.closed = true;
+      this.observers = this.currentObservers = null;
+    };
+    Object.defineProperty(Subject2.prototype, "observed", {
+      get: function() {
+        var _a;
+        return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Subject2.prototype._trySubscribe = function(subscriber) {
+      this._throwIfClosed();
+      return _super.prototype._trySubscribe.call(this, subscriber);
+    };
+    Subject2.prototype._subscribe = function(subscriber) {
+      this._throwIfClosed();
+      this._checkFinalizedStatuses(subscriber);
+      return this._innerSubscribe(subscriber);
+    };
+    Subject2.prototype._innerSubscribe = function(subscriber) {
+      var _this = this;
+      var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+      if (hasError || isStopped) {
+        return EMPTY_SUBSCRIPTION;
+      }
+      this.currentObservers = null;
+      observers.push(subscriber);
+      return new Subscription(function() {
+        _this.currentObservers = null;
+        arrRemove(observers, subscriber);
+      });
+    };
+    Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
+      var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+      if (hasError) {
+        subscriber.error(thrownError);
+      } else if (isStopped) {
+        subscriber.complete();
+      }
+    };
+    Subject2.prototype.asObservable = function() {
+      var observable2 = new Observable();
+      observable2.source = this;
+      return observable2;
+    };
+    Subject2.create = function(destination, source) {
+      return new AnonymousSubject(destination, source);
+    };
+    return Subject2;
+  }(Observable);
+  var AnonymousSubject = function(_super) {
+    __extends(AnonymousSubject2, _super);
+    function AnonymousSubject2(destination, source) {
+      var _this = _super.call(this) || this;
+      _this.destination = destination;
+      _this.source = source;
+      return _this;
+    }
+    AnonymousSubject2.prototype.next = function(value) {
+      var _a, _b;
+      (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+    };
+    AnonymousSubject2.prototype.error = function(err) {
+      var _a, _b;
+      (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+    };
+    AnonymousSubject2.prototype.complete = function() {
+      var _a, _b;
+      (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+    };
+    AnonymousSubject2.prototype._subscribe = function(subscriber) {
+      var _a, _b;
+      return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+    };
+    return AnonymousSubject2;
+  }(Subject);
+  var BehaviorSubject = function(_super) {
+    __extends(BehaviorSubject2, _super);
+    function BehaviorSubject2(_value) {
+      var _this = _super.call(this) || this;
+      _this._value = _value;
+      return _this;
+    }
+    Object.defineProperty(BehaviorSubject2.prototype, "value", {
+      get: function() {
+        return this.getValue();
+      },
+      enumerable: false,
+      configurable: true
+    });
+    BehaviorSubject2.prototype._subscribe = function(subscriber) {
+      var subscription = _super.prototype._subscribe.call(this, subscriber);
+      !subscription.closed && subscriber.next(this._value);
+      return subscription;
+    };
+    BehaviorSubject2.prototype.getValue = function() {
+      var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, _value = _a._value;
+      if (hasError) {
+        throw thrownError;
+      }
+      this._throwIfClosed();
+      return _value;
+    };
+    BehaviorSubject2.prototype.next = function(value) {
+      _super.prototype.next.call(this, this._value = value);
+    };
+    return BehaviorSubject2;
+  }(Subject);
+  function isScheduler(value) {
+    return value && isFunction(value.schedule);
+  }
+  function last(arr) {
+    return arr[arr.length - 1];
+  }
+  function popResultSelector(args) {
+    return isFunction(last(args)) ? args.pop() : void 0;
+  }
+  function popScheduler(args) {
+    return isScheduler(last(args)) ? args.pop() : void 0;
+  }
+  var isArrayLike = function(x) {
+    return x && typeof x.length === "number" && typeof x !== "function";
+  };
+  function isPromise(value) {
+    return isFunction(value === null || value === void 0 ? void 0 : value.then);
+  }
+  function isInteropObservable(input) {
+    return isFunction(input[observable]);
+  }
+  function isAsyncIterable(obj) {
+    return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+  }
+  function createInvalidObservableTypeError(input) {
+    return new TypeError("You provided " + (input !== null && typeof input === "object" ? "an invalid object" : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+  }
+  function getSymbolIterator() {
+    if (typeof Symbol !== "function" || !Symbol.iterator) {
+      return "@@iterator";
+    }
+    return Symbol.iterator;
+  }
+  var iterator = getSymbolIterator();
+  function isIterable(input) {
+    return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
+  }
+  function readableStreamLikeToAsyncGenerator(readableStream) {
+    return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+      var reader, _a, value, done;
+      return __generator(this, function(_b) {
+        switch (_b.label) {
+          case 0:
+            reader = readableStream.getReader();
+            _b.label = 1;
+          case 1:
+            _b.trys.push([1, , 9, 10]);
+            _b.label = 2;
+          case 2:
+            return [4, __await(reader.read())];
+          case 3:
+            _a = _b.sent(), value = _a.value, done = _a.done;
+            if (!done) return [3, 5];
+            return [4, __await(void 0)];
+          case 4:
+            return [2, _b.sent()];
+          case 5:
+            return [4, __await(value)];
+          case 6:
+            return [4, _b.sent()];
+          case 7:
+            _b.sent();
+            return [3, 2];
+          case 8:
+            return [3, 10];
+          case 9:
+            reader.releaseLock();
+            return [7];
+          case 10:
+            return [2];
+        }
+      });
+    });
+  }
+  function isReadableStreamLike(obj) {
+    return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+  }
+  function innerFrom(input) {
+    if (input instanceof Observable) {
+      return input;
+    }
+    if (input != null) {
+      if (isInteropObservable(input)) {
+        return fromInteropObservable(input);
+      }
+      if (isArrayLike(input)) {
+        return fromArrayLike(input);
+      }
+      if (isPromise(input)) {
+        return fromPromise(input);
+      }
+      if (isAsyncIterable(input)) {
+        return fromAsyncIterable(input);
+      }
+      if (isIterable(input)) {
+        return fromIterable(input);
+      }
+      if (isReadableStreamLike(input)) {
+        return fromReadableStreamLike(input);
+      }
+    }
+    throw createInvalidObservableTypeError(input);
+  }
+  function fromInteropObservable(obj) {
+    return new Observable(function(subscriber) {
+      var obs = obj[observable]();
+      if (isFunction(obs.subscribe)) {
+        return obs.subscribe(subscriber);
+      }
+      throw new TypeError("Provided object does not correctly implement Symbol.observable");
+    });
+  }
+  function fromArrayLike(array) {
+    return new Observable(function(subscriber) {
+      for (var i = 0; i < array.length && !subscriber.closed; i++) {
+        subscriber.next(array[i]);
+      }
+      subscriber.complete();
+    });
+  }
+  function fromPromise(promise) {
+    return new Observable(function(subscriber) {
+      promise.then(function(value) {
+        if (!subscriber.closed) {
+          subscriber.next(value);
+          subscriber.complete();
+        }
+      }, function(err) {
+        return subscriber.error(err);
+      }).then(null, reportUnhandledError);
+    });
+  }
+  function fromIterable(iterable) {
+    return new Observable(function(subscriber) {
+      var e_1, _a;
+      try {
+        for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+          var value = iterable_1_1.value;
+          subscriber.next(value);
+          if (subscriber.closed) {
+            return;
+          }
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+      subscriber.complete();
+    });
+  }
+  function fromAsyncIterable(asyncIterable) {
+    return new Observable(function(subscriber) {
+      process(asyncIterable, subscriber).catch(function(err) {
+        return subscriber.error(err);
+      });
+    });
+  }
+  function fromReadableStreamLike(readableStream) {
+    return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
+  }
+  function process(asyncIterable, subscriber) {
+    var asyncIterable_1, asyncIterable_1_1;
+    var e_2, _a;
+    return __awaiter(this, void 0, void 0, function() {
+      var value, e_2_1;
+      return __generator(this, function(_b) {
+        switch (_b.label) {
+          case 0:
+            _b.trys.push([0, 5, 6, 11]);
+            asyncIterable_1 = __asyncValues(asyncIterable);
+            _b.label = 1;
+          case 1:
+            return [4, asyncIterable_1.next()];
+          case 2:
+            if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
+            value = asyncIterable_1_1.value;
+            subscriber.next(value);
+            if (subscriber.closed) {
+              return [2];
+            }
+            _b.label = 3;
+          case 3:
+            return [3, 1];
+          case 4:
+            return [3, 11];
+          case 5:
+            e_2_1 = _b.sent();
+            e_2 = { error: e_2_1 };
+            return [3, 11];
+          case 6:
+            _b.trys.push([6, , 9, 10]);
+            if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
+            return [4, _a.call(asyncIterable_1)];
+          case 7:
+            _b.sent();
+            _b.label = 8;
+          case 8:
+            return [3, 10];
+          case 9:
+            if (e_2) throw e_2.error;
+            return [7];
+          case 10:
+            return [7];
+          case 11:
+            subscriber.complete();
+            return [2];
+        }
+      });
+    });
+  }
+  function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
+    if (delay === void 0) {
+      delay = 0;
+    }
+    if (repeat === void 0) {
+      repeat = false;
+    }
+    var scheduleSubscription = scheduler.schedule(function() {
+      work();
+      if (repeat) {
+        parentSubscription.add(this.schedule(null, delay));
+      } else {
+        this.unsubscribe();
+      }
+    }, delay);
+    parentSubscription.add(scheduleSubscription);
+    if (!repeat) {
+      return scheduleSubscription;
+    }
+  }
+  function observeOn(scheduler, delay) {
+    if (delay === void 0) {
+      delay = 0;
+    }
+    return operate(function(source, subscriber) {
+      source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+        return executeSchedule(subscriber, scheduler, function() {
+          return subscriber.next(value);
+        }, delay);
+      }, function() {
+        return executeSchedule(subscriber, scheduler, function() {
+          return subscriber.complete();
+        }, delay);
+      }, function(err) {
+        return executeSchedule(subscriber, scheduler, function() {
+          return subscriber.error(err);
+        }, delay);
+      }));
+    });
+  }
+  function subscribeOn(scheduler, delay) {
+    if (delay === void 0) {
+      delay = 0;
+    }
+    return operate(function(source, subscriber) {
+      subscriber.add(scheduler.schedule(function() {
+        return source.subscribe(subscriber);
+      }, delay));
+    });
+  }
+  function scheduleObservable(input, scheduler) {
+    return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+  }
+  function schedulePromise(input, scheduler) {
+    return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+  }
+  function scheduleArray(input, scheduler) {
+    return new Observable(function(subscriber) {
+      var i = 0;
+      return scheduler.schedule(function() {
+        if (i === input.length) {
+          subscriber.complete();
+        } else {
+          subscriber.next(input[i++]);
+          if (!subscriber.closed) {
+            this.schedule();
+          }
+        }
+      });
+    });
+  }
+  function scheduleIterable(input, scheduler) {
+    return new Observable(function(subscriber) {
+      var iterator$1;
+      executeSchedule(subscriber, scheduler, function() {
+        iterator$1 = input[iterator]();
+        executeSchedule(subscriber, scheduler, function() {
+          var _a;
+          var value;
+          var done;
+          try {
+            _a = iterator$1.next(), value = _a.value, done = _a.done;
+          } catch (err) {
+            subscriber.error(err);
+            return;
+          }
+          if (done) {
+            subscriber.complete();
+          } else {
+            subscriber.next(value);
+          }
+        }, 0, true);
+      });
+      return function() {
+        return isFunction(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return();
+      };
+    });
+  }
+  function scheduleAsyncIterable(input, scheduler) {
+    if (!input) {
+      throw new Error("Iterable cannot be null");
+    }
+    return new Observable(function(subscriber) {
+      executeSchedule(subscriber, scheduler, function() {
+        var iterator2 = input[Symbol.asyncIterator]();
+        executeSchedule(subscriber, scheduler, function() {
+          iterator2.next().then(function(result) {
+            if (result.done) {
+              subscriber.complete();
+            } else {
+              subscriber.next(result.value);
+            }
+          });
+        }, 0, true);
+      });
+    });
+  }
+  function scheduleReadableStreamLike(input, scheduler) {
+    return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
+  }
+  function scheduled(input, scheduler) {
+    if (input != null) {
+      if (isInteropObservable(input)) {
+        return scheduleObservable(input, scheduler);
+      }
+      if (isArrayLike(input)) {
+        return scheduleArray(input, scheduler);
+      }
+      if (isPromise(input)) {
+        return schedulePromise(input, scheduler);
+      }
+      if (isAsyncIterable(input)) {
+        return scheduleAsyncIterable(input, scheduler);
+      }
+      if (isIterable(input)) {
+        return scheduleIterable(input, scheduler);
+      }
+      if (isReadableStreamLike(input)) {
+        return scheduleReadableStreamLike(input, scheduler);
+      }
+    }
+    throw createInvalidObservableTypeError(input);
+  }
+  function from(input, scheduler) {
+    return scheduler ? scheduled(input, scheduler) : innerFrom(input);
+  }
+  function map(project, thisArg) {
+    return operate(function(source, subscriber) {
+      var index = 0;
+      source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+        subscriber.next(project.call(thisArg, value, index++));
+      }));
+    });
+  }
+  var isArray$1 = Array.isArray;
+  function callOrApply(fn, args) {
+    return isArray$1(args) ? fn.apply(void 0, __spreadArray([], __read(args))) : fn(args);
+  }
+  function mapOneOrManyArgs(fn) {
+    return map(function(args) {
+      return callOrApply(fn, args);
+    });
+  }
+  var isArray = Array.isArray;
+  var getPrototypeOf = Object.getPrototypeOf, objectProto = Object.prototype, getKeys = Object.keys;
+  function argsArgArrayOrObject(args) {
+    if (args.length === 1) {
+      var first_1 = args[0];
+      if (isArray(first_1)) {
+        return { args: first_1, keys: null };
+      }
+      if (isPOJO(first_1)) {
+        var keys = getKeys(first_1);
+        return {
+          args: keys.map(function(key) {
+            return first_1[key];
+          }),
+          keys
+        };
+      }
+    }
+    return { args, keys: null };
+  }
+  function isPOJO(obj) {
+    return obj && typeof obj === "object" && getPrototypeOf(obj) === objectProto;
+  }
+  function createObject(keys, values) {
+    return keys.reduce(function(result, key, i) {
+      return result[key] = values[i], result;
+    }, {});
+  }
+  function combineLatest() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    var scheduler = popScheduler(args);
+    var resultSelector = popResultSelector(args);
+    var _a = argsArgArrayOrObject(args), observables = _a.args, keys = _a.keys;
+    if (observables.length === 0) {
+      return from([], scheduler);
+    }
+    var result = new Observable(combineLatestInit(observables, scheduler, keys ? function(values) {
+      return createObject(keys, values);
+    } : identity));
+    return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
+  }
+  function combineLatestInit(observables, scheduler, valueTransform) {
+    if (valueTransform === void 0) {
+      valueTransform = identity;
+    }
+    return function(subscriber) {
+      maybeSchedule(scheduler, function() {
+        var length = observables.length;
+        var values = new Array(length);
+        var active = length;
+        var remainingFirstValues = length;
+        var _loop_1 = function(i2) {
+          maybeSchedule(scheduler, function() {
+            var source = from(observables[i2], scheduler);
+            var hasFirstValue = false;
+            source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+              values[i2] = value;
+              if (!hasFirstValue) {
+                hasFirstValue = true;
+                remainingFirstValues--;
+              }
+              if (!remainingFirstValues) {
+                subscriber.next(valueTransform(values.slice()));
+              }
+            }, function() {
+              if (!--active) {
+                subscriber.complete();
+              }
+            }));
+          }, subscriber);
+        };
+        for (var i = 0; i < length; i++) {
+          _loop_1(i);
+        }
+      }, subscriber);
+    };
+  }
+  function maybeSchedule(scheduler, execute, subscription) {
+    if (scheduler) {
+      executeSchedule(subscription, scheduler, execute);
+    } else {
+      execute();
+    }
+  }
+  class Chat {
+    constructor(api) {
+      __publicField(this, "users$", new BehaviorSubject([]));
+      __publicField(this, "conversations$", new BehaviorSubject([]));
+      __publicField(this, "selectedUser$", new BehaviorSubject(null));
+      __publicField(this, "messages$", new BehaviorSubject([]));
+      __publicField(this, "loading$", new BehaviorSubject(false));
+      __publicField(this, "error$", new BehaviorSubject(null));
+      __publicField(this, "typingUsers$", new BehaviorSubject(/* @__PURE__ */ new Set()));
+      __publicField(this, "hasMore$", new BehaviorSubject(false));
+      __publicField(this, "unread$", combineLatest([this.conversations$]).pipe(
+        map(([rows]) => rows.reduce((total, row) => total + Number(row.unread || 0), 0))
+      ));
+      __publicField(this, "socketUnsubscribe");
+      __publicField(this, "typingTimers", /* @__PURE__ */ new Map());
+      __publicField(this, "initialized", false);
+      this.api = api;
+    }
+    async initialize(force = false) {
+      if (this.initialized && !force) return;
+      this.initialized = true;
+      this.connectRealtime();
+      this.users$.next([]);
+      try {
+        await this.loadConversations();
+      } catch (error) {
+        this.initialized = false;
+        throw error;
+      }
+    }
+    async available() {
+      if (!this.api.token) return false;
+      try {
+        const response = await this.run({ "$/chat/status": {} }, true);
+        return Boolean(response == null ? void 0 : response.enabled);
+      } catch {
+        return false;
+      }
+    }
+    async loadDirectory(search = "", cursor) {
+      const query = search.trim();
+      if (query.length < 2) {
+        this.users$.next([]);
+        return [];
+      }
+      const response = await this.run({
+        "$/chat/directory": { query, cursor, limit: 25 }
+      });
+      const users = response.users || [];
+      this.users$.next(users);
+      const selected = this.selectedUser$.value;
+      const replacement = selected && users.find((user) => user.id === selected.id);
+      if (replacement) this.selectedUser$.next(replacement);
+      return users;
+    }
+    async loadConversations() {
+      const response = await this.run({ "$/chat/conversations": { limit: 75 } });
+      const conversations = (response.conversations || []).map((row) => ({
+        ...row,
+        lastMessage: row.lastMessage ? { ...row.lastMessage, status: "sent" } : null
+      }));
+      this.conversations$.next(conversations);
+      return conversations;
+    }
+    async selectUser(user) {
+      this.selectedUser$.next(user);
+      this.messages$.next([]);
+      this.hasMore$.next(false);
+      await this.loadHistory(user.id);
+      await this.markLatestRead();
+    }
+    async loadHistory(userId, before) {
+      this.loading$.next(true);
+      try {
+        const response = await this.run({
+          "$/chat/history": { userId, before, limit: 75 }
+        });
+        const messages = (response.messages || []).map((message) => ({ ...message, status: "sent" }));
+        this.messages$.next(before ? this.mergeMessages(messages, this.messages$.value) : messages);
+        this.hasMore$.next(Boolean(response.hasMore));
+        return messages;
+      } finally {
+        this.loading$.next(false);
+      }
+    }
+    async send(userId, body, clientId = this.createClientId()) {
+      const text = body.trim();
+      if (!text) throw new Error("Message cannot be empty.");
+      if (text.length > 4e3) throw new Error("Message cannot exceed 4,000 characters.");
+      const existing = this.messages$.value.find((row) => row.clientId === clientId);
+      const optimistic = existing ? { ...existing, status: "sending" } : {
+        id: `pending:${clientId}`,
+        conversationId: this.conversationId(this.currentUserId(), userId),
+        senderId: this.currentUserId(),
+        recipientId: userId,
+        body: text,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        clientId,
+        status: "sending"
+      };
+      this.upsertMessage(optimistic);
+      try {
+        const response = await this.run({
+          "$/chat/send": { userId, body: text, clientMessageId: clientId }
+        });
+        const message = { ...response.message, status: "sent" };
+        this.upsertMessage(message);
+        void this.loadConversations();
+        return message;
+      } catch (error) {
+        this.upsertMessage({ ...optimistic, status: "failed" });
+        throw error;
+      }
+    }
+    async retry(message) {
+      if (!message.clientId) throw new Error("This message cannot be retried.");
+      return this.send(message.recipientId, message.body, message.clientId);
+    }
+    async setTyping(userId, typing) {
+      await this.run({ "$/chat/typing": { userId, typing } }, true);
+    }
+    async markLatestRead() {
+      const peer = this.selectedUser$.value;
+      const messages = this.messages$.value;
+      const latest = [...messages].reverse().find((message) => message.senderId === (peer == null ? void 0 : peer.id) && !message.id.startsWith("pending:"));
+      if (!peer || !latest) return;
+      await this.run({ "$/chat/read": { userId: peer.id, messageId: latest.id } }, true);
+      this.conversations$.next(this.conversations$.value.map(
+        (row) => row.peer.id === peer.id ? { ...row, unread: 0 } : row
+      ));
+    }
+    destroy() {
+      var _a;
+      (_a = this.socketUnsubscribe) == null ? void 0 : _a.call(this);
+      this.socketUnsubscribe = void 0;
+      this.typingTimers.forEach((timer) => clearTimeout(timer));
+      this.typingTimers.clear();
+      this.initialized = false;
+    }
+    connectRealtime() {
+      if (this.socketUnsubscribe) return;
+      this.socketUnsubscribe = this.api.socket.addListener(
+        (event) => this.onSocketEvent(event),
+        () => this.api.socket.send({ chat: { subscribe: true } })
+      );
+    }
+    onSocketEvent(event) {
+      var _a, _b, _c, _d, _e;
+      if (!(event == null ? void 0 : event.type) || event.type.indexOf("chat.") !== 0) return;
+      if (event.type === "chat.message") {
+        const message = (_a = event.data) == null ? void 0 : _a.message;
+        const selected = this.selectedUser$.value;
+        if (message && selected && (message.senderId === selected.id || message.recipientId === selected.id)) {
+          this.upsertMessage({ ...message, status: "sent" });
+          if (message.senderId === selected.id) void this.markLatestRead();
+        }
+        void this.loadConversations();
+      } else if (event.type === "chat.read") {
+        this.applyReadReceipt(event.data);
+        void this.loadConversations();
+      } else if (event.type === "chat.conversation.updated") {
+        void this.loadConversations();
+      } else if (event.type === "chat.typing") {
+        const userId = Number((_b = event.data) == null ? void 0 : _b.userId);
+        if (!userId) return;
+        const next = new Set(this.typingUsers$.value);
+        if ((_c = event.data) == null ? void 0 : _c.typing) {
+          next.add(userId);
+          clearTimeout(this.typingTimers.get(userId));
+          this.typingTimers.set(userId, setTimeout(() => {
+            const later = new Set(this.typingUsers$.value);
+            later.delete(userId);
+            this.typingUsers$.next(later);
+          }, 5e3));
+        } else next.delete(userId);
+        this.typingUsers$.next(next);
+      } else if (event.type === "chat.presence") {
+        const userId = Number((_d = event.data) == null ? void 0 : _d.userId);
+        const online = Boolean((_e = event.data) == null ? void 0 : _e.online);
+        this.users$.next(this.users$.value.map((user) => user.id === userId ? { ...user, online } : user));
+        this.conversations$.next(this.conversations$.value.map(
+          (row) => row.peer.id === userId ? { ...row, peer: { ...row.peer, online } } : row
+        ));
+        const selected = this.selectedUser$.value;
+        if ((selected == null ? void 0 : selected.id) === userId) this.selectedUser$.next({ ...selected, online });
+      }
+    }
+    applyReadReceipt(data) {
+      const readerId = Number(data == null ? void 0 : data.userId);
+      const messageId = String((data == null ? void 0 : data.messageId) || "");
+      const readAt = String((data == null ? void 0 : data.readAt) || (/* @__PURE__ */ new Date()).toISOString());
+      const selected = this.selectedUser$.value;
+      if (!readerId || !messageId || (selected == null ? void 0 : selected.id) !== readerId) return;
+      this.messages$.next(this.messages$.value.map((message) => {
+        if (message.senderId !== this.currentUserId() || message.recipientId !== readerId) return message;
+        if (message.id.startsWith("pending:") || this.compareStreamIds(message.id, messageId) > 0) return message;
+        return { ...message, status: "sent", readAt };
+      }));
+    }
+    upsertMessage(message) {
+      if (!message) return;
+      const current = this.messages$.value;
+      const index = current.findIndex((row) => row.id === message.id || Boolean(message.clientId && row.clientId === message.clientId));
+      if (index < 0) this.messages$.next([...current, message]);
+      else {
+        const next = [...current];
+        next[index] = { ...next[index], ...message };
+        this.messages$.next(next);
+      }
+    }
+    mergeMessages(first, second) {
+      const out = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const message of [...first, ...second]) {
+        const key = message.clientId || message.id;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push(message);
+      }
+      return out;
+    }
+    async run(request, quiet = false) {
+      if (!quiet) this.error$.next(null);
+      try {
+        return await this.api.request(request, { noOptimize: true });
+      } catch (error) {
+        if (!quiet) this.error$.next(String((error == null ? void 0 : error.message) || (error == null ? void 0 : error.error) || "Chat is temporarily unavailable."));
+        throw error;
+      }
+    }
+    currentUserId() {
+      var _a;
+      return Number(((_a = this.api.jwtPayload) == null ? void 0 : _a.uid) || 0);
+    }
+    conversationId(a, b) {
+      return `${Math.min(a, b)}:${Math.max(a, b)}`;
+    }
+    compareStreamIds(a, b) {
+      const [ams, aseq] = a.split("-").map(Number);
+      const [bms, bseq] = b.split("-").map(Number);
+      return ams === bms ? (aseq || 0) - (bseq || 0) : (ams || 0) - (bms || 0);
+    }
+    createClientId() {
+      if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+      return Date.now().toString(36) + "-" + Math.random().toString(36).slice(2);
+    }
+  }
+  const icon = (path) => `<svg viewBox="0 0 24 24" aria-hidden="true"><path d="${path}"/></svg>`;
+  const CHAT_HTML = `
+<section class="dl-chat" role="dialog" aria-label="Datalynk Chat">
+  <header class="dl-chat__titlebar">
+    <div class="dl-chat__brand"><span class="dl-chat__mark">${icon("M4 5h16v11H9l-5 4V5zm3 4v2h2V9H7zm4 0v2h2V9h-2zm4 0v2h2V9h-2z")}</span><strong>Chat</strong></div>
+    <div class="dl-chat__window-actions">
+      <button class="dl-chat__icon-button dl-chat__popout" type="button" aria-label="Open chat in a separate window" title="Open in new window">${icon("M14 3h7v7h-2V6.41l-9.29 9.3-1.42-1.42 9.3-9.29H14V3zM5 5h6v2H5v12h12v-6h2v8H3V5h2z")}</button>
+      <button class="dl-chat__icon-button dl-chat__minimize" type="button" aria-label="Minimize chat" title="Minimize">${icon("M5 11h14v2H5z")}</button>
+      <button class="dl-chat__icon-button dl-chat__close" type="button" aria-label="Close chat" title="Close">${icon("M6.4 5 12 10.6 17.6 5 19 6.4 13.4 12 19 17.6 17.6 19 12 13.4 6.4 19 5 17.6 10.6 12 5 6.4z")}</button>
+    </div>
+  </header>
+  <div class="dl-chat__connection" role="status" hidden></div>
+  <div class="dl-chat__error" role="alert" hidden></div>
+  <div class="dl-chat__body">
+    <aside class="dl-chat__sidebar" aria-label="Conversations">
+      <label class="dl-chat__search-wrap">
+        <span class="sr-only">Search people</span>
+        ${icon("M10 4a6 6 0 1 0 3.87 10.58L19.3 20 20.7 18.6l-5.42-5.43A6 6 0 0 0 10 4zm0 2a4 4 0 1 1 0 8 4 4 0 0 1 0-8z")}
+        <input class="dl-chat__search" type="search" placeholder="Search people" autocomplete="off">
+      </label>
+      <div class="dl-chat__scroll">
+        <h2>Recent</h2>
+        <div class="dl-chat__conversations"></div>
+        <h2>People</h2>
+        <div class="dl-chat__people"></div>
+      </div>
+    </aside>
+    <main class="dl-chat__main">
+      <div class="dl-chat__empty">
+        <span class="dl-chat__empty-icon">${icon("M4 4h16v12H8l-4 4V4zm2 2v9.17L7.17 14H18V6H6z")}</span>
+        <h2>Your conversations</h2>
+        <p>Choose someone from your organization to send a message.</p>
+      </div>
+      <section class="dl-chat__thread" hidden>
+        <header class="dl-chat__thread-header">
+          <button class="dl-chat__icon-button dl-chat__back" type="button" aria-label="Back to conversations">${icon("M20 11H7.83l5.59-5.59L12 4l-8 8 8 8 1.42-1.41L7.83 13H20v-2z")}</button>
+          <span class="dl-chat__avatar dl-chat__thread-avatar"></span>
+          <div><strong class="dl-chat__thread-name"></strong><span class="dl-chat__thread-status"></span></div>
+        </header>
+        <button class="dl-chat__older" type="button">Load earlier messages</button>
+        <div class="dl-chat__messages" aria-live="polite"></div>
+        <div class="dl-chat__typing" aria-live="polite" hidden></div>
+        <footer class="dl-chat__compose">
+          <label class="sr-only" for="dl-chat-message">Message</label>
+          <textarea id="dl-chat-message" class="dl-chat__composer" rows="1" maxlength="4000" placeholder="Write a message"></textarea>
+          <button class="dl-chat__send" type="button" disabled aria-label="Send message" title="Send message">${icon("M3 20.4 21.85 12 3 3.6v6.53L16.46 12 3 13.87v6.53z")}</button>
+          <span class="dl-chat__hint">Enter to send, Shift+Enter for a new line</span>
+        </footer>
+      </section>
+    </main>
+  </div>
+</section>`;
+  const CHAT_CSS = `
+:host{all:initial;position:fixed;inset:0;z-index:2147483000;pointer-events:none;color:#17242b;font-family:"Segoe UI",Tahoma,Arial,sans-serif}
+*{box-sizing:border-box}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}
+button,input,textarea{font:inherit}
+.dl-chat{--teal:#3f6f85;--teal-deep:#2f596d;--teal-soft:#e9f1f4;--red:#c42d27;--green:#599e21;--ink:#17242b;--muted:#60717a;--line:#d7e0e4;position:fixed;right:22px;bottom:22px;width:min(720px,calc(100vw - 32px));height:min(640px,calc(100dvh - 32px));min-width:360px;min-height:460px;display:flex;flex-direction:column;overflow:hidden;resize:both;pointer-events:auto;background:#fff;border:1px solid #c7d2d7;border-radius:10px;box-shadow:0 18px 54px rgba(23,36,43,.24),0 3px 10px rgba(23,36,43,.12);container-type:inline-size}
+.dl-chat.is-popout{inset:0;width:100%;height:100dvh;min-width:0;min-height:0;resize:none;border:0;border-radius:0;box-shadow:none}.dl-chat.is-popout .dl-chat__minimize{display:none}
+.dl-chat__titlebar{height:46px;flex:0 0 46px;display:flex;align-items:center;justify-content:space-between;padding:0 8px 0 14px;color:#fff;background:var(--teal);cursor:move;touch-action:none;user-select:none}
+.dl-chat__brand{display:flex;align-items:center;gap:9px;font-size:15px;letter-spacing:.01em}.dl-chat__mark{display:grid;place-items:center;width:24px;height:24px}.dl-chat__mark svg{width:22px;height:22px;fill:currentColor}
+.dl-chat__window-actions{display:flex;gap:2px}.dl-chat__icon-button{display:grid;place-items:center;width:34px;height:34px;padding:0;border:0;border-radius:5px;color:inherit;background:transparent;cursor:pointer;transition:background-color 120ms ease-out,color 120ms ease-out}.dl-chat__icon-button:hover{background:rgba(255,255,255,.14)}.dl-chat__icon-button:focus-visible,.dl-chat button:focus-visible,.dl-chat input:focus-visible,.dl-chat textarea:focus-visible{outline:2px solid #f2c94c;outline-offset:2px}.dl-chat__icon-button svg{width:18px;height:18px;fill:currentColor}
+.dl-chat__connection,.dl-chat__error{padding:7px 14px;font-size:12px;line-height:1.35}.dl-chat__connection{color:#654d00;background:#fff4c7;border-bottom:1px solid #e8d68c}.dl-chat__error{color:#7b201c;background:#fbe9e8;border-bottom:1px solid #efbfbc}
+.dl-chat__body{min-height:0;flex:1;display:grid;grid-template-columns:260px minmax(0,1fr)}.dl-chat__sidebar{min-width:0;display:flex;flex-direction:column;background:#f4f7f8;border-right:1px solid var(--line)}
+.dl-chat__search-wrap{position:relative;display:block;margin:14px 12px 9px}.dl-chat__search-wrap>svg{position:absolute;left:10px;top:50%;width:17px;height:17px;fill:#70818a;transform:translateY(-50%);pointer-events:none}.dl-chat__search{width:100%;height:36px;padding:0 10px 0 34px;color:var(--ink);background:#fff;border:1px solid #c7d2d7;border-radius:6px;outline:0}.dl-chat__search:focus,.dl-chat__composer:focus{border-color:var(--teal);box-shadow:0 0 0 2px rgba(63,111,133,.15)}
+.dl-chat__scroll{min-height:0;overflow:auto;padding:0 8px 16px}.dl-chat__scroll h2{margin:14px 8px 6px;color:#63757e;font-size:11px;font-weight:700;letter-spacing:.07em;text-transform:uppercase}
+.dl-chat__person{position:relative;width:100%;display:grid;grid-template-columns:38px minmax(0,1fr) 8px;align-items:center;gap:10px;padding:8px;border:0;border-radius:7px;text-align:left;color:var(--ink);background:transparent;cursor:pointer;transition:background-color 120ms ease-out}.dl-chat__person:hover{background:#e5edef}.dl-chat__person.is-selected{background:#dce8ed}.dl-chat__avatar{display:grid;place-items:center;width:38px;height:38px;border-radius:50%;color:#fff;background:var(--teal);font-size:12px;font-weight:700;letter-spacing:.03em}.dl-chat__person-copy{min-width:0}.dl-chat__person-top,.dl-chat__person-bottom{display:flex;align-items:center;justify-content:space-between;gap:8px;min-width:0}.dl-chat__person-top strong,.dl-chat__person-bottom>span:first-child{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.dl-chat__person-top strong{font-size:13px;font-weight:600}.dl-chat__person-top time{flex:0 0 auto;color:#778891;font-size:10px}.dl-chat__person-bottom>span:first-child{color:var(--muted);font-size:11px}.dl-chat__presence{width:8px;height:8px;border:2px solid #87969d;border-radius:50%}.dl-chat__presence.is-online{border-color:var(--green);background:var(--green)}.dl-chat__unread{display:grid;place-items:center;min-width:18px;height:18px;padding:0 5px;border-radius:9px;color:#fff!important;background:var(--red);font-size:10px!important;font-weight:700}.dl-chat__list-empty{margin:6px 8px 12px;color:var(--muted);font-size:12px;line-height:1.45}
+.dl-chat__main{min-width:0;min-height:0}.dl-chat__empty{height:100%;display:flex;flex-direction:column;align-items:center;justify-content:center;padding:36px;text-align:center}.dl-chat__empty-icon{display:grid;place-items:center;width:58px;height:58px;color:var(--teal);background:var(--teal-soft);border-radius:50%}.dl-chat__empty-icon svg{width:27px;height:27px;fill:currentColor}.dl-chat__empty h2{margin:17px 0 5px;font-size:17px}.dl-chat__empty p{max-width:280px;margin:0;color:var(--muted);font-size:13px;line-height:1.5}
+.dl-chat__thread{height:100%;display:grid;grid-template-rows:auto auto minmax(0,1fr) auto auto}.dl-chat__thread[hidden],.dl-chat__empty[hidden]{display:none}.dl-chat__thread-header{height:62px;display:flex;align-items:center;gap:10px;padding:0 16px;border-bottom:1px solid var(--line)}.dl-chat__thread-header .dl-chat__avatar{width:36px;height:36px;flex:0 0 36px}.dl-chat__thread-header>div{min-width:0;display:flex;flex-direction:column}.dl-chat__thread-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:14px}.dl-chat__thread-status{position:relative;padding-left:11px;color:var(--muted);font-size:11px}.dl-chat__thread-status:before{content:"";position:absolute;left:0;top:50%;width:7px;height:7px;border:1.5px solid #87969d;border-radius:50%;transform:translateY(-50%)}.dl-chat__thread-status.is-online:before{border-color:var(--green);background:var(--green)}.dl-chat__back{display:none;color:var(--teal)}
+.dl-chat__older{justify-self:center;margin:7px 0 0;padding:4px 8px;border:0;color:var(--teal-deep);background:transparent;font-size:11px;cursor:pointer}.dl-chat__older:hover{text-decoration:underline}.dl-chat__messages{min-height:0;overflow-y:auto;padding:12px 18px 18px;scroll-behavior:smooth}.dl-chat__date{display:flex;align-items:center;gap:10px;margin:12px 0;color:#71838c;font-size:10px}.dl-chat__date:before,.dl-chat__date:after{content:"";height:1px;flex:1;background:#e3e9ec}.dl-chat__message{display:flex;margin:4px 0}.dl-chat__message.is-mine{justify-content:flex-end}.dl-chat__bubble{max-width:min(76%,430px);padding:8px 10px 6px;color:var(--ink);background:#edf2f4;border-radius:5px 11px 11px 11px;font-size:13px;line-height:1.42;overflow-wrap:anywhere}.dl-chat__message.is-mine .dl-chat__bubble{color:#fff;background:var(--teal);border-radius:11px 5px 11px 11px}.dl-chat__bubble>span{white-space:pre-wrap}.dl-chat__bubble time{display:block;margin-top:3px;color:#6c7e87;font-size:9px;text-align:right}.dl-chat__message.is-mine time{color:rgba(255,255,255,.72)}.dl-chat__retry{display:block;margin:5px 0 0 auto;padding:2px 7px;border:1px solid rgba(255,255,255,.65);border-radius:4px;color:#fff;background:transparent;font-size:10px;cursor:pointer}.dl-chat__retry:hover{background:rgba(255,255,255,.12)}.dl-chat__thread-empty{max-width:300px;margin:auto;padding:24px;color:var(--muted);font-size:12px;line-height:1.5;text-align:center}.dl-chat__typing{height:20px;padding:0 18px;color:var(--muted);font-size:11px;font-style:italic}
+.dl-chat__compose{position:relative;display:grid;grid-template-columns:minmax(0,1fr) 38px;gap:8px;padding:10px 14px 22px;border-top:1px solid var(--line)}.dl-chat__composer{width:100%;min-height:38px;max-height:92px;resize:none;padding:9px 11px;color:var(--ink);border:1px solid #bdcbd1;border-radius:7px;line-height:1.35;outline:0}.dl-chat__send{display:grid;place-items:center;width:38px;height:38px;padding:0;border:0;border-radius:7px;color:#fff;background:var(--teal);cursor:pointer;transition:background-color 120ms ease-out}.dl-chat__send:hover{background:var(--teal-deep)}.dl-chat__send:disabled{cursor:not-allowed;opacity:.45}.dl-chat__send svg{width:19px;height:19px;fill:currentColor}.dl-chat__hint{position:absolute;left:15px;bottom:5px;color:#829098;font-size:9px}
+.dl-chat.is-minimized{left:auto!important;top:auto!important;right:22px!important;bottom:0!important;width:280px!important;height:46px!important;min-height:46px;resize:none;border-radius:9px 9px 0 0}.dl-chat.is-minimized .dl-chat__titlebar{cursor:pointer}.dl-chat.is-minimized .dl-chat__body,.dl-chat.is-minimized .dl-chat__connection,.dl-chat.is-minimized .dl-chat__error{display:none}
+@container (max-width:520px){.dl-chat__body{grid-template-columns:1fr}.dl-chat__main{display:none}.dl-chat.has-selection .dl-chat__sidebar{display:none}.dl-chat.has-selection .dl-chat__main{display:block}.dl-chat__back{display:grid}.dl-chat__hint{display:none}.dl-chat__compose{padding-bottom:10px}}
+@media(max-width:600px){.dl-chat{inset:0;width:100%;height:100dvh;min-width:0;min-height:0;border:0;border-radius:0;resize:none}.dl-chat.is-minimized{inset:auto 12px 0 auto!important;width:min(280px,calc(100vw - 24px))!important;border:1px solid #c7d2d7;border-bottom:0}.dl-chat__titlebar{cursor:default}.dl-chat__popout{display:none}}
+@media(prefers-reduced-motion:reduce){.dl-chat *{scroll-behavior:auto!important;transition-duration:.01ms!important;animation-duration:.01ms!important}}
+`;
+  const windows = /* @__PURE__ */ new WeakMap();
+  function openChat(chat, options = {}) {
+    const doc = options.document || document;
+    const existing = windows.get(doc);
+    if (existing) {
+      existing.show();
+      return existing;
+    }
+    const view = new ChatWindow(chat, { ...options, document: doc });
+    windows.set(doc, view);
+    view.onDestroyed = () => windows.delete(doc);
+    return view;
+  }
+  function closeChat(doc = document) {
+    var _a;
+    (_a = windows.get(doc)) == null ? void 0 : _a.destroy();
+  }
+  class ChatWindow {
+    constructor(chat, options) {
+      __publicField(this, "doc");
+      __publicField(this, "host");
+      __publicField(this, "root");
+      __publicField(this, "subscriptions", []);
+      __publicField(this, "selected", null);
+      __publicField(this, "searchTimer");
+      __publicField(this, "typingTimer");
+      __publicField(this, "typingSent", false);
+      __publicField(this, "resizeObserver");
+      __publicField(this, "renderedMessageIds", "");
+      __publicField(this, "destroyed", false);
+      __publicField(this, "onDestroyed");
+      this.chat = chat;
+      this.options = options;
+      this.doc = options.document || document;
+      this.host = this.doc.createElement("div");
+      this.host.className = "datalynk-chat-host";
+      this.root = this.host.attachShadow({ mode: "open" });
+      this.root.innerHTML = `<style>${CHAT_CSS}</style>${CHAT_HTML}`;
+      this.doc.body.appendChild(this.host);
+      this.bind();
+      this.restoreGeometry();
+      this.subscribe();
+      this.restoreMinimized();
+      void this.initializeGui();
+      this.searchInput.focus();
+    }
+    get api() {
+      return this.chat.api;
+    }
+    show() {
+      this.host.hidden = false;
+      this.setMinimized(false);
+      this.searchInput.focus();
+    }
+    destroy() {
+      var _a, _b, _c, _d, _e, _f;
+      if (this.destroyed) return;
+      this.destroyed = true;
+      this.subscriptions.forEach((subscription) => subscription.unsubscribe());
+      (_a = this.resizeObserver) == null ? void 0 : _a.disconnect();
+      clearTimeout(this.searchTimer);
+      clearTimeout(this.typingTimer);
+      if (this.typingSent && this.selected) void this.chat.setTyping(this.selected.id, false).catch(() => void 0);
+      this.host.remove();
+      (_c = (_b = this.options).onClose) == null ? void 0 : _c.call(_b);
+      (_d = this.onDestroyed) == null ? void 0 : _d.call(this);
+      if (this.options.popout && !((_e = this.doc.defaultView) == null ? void 0 : _e.closed)) (_f = this.doc.defaultView) == null ? void 0 : _f.close();
+    }
+    get shell() {
+      return this.query(".dl-chat");
+    }
+    get searchInput() {
+      return this.query(".dl-chat__search");
+    }
+    get conversationList() {
+      return this.query(".dl-chat__conversations");
+    }
+    get messageList() {
+      return this.query(".dl-chat__messages");
+    }
+    get composer() {
+      return this.query(".dl-chat__composer");
+    }
+    get sendButton() {
+      return this.query(".dl-chat__send");
+    }
+    query(selector) {
+      const node = this.root.querySelector(selector);
+      if (!node) throw new Error(`Missing chat element: ${selector}`);
+      return node;
+    }
+    bind() {
+      var _a;
+      this.query(".dl-chat__close").addEventListener("click", () => this.destroy());
+      this.query(".dl-chat__minimize").addEventListener("click", () => this.setMinimized(!this.shell.classList.contains("is-minimized")));
+      this.query(".dl-chat__popout").addEventListener("click", () => this.popout());
+      this.query(".dl-chat__back").addEventListener("click", () => {
+        this.shell.classList.remove("has-selection");
+        this.searchInput.focus();
+      });
+      this.searchInput.addEventListener("input", () => {
+        clearTimeout(this.searchTimer);
+        this.searchTimer = setTimeout(() => void this.chat.loadDirectory(this.searchInput.value).catch(() => void 0), 220);
+      });
+      this.composer.addEventListener("input", () => this.onComposerInput());
+      this.composer.addEventListener("keydown", (event) => {
+        if (event.key === "Enter" && !event.shiftKey) {
+          event.preventDefault();
+          void this.send();
+        }
+      });
+      this.sendButton.addEventListener("click", () => void this.send());
+      this.query(".dl-chat__older").addEventListener("click", () => {
+        const first = this.chat.messages$.value.find((row) => !row.id.startsWith("pending:"));
+        if (this.selected && first) void this.chat.loadHistory(this.selected.id, first.id);
+      });
+      this.makeDraggable();
+      if (typeof ResizeObserver !== "undefined") {
+        this.resizeObserver = new ResizeObserver(() => this.saveGeometry());
+        this.resizeObserver.observe(this.shell);
+      }
+      (_a = this.doc.defaultView) == null ? void 0 : _a.addEventListener("beforeunload", () => this.destroy(), { once: true });
+    }
+    subscribe() {
+      this.subscriptions.push(
+        this.chat.users$.subscribe((users) => this.renderPeople(users)),
+        this.chat.conversations$.subscribe((rows) => this.renderConversations(rows)),
+        this.chat.selectedUser$.subscribe((user) => {
+          this.selected = user;
+          this.renderSelectedUser(user);
+        }),
+        this.chat.messages$.subscribe((messages) => this.renderMessages(messages)),
+        this.chat.typingUsers$.subscribe((users) => this.renderTyping(users)),
+        this.chat.error$.subscribe((error) => this.renderError(error)),
+        this.chat.hasMore$.subscribe((hasMore) => this.query(".dl-chat__older").toggleAttribute("hidden", !hasMore)),
+        this.api.status$.subscribe((status) => this.renderConnection(status)),
+        this.chat.unread$.subscribe((count) => {
+          var _a, _b;
+          return (_b = (_a = this.options).onUnreadChange) == null ? void 0 : _b.call(_a, count);
+        })
+      );
+    }
+    renderPeople(users) {
+      const query = this.searchInput.value.trim().toLowerCase();
+      const conversationIds = new Set(this.chat.conversations$.value.map((row) => row.peer.id));
+      const filtered = users.filter((user) => query ? [user.displayName, user.login].join(" ").toLowerCase().includes(query) : !conversationIds.has(user.id));
+      const target = this.query(".dl-chat__people");
+      target.replaceChildren();
+      if (!filtered.length) {
+        const empty = this.doc.createElement("p");
+        empty.className = "dl-chat__list-empty";
+        empty.textContent = query ? "No matching people" : "Search for someone to start a conversation.";
+        target.appendChild(empty);
+        return;
+      }
+      filtered.slice(0, query ? 30 : 8).forEach((user) => target.appendChild(this.personButton(user)));
+    }
+    renderConversations(rows) {
+      this.conversationList.replaceChildren();
+      if (!rows.length) {
+        const empty = this.doc.createElement("p");
+        empty.className = "dl-chat__list-empty";
+        empty.textContent = "No conversations yet.";
+        this.conversationList.appendChild(empty);
+      } else rows.forEach((row) => {
+        var _a;
+        const button = this.personButton(row.peer, row);
+        if (((_a = this.selected) == null ? void 0 : _a.id) === row.peer.id) button.classList.add("is-selected");
+        this.conversationList.appendChild(button);
+      });
+      this.renderPeople(this.chat.users$.value);
+    }
+    personButton(user, conversation) {
+      var _a;
+      const button = this.doc.createElement("button");
+      button.type = "button";
+      button.className = "dl-chat__person";
+      button.setAttribute("aria-label", `Open conversation with ${user.displayName}`);
+      const avatar = this.doc.createElement("span");
+      avatar.className = "dl-chat__avatar";
+      avatar.textContent = initials(user.displayName);
+      const copy = this.doc.createElement("span");
+      copy.className = "dl-chat__person-copy";
+      const top = this.doc.createElement("span");
+      top.className = "dl-chat__person-top";
+      const name = this.doc.createElement("strong");
+      name.textContent = user.displayName;
+      const time = this.doc.createElement("time");
+      time.textContent = (conversation == null ? void 0 : conversation.lastMessage) ? shortTime(conversation.lastMessage.createdAt) : "";
+      top.append(name, time);
+      const bottom = this.doc.createElement("span");
+      bottom.className = "dl-chat__person-bottom";
+      const preview = this.doc.createElement("span");
+      preview.textContent = ((_a = conversation == null ? void 0 : conversation.lastMessage) == null ? void 0 : _a.body) || user.login || "Start a conversation";
+      bottom.appendChild(preview);
+      if (conversation == null ? void 0 : conversation.unread) {
+        const badge = this.doc.createElement("span");
+        badge.className = "dl-chat__unread";
+        badge.textContent = String(conversation.unread);
+        badge.setAttribute("aria-label", `${conversation.unread} unread messages`);
+        bottom.appendChild(badge);
+      }
+      copy.append(top, bottom);
+      button.append(avatar, copy, presence(user.online, this.doc));
+      button.addEventListener("click", () => {
+        this.shell.classList.add("has-selection");
+        this.writeSelectedUser(user.id);
+        void this.chat.selectUser(user).then(() => this.composer.focus()).catch(() => void 0);
+      });
+      return button;
+    }
+    renderSelectedUser(user) {
+      this.query(".dl-chat__thread").toggleAttribute("hidden", !user);
+      this.query(".dl-chat__empty").toggleAttribute("hidden", Boolean(user));
+      if (!user) return;
+      this.query(".dl-chat__thread-avatar").textContent = initials(user.displayName);
+      this.query(".dl-chat__thread-name").textContent = user.displayName;
+      const status = this.query(".dl-chat__thread-status");
+      status.textContent = user.online ? "Online" : "Offline";
+      status.classList.toggle("is-online", user.online);
+      this.composer.placeholder = `Message ${user.firstName || user.displayName}`;
+      this.composer.value = this.readDraft(user.id);
+      this.onComposerInput();
+    }
+    renderMessages(messages) {
+      const signature = messages.map((row) => [row.id, row.status || "", row.readAt || ""].join(":")).join(",");
+      if (signature === this.renderedMessageIds) return;
+      const oldHeight = this.messageList.scrollHeight;
+      const oldTop = this.messageList.scrollTop;
+      const pinned = oldHeight - oldTop - this.messageList.clientHeight < 90;
+      this.renderedMessageIds = signature;
+      this.messageList.replaceChildren();
+      if (!messages.length && this.selected) {
+        const note = this.doc.createElement("div");
+        note.className = "dl-chat__thread-empty";
+        note.textContent = `This is the beginning of your conversation with ${this.selected.displayName}.`;
+        this.messageList.appendChild(note);
+        return;
+      }
+      let lastDate = "";
+      messages.forEach((message) => {
+        var _a, _b;
+        const date = new Date(message.createdAt);
+        const dateLabel = date.toLocaleDateString(void 0, { weekday: "short", month: "short", day: "numeric" });
+        if (dateLabel !== lastDate) {
+          const separator = this.doc.createElement("div");
+          separator.className = "dl-chat__date";
+          separator.textContent = dateLabel;
+          this.messageList.appendChild(separator);
+          lastDate = dateLabel;
+        }
+        const row = this.doc.createElement("div");
+        row.className = "dl-chat__message" + (message.senderId === Number((_a = this.api.jwtPayload) == null ? void 0 : _a.uid) ? " is-mine" : "");
+        const bubble = this.doc.createElement("div");
+        bubble.className = "dl-chat__bubble";
+        const body = this.doc.createElement("span");
+        body.textContent = message.body;
+        const time = this.doc.createElement("time");
+        time.dateTime = message.createdAt;
+        const mine = message.senderId === Number((_b = this.api.jwtPayload) == null ? void 0 : _b.uid);
+        const delivery = mine ? message.readAt ? "Read" : message.status === "failed" ? "Failed" : message.status === "sending" ? "Sending" : "Sent" : "";
+        time.textContent = new Intl.DateTimeFormat(void 0, { hour: "numeric", minute: "2-digit" }).format(date) + (delivery ? ` · ${delivery}` : "");
+        bubble.append(body, time);
+        if (message.status === "failed" && mine) {
+          const retry = this.doc.createElement("button");
+          retry.type = "button";
+          retry.className = "dl-chat__retry";
+          retry.textContent = "Retry";
+          retry.addEventListener("click", () => void this.chat.retry(message).catch(() => void 0));
+          bubble.appendChild(retry);
+        }
+        row.appendChild(bubble);
+        this.messageList.appendChild(row);
+      });
+      requestAnimationFrame(() => {
+        if (pinned || messages.length < 15) this.messageList.scrollTop = this.messageList.scrollHeight;
+        else this.messageList.scrollTop = oldTop + Math.max(0, this.messageList.scrollHeight - oldHeight);
+      });
+    }
+    renderTyping(users) {
+      var _a, _b;
+      const active = Boolean(this.selected && users.has(this.selected.id));
+      const node = this.query(".dl-chat__typing");
+      node.toggleAttribute("hidden", !active);
+      node.textContent = active ? `${((_a = this.selected) == null ? void 0 : _a.firstName) || ((_b = this.selected) == null ? void 0 : _b.displayName)} is typing...` : "";
+    }
+    renderError(error) {
+      const node = this.query(".dl-chat__error");
+      node.toggleAttribute("hidden", !error);
+      node.textContent = error || "";
+    }
+    renderConnection(status) {
+      const node = this.query(".dl-chat__connection");
+      node.toggleAttribute("hidden", status === "online");
+      node.textContent = status === "unauthorized" ? "Your session expired. Sign in again to continue chatting." : "Chat is reconnecting. Messages cannot be sent yet.";
+      this.sendButton.disabled = status !== "online" || !this.composer.value.trim();
+    }
+    onComposerInput() {
+      if (!this.selected) return;
+      this.writeDraft(this.selected.id, this.composer.value);
+      this.sendButton.disabled = !this.composer.value.trim() || this.api.status !== "online";
+      if (!this.composer.value.trim()) return;
+      if (!this.typingSent) {
+        this.typingSent = true;
+        void this.chat.setTyping(this.selected.id, true).catch(() => void 0);
+      }
+      clearTimeout(this.typingTimer);
+      this.typingTimer = setTimeout(() => {
+        if (this.selected) void this.chat.setTyping(this.selected.id, false).catch(() => void 0);
+        this.typingSent = false;
+      }, 1600);
+    }
+    async send() {
+      const peer = this.selected;
+      const body = this.composer.value.trim();
+      if (!peer || !body || this.api.status !== "online") return;
+      this.sendButton.disabled = true;
+      this.composer.disabled = true;
+      try {
+        await this.chat.send(peer.id, body);
+        this.composer.value = "";
+        this.writeDraft(peer.id, "");
+        if (this.typingSent) await this.chat.setTyping(peer.id, false).catch(() => void 0);
+        this.typingSent = false;
+      } finally {
+        this.composer.disabled = false;
+        this.sendButton.disabled = true;
+        this.composer.focus();
+      }
+    }
+    popout() {
+      var _a;
+      const popup = (_a = this.doc.defaultView) == null ? void 0 : _a.open("", "datalynk-chat", "popup,width=760,height=720,resizable=yes");
+      if (!popup) {
+        this.chat.error$.next("Allow pop-ups to open chat in a separate window.");
+        return;
+      }
+      popup.document.title = this.options.title || "Datalynk Chat";
+      popup.document.body.style.margin = "0";
+      openChat(this.chat, { ...this.options, document: popup.document, popout: true });
+      this.destroy();
+    }
+    makeDraggable() {
+      if (this.options.popout) {
+        this.shell.classList.add("is-popout");
+        return;
+      }
+      const handle = this.query(".dl-chat__titlebar");
+      handle.addEventListener("click", (event) => {
+        if (this.shell.classList.contains("is-minimized") && !event.target.closest("button")) {
+          this.setMinimized(false);
+        }
+      });
+      handle.addEventListener("pointerdown", (event) => {
+        if (event.target.closest("button")) return;
+        if (this.shell.classList.contains("is-minimized")) return;
+        const shell = this.shell;
+        const rect = shell.getBoundingClientRect();
+        const offsetX = event.clientX - rect.left;
+        const offsetY = event.clientY - rect.top;
+        handle.setPointerCapture(event.pointerId);
+        const move = (next) => {
+          var _a, _b;
+          const maxX = Math.max(0, (((_a = this.doc.defaultView) == null ? void 0 : _a.innerWidth) || 0) - shell.offsetWidth);
+          const maxY = Math.max(0, (((_b = this.doc.defaultView) == null ? void 0 : _b.innerHeight) || 0) - shell.offsetHeight);
+          shell.style.left = Math.min(maxX, Math.max(0, next.clientX - offsetX)) + "px";
+          shell.style.top = Math.min(maxY, Math.max(0, next.clientY - offsetY)) + "px";
+          shell.style.right = "auto";
+          shell.style.bottom = "auto";
+        };
+        const end = () => {
+          handle.removeEventListener("pointermove", move);
+          handle.removeEventListener("pointerup", end);
+          handle.removeEventListener("pointercancel", end);
+          this.saveGeometry();
+        };
+        handle.addEventListener("pointermove", move);
+        handle.addEventListener("pointerup", end);
+        handle.addEventListener("pointercancel", end);
+      });
+    }
+    async initializeGui() {
+      try {
+        await this.chat.initialize();
+        const selectedId = this.readSelectedUser();
+        if (!selectedId || this.chat.selectedUser$.value) return;
+        const conversation = this.chat.conversations$.value.find((row) => row.peer.id === selectedId);
+        if (conversation) {
+          this.shell.classList.add("has-selection");
+          await this.chat.selectUser(conversation.peer);
+        }
+      } catch {
+      }
+    }
+    restoreMinimized() {
+      try {
+        if (localStorage.getItem(this.storageKey("minimized")) === "1") this.setMinimized(true, false);
+      } catch {
+      }
+    }
+    setMinimized(minimized, persist = true) {
+      var _a;
+      if (this.options.popout) return;
+      if (minimized && !this.shell.classList.contains("is-minimized")) this.saveGeometry();
+      this.shell.classList.toggle("is-minimized", minimized);
+      const button = this.query(".dl-chat__minimize");
+      button.setAttribute("aria-label", minimized ? "Restore chat" : "Minimize chat");
+      button.title = minimized ? "Restore" : "Minimize";
+      (_a = button.querySelector("path")) == null ? void 0 : _a.setAttribute("d", minimized ? "M7.4 15.4 12 10.8l4.6 4.6L18 14l-6-6-6 6 1.4 1.4z" : "M5 11h14v2H5z");
+      if (!minimized) this.restoreGeometry();
+      if (persist) this.saveMinimized(minimized);
+    }
+    saveMinimized(value) {
+      try {
+        localStorage.setItem(this.storageKey("minimized"), value ? "1" : "0");
+      } catch {
+      }
+    }
+    readSelectedUser() {
+      try {
+        return Number(localStorage.getItem(this.storageKey("selected")) || 0);
+      } catch {
+        return 0;
+      }
+    }
+    writeSelectedUser(userId) {
+      try {
+        localStorage.setItem(this.storageKey("selected"), String(userId));
+      } catch {
+      }
+    }
+    storageKey(suffix) {
+      return `datalynk-chat:${this.api.spoke || "default"}:${suffix}`;
+    }
+    restoreGeometry() {
+      var _a, _b;
+      if (this.options.popout) return;
+      try {
+        const stored = JSON.parse(localStorage.getItem(this.storageKey("geometry")) || "null");
+        if (!stored) return;
+        const maxWidth = Math.max(360, (((_a = this.doc.defaultView) == null ? void 0 : _a.innerWidth) || 760) - 16);
+        const maxHeight = Math.max(460, (((_b = this.doc.defaultView) == null ? void 0 : _b.innerHeight) || 720) - 16);
+        this.shell.style.width = Math.min(maxWidth, Math.max(360, stored.width || 720)) + "px";
+        this.shell.style.height = Math.min(maxHeight, Math.max(460, stored.height || 640)) + "px";
+        this.shell.style.left = Math.max(0, Math.min(stored.left || 8, maxWidth - 120)) + "px";
+        this.shell.style.top = Math.max(0, Math.min(stored.top || 8, maxHeight - 60)) + "px";
+        this.shell.style.right = "auto";
+        this.shell.style.bottom = "auto";
+      } catch {
+      }
+    }
+    saveGeometry() {
+      if (this.options.popout || this.destroyed || this.shell.classList.contains("is-minimized")) return;
+      const rect = this.shell.getBoundingClientRect();
+      try {
+        localStorage.setItem(this.storageKey("geometry"), JSON.stringify({
+          left: rect.left,
+          top: rect.top,
+          width: rect.width,
+          height: rect.height
+        }));
+      } catch {
+      }
+    }
+    readDraft(userId) {
+      try {
+        return localStorage.getItem(this.storageKey("draft:" + userId)) || "";
+      } catch {
+        return "";
+      }
+    }
+    writeDraft(userId, value) {
+      try {
+        if (value) localStorage.setItem(this.storageKey("draft:" + userId), value);
+        else localStorage.removeItem(this.storageKey("draft:" + userId));
+      } catch {
+      }
+    }
+  }
+  function initials(name) {
+    return name.split(/\s+/).filter(Boolean).slice(0, 2).map((part) => part[0]).join("").toUpperCase() || "?";
+  }
+  function shortTime(value) {
+    if (!value) return "";
+    const date = new Date(value);
+    return date.toDateString() === (/* @__PURE__ */ new Date()).toDateString() ? new Intl.DateTimeFormat(void 0, { hour: "numeric", minute: "2-digit" }).format(date) : new Intl.DateTimeFormat(void 0, { month: "short", day: "numeric" }).format(date);
+  }
+  function presence(online, doc) {
+    const node = doc.createElement("span");
+    node.className = "dl-chat__presence" + (online ? " is-online" : "");
+    node.title = online ? "Online" : "Offline";
+    node.setAttribute("aria-label", node.title);
+    return node;
+  }
+  exports2.Chat = Chat;
+  exports2.ChatWindow = ChatWindow;
+  exports2.closeChat = closeChat;
+  exports2.openChat = openChat;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});