@sockethub/server 5.0.0-alpha.10

package/res/sockethub-client.js

@@ -0,0 +1,631 @@
+(() => {
+  var __create = Object.create;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __toESM = (mod, isNodeMode, target) => {
+    target = mod != null ? __create(__getProtoOf(mod)) : {};
+    const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: () => mod[key],
+          enumerable: true
+        });
+    return to;
+  };
+  var __moduleCache = /* @__PURE__ */ new WeakMap;
+  var __toCommonJS = (from) => {
+    var entry = __moduleCache.get(from), desc;
+    if (entry)
+      return entry;
+    entry = __defProp({}, "__esModule", { value: true });
+    if (from && typeof from === "object" || typeof from === "function")
+      __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+        get: () => from[key],
+        enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+      }));
+    __moduleCache.set(from, entry);
+    return entry;
+  };
+  var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, {
+        get: all[name],
+        enumerable: true,
+        configurable: true,
+        set: (newValue) => all[name] = () => newValue
+      });
+  };
+
+  // ../../node_modules/eventemitter3/index.js
+  var require_eventemitter3 = __commonJS((exports, module) => {
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {}
+    if (Object.create) {
+      Events.prototype = Object.create(null);
+      if (!new Events().__proto__)
+        prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt])
+        emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn)
+        emitter._events[evt].push(listener);
+      else
+        emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0)
+        emitter._events = new Events;
+      else
+        delete emitter._events[evt];
+    }
+    function EventEmitter() {
+      this._events = new Events;
+      this._eventsCount = 0;
+    }
+    EventEmitter.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0)
+        return names;
+      for (name in events = this._events) {
+        if (has.call(events, name))
+          names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers)
+        return [];
+      if (handlers.fn)
+        return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners)
+        return 0;
+      if (listeners.fn)
+        return 1;
+      return listeners.length;
+    };
+    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once)
+          this.removeListener(event, listeners.fn, undefined, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1);i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0;i < length; i++) {
+          if (listeners[i].once)
+            this.removeListener(event, listeners[i].fn, undefined, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args)
+                for (j = 1, args = new Array(len - 1);j < len; j++) {
+                  args[j - 1] = arguments[j];
+                }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length)
+          this._events[evt] = events.length === 1 ? events[0] : events;
+        else
+          clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt])
+          clearEvent(this, evt);
+      } else {
+        this._events = new Events;
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+    EventEmitter.prefixed = prefix;
+    EventEmitter.EventEmitter = EventEmitter;
+    if (typeof module !== "undefined") {
+      module.exports = EventEmitter;
+    }
+  });
+
+  // src/sockethub-client.ts
+  var exports_sockethub_client = {};
+  __export(exports_sockethub_client, {
+    default: () => SockethubClient
+  });
+
+  // ../../node_modules/eventemitter3/index.mjs
+  var import__ = __toESM(require_eventemitter3(), 1);
+  var eventemitter3_default = import__.default;
+
+  // ../activity-streams/src/activity-streams.ts
+  /*!
+   * activity-streams
+   *   https://github.com/silverbucket/activity-streams
+   *
+   * Developed and Maintained by:
+   *   Nick Jennings <nick@silverbucket.net>
+   *
+   * activity-streams is released under the MIT (see LICENSE).
+   *
+   * You don't have to do anything special to choose one license or the other
+   * and you don't have to notify anyone which license you are using.
+   * Please see the corresponding license file for details of these licenses.
+   * You are free to use, modify and distribute this software, but all copyright
+   * information must remain.
+   *
+   */
+  var ee = new eventemitter3_default;
+  var baseProps = {
+    stream: [
+      "id",
+      "type",
+      "actor",
+      "target",
+      "object",
+      "context",
+      "context",
+      "published",
+      "error"
+    ],
+    object: [
+      "id",
+      "type",
+      "context",
+      "alias",
+      "attachedTo",
+      "attachment",
+      "attributedTo",
+      "attributedWith",
+      "condition",
+      "content",
+      "contentMap",
+      "context",
+      "contextOf",
+      "name",
+      "endTime",
+      "generator",
+      "generatorOf",
+      "group",
+      "icon",
+      "image",
+      "inReplyTo",
+      "members",
+      "memberOf",
+      "message",
+      "location",
+      "locationOf",
+      "objectOf",
+      "originOf",
+      "presence",
+      "preview",
+      "previewOf",
+      "provider",
+      "providerOf",
+      "published",
+      "rating",
+      "relationship",
+      "resultOf",
+      "replies",
+      "role",
+      "scope",
+      "scopeOf",
+      "startTime",
+      "status",
+      "summary",
+      "topic",
+      "tag",
+      "tagOf",
+      "targetOf",
+      "title",
+      "titleMap",
+      "updated",
+      "url",
+      "xmpp:stanza-id"
+    ]
+  };
+  var rename = {
+    "@id": "id",
+    "@type": "type",
+    verb: "type",
+    displayName: "name",
+    objectType: "type",
+    platform: "context"
+  };
+  var expand = {
+    actor: {
+      primary: "id",
+      props: baseProps
+    },
+    target: {
+      primary: "id",
+      props: baseProps
+    },
+    object: {
+      primary: "content",
+      props: baseProps
+    }
+  };
+  var objs = new Map;
+  var customProps = {};
+  var failOnUnknownObjectProperties = false;
+  var warnOnUnknownObjectProperties = true;
+  var specialObjs = [];
+  function matchesCustomProp(type, key) {
+    if (customProps[type] instanceof Object) {
+      const obj = customProps[type];
+      if (obj.includes(key)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function renameProp(obj, key) {
+    obj[rename[key]] = obj[key];
+    delete obj[key];
+    return obj;
+  }
+  function validateObject(type, incomingObj, requireId = false) {
+    if (incomingObj === null) {
+      throw new Error(`ActivityStreams validation failed: the "${type}" property is null. Example: { id: "user@example.com", type: "person" }`);
+    }
+    if (incomingObj === undefined) {
+      throw new Error(`ActivityStreams validation failed: the "${type}" property is undefined. Example: { id: "user@example.com", type: "person" }`);
+    }
+    if (typeof incomingObj === "string") {
+      throw new Error(`ActivityStreams validation failed: the "${type}" property received string "${incomingObj}" but expected an object. Use: { id: "${incomingObj}", type: "person" }`);
+    }
+    if (typeof incomingObj !== "object" || Array.isArray(incomingObj)) {
+      const receivedType = Array.isArray(incomingObj) ? "array" : typeof incomingObj;
+      const receivedValue = String(incomingObj);
+      throw new Error(`ActivityStreams validation failed: the "${type}" property must be an object, received ${receivedType} (${receivedValue}). Example: { id: "user@example.com", type: "person" }`);
+    }
+    const obj = incomingObj;
+    if (requireId && !obj.id) {
+      throw new Error(`ActivityStreams validation failed: the "${type}" property requires an 'id' property. Example: { id: "user@example.com", type: "person" }`);
+    }
+    const unknownKeys = Object.keys(incomingObj).filter((key) => {
+      return !baseProps[type].includes(key);
+    });
+    for (const key of unknownKeys) {
+      let ao = incomingObj;
+      if (rename[key]) {
+        ao = renameProp(ao, key);
+        continue;
+      }
+      if (matchesCustomProp(ao.type, key)) {
+        continue;
+      }
+      if (!specialObjs.includes(ao.type)) {
+        console.log(ao);
+        const receivedValue = typeof ao[key] === "string" ? `"${ao[key]}"` : String(ao[key]);
+        const err = `ActivityStreams validation failed: property "${key}" with value ${receivedValue} is not allowed on the "${type}" object of type "${ao.type}".`;
+        if (failOnUnknownObjectProperties) {
+          throw new Error(err);
+        }
+        if (warnOnUnknownObjectProperties) {
+          console.warn(err);
+        }
+      }
+    }
+  }
+  function ensureProps(obj) {
+    return obj;
+  }
+  function expandStream(meta) {
+    const stream = {};
+    for (const key of Object.keys(meta)) {
+      if (typeof meta[key] === "string") {
+        stream[key] = objs.get(meta[key]) || meta[key];
+      } else if (Array.isArray(meta[key])) {
+        stream[key] = [];
+        for (const entry of meta[key]) {
+          if (typeof entry === "string") {
+            stream[key].push(objs.get(entry) || entry);
+          }
+        }
+      } else {
+        stream[key] = meta[key];
+      }
+    }
+    for (const key of Object.keys(expand)) {
+      if (typeof stream[key] === "string") {
+        const idx = expand[key].primary;
+        const obj = {};
+        obj[idx] = stream[key];
+        stream[key] = obj;
+      }
+    }
+    return stream;
+  }
+  function Stream(meta) {
+    validateObject("stream", meta);
+    if (typeof meta.object === "object") {
+      validateObject("object", meta.object);
+    }
+    const stream = expandStream(meta);
+    ee.emit("activity-stream", stream);
+    return stream;
+  }
+  var _Object = {
+    create: (obj) => {
+      validateObject("object", obj, true);
+      const ao = ensureProps(obj);
+      objs.set(ao.id, ao);
+      ee.emit("activity-object-create", ao);
+      return ao;
+    },
+    delete: (id) => {
+      const result = objs.delete(id);
+      if (result) {
+        ee.emit("activity-object-delete", id);
+      }
+      return result;
+    },
+    get: (id, expand2) => {
+      let obj = objs.get(id);
+      if (!obj) {
+        if (!expand2) {
+          return id;
+        }
+        obj = { id };
+      }
+      return ensureProps(obj);
+    },
+    list: () => objs.keys()
+  };
+  function ASFactory(opts = {}) {
+    specialObjs = opts?.specialObjs || [];
+    failOnUnknownObjectProperties = typeof opts.failOnUnknownObjectProperties === "boolean" ? opts.failOnUnknownObjectProperties : failOnUnknownObjectProperties;
+    warnOnUnknownObjectProperties = typeof opts.warnOnUnknownObjectProperties === "boolean" ? opts.warnOnUnknownObjectProperties : warnOnUnknownObjectProperties;
+    for (const propName of Object.keys(opts.customProps || {})) {
+      if (typeof opts.customProps[propName] === "object") {
+        customProps[propName] = opts.customProps[propName];
+      }
+    }
+    return {
+      Stream,
+      Object: _Object,
+      on: (event, func) => ee.on(event, func),
+      once: (event, func) => ee.once(event, func),
+      off: (event, funcName) => ee.off(event, funcName)
+    };
+  }
+  ((global) => {
+    global.ASFactor = ASFactory;
+  })(typeof window === "object" ? window : {});
+
+  // src/sockethub-client.ts
+  class SockethubClient {
+    events = {
+      credentials: new Map,
+      "activity-object": new Map,
+      connect: new Map,
+      join: new Map
+    };
+    _socket;
+    ActivityStreams;
+    socket;
+    debug = true;
+    constructor(socket) {
+      if (!socket) {
+        throw new Error("SockethubClient requires a socket.io instance");
+      }
+      this._socket = socket;
+      this.socket = this.createPublicEmitter();
+      this.registerSocketIOHandlers();
+      this.initActivityStreams();
+      this.ActivityStreams.on("activity-object-create", (obj) => {
+        socket.emit("activity-object", obj, (err) => {
+          if (err) {
+            console.error("failed to create activity-object ", err);
+          } else {
+            this.eventActivityObject(obj);
+          }
+        });
+      });
+      socket.on("activity-object", (obj) => {
+        this.ActivityStreams.Object.create(obj);
+      });
+    }
+    initActivityStreams() {
+      this.ActivityStreams = ASFactory({ specialObjs: ["credentials"] });
+    }
+    clearCredentials() {
+      this.events.credentials.clear();
+    }
+    createPublicEmitter() {
+      const socket = new eventemitter3_default;
+      socket._emit = socket.emit;
+      socket.emit = (event, content, callback) => {
+        if (event === "credentials") {
+          this.eventCredentials(content);
+        } else if (event === "activity-object") {
+          this.eventActivityObject(content);
+        } else if (event === "message") {
+          this.eventMessage(content);
+        }
+        this._socket.emit(event, content, callback);
+      };
+      socket.connected = false;
+      socket.disconnect = () => {
+        this._socket.disconnect();
+      };
+      socket.connect = () => {
+        this._socket.connect();
+      };
+      return socket;
+    }
+    eventActivityObject(content) {
+      if (content.id) {
+        this.events["activity-object"].set(content.id, content);
+      }
+    }
+    eventCredentials(content) {
+      if (content.object && content.object.type === "credentials") {
+        const key = content.actor.id || content.actor;
+        this.events.credentials.set(key, content);
+      }
+    }
+    eventMessage(content) {
+      if (!this._socket.connected) {
+        return;
+      }
+      const key = SockethubClient.getKey(content);
+      if (content.type === "join" || content.type === "connect") {
+        this.events[content.type].set(key, content);
+      } else if (content.type === "leave") {
+        this.events.join.delete(key);
+      } else if (content.type === "disconnect") {
+        this.events.connect.delete(key);
+      }
+    }
+    static getKey(content) {
+      const actor = content.actor?.id || content.actor;
+      if (!actor) {
+        throw new Error(`actor property not present for message type: ${content?.type}`);
+      }
+      const target = content.target ? content.target.id || content.target : "";
+      return `${actor}-${target}`;
+    }
+    log(msg, obj) {
+      if (this.debug) {
+        console.log(msg, obj);
+      }
+    }
+    registerSocketIOHandlers() {
+      const callHandler = (event) => {
+        return async (obj) => {
+          if (event === "connect") {
+            this.socket.id = this._socket.id;
+            this.socket.connected = true;
+            this.replay("activity-object", this.events["activity-object"]);
+            this.replay("credentials", this.events.credentials);
+            this.replay("message", this.events.connect);
+            this.replay("message", this.events.join);
+          } else if (event === "disconnect") {
+            this.socket.connected = false;
+          }
+          this.socket._emit(event, obj);
+        };
+      };
+      this._socket.on("connect", callHandler("connect"));
+      this._socket.on("connect_error", callHandler("connect_error"));
+      this._socket.on("disconnect", callHandler("disconnect"));
+      this._socket.on("message", (obj) => {
+        this.socket._emit("message", this.ActivityStreams.Stream(obj));
+      });
+    }
+    hasActorId(obj) {
+      return "actor" in obj && obj.actor !== null && typeof obj.actor === "object" && "id" in obj.actor && typeof obj.actor.id === "string";
+    }
+    replay(name, asMap) {
+      for (const obj of asMap.values()) {
+        const expandedObj = this.ActivityStreams.Stream(obj);
+        let id = expandedObj?.id;
+        if (this.hasActorId(expandedObj)) {
+          id = expandedObj.actor.id;
+        }
+        this.log(`replaying ${name} for ${id}`);
+        this._socket.emit(name, expandedObj);
+      }
+    }
+  }
+  ((global) => {
+    global.SockethubClient = SockethubClient;
+  })(typeof window === "object" ? window : {});
+})();
+
+//# debugId=6959089BEE28E78064756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../node_modules/eventemitter3/index.js", "../../node_modules/eventemitter3/index.mjs", "../activity-streams/src/activity-streams.ts", "src/sockethub-client.ts"],
  "sourcesContent": [
    "'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n  , prefix = '~';\n\n/**\n * Constructor to create a storage for our `EE` objects.\n * An `Events` instance is a plain object whose properties are event names.\n *\n * @constructor\n * @private\n */\nfunction Events() {}\n\n//\n// We try to not inherit from `Object.prototype`. In some engines creating an\n// instance in this way is faster than calling `Object.create(null)` directly.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// character to make sure that the built-in object properties are not\n// overridden or used as an attack vector.\n//\nif (Object.create) {\n  Events.prototype = Object.create(null);\n\n  //\n  // This hack is needed because the `__proto__` property is still inherited in\n  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\n  //\n  if (!new Events().__proto__) prefix = false;\n}\n\n/**\n * Representation of a single event listener.\n *\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\n * @constructor\n * @private\n */\nfunction EE(fn, context, once) {\n  this.fn = fn;\n  this.context = context;\n  this.once = once || false;\n}\n\n/**\n * Add a listener for a given event.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} once Specify if the listener is a one-time listener.\n * @returns {EventEmitter}\n * @private\n */\nfunction addListener(emitter, event, fn, context, once) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('The listener must be a function');\n  }\n\n  var listener = new EE(fn, context || emitter, once)\n    , evt = prefix ? prefix + event : event;\n\n  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\n  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\n  else emitter._events[evt] = [emitter._events[evt], listener];\n\n  return emitter;\n}\n\n/**\n * Clear event by name.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} evt The Event name.\n * @private\n */\nfunction clearEvent(emitter, evt) {\n  if (--emitter._eventsCount === 0) emitter._events = new Events();\n  else delete emitter._events[evt];\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @public\n */\nfunction EventEmitter() {\n  this._events = new Events();\n  this._eventsCount = 0;\n}\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n  var names = []\n    , events\n    , name;\n\n  if (this._eventsCount === 0) return names;\n\n  for (name in (events = this._events)) {\n    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n  }\n\n  if (Object.getOwnPropertySymbols) {\n    return names.concat(Object.getOwnPropertySymbols(events));\n  }\n\n  return names;\n};\n\n/**\n * Return the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Array} The registered listeners.\n * @public\n */\nEventEmitter.prototype.listeners = function listeners(event) {\n  var evt = prefix ? prefix + event : event\n    , handlers = this._events[evt];\n\n  if (!handlers) return [];\n  if (handlers.fn) return [handlers.fn];\n\n  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\n    ee[i] = handlers[i].fn;\n  }\n\n  return ee;\n};\n\n/**\n * Return the number of listeners listening to a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Number} The number of listeners.\n * @public\n */\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\n  var evt = prefix ? prefix + event : event\n    , listeners = this._events[evt];\n\n  if (!listeners) return 0;\n  if (listeners.fn) return 1;\n  return listeners.length;\n};\n\n/**\n * Calls each of the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Boolean} `true` if the event had listeners, else `false`.\n * @public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return false;\n\n  var listeners = this._events[evt]\n    , len = arguments.length\n    , args\n    , i;\n\n  if (listeners.fn) {\n    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n    switch (len) {\n      case 1: return listeners.fn.call(listeners.context), true;\n      case 2: return listeners.fn.call(listeners.context, a1), true;\n      case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n    }\n\n    for (i = 1, args = new Array(len -1); i < len; i++) {\n      args[i - 1] = arguments[i];\n    }\n\n    listeners.fn.apply(listeners.context, args);\n  } else {\n    var length = listeners.length\n      , j;\n\n    for (i = 0; i < length; i++) {\n      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n      switch (len) {\n        case 1: listeners[i].fn.call(listeners[i].context); break;\n        case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\n        default:\n          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n            args[j - 1] = arguments[j];\n          }\n\n          listeners[i].fn.apply(listeners[i].context, args);\n      }\n    }\n  }\n\n  return true;\n};\n\n/**\n * Add a listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n  return addListener(this, event, fn, context, false);\n};\n\n/**\n * Add a one-time listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n  return addListener(this, event, fn, context, true);\n};\n\n/**\n * Remove the listeners of a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn Only remove the listeners that match this function.\n * @param {*} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return this;\n  if (!fn) {\n    clearEvent(this, evt);\n    return this;\n  }\n\n  var listeners = this._events[evt];\n\n  if (listeners.fn) {\n    if (\n      listeners.fn === fn &&\n      (!once || listeners.once) &&\n      (!context || listeners.context === context)\n    ) {\n      clearEvent(this, evt);\n    }\n  } else {\n    for (var i = 0, events = [], length = listeners.length; i < length; i++) {\n      if (\n        listeners[i].fn !== fn ||\n        (once && !listeners[i].once) ||\n        (context && listeners[i].context !== context)\n      ) {\n        events.push(listeners[i]);\n      }\n    }\n\n    //\n    // Reset the array, or remove it completely if we have no more listeners.\n    //\n    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\n    else clearEvent(this, evt);\n  }\n\n  return this;\n};\n\n/**\n * Remove all listeners, or those of the specified event.\n *\n * @param {(String|Symbol)} [event] The event name.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n  var evt;\n\n  if (event) {\n    evt = prefix ? prefix + event : event;\n    if (this._events[evt]) clearEvent(this, evt);\n  } else {\n    this._events = new Events();\n    this._eventsCount = 0;\n  }\n\n  return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Allow `EventEmitter` to be imported as module namespace.\n//\nEventEmitter.EventEmitter = EventEmitter;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n  module.exports = EventEmitter;\n}\n",
    "import EventEmitter from './index.js'\n\nexport { EventEmitter }\nexport default EventEmitter\n",
    "/*!\n * activity-streams\n *   https://github.com/silverbucket/activity-streams\n *\n * Developed and Maintained by:\n *   Nick Jennings <nick@silverbucket.net>\n *\n * activity-streams is released under the MIT (see LICENSE).\n *\n * You don't have to do anything special to choose one license or the other\n * and you don't have to notify anyone which license you are using.\n * Please see the corresponding license file for details of these licenses.\n * You are free to use, modify and distribute this software, but all copyright\n * information must remain.\n *\n */\n\nimport type { ActivityObject, ActivityStream } from \"@sockethub/schemas\";\nimport EventEmitter from \"eventemitter3\";\n\nconst ee = new EventEmitter();\nconst baseProps = {\n    stream: [\n        \"id\",\n        \"type\",\n        \"actor\",\n        \"target\",\n        \"object\",\n        \"context\",\n        \"context\",\n        \"published\",\n        \"error\",\n    ],\n    object: [\n        \"id\",\n        \"type\",\n        \"context\",\n        \"alias\",\n        \"attachedTo\",\n        \"attachment\",\n        \"attributedTo\",\n        \"attributedWith\",\n        \"condition\",\n        \"content\",\n        \"contentMap\",\n        \"context\",\n        \"contextOf\",\n        \"name\",\n        \"endTime\",\n        \"generator\",\n        \"generatorOf\",\n        \"group\",\n        \"icon\",\n        \"image\",\n        \"inReplyTo\",\n        \"members\",\n        \"memberOf\",\n        \"message\",\n        \"location\",\n        \"locationOf\",\n        \"objectOf\",\n        \"originOf\",\n        \"presence\",\n        \"preview\",\n        \"previewOf\",\n        \"provider\",\n        \"providerOf\",\n        \"published\",\n        \"rating\",\n        \"relationship\",\n        \"resultOf\",\n        \"replies\",\n        \"role\",\n        \"scope\",\n        \"scopeOf\",\n        \"startTime\",\n        \"status\",\n        \"summary\",\n        \"topic\",\n        \"tag\",\n        \"tagOf\",\n        \"targetOf\",\n        \"title\",\n        \"titleMap\",\n        \"updated\",\n        \"url\",\n        \"xmpp:stanza-id\",\n    ],\n};\nconst rename = {\n    \"@id\": \"id\",\n    \"@type\": \"type\",\n    verb: \"type\",\n    displayName: \"name\",\n    objectType: \"type\",\n    platform: \"context\",\n};\nconst expand = {\n    actor: {\n        primary: \"id\",\n        props: baseProps,\n    },\n    target: {\n        primary: \"id\",\n        props: baseProps,\n    },\n    object: {\n        primary: \"content\",\n        props: baseProps,\n    },\n};\n\ntype CustomProps = {\n    [key: string]: string | number | boolean | object | string[];\n};\n\nconst objs = new Map();\nconst customProps: CustomProps = {};\n\nlet failOnUnknownObjectProperties = false;\nlet warnOnUnknownObjectProperties = true;\nlet specialObjs = []; // the objects don't get rejected for bad props\n\nfunction matchesCustomProp(type: string, key: string) {\n    if (customProps[type] instanceof Object) {\n        const obj = customProps[type] as string[];\n        if (obj.includes(key)) {\n            return true;\n        }\n    }\n    return false;\n}\n\nfunction renameProp<T>(obj: T, key: string): T {\n    obj[rename[key]] = obj[key];\n    delete obj[key];\n    return obj;\n}\n\nfunction validateObject<T>(type: string, incomingObj: T, requireId = false) {\n    // Input validation with clear error messages\n    if (incomingObj === null) {\n        throw new Error(\n            `ActivityStreams validation failed: the \"${type}\" property is null. Example: { id: \"user@example.com\", type: \"person\" }`,\n        );\n    }\n\n    if (incomingObj === undefined) {\n        throw new Error(\n            `ActivityStreams validation failed: the \"${type}\" property is undefined. Example: { id: \"user@example.com\", type: \"person\" }`,\n        );\n    }\n\n    if (typeof incomingObj === \"string\") {\n        throw new Error(\n            `ActivityStreams validation failed: the \"${type}\" property received string \"${incomingObj}\" but expected an object. Use: { id: \"${incomingObj}\", type: \"person\" }`,\n        );\n    }\n\n    if (typeof incomingObj !== \"object\" || Array.isArray(incomingObj)) {\n        const receivedType = Array.isArray(incomingObj)\n            ? \"array\"\n            : typeof incomingObj;\n        const receivedValue = String(incomingObj);\n        throw new Error(\n            `ActivityStreams validation failed: the \"${type}\" property must be an object, received ${receivedType} (${receivedValue}). Example: { id: \"user@example.com\", type: \"person\" }`,\n        );\n    }\n\n    // Require 'id' property when explicitly requested (e.g., Object.create())\n    const obj = incomingObj as ActivityObject;\n    if (requireId && !obj.id) {\n        throw new Error(\n            `ActivityStreams validation failed: the \"${type}\" property requires an 'id' property. Example: { id: \"user@example.com\", type: \"person\" }`,\n        );\n    }\n\n    const unknownKeys = Object.keys(incomingObj).filter(\n        (key: string): boolean => {\n            return !baseProps[type].includes(key);\n        },\n    );\n\n    for (const key of unknownKeys) {\n        let ao: ActivityObject = incomingObj as ActivityObject;\n        if (rename[key]) {\n            // rename property instead of fail\n            ao = renameProp(ao, key);\n            continue;\n        }\n\n        if (matchesCustomProp(ao.type, key)) {\n            // custom property matches, continue\n            continue;\n        }\n\n        if (!specialObjs.includes(ao.type)) {\n            // not defined as a special prop\n            // don't know what to do with it, so throw error\n            console.log(ao);\n            const receivedValue =\n                typeof ao[key] === \"string\" ? `\"${ao[key]}\"` : String(ao[key]);\n            const err = `ActivityStreams validation failed: property \"${key}\" with value ${receivedValue} is not allowed on the \"${type}\" object of type \"${ao.type}\".`;\n            if (failOnUnknownObjectProperties) {\n                throw new Error(err);\n            }\n            if (warnOnUnknownObjectProperties) {\n                console.warn(err);\n            }\n        }\n    }\n}\n\nfunction ensureProps(obj: ActivityObject): ActivityObject {\n    // ensure the name property, which can generally be inferred from the id\n    // name = obj.match(/(?(?\\w+):\\/\\/)(?:.+@)?(.+?)(?:\\/|$)/)[1]\n    return obj;\n}\n\nfunction expandStream(meta: ActivityStream) {\n    const stream = {};\n    for (const key of Object.keys(meta)) {\n        if (typeof meta[key] === \"string\") {\n            stream[key] = objs.get(meta[key]) || meta[key];\n        } else if (Array.isArray(meta[key])) {\n            stream[key] = [];\n            for (const entry of meta[key]) {\n                if (typeof entry === \"string\") {\n                    stream[key].push(objs.get(entry) || entry);\n                }\n            }\n        } else {\n            stream[key] = meta[key];\n        }\n    }\n\n    // only expand string into objects if they are in the expand list\n    for (const key of Object.keys(expand)) {\n        if (typeof stream[key] === \"string\") {\n            const idx = expand[key].primary;\n            const obj = {};\n            obj[idx] = stream[key];\n            stream[key] = obj;\n        }\n    }\n    return stream;\n}\n\nfunction Stream(\n    meta: ActivityStream,\n): ActivityStream | ActivityObject | Record<string, never> {\n    validateObject(\"stream\", meta);\n    if (typeof meta.object === \"object\") {\n        validateObject(\"object\", meta.object);\n    }\n    const stream = expandStream(meta);\n    ee.emit(\"activity-stream\", stream);\n    return stream;\n}\n\nexport interface ActivityObjectManager {\n    create(obj: unknown): unknown;\n    delete(id: string): boolean;\n    list(): IterableIterator<unknown>;\n    get(id: string, expand?: boolean): unknown;\n}\n\nconst _Object: ActivityObjectManager = {\n    create: (obj: ActivityObject) => {\n        validateObject(\"object\", obj, true); // require ID for Object.create()\n        const ao = ensureProps(obj);\n        objs.set(ao.id, ao);\n        ee.emit(\"activity-object-create\", ao);\n        return ao;\n    },\n\n    delete: (id) => {\n        const result = objs.delete(id);\n        if (result) {\n            ee.emit(\"activity-object-delete\", id);\n        }\n        return result;\n    },\n\n    get: (id, expand) => {\n        let obj = objs.get(id);\n        if (!obj) {\n            if (!expand) {\n                return id;\n            }\n            obj = { id: id };\n        }\n        return ensureProps(obj);\n    },\n\n    list: (): IterableIterator<unknown> => objs.keys(),\n};\n\nexport interface ASFactoryOptions {\n    specialObjs?: Array<string>;\n    failOnUnknownObjectProperties?: boolean;\n    warnOnUnknownObjectProperties?: boolean;\n    customProps?: CustomProps;\n}\n\ntype EventCallback = (...args: unknown[]) => void;\n\nexport interface ASManager {\n    Stream(meta: unknown): ActivityStream | ActivityObject;\n    Object: ActivityObjectManager;\n    on(event: string, func: EventCallback): void;\n    once(event: string, func: EventCallback): void;\n    off(event: string, func: EventCallback): void;\n}\n\nexport function ASFactory(opts: ASFactoryOptions = {}): ASManager {\n    specialObjs = opts?.specialObjs || [];\n    failOnUnknownObjectProperties =\n        typeof opts.failOnUnknownObjectProperties === \"boolean\"\n            ? opts.failOnUnknownObjectProperties\n            : failOnUnknownObjectProperties;\n    warnOnUnknownObjectProperties =\n        typeof opts.warnOnUnknownObjectProperties === \"boolean\"\n            ? opts.warnOnUnknownObjectProperties\n            : warnOnUnknownObjectProperties;\n    for (const propName of Object.keys(opts.customProps || {})) {\n        if (typeof opts.customProps[propName] === \"object\") {\n            customProps[propName] = opts.customProps[propName];\n        }\n    }\n\n    return {\n        Stream: Stream,\n        Object: _Object,\n        on: (event, func) => ee.on(event, func),\n        once: (event, func) => ee.once(event, func),\n        off: (event, funcName) => ee.off(event, funcName),\n    } as ASManager;\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\n((global: any) => {\n    global.ASFactor = ASFactory;\n})(typeof window === \"object\" ? window : {});\n",
    "import { ASFactory, type ASManager } from \"@sockethub/activity-streams\";\nimport type {\n    ActivityObject,\n    ActivityStream,\n    BaseActivityObject,\n} from \"@sockethub/schemas\";\nimport EventEmitter from \"eventemitter3\";\nimport type { Socket } from \"socket.io-client\";\n\nexport interface EventMapping {\n    credentials: Map<string, ActivityStream>;\n    \"activity-object\": Map<string, BaseActivityObject>;\n    connect: Map<string, ActivityStream>;\n    join: Map<string, ActivityStream>;\n}\n\ninterface CustomEmitter extends EventEmitter {\n    _emit(s: string, o: unknown, c?: unknown): void;\n    connect(): void;\n    disconnect(): void;\n    connected: boolean;\n    id: string;\n}\n\n/**\n * SockethubClient - Client library for Sockethub protocol gateway\n *\n * A JavaScript client for connecting to Sockethub servers. Provides a high-level\n * API for sending and receiving ActivityStreams messages over Socket.IO, with\n * automatic state management and reconnection handling.\n *\n * Sockethub acts as a protocol gateway, translating ActivityStreams messages into\n * various protocols (XMPP, IRC, RSS, etc.). This client handles the communication\n * with the Sockethub server, including credential management, connection state,\n * and automatic reconnection.\n *\n * ## Automatic Reconnection & State Replay\n *\n * This client automatically handles transient network disconnections by storing\n * connection state in memory and replaying it when the socket reconnects.\n *\n * ### Security Model\n *\n * **Storage Location:**\n * - All credentials and state are stored ONLY in JavaScript memory (heap)\n * - Nothing is persisted to localStorage, sessionStorage, cookies, or disk\n * - Memory is cleared when the browser tab closes or page refreshes\n *\n * **Replay Triggers:**\n * - Automatic replay occurs on Socket.IO reconnection events\n * - Typically triggered by brief network interruptions (WiFi switching, mobile network blips)\n * - Does NOT occur on page refresh (new SockethubClient instance = empty state)\n *\n * **Server Restart Behavior:**\n * - If server restarts, client socket will reconnect and replay credentials\n * - Server must handle replayed credentials appropriately (validate, reject stale sessions, etc.)\n * - Applications should implement proper session validation server-side\n *\n * **Lifetime:**\n * - Credentials exist only during the browser tab's lifetime\n * - Cleared on page reload, tab close, or manual disconnect\n * - Not accessible across tabs or after browser restart\n *\n * **What Gets Replayed:**\n * - Credentials (username/password/tokens sent via credentials event)\n * - Activity Objects (actor definitions)\n * - Connect commands (platform connections)\n * - Join commands (room/channel joins)\n *\n * @example\n * ```typescript\n * // Create client\n * const socket = io('http://localhost:10550');\n * const client = new SockethubClient(socket);\n *\n * // Send credentials - these will be replayed on reconnection\n * client.socket.emit('credentials', {\n *   actor: 'user@example.com',\n *   object: { username: 'user', password: 'pass' }\n * });\n *\n * // If network disconnects and reconnects, credentials are automatically replayed\n * // If page refreshes, credentials are lost and must be resent\n * ```\n */\nexport default class SockethubClient {\n    /**\n     * In-memory storage for client state that should be replayed on reconnection.\n     *\n     * Security: Stored ONLY in JavaScript heap memory. Never persisted to disk,\n     * localStorage, or any permanent storage. Cleared on page reload.\n     */\n    private events: EventMapping = {\n        credentials: new Map(),\n        \"activity-object\": new Map(),\n        connect: new Map(),\n        join: new Map(),\n    };\n    private _socket: Socket;\n    public ActivityStreams: ASManager;\n    public socket: CustomEmitter;\n    public debug = true;\n\n    constructor(socket: Socket) {\n        if (!socket) {\n            throw new Error(\"SockethubClient requires a socket.io instance\");\n        }\n        this._socket = socket;\n\n        this.socket = this.createPublicEmitter();\n        this.registerSocketIOHandlers();\n        this.initActivityStreams();\n\n        this.ActivityStreams.on(\n            \"activity-object-create\",\n            (obj: ActivityObject) => {\n                socket.emit(\"activity-object\", obj, (err: never) => {\n                    if (err) {\n                        console.error(\"failed to create activity-object \", err);\n                    } else {\n                        this.eventActivityObject(obj);\n                    }\n                });\n            },\n        );\n\n        socket.on(\"activity-object\", (obj) => {\n            this.ActivityStreams.Object.create(obj);\n        });\n    }\n\n    initActivityStreams() {\n        this.ActivityStreams = ASFactory({ specialObjs: [\"credentials\"] });\n    }\n\n    /**\n     * Clear stored credentials to prevent automatic replay on reconnection.\n     *\n     * This method removes all stored credentials from memory. Useful for\n     * security-sensitive applications that want to prevent automatic credential\n     * replay when the socket reconnects.\n     *\n     * @example\n     * ```typescript\n     * // Clear credentials on disconnect\n     * sc.socket.on('disconnect', () => {\n     *   sc.clearCredentials();\n     * });\n     * ```\n     */\n    public clearCredentials(): void {\n        this.events.credentials.clear();\n    }\n\n    private createPublicEmitter(): CustomEmitter {\n        const socket = new EventEmitter() as CustomEmitter;\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        socket._emit = socket.emit;\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        socket.emit = (event, content, callback): void => {\n            if (event === \"credentials\") {\n                this.eventCredentials(content);\n            } else if (event === \"activity-object\") {\n                this.eventActivityObject(content);\n            } else if (event === \"message\") {\n                this.eventMessage(content);\n            }\n            this._socket.emit(event as string, content, callback);\n        };\n        socket.connected = false;\n        socket.disconnect = () => {\n            this._socket.disconnect();\n        };\n        socket.connect = () => {\n            this._socket.connect();\n        };\n        return socket;\n    }\n\n    private eventActivityObject(content: ActivityObject) {\n        if (content.id) {\n            this.events[\"activity-object\"].set(content.id, content);\n        }\n    }\n\n    private eventCredentials(content: ActivityStream) {\n        if (content.object && content.object.type === \"credentials\") {\n            const key: string =\n                content.actor.id || (content.actor as unknown as string);\n            this.events.credentials.set(key, content);\n        }\n    }\n\n    private eventMessage(content: BaseActivityObject) {\n        if (!this._socket.connected) {\n            return;\n        }\n        // either stores or delete the specified content onto the storedJoins map,\n        // for reply once we're back online.\n        const key = SockethubClient.getKey(content as ActivityStream);\n        if (content.type === \"join\" || content.type === \"connect\") {\n            this.events[content.type].set(key, content as ActivityStream);\n        } else if (content.type === \"leave\") {\n            this.events.join.delete(key);\n        } else if (content.type === \"disconnect\") {\n            this.events.connect.delete(key);\n        }\n    }\n\n    private static getKey(content: ActivityStream) {\n        const actor = content.actor?.id || content.actor;\n        if (!actor) {\n            throw new Error(\n                `actor property not present for message type: ${content?.type}`,\n            );\n        }\n        const target = content.target\n            ? content.target.id || content.target\n            : \"\";\n        return `${actor}-${target}`;\n    }\n\n    private log(msg: string, obj?: unknown) {\n        if (this.debug) {\n            console.log(msg, obj);\n        }\n    }\n\n    private registerSocketIOHandlers() {\n        // middleware for events which don't deal in AS objects\n        const callHandler = (event: string) => {\n            return async (obj?: unknown) => {\n                if (event === \"connect\") {\n                    this.socket.id = this._socket.id;\n                    this.socket.connected = true;\n\n                    /**\n                     * Automatic state replay on reconnection.\n                     *\n                     * When Socket.IO reconnects after a network interruption, we automatically\n                     * replay all stored state to restore the session seamlessly:\n                     *\n                     * 1. Activity Objects (actor definitions)\n                     * 2. Credentials (authentication)\n                     * 3. Connect commands (platform connections)\n                     * 4. Join commands (room/channel memberships)\n                     *\n                     * This allows the client to survive brief network blips without requiring\n                     * user intervention. However, the server must properly validate replayed\n                     * credentials as they may be stale or revoked.\n                     */\n                    this.replay(\n                        \"activity-object\",\n                        this.events[\"activity-object\"],\n                    );\n                    this.replay(\"credentials\", this.events.credentials);\n                    this.replay(\"message\", this.events.connect);\n                    this.replay(\"message\", this.events.join);\n                } else if (event === \"disconnect\") {\n                    this.socket.connected = false;\n                }\n                this.socket._emit(event, obj);\n            };\n        };\n\n        // register for events that give us information on connection status\n        this._socket.on(\"connect\", callHandler(\"connect\"));\n        this._socket.on(\"connect_error\", callHandler(\"connect_error\"));\n        this._socket.on(\"disconnect\", callHandler(\"disconnect\"));\n\n        // use as middleware to receive incoming Sockethub messages and unpack them\n        // using the ActivityStreams library before passing them along to the app.\n        this._socket.on(\"message\", (obj) => {\n            this.socket._emit(\"message\", this.ActivityStreams.Stream(obj));\n        });\n    }\n\n    /**\n     * Type guard to check if an object is an ActivityStream with a valid actor.id.\n     */\n    private hasActorId(\n        obj: ActivityStream | ActivityObject,\n    ): obj is ActivityStream {\n        return (\n            \"actor\" in obj &&\n            obj.actor !== null &&\n            typeof obj.actor === \"object\" &&\n            \"id\" in obj.actor &&\n            typeof obj.actor.id === \"string\"\n        );\n    }\n\n    /**\n     * Replays previously sent events to the server after reconnection.\n     *\n     * This method is called automatically when the Socket.IO connection is\n     * re-established after a transient network interruption. It resends\n     * credentials and connection state so the user doesn't need to manually\n     * re-authenticate or rejoin channels.\n     *\n     * Security considerations:\n     * - Only replays events stored in memory during this session\n     * - Does not replay after page refresh (memory cleared)\n     * - Server should validate replayed credentials (may be stale/revoked)\n     *\n     * @param name - Event name to emit (\"credentials\", \"activity-object\", \"message\")\n     * @param asMap - Map of events to replay\n     */\n    private replay(\n        name: string,\n        asMap: Map<string, ActivityStream | BaseActivityObject>,\n    ) {\n        for (const obj of asMap.values()) {\n            const expandedObj = this.ActivityStreams.Stream(obj);\n            let id = expandedObj?.id;\n            if (this.hasActorId(expandedObj)) {\n                id = expandedObj.actor.id;\n            }\n            this.log(`replaying ${name} for ${id}`);\n            this._socket.emit(name, expandedObj);\n        }\n    }\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\n((global: any) => {\n    global.SockethubClient = SockethubClient;\n    // @ts-ignore\n})(typeof window === \"object\" ? window : {});\n"
  ],
  "mappings": "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",
  "debugId": "6959089BEE28E78064756E2164756E21",
  "names": []
}