@sockethub/platform-irc 4.0.0-alpha.6 → 4.0.0-alpha.7

package/dist/index.js

@@ -0,0 +1,2194 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../../node_modules/r-result/result.js
+var require_result = __commonJS((exports, module) => {
+  var inspect = __require("util").inspect;
+  var Ok = function(t) {
+    const Result = Object.create(methods);
+    Result.is_ok = true;
+    Result.value = t;
+    return Result;
+  };
+  var Fail = function(f) {
+    const Result = Object.create(methods);
+    Result.is_ok = false;
+    Result.value = f;
+    return Result;
+  };
+  var methods = {
+    ok: function(errorMessage) {
+      if (this.is_ok) {
+        return this.value;
+      } else {
+        if (errorMessage) {
+          throw new TypeError(errorMessage);
+        } else {
+          throw new TypeError("Attempted to unwrap Ok(t) but got Fail(f) instead.");
+        }
+      }
+    },
+    fail: function(errorMessage) {
+      if (this.is_ok) {
+        if (errorMessage) {
+          throw new TypeError(errorMessage);
+        } else {
+          throw new TypeError("Attempted to unwrap Fail(f) but got Ok(t) instead.");
+        }
+      } else {
+        return this.value;
+      }
+    },
+    isOk: function() {
+      return this.is_ok;
+    },
+    isFail: function() {
+      return !this.is_ok;
+    },
+    map: function(f) {
+      if (this.is_ok) {
+        return Ok(f(this.value));
+      } else {
+        return this;
+      }
+    },
+    mapFail: function(f) {
+      if (this.is_ok) {
+        return this;
+      } else {
+        return Fail(f(this.value));
+      }
+    },
+    and: function(rhsResult) {
+      if (this.is_ok) {
+        return rhsResult;
+      } else {
+        return this;
+      }
+    },
+    or: function(rhsResult) {
+      if (this.is_ok) {
+        return this;
+      } else {
+        return rhsResult;
+      }
+    },
+    andThen: function(f) {
+      if (this.is_ok) {
+        return f(this.value);
+      } else {
+        return this;
+      }
+    },
+    orElse: function(f) {
+      if (this.is_ok) {
+        return this;
+      } else {
+        return f(this.value);
+      }
+    },
+    toArray: function() {
+      if (this.is_ok) {
+        return [this.value];
+      } else {
+        return [];
+      }
+    },
+    unwrapOr: function(defaultValue) {
+      if (this.is_ok) {
+        return this.value;
+      } else {
+        return defaultValue;
+      }
+    },
+    unwrapOrElse: function(defaultFn) {
+      if (this.is_ok) {
+        return this.value;
+      } else {
+        return defaultFn(this.value);
+      }
+    },
+    match: function(matchBlock) {
+      if (this.is_ok) {
+        return matchBlock.Ok(this.value);
+      } else {
+        return matchBlock.Fail(this.value);
+      }
+    },
+    inspect: function(depth, opts) {
+      var tag = this.is_ok ? "Ok" : "Fail";
+      var padding = this.is_ok ? "    " : "      ";
+      if (depth < 0) {
+        return opts.stylize("[" + tag + "]", "boolean");
+      }
+      var recurseOpts = {};
+      Object.keys(opts).forEach(function(key) {
+        recurseOpts[key] = opts[key];
+      });
+      recurseOpts.depth = opts.depth === null ? null : opts.depth - 1;
+      const inner = inspect(this.value, recurseOpts).replace(/\n/g, `
+` + padding);
+      return opts.stylize(tag, "boolean") + "( " + inner + " )";
+    },
+    debug: function(logfn, inspectOpts) {
+      logfn(inspect(this, inspectOpts));
+      return this;
+    },
+    debugOk: function(logfn, inspectOpts) {
+      if (this.is_ok) {
+        logfn(inspect(this.value, inspectOpts));
+      }
+      return this;
+    },
+    debugFail: function(logfn, inspectOpts) {
+      if (!this.is_ok) {
+        logfn(inspect(this.value, inspectOpts));
+      }
+      return this;
+    }
+  };
+  module.exports = {
+    Ok,
+    Fail
+  };
+  var methodToFunction = function(method) {
+    return function() {
+      var context = arguments[0];
+      var args = Array.prototype.slice.call(arguments, 1);
+      return method.apply(context, args);
+    };
+  };
+  Object.keys(methods).forEach(function(key) {
+    if (key === "inspect") {
+      return;
+    }
+    var method = methods[key];
+    module.exports[key] = methodToFunction(method);
+  });
+});
+
+// ../../node_modules/irc-socket-sasl/irc-socket.js
+var require_irc_socket = __commonJS((exports, module) => {
+  var EventEmitter = __require("events").EventEmitter;
+  var format = __require("util").format;
+  var rresult = require_result();
+  var Ok = rresult.Ok;
+  var Fail = rresult.Fail;
+  var includes = function(array, value) {
+    return array.indexOf(value) !== -1;
+  };
+  var copyJsonMaybe = function(object) {
+    if (!object) {
+      return;
+    }
+    return JSON.parse(JSON.stringify(object));
+  };
+  var endsWith = function(string, postfix) {
+    return string.lastIndexOf(postfix) === string.length - postfix.length;
+  };
+  var failures = {
+    killed: "killed",
+    nicknamesUnavailable: "nicknames unavailable",
+    badProxyConfiguration: "bad proxy configuration",
+    missingRequiredCapabilities: "missing required capabilities",
+    badPassword: "bad password",
+    socketEnded: "socket ended"
+  };
+
+  class IrcSocket extends EventEmitter {
+    constructor(config, netSocket) {
+      super();
+      this.impl = netSocket || config.socket;
+      this.status = "initialized";
+      this.pending = true;
+      this.startupPromise = new Promise((resolve, reject) => {
+        this.resolvePromise = (res) => {
+          this.pending = false;
+          resolve(res);
+        };
+        this.rejectPromise = (res) => {
+          this.pending = false;
+          reject(res);
+        };
+      });
+      this.proxy = config.proxy;
+      this.password = config.password;
+      this.capabilities = copyJsonMaybe(config.capabilities);
+      if (config.saslPassword) {
+        this.saslUsername = config.saslUsername || config.username;
+        this.saslPassword = config.saslPassword;
+      }
+      this.username = config.username;
+      this.realname = config.realname;
+      this.nicknames = config.nicknames.slice();
+      this.timeout = config.timeout || 5 * 60 * 1000;
+      this.connectOptions = typeof config.connectOptions === "object" ? Object.create(config.connectOptions) : {};
+      this.connectOptions.port = config.port || 6667;
+      this.connectOptions.host = config.server;
+      this.on("data", function(line) {
+        if (line.slice(0, 4) === "PING") {
+          this.raw(["PONG", line.slice(line.indexOf(":"))]);
+        }
+      });
+      this.on("timeout", function() {
+        this.end();
+      });
+    }
+    static connectFailures = failures;
+    _setHandlers() {
+      let timeout = null;
+      const timeoutPeriod = this.timeout;
+      const onSilence = () => {
+        timeout = setTimeout(onNoPong, timeoutPeriod);
+        this.raw("PING :ignored");
+      };
+      const onNoPong = () => {
+        this.emit("timeout");
+      };
+      (() => {
+        const emitLine = this.emit.bind(this, "data");
+        let lastLine = "";
+        const onData = (data) => {
+          let lines = data.split(`\r
+`);
+          lines[0] = lastLine + lines[0];
+          lastLine = lines.pop();
+          lines.forEach(function(line) {
+            emitLine(line.normalize());
+          });
+          clearTimeout(timeout);
+          timeout = setTimeout(onSilence, timeoutPeriod);
+        };
+        this.connection.on("data", onData);
+      })();
+      this.connection.once("connect", () => {
+        if (!this.pending) {
+          return;
+        }
+        this.status = "starting";
+        this.emit("connect");
+        timeout = setTimeout(onSilence, timeoutPeriod);
+        let serverCapabilities, acknowledgedCapabilities, sentRequests, respondedRequests, allRequestsSent, nickname;
+        if (this.capabilities) {
+          this.capabilities.requires = this.capabilities.requires || [];
+          this.capabilities.wants = this.capabilities.wants || [];
+          acknowledgedCapabilities = this.capabilities.requires.slice();
+          sentRequests = 0;
+          respondedRequests = 0;
+          allRequestsSent = false;
+        }
+        const sendUser = () => {
+          this.raw(format("USER %s 8 * :%s", this.username, this.realname));
+        };
+        const sendNick = () => {
+          if (this.nicknames.length === 0) {
+            this.raw("QUIT");
+            this.resolvePromise(Fail(failures.nicknamesUnavailable));
+            return;
+          }
+          nickname = this.nicknames[0];
+          this.nicknames.shift();
+          this.raw(["NICK", nickname]);
+        };
+        const startupHandler = (line) => {
+          const parts = line.split(" ");
+          if (parts[0] === "ERROR") {
+            this.resolvePromise(Fail(failures.badProxyConfiguration));
+            return;
+          } else if (parts[0] === "PING") {
+            return;
+          }
+          const numeric = parts[1];
+          if (numeric === "CAP") {
+            let capabilities = this.capabilities;
+            if (parts[3] === "LS") {
+              serverCapabilities = parts.slice(4);
+              serverCapabilities[0] = serverCapabilities[0].slice(1);
+              if (capabilities.requires.length !== 0) {
+                if (capabilities.requires.every((capability) => {
+                  return includes(serverCapabilities, capability);
+                })) {
+                  this.raw(format("CAP REQ :%s", capabilities.requires.join(" ")));
+                  sentRequests += 1;
+                } else {
+                  this.raw("QUIT");
+                  this.resolvePromise(Fail(failures.missingRequiredCapabilities));
+                  return;
+                }
+              }
+              capabilities.wants.filter((capability) => {
+                return includes(serverCapabilities, capability);
+              }).forEach((capability) => {
+                this.raw(format("CAP REQ :%s", capability));
+                sentRequests += 1;
+              });
+              return;
+            } else if (parts[3] === "NAK") {
+              respondedRequests += 1;
+              const capability = parts[4].slice(1);
+              if (includes(capabilities.requires, capability)) {
+                this.raw("QUIT");
+                this.resolvePromise(Fail(failures.missingRequiredCapabilities));
+                return;
+              }
+            } else if (parts[3] === "ACK") {
+              respondedRequests += 1;
+              const capability = parts[4].slice(1);
+              if (includes(capabilities.wants, capability)) {
+                acknowledgedCapabilities.push(capability);
+              }
+              if (acknowledgedCapabilities.includes("sasl")) {
+                this.raw(["AUTHENTICATE", "PLAIN"]);
+              }
+            }
+            if (sentRequests === respondedRequests) {
+              if (!this.saslPassword) {
+                this.raw("CAP END");
+              }
+              sendUser();
+              sendNick();
+            }
+          } else if (numeric === "NOTICE") {
+            if (endsWith(line, "Login unsuccessful")) {
+              this.resolvePromise(Fail(failures.badPassword));
+            }
+          } else if (parts[0] === "AUTHENTICATE") {
+            if (parts[1] === "+") {
+              const encPW = Buffer.from(this.saslUsername + "\x00" + this.saslUsername + "\x00" + this.saslPassword).toString("base64");
+              this.raw(["AUTHENTICATE", encPW]);
+            }
+          } else if (numeric === "903") {
+            this.raw("CAP END");
+          } else if (numeric === "001") {
+            this.status = "running";
+            const data = {
+              capabilities: acknowledgedCapabilities,
+              nickname
+            };
+            this.emit("ready", data);
+            this.resolvePromise(Ok(data));
+          } else if (includes(["410", "421"], numeric)) {
+            if (this.capabilities.requires) {
+              this.raw("QUIT");
+              this.resolvePromise(Fail(failures.missingRequiredCapabilities));
+            } else {
+              sendUser();
+              sendNick();
+            }
+          } else if (numeric === "464") {
+            this.resolvePromise(Fail(failures.badPassword));
+          } else if (includes(["431", "432", "433", "436", "437", "484"], numeric)) {
+            sendNick();
+          } else if (numeric === "PING") {}
+        };
+        this.on("data", startupHandler);
+        this.startupPromise.finally(() => {
+          this.removeListener("data", startupHandler);
+        });
+        if (typeof this.proxy === "object") {
+          const proxy = this.proxy;
+          this.raw(["WEBIRC", proxy.password, proxy.username, proxy.hostname, proxy.ip]);
+        }
+        if (typeof this.password === "string") {
+          this.raw(["PASS", this.password]);
+        }
+        if (typeof this.capabilities === "object") {
+          this.raw("CAP LS");
+        } else {
+          sendUser();
+          sendNick();
+        }
+      });
+      this.connection.on("error", (error) => {
+        this.status = "closed";
+        this.emit("error", error);
+      });
+      this.connection.on("close", () => {
+        if (this.status === "starting" || this.status === "connecting") {
+          this.resolvePromise(Fail(failures.killed));
+        }
+        this.status = "closed";
+        this.emit("close");
+      });
+      this.connection.on("end", () => {
+        this.emit("end");
+        if (this.pending) {
+          this.resolvePromise(Fail(failures.socketEnded));
+        }
+        clearTimeout(timeout);
+      });
+      this.connection.on("timeout", () => {
+        this.emit("timeout");
+      });
+      this.connection.setEncoding("utf-8");
+      this.connection.setNoDelay();
+    }
+    connect() {
+      if (this.isStarted()) {
+        throw new Error("Cannot restart an irc Socket.");
+      }
+      this.status = "connecting";
+      this.connection = this.impl.connect(this.connectOptions);
+      this._setHandlers(this.connection);
+      return this.startupPromise;
+    }
+    end() {
+      if (!this.isConnected()) {
+        return;
+      }
+      if (this.pending) {
+        this.resolvePromise(Fail(failures.socketEnded));
+      }
+      this.connection.end();
+    }
+    raw(message) {
+      if (!this.isConnected()) {
+        return;
+      }
+      if (Array.isArray(message)) {
+        message = message.join(" ");
+      }
+      if (message.indexOf(`
+`) !== -1) {
+        throw new Error("Newline detected in message. Use multiple raws instead.");
+      }
+      this.connection.write(message + `\r
+`, "utf-8");
+    }
+    setTimeout(timeout, callback) {
+      this.connection.setTimeout(timeout, callback);
+    }
+    isStarted() {
+      return this.status !== "initialized";
+    }
+    isConnected() {
+      return includes(["connecting", "starting", "running"], this.status);
+    }
+    isReady() {
+      return this.status === "running";
+    }
+    getRealName() {
+      return this._realname;
+    }
+  }
+  module.exports = IrcSocket;
+});
+
+// ../../node_modules/ms/index.js
+var require_ms = __commonJS((exports, module) => {
+  var s = 1000;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 365.25;
+  module.exports = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse(val);
+    } else if (type === "number" && isFinite(val)) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
+  };
+  function parse(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+    if (!match) {
+      return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return;
+    }
+  }
+  function fmtShort(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return Math.round(ms / d) + "d";
+    }
+    if (msAbs >= h) {
+      return Math.round(ms / h) + "h";
+    }
+    if (msAbs >= m) {
+      return Math.round(ms / m) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms / s) + "s";
+    }
+    return ms + "ms";
+  }
+  function fmtLong(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return plural(ms, msAbs, d, "day");
+    }
+    if (msAbs >= h) {
+      return plural(ms, msAbs, h, "hour");
+    }
+    if (msAbs >= m) {
+      return plural(ms, msAbs, m, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms, msAbs, s, "second");
+    }
+    return ms + " ms";
+  }
+  function plural(ms, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+  }
+});
+
+// ../../node_modules/debug/src/common.js
+var require_common = __commonJS((exports, module) => {
+  function setup(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce;
+    createDebug.disable = disable;
+    createDebug.enable = enable;
+    createDebug.enabled = enabled;
+    createDebug.humanize = require_ms();
+    createDebug.destroy = destroy;
+    Object.keys(env).forEach((key) => {
+      createDebug[key] = env[key];
+    });
+    createDebug.names = [];
+    createDebug.skips = [];
+    createDebug.formatters = {};
+    function selectColor(namespace) {
+      let hash = 0;
+      for (let i = 0;i < namespace.length; i++) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
+      }
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    function createDebug(namespace) {
+      let prevTime;
+      let enableOverride = null;
+      let namespacesCache;
+      let enabledCache;
+      function debug(...args) {
+        if (!debug.enabled) {
+          return;
+        }
+        const self = debug;
+        const curr = Number(new Date);
+        const ms = curr - (prevTime || curr);
+        self.diff = ms;
+        self.prev = prevTime;
+        self.curr = curr;
+        prevTime = curr;
+        args[0] = createDebug.coerce(args[0]);
+        if (typeof args[0] !== "string") {
+          args.unshift("%O");
+        }
+        let index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+          if (match === "%%") {
+            return "%";
+          }
+          index++;
+          const formatter = createDebug.formatters[format];
+          if (typeof formatter === "function") {
+            const val = args[index];
+            match = formatter.call(self, val);
+            args.splice(index, 1);
+            index--;
+          }
+          return match;
+        });
+        createDebug.formatArgs.call(self, args);
+        const logFn = self.log || createDebug.log;
+        logFn.apply(self, args);
+      }
+      debug.namespace = namespace;
+      debug.useColors = createDebug.useColors();
+      debug.color = createDebug.selectColor(namespace);
+      debug.extend = extend;
+      debug.destroy = createDebug.destroy;
+      Object.defineProperty(debug, "enabled", {
+        enumerable: true,
+        configurable: false,
+        get: () => {
+          if (enableOverride !== null) {
+            return enableOverride;
+          }
+          if (namespacesCache !== createDebug.namespaces) {
+            namespacesCache = createDebug.namespaces;
+            enabledCache = createDebug.enabled(namespace);
+          }
+          return enabledCache;
+        },
+        set: (v) => {
+          enableOverride = v;
+        }
+      });
+      if (typeof createDebug.init === "function") {
+        createDebug.init(debug);
+      }
+      return debug;
+    }
+    function extend(namespace, delimiter) {
+      const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+      newDebug.log = this.log;
+      return newDebug;
+    }
+    function enable(namespaces) {
+      createDebug.save(namespaces);
+      createDebug.namespaces = namespaces;
+      createDebug.names = [];
+      createDebug.skips = [];
+      const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+      for (const ns of split) {
+        if (ns[0] === "-") {
+          createDebug.skips.push(ns.slice(1));
+        } else {
+          createDebug.names.push(ns);
+        }
+      }
+    }
+    function matchesTemplate(search, template) {
+      let searchIndex = 0;
+      let templateIndex = 0;
+      let starIndex = -1;
+      let matchIndex = 0;
+      while (searchIndex < search.length) {
+        if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+          if (template[templateIndex] === "*") {
+            starIndex = templateIndex;
+            matchIndex = searchIndex;
+            templateIndex++;
+          } else {
+            searchIndex++;
+            templateIndex++;
+          }
+        } else if (starIndex !== -1) {
+          templateIndex = starIndex + 1;
+          matchIndex++;
+          searchIndex = matchIndex;
+        } else {
+          return false;
+        }
+      }
+      while (templateIndex < template.length && template[templateIndex] === "*") {
+        templateIndex++;
+      }
+      return templateIndex === template.length;
+    }
+    function disable() {
+      const namespaces = [
+        ...createDebug.names,
+        ...createDebug.skips.map((namespace) => "-" + namespace)
+      ].join(",");
+      createDebug.enable("");
+      return namespaces;
+    }
+    function enabled(name) {
+      for (const skip of createDebug.skips) {
+        if (matchesTemplate(name, skip)) {
+          return false;
+        }
+      }
+      for (const ns of createDebug.names) {
+        if (matchesTemplate(name, ns)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function coerce(val) {
+      if (val instanceof Error) {
+        return val.stack || val.message;
+      }
+      return val;
+    }
+    function destroy() {
+      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+    }
+    createDebug.enable(createDebug.load());
+    return createDebug;
+  }
+  module.exports = setup;
+});
+
+// ../../node_modules/debug/src/browser.js
+var require_browser = __commonJS((exports, module) => {
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.storage = localstorage();
+  exports.destroy = (() => {
+    let warned = false;
+    return () => {
+      if (!warned) {
+        warned = true;
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+    };
+  })();
+  exports.colors = [
+    "#0000CC",
+    "#0000FF",
+    "#0033CC",
+    "#0033FF",
+    "#0066CC",
+    "#0066FF",
+    "#0099CC",
+    "#0099FF",
+    "#00CC00",
+    "#00CC33",
+    "#00CC66",
+    "#00CC99",
+    "#00CCCC",
+    "#00CCFF",
+    "#3300CC",
+    "#3300FF",
+    "#3333CC",
+    "#3333FF",
+    "#3366CC",
+    "#3366FF",
+    "#3399CC",
+    "#3399FF",
+    "#33CC00",
+    "#33CC33",
+    "#33CC66",
+    "#33CC99",
+    "#33CCCC",
+    "#33CCFF",
+    "#6600CC",
+    "#6600FF",
+    "#6633CC",
+    "#6633FF",
+    "#66CC00",
+    "#66CC33",
+    "#9900CC",
+    "#9900FF",
+    "#9933CC",
+    "#9933FF",
+    "#99CC00",
+    "#99CC33",
+    "#CC0000",
+    "#CC0033",
+    "#CC0066",
+    "#CC0099",
+    "#CC00CC",
+    "#CC00FF",
+    "#CC3300",
+    "#CC3333",
+    "#CC3366",
+    "#CC3399",
+    "#CC33CC",
+    "#CC33FF",
+    "#CC6600",
+    "#CC6633",
+    "#CC9900",
+    "#CC9933",
+    "#CCCC00",
+    "#CCCC33",
+    "#FF0000",
+    "#FF0033",
+    "#FF0066",
+    "#FF0099",
+    "#FF00CC",
+    "#FF00FF",
+    "#FF3300",
+    "#FF3333",
+    "#FF3366",
+    "#FF3399",
+    "#FF33CC",
+    "#FF33FF",
+    "#FF6600",
+    "#FF6633",
+    "#FF9900",
+    "#FF9933",
+    "#FFCC00",
+    "#FFCC33"
+  ];
+  function useColors() {
+    if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+      return true;
+    }
+    if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+      return false;
+    }
+    let m;
+    return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+  }
+  function formatArgs(args) {
+    args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+    if (!this.useColors) {
+      return;
+    }
+    const c = "color: " + this.color;
+    args.splice(1, 0, c, "color: inherit");
+    let index = 0;
+    let lastC = 0;
+    args[0].replace(/%[a-zA-Z%]/g, (match) => {
+      if (match === "%%") {
+        return;
+      }
+      index++;
+      if (match === "%c") {
+        lastC = index;
+      }
+    });
+    args.splice(lastC, 0, c);
+  }
+  exports.log = console.debug || console.log || (() => {});
+  function save(namespaces) {
+    try {
+      if (namespaces) {
+        exports.storage.setItem("debug", namespaces);
+      } else {
+        exports.storage.removeItem("debug");
+      }
+    } catch (error) {}
+  }
+  function load() {
+    let r;
+    try {
+      r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+    } catch (error) {}
+    if (!r && typeof process !== "undefined" && "env" in process) {
+      r = process.env.DEBUG;
+    }
+    return r;
+  }
+  function localstorage() {
+    try {
+      return localStorage;
+    } catch (error) {}
+  }
+  module.exports = require_common()(exports);
+  var { formatters } = module.exports;
+  formatters.j = function(v) {
+    try {
+      return JSON.stringify(v);
+    } catch (error) {
+      return "[UnexpectedJSONParseError]: " + error.message;
+    }
+  };
+});
+
+// ../../node_modules/has-flag/index.js
+var require_has_flag = __commonJS((exports, module) => {
+  module.exports = (flag, argv = process.argv) => {
+    const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf("--");
+    return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+  };
+});
+
+// ../../node_modules/supports-color/index.js
+var require_supports_color = __commonJS((exports, module) => {
+  var os = __require("os");
+  var tty = __require("tty");
+  var hasFlag = require_has_flag();
+  var { env } = process;
+  var flagForceColor;
+  if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+    flagForceColor = 0;
+  } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+    flagForceColor = 1;
+  }
+  function envForceColor() {
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        return 1;
+      }
+      if (env.FORCE_COLOR === "false") {
+        return 0;
+      }
+      return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    }
+  }
+  function translateLevel(level) {
+    if (level === 0) {
+      return false;
+    }
+    return {
+      level,
+      hasBasic: true,
+      has256: level >= 2,
+      has16m: level >= 3
+    };
+  }
+  function supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+    const noFlagForceColor = envForceColor();
+    if (noFlagForceColor !== undefined) {
+      flagForceColor = noFlagForceColor;
+    }
+    const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+    if (forceColor === 0) {
+      return 0;
+    }
+    if (sniffFlags) {
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+    }
+    if (haveStream && !streamIsTTY && forceColor === undefined) {
+      return 0;
+    }
+    const min = forceColor || 0;
+    if (env.TERM === "dumb") {
+      return min;
+    }
+    if (process.platform === "win32") {
+      const osRelease = os.release().split(".");
+      if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+        return Number(osRelease[2]) >= 14931 ? 3 : 2;
+      }
+      return 1;
+    }
+    if ("CI" in env) {
+      if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+        return 1;
+      }
+      return min;
+    }
+    if ("TEAMCITY_VERSION" in env) {
+      return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    }
+    if (env.COLORTERM === "truecolor") {
+      return 3;
+    }
+    if ("TERM_PROGRAM" in env) {
+      const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+      switch (env.TERM_PROGRAM) {
+        case "iTerm.app":
+          return version >= 3 ? 3 : 2;
+        case "Apple_Terminal":
+          return 2;
+      }
+    }
+    if (/-256(color)?$/i.test(env.TERM)) {
+      return 2;
+    }
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+      return 1;
+    }
+    if ("COLORTERM" in env) {
+      return 1;
+    }
+    return min;
+  }
+  function getSupportLevel(stream, options = {}) {
+    const level = supportsColor(stream, {
+      streamIsTTY: stream && stream.isTTY,
+      ...options
+    });
+    return translateLevel(level);
+  }
+  module.exports = {
+    supportsColor: getSupportLevel,
+    stdout: getSupportLevel({ isTTY: tty.isatty(1) }),
+    stderr: getSupportLevel({ isTTY: tty.isatty(2) })
+  };
+});
+
+// ../../node_modules/debug/src/node.js
+var require_node = __commonJS((exports, module) => {
+  var tty = __require("tty");
+  var util = __require("util");
+  exports.init = init;
+  exports.log = log;
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.destroy = util.deprecate(() => {}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+  exports.colors = [6, 2, 3, 4, 5, 1];
+  try {
+    const supportsColor = require_supports_color();
+    if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+      exports.colors = [
+        20,
+        21,
+        26,
+        27,
+        32,
+        33,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        56,
+        57,
+        62,
+        63,
+        68,
+        69,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        92,
+        93,
+        98,
+        99,
+        112,
+        113,
+        128,
+        129,
+        134,
+        135,
+        148,
+        149,
+        160,
+        161,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        171,
+        172,
+        173,
+        178,
+        179,
+        184,
+        185,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        203,
+        204,
+        205,
+        206,
+        207,
+        208,
+        209,
+        214,
+        215,
+        220,
+        221
+      ];
+    }
+  } catch (error) {}
+  exports.inspectOpts = Object.keys(process.env).filter((key) => {
+    return /^debug_/i.test(key);
+  }).reduce((obj, key) => {
+    const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+      return k.toUpperCase();
+    });
+    let val = process.env[key];
+    if (/^(yes|on|true|enabled)$/i.test(val)) {
+      val = true;
+    } else if (/^(no|off|false|disabled)$/i.test(val)) {
+      val = false;
+    } else if (val === "null") {
+      val = null;
+    } else {
+      val = Number(val);
+    }
+    obj[prop] = val;
+    return obj;
+  }, {});
+  function useColors() {
+    return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+  }
+  function formatArgs(args) {
+    const { namespace: name, useColors: useColors2 } = this;
+    if (useColors2) {
+      const c = this.color;
+      const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+      const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+      args[0] = prefix + args[0].split(`
+`).join(`
+` + prefix);
+      args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+    } else {
+      args[0] = getDate() + name + " " + args[0];
+    }
+  }
+  function getDate() {
+    if (exports.inspectOpts.hideDate) {
+      return "";
+    }
+    return new Date().toISOString() + " ";
+  }
+  function log(...args) {
+    return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + `
+`);
+  }
+  function save(namespaces) {
+    if (namespaces) {
+      process.env.DEBUG = namespaces;
+    } else {
+      delete process.env.DEBUG;
+    }
+  }
+  function load() {
+    return process.env.DEBUG;
+  }
+  function init(debug) {
+    debug.inspectOpts = {};
+    const keys = Object.keys(exports.inspectOpts);
+    for (let i = 0;i < keys.length; i++) {
+      debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+    }
+  }
+  module.exports = require_common()(exports);
+  var { formatters } = module.exports;
+  formatters.o = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts).split(`
+`).map((str) => str.trim()).join(" ");
+  };
+  formatters.O = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts);
+  };
+});
+
+// ../../node_modules/debug/src/index.js
+var require_src = __commonJS((exports, module) => {
+  if (typeof process === "undefined" || process.type === "renderer" || false || process.__nwjs) {
+    module.exports = require_browser();
+  } else {
+    module.exports = require_node();
+  }
+});
+
+// src/octal-hack.js
+var require_octal_hack = __commonJS((exports, module) => {
+  module.exports = (content) => {
+    return "\x01ACTION " + content + "\x01";
+  };
+});
+
+// src/index.ts
+var import_irc_socket_sasl = __toESM(require_irc_socket(), 1);
+import net from "node:net";
+import tls from "node:tls";
+
+// ../irc2as/src/index.js
+var import_debug = __toESM(require_src(), 1);
+import events from "node:events";
+
+// ../irc2as/src/as-emitter.js
+var EVENT_INCOMING = "incoming";
+var EVENT_ERROR = "error";
+
+class ASEmitter {
+  constructor(events, server) {
+    this.server = server;
+    this.events = events;
+  }
+  emitEvent(code, asObject) {
+    if (typeof asObject === "object" && !asObject.published) {
+      asObject.published = `${Date.now()}`;
+    }
+    this.events.emit(code, asObject);
+  }
+  __generalError(nick, content) {
+    return {
+      context: "irc",
+      type: "update",
+      actor: {
+        type: "person",
+        id: `${nick}@${this.server}`,
+        name: nick
+      },
+      target: {
+        type: "service",
+        id: this.server
+      },
+      error: content
+    };
+  }
+  presence(nick, role, channel) {
+    this.emitEvent(EVENT_INCOMING, {
+      context: "irc",
+      type: "update",
+      actor: {
+        type: "person",
+        id: `${nick}@${this.server}`,
+        name: nick
+      },
+      target: {
+        type: "room",
+        id: `${this.server}/${channel}`,
+        name: channel
+      },
+      object: {
+        type: "presence",
+        role
+      }
+    });
+  }
+  channelError(channel, nick, content) {
+    this.emitEvent(EVENT_ERROR, {
+      context: "irc",
+      type: "update",
+      actor: {
+        type: "person",
+        id: `${nick}@${this.server}`
+      },
+      target: {
+        type: "room",
+        id: `${this.server}/${channel}`
+      },
+      error: content
+    });
+  }
+  nickError(nick, content) {
+    this.emitEvent(EVENT_ERROR, this.__generalError(nick, content));
+  }
+  notice(nick, content) {
+    this.emitEvent(EVENT_INCOMING, {
+      context: "irc",
+      type: "send",
+      actor: {
+        type: "service",
+        id: this.server
+      },
+      object: {
+        type: "message",
+        content
+      },
+      target: {
+        type: "person",
+        id: `${nick}@${this.server}`,
+        name: nick
+      }
+    });
+  }
+  serviceError(nick, content) {
+    this.emitEvent(EVENT_ERROR, this.__generalError(nick, content));
+  }
+  joinError(nick) {
+    this.emitEvent(EVENT_ERROR, {
+      context: "irc",
+      type: "join",
+      actor: {
+        id: this.server,
+        type: "service"
+      },
+      error: `no such channel ${nick}`,
+      target: {
+        id: `${nick}@${this.server}`,
+        type: "person"
+      }
+    });
+  }
+  topicChange(channel, nick, content) {
+    this.emitEvent(EVENT_INCOMING, {
+      context: "irc",
+      type: "update",
+      actor: {
+        type: "person",
+        id: `${nick}@${this.server}`,
+        name: nick
+      },
+      target: {
+        type: "room",
+        id: `${this.server}/${channel}`,
+        name: channel
+      },
+      object: {
+        type: "topic",
+        content
+      }
+    });
+  }
+  joinRoom(channel, nick) {
+    this.emitEvent(EVENT_INCOMING, {
+      context: "irc",
+      type: "join",
+      actor: {
+        type: "person",
+        id: `${nick}@${this.server}`,
+        name: nick
+      },
+      target: {
+        type: "room",
+        id: `${this.server}/${channel}`,
+        name: channel
+      }
+    });
+  }
+  userQuit(nick) {
+    this.emitEvent(EVENT_INCOMING, {
+      context: "irc",
+      type: "leave",
+      actor: {
+        type: "person",
+        id: `${nick}@${this.server}`,
+        name: nick
+      },
+      target: {
+        type: "service",
+        id: this.server
+      },
+      object: {
+        type: "message",
+        content: "user has quit"
+      }
+    });
+  }
+  userPart(channel, nick) {
+    this.emitEvent(EVENT_INCOMING, {
+      context: "irc",
+      type: "leave",
+      actor: {
+        type: "person",
+        id: `${nick}@${this.server}`,
+        name: nick
+      },
+      target: {
+        type: "room",
+        id: `${this.server}/${channel}`,
+        name: channel
+      },
+      object: {
+        type: "message",
+        content: "user has left the channel"
+      }
+    });
+  }
+  privMsg(nick, target, content) {
+    let type;
+    let message;
+    if (content.startsWith("+\x01ACTION ")) {
+      type = "me";
+      message = content.split(/^\+\u0001ACTION\s+/)[1].split(/\u0001$/)[0];
+    } else {
+      type = "message";
+      message = content;
+    }
+    this.emitEvent(EVENT_INCOMING, {
+      context: "irc",
+      type: "send",
+      actor: {
+        type: "person",
+        id: `${nick}@${this.server}`,
+        name: nick
+      },
+      target: {
+        type: target.startsWith("#") ? "room" : "person",
+        id: `${this.server}/${target}`,
+        name: target
+      },
+      object: {
+        type,
+        content: message
+      }
+    });
+  }
+  role(type, nick, target, role, channel) {
+    this.emitEvent(EVENT_INCOMING, {
+      context: "irc",
+      type,
+      actor: {
+        type: "person",
+        id: `${nick}@${this.server}`,
+        name: nick
+      },
+      target: {
+        type: "person",
+        id: `${target}@${this.server}`,
+        name: target
+      },
+      object: {
+        type: "relationship",
+        relationship: "role",
+        subject: {
+          type: "presence",
+          role
+        },
+        object: {
+          type: "room",
+          id: `${this.server}/${channel}`,
+          name: channel
+        }
+      }
+    });
+  }
+  nickChange(nick, content) {
+    this.emitEvent(EVENT_INCOMING, {
+      context: "irc",
+      type: "update",
+      actor: {
+        type: "person",
+        id: `${nick}@${this.server}`,
+        name: nick
+      },
+      target: {
+        type: "person",
+        id: `${content}@${this.server}`,
+        name: content
+      },
+      object: {
+        type: "address"
+      }
+    });
+  }
+}
+
+// ../irc2as/src/index.js
+var log = import_debug.default("irc2as");
+var EVENT_INCOMING2 = "incoming";
+var EVENT_PONG = "pong";
+var EVENT_PING = "ping";
+var EVENT_UNPROCESSED = "unprocessed";
+var ERR_BAD_NICK = "432";
+var ERR_CHAN_PRIVS = "482";
+var ERR_NICK_IN_USE = "433";
+var ERR_TEMP_UNAVAIL = "437";
+var ERR_NO_CHANNEL = "403";
+var ERR_NOT_INVITED = "471";
+var ERR_BADMODE = "472";
+var ERR_INVITE_ONLY = "473";
+var ERR_BANNED = "474";
+var ERR_BADKEY = "475";
+var ERR_BADMASK = "476";
+var ERR_NOCHANMODES = "477";
+var ERR_BANLISTFULL = "478";
+var JOIN = "JOIN";
+var MODE = "MODE";
+var MOTD = "372";
+var MOTD_END = "376";
+var NAMES = "353";
+var NICK = "NICK";
+var NOTICE = "NOTICE";
+var PART = "PART";
+var PING = "PING";
+var PONG = "PONG";
+var PRIVMSG = "PRIVMSG";
+var QUIT = "QUIT";
+var TOPIC_CHANGE = "TOPIC";
+var TOPIC_IS = "332";
+var TOPIC_SET_BY = "333";
+var WHO = "352";
+var WHO_OLD = "354";
+var ROLE = {
+  "@": "owner",
+  "%": "admin",
+  "*": "participant"
+};
+var MODES = {
+  o: "owner",
+  h: "admin",
+  v: "participant"
+};
+function getNickFromServer(server) {
+  return server.split(/^:/)[1].split("!")[0];
+}
+
+class IrcToActivityStreams {
+  constructor(cfg) {
+    const config = cfg || {};
+    this.server = config.server;
+    this.events = new events.EventEmitter;
+    this.__buffer = {};
+    this.__buffer[NAMES] = {};
+  }
+  input(payload) {
+    log(payload);
+    if (typeof payload !== "string") {
+      log("unable to process incoming message as it was not a string.");
+      return false;
+    }
+    if (payload.length < 3) {
+      log("unable to process incoming string, length smaller than 3.");
+      return false;
+    }
+    const incoming = payload.trim();
+    const [metadata, content] = incoming.split(" :");
+    const [server, code, pos1, pos2, pos3, ...msg] = metadata.split(" ");
+    const channel = typeof pos1 === "string" && pos1.startsWith("#") ? pos1 : typeof pos2 === "string" && pos2.startsWith("#") ? pos2 : typeof pos3 === "string" && pos3.startsWith("#") ? pos3 : undefined;
+    if (metadata === PING) {
+      this.events.emit(EVENT_PING, `${Date.now()}`);
+      return true;
+    }
+    log(`[${code}] server: ${server} channel: ${channel} 1: ${pos1}, 2: ${pos2}, 3: ${pos3}. content: `, content);
+    this.__processIRCCodes(code, server, channel, pos1, pos2, pos3, content, msg, incoming);
+  }
+  __processIRCCodes(code, server, channel, pos1, pos2, pos3, content, msg, incoming) {
+    const ase = new ASEmitter(this.events, this.server);
+    let nick;
+    let type;
+    let role;
+    switch (code) {
+      case ERR_CHAN_PRIVS:
+      case ERR_NOT_INVITED:
+      case ERR_BADMODE:
+      case ERR_INVITE_ONLY:
+      case ERR_BANNED:
+      case ERR_BADKEY:
+      case ERR_BADMASK:
+      case ERR_NOCHANMODES:
+      case ERR_BANLISTFULL:
+        ase.channelError(channel, pos1, content);
+        break;
+      case ERR_NICK_IN_USE:
+      case ERR_BAD_NICK:
+        ase.serviceError(pos2, content);
+        break;
+      case ERR_NO_CHANNEL:
+        ase.joinError(pos2);
+        break;
+      case ERR_TEMP_UNAVAIL:
+        ase.nickError(pos2, content);
+        break;
+      case JOIN:
+        ase.joinRoom(channel, getNickFromServer(server));
+        break;
+      case MODE: {
+        const user_mode = pos2 || content;
+        if (!channel) {
+          break;
+        }
+        if (!pos3) {
+          break;
+        }
+        role = MODES[user_mode[1]] || "member";
+        type = "add";
+        if (user_mode[0] === "-") {
+          type = "remove";
+        }
+        ase.role(type, getNickFromServer(server), pos3, role, channel);
+        break;
+      }
+      case MOTD:
+        if (!this.__buffer[MOTD]) {
+          this.__buffer[MOTD] = {
+            context: "irc",
+            type: "update",
+            actor: {
+              type: "service",
+              id: this.server,
+              name: this.server
+            },
+            object: {
+              type: "topic",
+              content
+            }
+          };
+        } else {
+          this.__buffer[MOTD].object.content += ` ${content}`;
+        }
+        break;
+      case MOTD_END:
+        if (!this.__buffer[MOTD]) {
+          break;
+        }
+        ase.emitEvent(EVENT_INCOMING2, this.__buffer[MOTD]);
+        delete this.__buffer[MOTD];
+        break;
+      case NAMES:
+        for (const entry of content.split(" ")) {
+          role = "member";
+          let username = entry;
+          if (ROLE[entry[0]]) {
+            username = entry.substr(1);
+            role = ROLE[entry[0]];
+          }
+          ase.presence(username, role, channel);
+        }
+        break;
+      case NICK:
+        ase.nickChange(getNickFromServer(server), content);
+        break;
+      case NOTICE:
+        ase.notice(pos1, content);
+        break;
+      case PART:
+        ase.userPart(channel, getNickFromServer(server));
+        break;
+      case PONG:
+        this.events.emit(EVENT_PONG, `${Date.now()}`);
+        break;
+      case PRIVMSG:
+        ase.privMsg(getNickFromServer(server), pos1, content);
+        break;
+      case QUIT:
+        ase.userQuit(getNickFromServer(server));
+        break;
+      case TOPIC_CHANGE:
+        ase.topicChange(channel, getNickFromServer(server), content);
+        break;
+      case TOPIC_IS:
+        this.__buffer[TOPIC_IS] = {
+          context: "irc",
+          type: "update",
+          actor: undefined,
+          target: {
+            type: "room",
+            id: `${this.server}/${channel}`,
+            name: channel
+          },
+          object: {
+            type: "topic",
+            content
+          }
+        };
+        break;
+      case TOPIC_SET_BY:
+        if (!this.__buffer[TOPIC_IS]) {
+          break;
+        }
+        nick = pos3.split("!")[0];
+        this.__buffer[TOPIC_IS].actor = {
+          type: "person",
+          id: `${nick}@${this.server}`,
+          name: nick
+        };
+        this.__buffer[TOPIC_IS].published = msg[0];
+        ase.emitEvent(EVENT_INCOMING2, this.__buffer[TOPIC_IS]);
+        delete this.__buffer[TOPIC_IS];
+        break;
+      case WHO:
+      case WHO_OLD:
+        nick = msg[3].length <= 2 ? msg[2] : msg[3];
+        if (nick === "undefined") {
+          break;
+        }
+        role = MODES[pos2[1]] || "member";
+        ase.presence(nick, role, channel);
+        break;
+      default:
+        this.events.emit(EVENT_UNPROCESSED, incoming);
+        break;
+    }
+  }
+}
+// package.json
+var package_default = {
+  name: "@sockethub/platform-irc",
+  description: "A sockethub platform module implementing IRC functionality",
+  version: "4.0.0-alpha.7",
+  private: false,
+  author: "Nick Jennings <nick@silverbucket.net>",
+  license: "LGPL-3.0+",
+  publishConfig: {
+    access: "public"
+  },
+  type: "module",
+  main: "dist/index.js",
+  exports: {
+    ".": {
+      bun: "./src/index.ts",
+      import: "./dist/index.js",
+      default: "./dist/index.js"
+    }
+  },
+  files: ["src/", "dist/"],
+  engines: {
+    bun: ">=1.2"
+  },
+  keywords: [
+    "sockethub",
+    "messaging",
+    "activitystreams",
+    "activity",
+    "streams",
+    "protocol",
+    "irc"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/sockethub/sockethub.git",
+    directory: "packages/platform-irc"
+  },
+  homepage: "https://github.com/sockethub/sockethub/tree/master/packages/platform-irc",
+  scripts: {
+    build: "bun build src/index.ts --outdir dist --target node --format esm --sourcemap=external",
+    clean: "rm -rf dist",
+    doc: "typedoc --options typedoc.json"
+  },
+  dependencies: {
+    "@sockethub/irc2as": "^4.0.0-alpha.7",
+    "irc-socket-sasl": "^4.0.0"
+  },
+  devDependencies: {
+    "@sockethub/schemas": "^3.0.0-alpha.7",
+    "@types/bun": "latest",
+    typedoc: "^0.28.14"
+  },
+  peerDependencies: {
+    "@sockethub/server": "^5.0.0-alpha.6"
+  },
+  peerDependenciesMeta: {
+    "@sockethub/server": {
+      optional: true
+    }
+  },
+  gitHead: "e69e26b98c4bce1279aae4dc356b9a0f7e7de659"
+};
+
+// src/schema.ts
+var version = package_default.version;
+var PlatformIrcSchema = {
+  name: "irc",
+  version,
+  messages: {
+    required: ["type"],
+    properties: {
+      type: {
+        enum: [
+          "connect",
+          "update",
+          "join",
+          "leave",
+          "send",
+          "query",
+          "announce",
+          "disconnect"
+        ]
+      }
+    }
+  },
+  credentials: {
+    required: ["object"],
+    properties: {
+      actor: {
+        type: "object",
+        required: ["id"]
+      },
+      object: {
+        type: "object",
+        required: ["type", "nick", "server"],
+        additionalProperties: false,
+        properties: {
+          type: {
+            type: "string"
+          },
+          nick: {
+            type: "string"
+          },
+          username: {
+            type: "string"
+          },
+          password: {
+            type: "string"
+          },
+          server: {
+            type: "string"
+          },
+          port: {
+            type: "number"
+          },
+          secure: {
+            type: "boolean"
+          },
+          sasl: {
+            type: "boolean"
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/index.ts
+class IRC {
+  debug;
+  credentialsHash;
+  config = {
+    persist: true,
+    requireCredentials: ["connect", "update"],
+    initialized: false,
+    connectTimeoutMs: 30000
+  };
+  updateActor;
+  sendToClient;
+  irc2as;
+  forceDisconnect = false;
+  clientConnecting = false;
+  client;
+  jobQueue = [];
+  channels = new Set;
+  handledActors = new Set;
+  constructor(session) {
+    this.debug = session.debug;
+    this.sendToClient = session.sendToClient;
+    this.updateActor = session.updateActor;
+  }
+  get schema() {
+    return PlatformIrcSchema;
+  }
+  connect(job, credentials, done) {
+    this.getClient(job.actor.id, credentials, (err) => {
+      if (err) {
+        return done(err);
+      }
+      return done();
+    });
+  }
+  join(job, done) {
+    this.debug(`join() called for ${job.actor.id}`);
+    this.getClient(job.actor.id, false, (err, client) => {
+      if (err) {
+        return done(err);
+      }
+      if (this.channels.has(job.target.name)) {
+        this.debug(`channel ${job.target.name} already joined`);
+        return done();
+      }
+      this.jobQueue.push(() => {
+        this.hasJoined(job.target.name);
+        done();
+      });
+      this.debug(`sending join ${job.target.name}`);
+      client.raw(["JOIN", job.target.name]);
+      client.raw(`PING ${job.actor.name}`);
+    });
+  }
+  leave(job, done) {
+    this.debug(`leave() called for ${job.actor.name}`);
+    this.getClient(job.actor.id, false, (err, client) => {
+      if (err) {
+        return done(err);
+      }
+      this.hasLeft(job.target.name);
+      client.raw(["PART", job.target.name]);
+      done();
+    });
+  }
+  send(job, done) {
+    this.debug(`send() called for ${job.actor.id} target: ${job.target.id}`);
+    this.getClient(job.actor.id, false, async (err, client) => {
+      if (err) {
+        return done(err);
+      }
+      if (typeof job.object.content !== "string") {
+        return done("cannot send message with no object.content");
+      }
+      const match = /(\/\w+)\s*([\s\S]*)/.exec(job.object.content);
+      if (match) {
+        const cmd = match[1].substring(1).toUpperCase();
+        const msg = match[2].trim();
+        if (cmd === "ME") {
+          job.object.type = "me";
+          job.object.content = msg;
+        } else if (cmd === "NOTICE") {
+          job.object.type = "notice";
+          job.object.content = msg;
+        }
+      } else {
+        job.object.content = job.object.content.trim();
+      }
+      if (job.object.type === "me") {
+        const buildCommand = await Promise.resolve().then(() => __toESM(require_octal_hack(), 1));
+        const message = buildCommand(job.object.content);
+        client.raw("PRIVMSG " + job.target.name + " :" + message);
+        return done("IRC commands temporarily disabled");
+      }
+      if (job.object.type === "notice") {
+        client.raw(`NOTICE ${job.target.name} :${job.object.content}`);
+      } else if (this.isJoined(job.target.name)) {
+        client.raw(`PRIVMSG ${job.target.name} :${job.object.content}`);
+      } else {
+        return done("cannot send message to a channel of which you've not first joined.");
+      }
+      this.jobQueue.push(done);
+      client.raw(`PING ${job.actor.name}`);
+    });
+  }
+  update(job, credentials, done) {
+    this.debug(`update() called for ${job.actor.id}`);
+    this.getClient(job.actor.id, false, (err, client) => {
+      if (err) {
+        return done(err);
+      }
+      if (job.object.type === "address") {
+        this.debug(`changing nick from ${job.actor.name} to ${job.target.name}`);
+        this.handledActors.add(job.target.id);
+        this.jobQueue.push(async (err2) => {
+          if (err2) {
+            this.handledActors.delete(job.target.id);
+            return done(err2);
+          }
+          credentials.object.nick = job.target.name;
+          credentials.actor.id = `${job.target.name}@${credentials.object.server}`;
+          credentials.actor.name = job.target.name;
+          await this.updateActor(credentials);
+          done();
+        });
+        client.raw(["NICK", job.target.name]);
+      } else if (job.object.type === "topic") {
+        this.debug(`changing topic in channel ${job.target.name}`);
+        this.jobQueue.push(done);
+        client.raw(["topic", job.target.name, job.object.content]);
+      } else {
+        return done(`unknown update action: ${job.object.type}`);
+      }
+      client.raw(`PING ${job.actor.name}`);
+    });
+  }
+  query(job, done) {
+    this.debug(`query() called for ${job.actor.id}`);
+    this.getClient(job.actor.id, false, (err, client) => {
+      if (err) {
+        return done(err);
+      }
+      if (job.object.type === "attendance") {
+        this.debug(`query() - sending NAMES for ${job.target.name}`);
+        client.raw(["NAMES", job.target.name]);
+        done();
+      } else {
+        done(`unknown 'type' '${job.object.type}'`);
+      }
+    });
+  }
+  disconnect(job, done) {
+    this.debug(`disconnect called for ${job.actor.id}`);
+    this.cleanup(done);
+  }
+  cleanup(done) {
+    this.debug("cleanup() called");
+    this.config.initialized = false;
+    this.forceDisconnect = true;
+    if (typeof this.client === "object") {
+      if (typeof this.client.end === "function") {
+        this.client.end();
+      }
+    }
+    this.client = undefined;
+    return done();
+  }
+  isJoined(channel) {
+    if (channel.indexOf("#") === 0) {
+      return this.channels.has(channel);
+    }
+    return true;
+  }
+  hasJoined(channel) {
+    this.debug(`joined ${channel}`);
+    if (!this.channels.has(channel)) {
+      this.channels.add(channel);
+    }
+  }
+  hasLeft(channel) {
+    this.debug(`left ${channel}`);
+    if (this.channels.has(channel)) {
+      this.channels.delete(channel);
+    }
+  }
+  getClient(key, credentials, cb) {
+    this.debug(`getClient called, connecting: ${this.clientConnecting}`);
+    if (this.client) {
+      this.handledActors.add(key);
+      return cb(null, this.client);
+    }
+    if (this.clientConnecting) {
+      setTimeout(() => {
+        if (this.client) {
+          this.debug(`resolving delayed getClient call for ${key}`);
+          this.handledActors.add(key);
+          return cb(null, this.client);
+        }
+        return cb("failed to get irc client, please try again.");
+      }, this.config.connectTimeoutMs);
+      return;
+    }
+    if (!credentials) {
+      return cb("no client found, and no credentials specified. you must connect first");
+    }
+    this.ircConnect(credentials, (err, client) => {
+      if (err) {
+        this.config.initialized = false;
+        return cb(err);
+      }
+      this.handledActors.add(key);
+      this.client = client;
+      this.registerListeners(credentials.object.server);
+      this.config.initialized = true;
+      return cb(null, client);
+    });
+  }
+  ircConnect(credentials, cb) {
+    this.clientConnecting = true;
+    const is_secure = typeof credentials.object.secure === "boolean" ? credentials.object.secure : true;
+    const is_sasl = typeof credentials.object.sasl === "boolean" ? credentials.object.sasl : !!credentials.object.password;
+    const module_options = {
+      username: credentials.object.username || credentials.object.nick,
+      nicknames: [credentials.object.nick],
+      server: credentials.object.server || "irc.libera.chat",
+      realname: credentials.actor.name || credentials.object.nick,
+      port: credentials.object.port ? typeof credentials.object.port === "string" ? Number.parseInt(credentials.object.port, 10) : credentials.object.port : is_secure ? 6697 : 6667,
+      debug: console.log
+    };
+    if (is_secure) {
+      module_options.connectOptions = { rejectUnauthorized: false };
+    }
+    if (is_sasl) {
+      module_options.saslPassword = credentials.object.password;
+      module_options.capabilities = { requires: ["sasl"] };
+    }
+    this.debug(`attempting to connect to ${module_options.server}:${module_options.port} transport: ${is_secure ? "secure" : "clear"} sasl: ${is_sasl}`);
+    const client = new import_irc_socket_sasl.default(module_options, is_secure ? tls : net);
+    const forceDisconnect = (err) => {
+      this.forceDisconnect = true;
+      this.clientConnecting = false;
+      if (client && typeof client.end === "function") {
+        client.end();
+      }
+      if (this.client && typeof this.client.end === "function") {
+        this.client.end();
+      }
+      cb(err);
+    };
+    client.once("error", (err) => {
+      this.debug(`irc client 'error' occurred. `, err);
+      forceDisconnect("error connecting to server.");
+    });
+    client.once("close", () => {
+      this.debug(`irc client 'close' event fired.`);
+      forceDisconnect("connection to server closed.");
+    });
+    client.once("timeout", () => {
+      this.debug("timeout occurred, force-disconnect");
+      forceDisconnect("connection timeout to server.");
+    });
+    client.connect().then((res) => {
+      if (res.isFail()) {
+        return cb(`unable to connect to server: ${res.fail()}`);
+      }
+      const capabilities = res.ok();
+      this.clientConnecting = false;
+      if (this.forceDisconnect) {
+        client.end();
+        return cb("force disconnect active, aborting connect.");
+      }
+      this.debug(`connected to ${module_options.server} capabilities: `, capabilities);
+      return cb(null, client);
+    });
+  }
+  completeJob(err) {
+    this.debug(`completing job, queue count: ${this.jobQueue.length}`);
+    const done = this.jobQueue.shift();
+    if (typeof done === "function") {
+      done(err);
+    } else if (this.jobQueue.length === 0) {
+      this.debug("WARNING: job completion event received with an empty job queue.");
+    } else {
+      this.debug(`WARNING: job completion found non-function in queue (${typeof done}), ${this.jobQueue.length} items remain.`);
+    }
+  }
+  registerListeners(server) {
+    this.irc2as = new IrcToActivityStreams({ server });
+    this.client.on("data", (data) => {
+      this.irc2as.input(data);
+    });
+    this.irc2as.events.on("incoming", (asObject) => {
+      if (typeof asObject.actor === "object" && typeof asObject.actor.name === "string" && this.handledActors.has(asObject.actor.id)) {
+        this.completeJob();
+      } else {
+        this.debug(`calling sendToClient for ${asObject.actor.id}`, [
+          ...this.handledActors.keys()
+        ]);
+        this.sendToClient(asObject);
+      }
+    });
+    this.irc2as.events.on("unprocessed", (s) => {
+      this.debug(`unprocessed irc message:> ${s}`);
+    });
+    this.irc2as.events.on("error", (asObject) => {
+      this.debug(`message error response ${asObject.object.content}`);
+      this.completeJob(asObject.object.content);
+    });
+    this.irc2as.events.on("pong", (timestamp) => {
+      this.debug(`received PONG at ${timestamp}`);
+      this.completeJob();
+    });
+    this.irc2as.events.on("ping", (timestamp) => {
+      this.debug(`received PING at ${timestamp}`);
+      this.client.raw("PONG");
+    });
+  }
+}
+export {
+  IRC as default
+};
+
+//# debugId=A97EC20DD7F97FB264756E2164756E21