@sockethub/irc2as 4.0.0-alpha.10

package/dist/index.js

@@ -0,0 +1,1263 @@
+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/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/index.js
+var import_debug = __toESM(require_src(), 1);
+import events from "node:events";
+
+// 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"
+      }
+    });
+  }
+}
+
+// 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;
+    }
+  }
+}
+export {
+  IrcToActivityStreams
+};
+
+//# debugId=EF561318CD0E9A7D64756E2164756E21