smule.js 1.3.1 → 1.4.0

package/dist/index.js

@@ -1,3 +1,654 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/ltx/lib/escape.js
+var require_escape = __commonJS({
+  "node_modules/ltx/lib/escape.js"(exports) {
+    "use strict";
+    var escapeXMLTable = {
+      "&": "&",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&apos;"
+    };
+    function escapeXMLReplace(match) {
+      return escapeXMLTable[match];
+    }
+    var unescapeXMLTable = {
+      "&amp;": "&",
+      "&lt;": "<",
+      "&gt;": ">",
+      "&quot;": '"',
+      "&apos;": "'"
+    };
+    function unescapeXMLReplace(match) {
+      if (match[1] === "#") {
+        const num = match[2] === "x" ? parseInt(match.slice(3), 16) : parseInt(match.slice(2), 10);
+        if (num === 9 || num === 10 || num === 13 || num >= 32 && num <= 55295 || num >= 57344 && num <= 65533 || num >= 65536 && num <= 1114111) {
+          return String.fromCodePoint(num);
+        }
+        throw new Error("Illegal XML character 0x" + num.toString(16));
+      }
+      if (unescapeXMLTable[match]) {
+        return unescapeXMLTable[match] || match;
+      }
+      throw new Error("Illegal XML entity " + match);
+    }
+    function escapeXML2(s) {
+      return s.replace(/["&'<>]/g, escapeXMLReplace);
+    }
+    function unescapeXML2(s) {
+      let result = "";
+      let start = -1;
+      let end = -1;
+      let previous = 0;
+      while ((start = s.indexOf("&", previous)) !== -1 && (end = s.indexOf(";", start + 1)) !== -1) {
+        result = result + s.slice(previous, start) + unescapeXMLReplace(s.slice(start, end + 1));
+        previous = end + 1;
+      }
+      if (previous === 0) return s;
+      result = result + s.substring(previous);
+      return result;
+    }
+    function escapeXMLText2(s) {
+      return s.replace(/[&<>]/g, escapeXMLReplace);
+    }
+    function unescapeXMLText2(s) {
+      return s.replace(/&(amp|#38|lt|#60|gt|#62);/g, unescapeXMLReplace);
+    }
+    exports.escapeXML = escapeXML2;
+    exports.escapeXMLText = escapeXMLText2;
+    exports.unescapeXML = unescapeXML2;
+    exports.unescapeXMLText = unescapeXMLText2;
+  }
+});
+
+// node_modules/ltx/lib/Element.js
+var require_Element = __commonJS({
+  "node_modules/ltx/lib/Element.js"(exports, module) {
+    "use strict";
+    var escape = require_escape();
+    var Element5 = class _Element {
+      constructor(name, attrs) {
+        this.name = name;
+        this.parent = null;
+        this.children = [];
+        this.attrs = {};
+        this.setAttrs(attrs);
+      }
+      /* Accessors */
+      /**
+       * if (element.is('message', 'jabber:client')) ...
+       **/
+      is(name, xmlns) {
+        return this.getName() === name && (!xmlns || this.getNS() === xmlns);
+      }
+      /* without prefix */
+      getName() {
+        const idx = this.name.indexOf(":");
+        return idx >= 0 ? this.name.slice(idx + 1) : this.name;
+      }
+      /**
+       * retrieves the namespace of the current element, upwards recursively
+       **/
+      getNS() {
+        const idx = this.name.indexOf(":");
+        if (idx >= 0) {
+          const prefix = this.name.slice(0, idx);
+          return this.findNS(prefix);
+        }
+        return this.findNS();
+      }
+      /**
+       * find the namespace to the given prefix, upwards recursively
+       **/
+      findNS(prefix) {
+        if (!prefix) {
+          if (this.attrs.xmlns) {
+            return this.attrs.xmlns;
+          } else if (this.parent) {
+            return this.parent.findNS();
+          }
+        } else {
+          const attr = "xmlns:" + prefix;
+          if (this.attrs[attr]) {
+            return this.attrs[attr];
+          } else if (this.parent) {
+            return this.parent.findNS(prefix);
+          }
+        }
+      }
+      /**
+       * Recursiverly gets all xmlns defined, in the form of {url:prefix}
+       **/
+      getXmlns() {
+        let namespaces = {};
+        if (this.parent) {
+          namespaces = this.parent.getXmlns();
+        }
+        for (const attr in this.attrs) {
+          const m = attr.match("xmlns:?(.*)");
+          if (this.attrs.hasOwnProperty(attr) && m) {
+            namespaces[this.attrs[attr]] = m[1];
+          }
+        }
+        return namespaces;
+      }
+      setAttrs(attrs) {
+        if (typeof attrs === "string") {
+          this.attrs.xmlns = attrs;
+        } else if (attrs) {
+          Object.assign(this.attrs, attrs);
+        }
+      }
+      /**
+       * xmlns can be null, returns the matching attribute.
+       **/
+      getAttr(name, xmlns) {
+        if (!xmlns) {
+          return this.attrs[name];
+        }
+        const namespaces = this.getXmlns();
+        if (!namespaces[xmlns]) {
+          return null;
+        }
+        return this.attrs[[namespaces[xmlns], name].join(":")];
+      }
+      /**
+       * xmlns can be null
+       **/
+      getChild(name, xmlns) {
+        return this.getChildren(name, xmlns)[0];
+      }
+      /**
+       * xmlns can be null
+       **/
+      getChildren(name, xmlns) {
+        const result = [];
+        for (const child of this.children) {
+          if (child.getName && child.getName() === name && (!xmlns || child.getNS() === xmlns)) {
+            result.push(child);
+          }
+        }
+        return result;
+      }
+      /**
+       * xmlns and recursive can be null
+       **/
+      getChildByAttr(attr, val, xmlns, recursive) {
+        return this.getChildrenByAttr(attr, val, xmlns, recursive)[0];
+      }
+      /**
+       * xmlns and recursive can be null
+       **/
+      getChildrenByAttr(attr, val, xmlns, recursive) {
+        let result = [];
+        for (const child of this.children) {
+          if (child.attrs && child.attrs[attr] === val && (!xmlns || child.getNS() === xmlns)) {
+            result.push(child);
+          }
+          if (recursive && child.getChildrenByAttr) {
+            result.push(child.getChildrenByAttr(attr, val, xmlns, true));
+          }
+        }
+        if (recursive) {
+          result = result.flat();
+        }
+        return result;
+      }
+      getChildrenByFilter(filter, recursive) {
+        let result = [];
+        for (const child of this.children) {
+          if (filter(child)) {
+            result.push(child);
+          }
+          if (recursive && child.getChildrenByFilter) {
+            result.push(child.getChildrenByFilter(filter, true));
+          }
+        }
+        if (recursive) {
+          result = result.flat();
+        }
+        return result;
+      }
+      getText() {
+        let text = "";
+        for (const child of this.children) {
+          if (typeof child === "string" || typeof child === "number") {
+            text += child;
+          }
+        }
+        return text;
+      }
+      getChildText(name, xmlns) {
+        const child = this.getChild(name, xmlns);
+        return child ? child.getText() : null;
+      }
+      /**
+       * Return all direct descendents that are Elements.
+       * This differs from `getChildren` in that it will exclude text nodes,
+       * processing instructions, etc.
+       */
+      getChildElements() {
+        return this.getChildrenByFilter((child) => {
+          return child instanceof _Element;
+        });
+      }
+      /* Builder */
+      /** returns uppermost parent */
+      root() {
+        if (this.parent) {
+          return this.parent.root();
+        }
+        return this;
+      }
+      /** just parent or itself */
+      up() {
+        if (this.parent) {
+          return this.parent;
+        }
+        return this;
+      }
+      /** create child node and return it */
+      c(name, attrs) {
+        return this.cnode(new _Element(name, attrs));
+      }
+      cnode(child) {
+        this.children.push(child);
+        if (typeof child === "object") {
+          child.parent = this;
+        }
+        return child;
+      }
+      append(...nodes) {
+        for (const node of nodes) {
+          this.children.push(node);
+          if (typeof node === "object") {
+            node.parent = this;
+          }
+        }
+      }
+      prepend(...nodes) {
+        for (const node of nodes) {
+          this.children.unshift(node);
+          if (typeof node === "object") {
+            node.parent = this;
+          }
+        }
+      }
+      /** add text node and return element */
+      t(text) {
+        this.children.push(text);
+        return this;
+      }
+      /* Manipulation */
+      /**
+       * Either:
+       *   el.remove(childEl)
+       *   el.remove('author', 'urn:...')
+       */
+      remove(el, xmlns) {
+        const filter = typeof el === "string" ? (child) => {
+          return !(child.is && child.is(el, xmlns));
+        } : (child) => {
+          return child !== el;
+        };
+        this.children = this.children.filter(filter);
+        return this;
+      }
+      text(val) {
+        if (val && this.children.length === 1) {
+          this.children[0] = val;
+          return this;
+        }
+        return this.getText();
+      }
+      attr(attr, val) {
+        if (typeof val !== "undefined" || val === null) {
+          if (!this.attrs) {
+            this.attrs = {};
+          }
+          this.attrs[attr] = val;
+          return this;
+        }
+        return this.attrs[attr];
+      }
+      /* Serialization */
+      toString() {
+        let s = "";
+        this.write((c) => {
+          s += c;
+        });
+        return s;
+      }
+      _addChildren(writer) {
+        writer(">");
+        for (const child of this.children) {
+          if (child != null) {
+            if (child.write) {
+              child.write(writer);
+            } else if (typeof child === "string") {
+              writer(escape.escapeXMLText(child));
+            } else if (child.toString) {
+              writer(escape.escapeXMLText(child.toString(10)));
+            }
+          }
+        }
+        writer("</");
+        writer(this.name);
+        writer(">");
+      }
+      write(writer) {
+        writer("<");
+        writer(this.name);
+        for (const k in this.attrs) {
+          const v = this.attrs[k];
+          if (v != null) {
+            writer(" ");
+            writer(k);
+            writer('="');
+            writer(escape.escapeXML(typeof v === "string" ? v : v.toString(10)));
+            writer('"');
+          }
+        }
+        if (this.children.length === 0) {
+          writer("/>");
+        } else {
+          this._addChildren(writer);
+        }
+      }
+    };
+    Element5.prototype.tree = Element5.prototype.root;
+    module.exports = Element5;
+  }
+});
+
+// node_modules/ltx/lib/createElement.js
+var require_createElement = __commonJS({
+  "node_modules/ltx/lib/createElement.js"(exports, module) {
+    "use strict";
+    var Element5 = require_Element();
+    function append(el, child) {
+      if (Array.isArray(child)) {
+        for (const c of child) append(el, c);
+        return;
+      }
+      if (child === "" || child == null || child === true || child === false) {
+        return;
+      }
+      el.cnode(child);
+    }
+    function createElement2(name, attrs, ...children) {
+      if (typeof attrs === "object" && attrs !== null) {
+        delete attrs.__source;
+        delete attrs.__self;
+        for (const [key, value] of Object.entries(attrs)) {
+          if (value == null) delete attrs[key];
+          else attrs[key] = value.toString(10);
+        }
+      }
+      const el = new Element5(name, attrs);
+      for (const child of children) {
+        append(el, child);
+      }
+      return el;
+    }
+    module.exports = createElement2;
+  }
+});
+
+// node_modules/ltx/lib/parsers/ltx.js
+var require_ltx = __commonJS({
+  "node_modules/ltx/lib/parsers/ltx.js"(exports, module) {
+    "use strict";
+    var events = __require("events");
+    var escape = require_escape();
+    var STATE_TEXT = 0;
+    var STATE_IGNORE_COMMENT = 1;
+    var STATE_IGNORE_INSTRUCTION = 2;
+    var STATE_TAG_NAME = 3;
+    var STATE_TAG = 4;
+    var STATE_ATTR_NAME = 5;
+    var STATE_ATTR_EQ = 6;
+    var STATE_ATTR_QUOT = 7;
+    var STATE_ATTR_VALUE = 8;
+    var STATE_CDATA = 9;
+    var STATE_IGNORE_CDATA = 10;
+    var SaxLtx = class extends events.EventEmitter {
+      constructor() {
+        super();
+        let state = STATE_TEXT;
+        let remainder;
+        let parseRemainder;
+        let tagName;
+        let attrs;
+        let endTag;
+        let selfClosing;
+        let attrQuote;
+        let attrQuoteChar;
+        let recordStart = 0;
+        let attrName;
+        this._handleTagOpening = function _handleTagOpening(endTag2, tagName2, attrs2) {
+          if (!endTag2) {
+            this.emit("startElement", tagName2, attrs2);
+            if (selfClosing) {
+              this.emit("endElement", tagName2, true);
+            }
+          } else {
+            this.emit("endElement", tagName2, false);
+          }
+        };
+        this.write = function write(data) {
+          if (typeof data !== "string") {
+            data = data.toString();
+          }
+          let pos = 0;
+          if (remainder) {
+            data = remainder + data;
+            pos += !parseRemainder ? remainder.length : 0;
+            parseRemainder = false;
+            remainder = null;
+          }
+          function endRecording() {
+            if (typeof recordStart === "number") {
+              const recorded = data.slice(recordStart, pos);
+              recordStart = void 0;
+              return recorded;
+            }
+          }
+          for (; pos < data.length; pos++) {
+            switch (state) {
+              case STATE_TEXT: {
+                const lt = data.indexOf("<", pos);
+                if (lt !== -1 && pos !== lt) {
+                  pos = lt;
+                }
+                break;
+              }
+              case STATE_ATTR_VALUE: {
+                const quot = data.indexOf(attrQuoteChar, pos);
+                if (quot !== -1) {
+                  pos = quot;
+                }
+                break;
+              }
+              case STATE_IGNORE_COMMENT: {
+                const endcomment = data.indexOf("-->", pos);
+                if (endcomment !== -1) {
+                  pos = endcomment + 2;
+                }
+                break;
+              }
+              case STATE_IGNORE_CDATA: {
+                const endCDATA = data.indexOf("]]>", pos);
+                if (endCDATA !== -1) {
+                  pos = endCDATA + 2;
+                }
+                break;
+              }
+            }
+            const c = data.charCodeAt(pos);
+            switch (state) {
+              case STATE_TEXT:
+                if (c === 60) {
+                  const text = endRecording();
+                  if (text) {
+                    this.emit("text", escape.unescapeXML(text));
+                  }
+                  state = STATE_TAG_NAME;
+                  recordStart = pos + 1;
+                  attrs = {};
+                }
+                break;
+              case STATE_CDATA:
+                if (c === 93) {
+                  if (data.substr(pos + 1, 2) === "]>") {
+                    const cData = endRecording();
+                    if (cData) {
+                      this.emit("text", cData);
+                    }
+                    state = STATE_TEXT;
+                  } else if (data.length < pos + 2) {
+                    parseRemainder = true;
+                    pos = data.length;
+                  }
+                }
+                break;
+              case STATE_TAG_NAME:
+                if (c === 47 && recordStart === pos) {
+                  recordStart = pos + 1;
+                  endTag = true;
+                } else if (c === 33) {
+                  if (data.substr(pos + 1, 7) === "[CDATA[") {
+                    recordStart = pos + 8;
+                    state = STATE_CDATA;
+                  } else if (data.length < pos + 8 && "[CDATA[".startsWith(data.slice(pos + 1))) {
+                    parseRemainder = true;
+                    pos = data.length;
+                  } else {
+                    recordStart = void 0;
+                    state = STATE_IGNORE_COMMENT;
+                  }
+                } else if (c === 63) {
+                  recordStart = void 0;
+                  state = STATE_IGNORE_INSTRUCTION;
+                } else if (c <= 32 || c === 47 || c === 62) {
+                  tagName = endRecording();
+                  pos--;
+                  state = STATE_TAG;
+                }
+                break;
+              case STATE_IGNORE_COMMENT:
+                if (c === 62) {
+                  const prevFirst = data.charCodeAt(pos - 1);
+                  const prevSecond = data.charCodeAt(pos - 2);
+                  if (prevFirst === 45 && prevSecond === 45 || prevFirst === 93 && prevSecond === 93) {
+                    state = STATE_TEXT;
+                  }
+                }
+                break;
+              case STATE_IGNORE_INSTRUCTION:
+                if (c === 62) {
+                  const prev = data.charCodeAt(pos - 1);
+                  if (prev === 63) {
+                    state = STATE_TEXT;
+                  }
+                }
+                break;
+              case STATE_TAG:
+                if (c === 62) {
+                  this._handleTagOpening(endTag, tagName, attrs);
+                  tagName = void 0;
+                  attrs = void 0;
+                  endTag = void 0;
+                  selfClosing = void 0;
+                  state = STATE_TEXT;
+                  recordStart = pos + 1;
+                } else if (c === 47) {
+                  selfClosing = true;
+                } else if (c > 32) {
+                  recordStart = pos;
+                  state = STATE_ATTR_NAME;
+                }
+                break;
+              case STATE_ATTR_NAME:
+                if (c <= 32 || c === 61) {
+                  attrName = endRecording();
+                  pos--;
+                  state = STATE_ATTR_EQ;
+                }
+                break;
+              case STATE_ATTR_EQ:
+                if (c === 61) {
+                  state = STATE_ATTR_QUOT;
+                }
+                break;
+              case STATE_ATTR_QUOT:
+                if (c === 34 || c === 39) {
+                  attrQuote = c;
+                  attrQuoteChar = c === 34 ? '"' : "'";
+                  state = STATE_ATTR_VALUE;
+                  recordStart = pos + 1;
+                }
+                break;
+              case STATE_ATTR_VALUE:
+                if (c === attrQuote) {
+                  const value = escape.unescapeXML(endRecording());
+                  attrs[attrName] = value;
+                  attrName = void 0;
+                  state = STATE_TAG;
+                }
+                break;
+            }
+          }
+          if (typeof recordStart === "number" && recordStart <= data.length) {
+            remainder = data.slice(recordStart);
+            recordStart = 0;
+          }
+        };
+      }
+      end(data) {
+        if (data) {
+          this.write(data);
+        }
+        this.write = function write() {
+        };
+      }
+    };
+    module.exports = SaxLtx;
+  }
+});
+
 // src/types/smule-requests.ts
 import { randomUUID } from "crypto";
 var Device = class {
@@ -664,7 +1315,7 @@ var SmuleUtil;
 import axios from "axios";
 
 // src/smule-live-chat.ts
-import { client, xml } from "@xmpp/client";
+import { client, xml as xml2 } from "@xmpp/client";
 
 // src/smule-urls.ts
 var SmuleUrls;
@@ -1297,22 +1948,117 @@ var SmuleUrls;
   ]);
 })(SmuleUrls || (SmuleUrls = {}));
 
+// node_modules/@xmpp/xml/index.js
+var import_Element2 = __toESM(require_Element(), 1);
+var import_createElement = __toESM(require_createElement(), 1);
+var import_escape = __toESM(require_escape(), 1);
+
+// node_modules/@xmpp/xml/lib/Parser.js
+var import_ltx = __toESM(require_ltx(), 1);
+var import_Element = __toESM(require_Element(), 1);
+
+// node_modules/@xmpp/events/index.js
+import { EventEmitter } from "events";
+
+// node_modules/@xmpp/xml/lib/XMLError.js
+var XMLError = class extends Error {
+  constructor(...args) {
+    super(...args);
+    this.name = "XMLError";
+  }
+};
+
+// node_modules/@xmpp/xml/lib/Parser.js
+var Parser = class extends EventEmitter {
+  constructor() {
+    super();
+    const parser = new import_ltx.default();
+    this.root = null;
+    this.cursor = null;
+    parser.on("startElement", this.onStartElement.bind(this));
+    parser.on("endElement", this.onEndElement.bind(this));
+    parser.on("text", this.onText.bind(this));
+    this.parser = parser;
+  }
+  onStartElement(name, attrs) {
+    const element = new import_Element.default(name, attrs);
+    const { root, cursor } = this;
+    if (!root) {
+      this.root = element;
+      this.emit("start", element);
+    } else if (cursor !== root) {
+      cursor.append(element);
+    }
+    this.cursor = element;
+  }
+  onEndElement(name) {
+    const { root, cursor } = this;
+    if (name !== cursor.name) {
+      this.emit("error", new XMLError(`${cursor.name} must be closed.`));
+      return;
+    }
+    if (cursor === root) {
+      this.emit("end", root);
+      return;
+    }
+    if (!cursor.parent) {
+      cursor.parent = root;
+      this.emit("element", cursor);
+      this.cursor = root;
+      return;
+    }
+    this.cursor = cursor.parent;
+  }
+  onText(str) {
+    const { cursor } = this;
+    if (!cursor) {
+      this.emit("error", new XMLError(`${str} must be a child.`));
+      return;
+    }
+    cursor.t(str);
+  }
+  write(data) {
+    this.parser.write(data);
+  }
+  end(data) {
+    if (data) {
+      this.parser.write(data);
+    }
+  }
+};
+Parser.XMLError = XMLError;
+var Parser_default = Parser;
+
+// node_modules/@xmpp/xml/index.js
+function xml(...args) {
+  return (0, import_createElement.default)(...args);
+}
+Object.assign(xml, {
+  Element: import_Element2.default,
+  createElement: import_createElement.default,
+  Parser: Parser_default,
+  escapeXML: import_escape.escapeXML,
+  unescapeXML: import_escape.unescapeXML,
+  escapeXMLText: import_escape.escapeXMLText,
+  unescapeXMLText: import_escape.unescapeXMLText,
+  XMLError,
+  xml
+});
+
 // src/smule-live-chat.ts
-import "@xmpp/xml";
-import EventEmitter from "events";
+import EventEmitter2 from "events";
 import "@xmpp/jid";
+import { randomUUID as randomUUID2 } from "crypto";
 var SmuleLiveChat = class {
-  events = new EventEmitter();
+  events = new EventEmitter2();
   state = "closed";
   client;
   jid;
-  ongoingIq = false;
-  iqHasMore = false;
-  lastIqId = "0";
+  iqs = {};
   roomJID = null;
   roomUsers = [];
   chat = { messages: [] };
-  constructor(userId, session, host = SmuleUrls.userChat, roomJID) {
+  constructor(userId, session, host = SmuleUrls.cfireChat, roomJID) {
     this.client = client({
       service: "xmpp://" + host,
       domain: host,
@@ -1344,22 +2090,25 @@ var SmuleLiveChat = class {
     this.jid = await this.client.start();
     this._log("Connected as:", this.jid.getLocal() + "@" + this.jid.getDomain());
     this.client.send(
-      xml(
+      xml2(
         "presence",
         { to: this.roomJID + "/" + this.jid.getLocal() },
-        xml(
+        xml2(
           "x",
           { xmlns: "http://jabber.org/protocol/muc" },
-          xml(
+          xml2(
             "password"
           ),
-          xml(
+          xml2(
             "history",
             { maxstanzas: "1" }
           )
         )
       )
     );
+    this.sendIqQuery("http://jabber.org/protocol/disco#info", (el) => {
+      console.log("reply from disco", el);
+    });
   }
   /**
    * Disconnects the client from the XMPP server.
@@ -1371,83 +2120,41 @@ var SmuleLiveChat = class {
    */
   async disconnect() {
     try {
+      await this.client.send(xml2("presence", { type: "unavailable" }));
       await this.client.stop();
     } catch {
     }
   }
-  /**
-   * Send a chat state to the server. This is used to
-   * signal whether you are currently active or not.
-   *
-   * active -> You're active
-   * 
-   * composing -> Typing
-   * 
-   * paused -> Just stopped typing
-   * 
-   * inactive -> You're inactive
-   * 
-   * gone -> You're hidden / disconnected / You've left the chat
-   * 
-   * @param state One of `active`, `composing`, `paused`, `inactive`, or `gone`.
-   *              Default is `active`
-   */
-  async sendChatState(to, state = "active") {
-    if (typeof to != "string" && "accountId" in to) to = this.getJIDFromUserId(to.accountId);
-    await this.client.send(
-      xml(
-        "message",
-        { to: to.toString(), type: "chat" },
-        xml(
-          "chatstate",
-          { xmlns: "http://jabber.org/protocol/chatstates" },
-          state
-        )
+  sendIq(data, callback, iqType = "get") {
+    const id = randomUUID2();
+    this.iqs[id] = callback;
+    this.client.send(
+      xml2(
+        "iq",
+        { from: this.jid.toString(), to: this.roomJID, type: iqType, id },
+        data
       )
     );
   }
-  /**
-   * Loads the entire message history
-   * @param limit The maximum number of messages to fetch. Default is 50.
-   * @remarks This currently recurses until it loads ALL archived messages.
-   *          This means that it will take a long time to load all messages.
-   * @remarks Filtering by a specific JID may not work yet
-   */
-  async loadMessageHistory(limit = 50, before = null, after = null, jid) {
-    this._log("Loading live chat history...");
-    this.ongoingIq = true;
-    await this.client.send(
-      xml(
-        "iq",
-        { from: this.jid.toString(), to: this.roomJID, type: "get", id: "meow" },
-        xml(
-          "query",
-          { xmlns: "http://jabber.org/protocol/muc#history" }
-        )
-      )
+  sendIqQuery(xmlns, callback, iqType = "get") {
+    this.sendIq(
+      xml2("query", { xmlns }),
+      callback,
+      iqType
     );
-    while (this.ongoingIq) await new Promise((resolve) => setTimeout(resolve, 100));
   }
   /**
-   * Send a text message
-   * @param jid The JID to send the message to
+   * Send a text message to the livestream
    * @param message The message body
    */
-  async sendTextMessage(jid, message) {
-    if (typeof jid != "string" && "accountId" in jid) jid = this.getJIDFromUserId(jid.accountId);
+  async sendTextMessage(message) {
     await this.client.send(
-      xml(
+      xml2(
         "message",
-        { to: jid.toString(), type: "groupchat" },
-        xml("body", {}, message)
+        { to: this.roomJID, type: "groupchat" },
+        xml2("body", {}, message)
       )
     );
-    const data = {
-      sender: parseInt(this.jid.getLocal()),
-      content: message
-    };
-    this.chat[this.getUserIdFromJID(jid.toString())].messages.push(data);
-    this.events.emit("message", data);
   }
   /**
    * Read-only jid to prevent any bugs
@@ -1560,6 +2267,23 @@ var SmuleLiveChat = class {
       this._log("Got host left!", data2);
       this.events.emit("host-left", data2);
     }
+    child = el.getChild("song-listen");
+    if (child) {
+      const data2 = {
+        arrKey: child.getChild("arrangement-key").getText(),
+        hostSessionId: child.getChild("host-session-id").getText()
+      };
+      this._log("Got song listen!", data2);
+      this.events.emit("song-listen", data2);
+    }
+    child = el.getChild("campfire-ended");
+    if (child) {
+      const data2 = {
+        reason: child.getChild("reason").getText()
+      };
+      this._log("Got stop livestream!", data2);
+      this.events.emit("stop-livestream", data2);
+    }
     child = el.getChild("result");
     if (!child) return;
     child = child.getChild("forwarded");
@@ -1583,15 +2307,17 @@ var SmuleLiveChat = class {
     if (child) {
       child = child.getChild("item");
       if (child) {
-        if (!el.getAttr("jid")) return;
-        const data = {
-          user: this.getUserIdFromJID(el.getAttr("jid")),
-          role: child.getAttr("role"),
-          affiliation: child.getAttr("affiliation")
-        };
-        this._log("Got presence!", data);
-        this.roomUsers.push(data);
-        this.events.emit("presence", data);
+        if (!el.getAttr("jid")) {
+        } else {
+          const data = {
+            user: this.getUserIdFromJID(el.getAttr("jid")),
+            role: child.getAttr("role"),
+            affiliation: child.getAttr("affiliation")
+          };
+          this._log("Got presence!", data);
+          this.roomUsers.push(data);
+          this.events.emit("presence", data);
+        }
       }
     }
   }
@@ -1688,22 +2414,11 @@ var SmuleLiveChat = class {
       this.parsePresence(el);
     } else {
       if (el.is("iq")) {
-        let child = el.getChild("fin");
-        if (child) {
-          if (child.getAttr("complete") == "false") {
-            this.iqHasMore = true;
-            child = child.getChild("set");
-            if (child) {
-              child = child.getChild("last");
-              if (child) {
-                this.lastIqId = child.getText();
-              }
-            }
-          } else {
-            this.iqHasMore = false;
-          }
+        const id = el.getAttr("id");
+        if (id) {
+          this.iqs[id](el);
+          delete this.iqs[id];
         }
-        this.ongoingIq = false;
       }
       this._log("Stanza!", el.toString());
     }
@@ -2136,21 +2851,17 @@ var SmuleMIDI;
 })(SmuleMIDI || (SmuleMIDI = {}));
 
 // src/smule-chat.ts
-import { client as client2, xml as xml2 } from "@xmpp/client";
-import "@xmpp/xml";
-import EventEmitter2 from "events";
+import { client as client2, xml as xml3 } from "@xmpp/client";
+import EventEmitter3 from "events";
 import "@xmpp/jid";
+import { randomUUID as randomUUID3 } from "crypto";
 var SmuleChat = class {
-  events = new EventEmitter2();
+  events = new EventEmitter3();
   state = "closed";
   client;
   jid;
-  ongoingIq = false;
-  iqHasMore = false;
-  lastIqId = "0";
-  isLive = false;
+  iqs = {};
   roomJID = null;
-  roomUsers = [];
   chats = {};
   constructor(userId, session, host = SmuleUrls.userChat, roomJID) {
     this.client = client2({
@@ -2161,7 +2872,6 @@ var SmuleChat = class {
       username: userId + "",
       password: session
     });
-    this.isLive = host != SmuleUrls.userChat || !!roomJID;
     this.roomJID = roomJID;
     this.client.on("close", (el) => this.onClose(el));
     this.client.on("closing", () => this.onClosing());
@@ -2184,27 +2894,7 @@ var SmuleChat = class {
   async connect() {
     this.jid = await this.client.start();
     this._log("Connected as:", this.jid.getLocal() + "@" + this.jid.getDomain());
-    if (!this.isLive && !this.roomJID) {
-      this.client.send(xml2("presence", {}));
-    } else {
-      this.client.send(
-        xml2(
-          "presence",
-          { to: this.roomJID + "/" + this.jid.getLocal() },
-          xml2(
-            "x",
-            { xmlns: "http://jabber.org/protocol/muc" },
-            xml2(
-              "password"
-            ),
-            xml2(
-              "history",
-              { maxstanzas: "1" }
-            )
-          )
-        )
-      );
-    }
+    this.client.send(xml3("presence", {}));
   }
   /**
    * Disconnects the client from the XMPP server.
@@ -2216,10 +2906,29 @@ var SmuleChat = class {
    */
   async disconnect() {
     try {
+      await this.client.send(xml3("presence", { type: "unavailable" }));
       await this.client.stop();
     } catch {
     }
   }
+  sendIq(data, callback, iqType = "get") {
+    const id = randomUUID3();
+    this.iqs[id] = callback;
+    this.client.send(
+      xml3(
+        "iq",
+        { from: this.jid.toString(), to: this.roomJID, type: iqType, id },
+        data
+      )
+    );
+  }
+  sendIqQuery(xmlns, callback, iqType = "get") {
+    this.sendIq(
+      xml3("query", { xmlns }),
+      callback,
+      iqType
+    );
+  }
   /**
    * Send a chat state to the server. This is used to
    * signal whether you are currently active or not.
@@ -2240,10 +2949,10 @@ var SmuleChat = class {
   async sendChatState(to, state = "active") {
     if (typeof to != "string" && "accountId" in to) to = this.getJIDFromUserId(to.accountId);
     await this.client.send(
-      xml2(
+      xml3(
         "message",
         { to: to.toString(), type: "chat" },
-        xml2(
+        xml3(
           "chatstate",
           { xmlns: "http://jabber.org/protocol/chatstates" },
           state
@@ -2259,50 +2968,29 @@ var SmuleChat = class {
    * @remarks Filtering by a specific JID may not work yet
    */
   async loadMessageHistory(limit = 50, before = null, after = null, jid) {
-    if (!this.isLive) {
-      if (this.ongoingIq) this._log("Waiting for previous iq to finish...");
-      while (this.ongoingIq) await new Promise((resolve) => setTimeout(resolve, 100));
-      if (jid)
-        this._log(`Loading ${limit} messages with ${jid}...`);
-      else
-        this._log(`Loading ${limit} messages from history...`);
-      if (!before && !after && !jid) this.chats = {};
-      this.ongoingIq = true;
-      await this.client.send(
-        xml2(
-          "iq",
-          { type: "set", id: "mam-query" },
-          xml2(
-            "query",
-            { xmlns: "urn:xmpp:mam:2" },
-            xml2(
-              "set",
-              { xmlns: "http://jabber.org/protocol/rsm" },
-              xml2("max", {}, limit.toString()),
-              before ? xml2("before", {}, before.toString()) : null,
-              after ? xml2("after", {}, after.toString()) : null
-            ),
-            jid ? xml2("with", {}, jid.toString()) : null
-          )
-        )
-      );
-      while (this.ongoingIq) await new Promise((resolve) => setTimeout(resolve, 100));
-      if (this.iqHasMore) await this.loadMessageHistory(limit, null, this.lastIqId, jid);
-    } else {
-      this._log("Loading live chat history...");
-      this.ongoingIq = true;
-      await this.client.send(
-        xml2(
-          "iq",
-          { from: this.jid.toString(), to: this.roomJID, type: "get", id: "meow" },
-          xml2(
-            "query",
-            { xmlns: "http://jabber.org/protocol/muc#history" }
-          )
-        )
-      );
-      while (this.ongoingIq) await new Promise((resolve) => setTimeout(resolve, 100));
-    }
+    if (jid)
+      this._log(`Loading ${limit} messages with ${jid}...`);
+    else
+      this._log(`Loading ${limit} messages from history...`);
+    if (!before && !after && !jid) this.chats = {};
+    this.sendIq(
+      xml3(
+        "query",
+        { xmlns: "urn:xmpp:mam:2" },
+        xml3(
+          "set",
+          { xmlns: "http://jabber.org/protocol/rsm" },
+          xml3("max", {}, limit.toString()),
+          before ? xml3("before", {}, before.toString()) : null,
+          after ? xml3("after", {}, after.toString()) : null
+        ),
+        jid ? xml3("with", {}, jid.toString()) : null
+      ),
+      (el) => {
+        this._log("Finished loading history!", el.toString());
+      },
+      "set"
+    );
   }
   /**
    * Send a text message
@@ -2312,18 +3000,12 @@ var SmuleChat = class {
   async sendTextMessage(jid, message) {
     if (typeof jid != "string" && "accountId" in jid) jid = this.getJIDFromUserId(jid.accountId);
     await this.client.send(
-      xml2(
+      xml3(
         "message",
-        { to: jid.toString(), type: this.isLive ? "groupchat" : "chat" },
-        xml2("body", {}, message)
+        { to: jid.toString(), type: "chat" },
+        xml3("body", {}, message)
       )
     );
-    let data = {
-      sender: parseInt(this.jid.getLocal()),
-      content: message
-    };
-    this.chats[this.getUserIdFromJID(jid.toString())].messages.push(data);
-    this.events.emit("message", data);
   }
   /**
    * Send a performance / recording 
@@ -2333,19 +3015,19 @@ var SmuleChat = class {
   async sendPerformanceMessage(jid, performanceKey) {
     if (typeof jid != "string" && "accountId" in jid) jid = this.getJIDFromUserId(jid.accountId);
     await this.client.send(
-      xml2(
+      xml3(
         "message",
         { to: jid.toString(), type: "chat" },
-        xml2(
+        xml3(
           "performance",
           { xmlns: "urn:x-smule:xmpp" },
-          xml2(
+          xml3(
             "key",
             {},
             performanceKey
           )
         ),
-        xml2("body", {}, "")
+        xml3("body", {}, "")
       )
     );
   }
@@ -2356,29 +3038,10 @@ var SmuleChat = class {
   async sendReadReceipt(jid) {
     if (typeof jid != "string" && "accountId" in jid) jid = this.getJIDFromUserId(jid.accountId);
     await this.client.send(
-      xml2(
+      xml3(
         "message",
         { to: jid.toString(), type: "chat" },
-        xml2("received", { xmlns: "urn:xmpp:receipts" })
-      )
-    );
-  }
-  //TODO - Most definitely not required
-  async archiveMessage(jid, message) {
-    if (typeof jid != "string" && "accountId" in jid) jid = this.getJIDFromUserId(jid.accountId);
-    await this.client.send(
-      xml2(
-        "iq",
-        { type: "set" },
-        xml2(
-          "archive",
-          { xmlns: "urn:xmpp:mam:2" },
-          xml2(
-            "item",
-            { with: jid, id: Math.random().toString(16).substring(2, 8) },
-            xml2("body", {}, message)
-          )
-        )
+        xml3("received", { xmlns: "urn:xmpp:receipts" })
       )
     );
   }
@@ -2396,7 +3059,6 @@ var SmuleChat = class {
    */
   getUserIdFromJID(jid) {
     if (!(typeof jid == "string")) return parseInt(jid.getLocal());
-    if (jid.includes("/")) return parseInt(jid.split("/")[1]);
     return parseInt(jid.split("@")[0]);
   }
   /**
@@ -2406,7 +3068,6 @@ var SmuleChat = class {
    */
   getJIDFromUserId(userId) {
     if (typeof userId != "string" && typeof userId != "number" && "accountId" in userId) userId = userId.accountId;
-    if (this.isLive) return this.roomJID + "/" + userId;
     return userId + "@" + this.jid.getDomain();
   }
   //* Processes all message-like elements
@@ -2431,7 +3092,6 @@ var SmuleChat = class {
     }
     child = el.getChild("body");
     const perfChild = el.getChild("performance");
-    const perfStartChild = el.getChild("performance-start");
     if (child && (child.getText().trim().length > 0 || perfChild)) {
       this._log("Got message!", child.getText());
       let performanceKey2 = void 0;
@@ -2462,7 +3122,8 @@ var SmuleChat = class {
       content: child.getText(),
       sender: this.getUserIdFromJID(child.parent.getAttr("from")),
       id: child.parent.getAttr("id"),
-      performanceKey
+      performanceKey,
+      systemMessage: !!child.parent.getChild("smule-system-msg")
     };
     let chat = this.jid.getLocal().includes(data.sender + "") ? this.getUserIdFromJID(child.parent.getAttr("to")) : data.sender;
     this.events.emit("history", data);
@@ -2471,25 +3132,6 @@ var SmuleChat = class {
   }
   parsePresence(el) {
     if (el.children.length < 1) return;
-    if (this.isLive) {
-      let child = el.getChildByAttr("xmlns", "http://jabber.org/protocol/muc#user");
-      if (child) {
-        child = child.getChild("item");
-        if (child) {
-          if (!el.getAttr("jid")) return;
-          let user = this.getUserIdFromJID(el.getAttr("jid"));
-          let role = child.getAttr("role");
-          let affiliation = child.getAttr("affiliation");
-          let data = {
-            user,
-            role,
-            affiliation
-          };
-          this.roomUsers.push(data);
-          this.events.emit("presence", data);
-        }
-      }
-    }
   }
   /**
    * Fetches the chats currently loaded
@@ -2507,9 +3149,6 @@ var SmuleChat = class {
     if (!(user in this.chats)) this.chats[user] = { messages: [] };
     return this.chats[user];
   }
-  fetchUsers() {
-    return this.roomUsers;
-  }
   //#region Internal events
   onClose(el) {
     this._log("Closed!:", el);
@@ -2593,22 +3232,11 @@ var SmuleChat = class {
       this.parsePresence(el);
     } else {
       if (el.is("iq")) {
-        let child = el.getChild("fin");
-        if (child) {
-          if (child.getAttr("complete") == "false") {
-            this.iqHasMore = true;
-            child = child.getChild("set");
-            if (child) {
-              child = child.getChild("last");
-              if (child) {
-                this.lastIqId = child.getText();
-              }
-            }
-          } else {
-            this.iqHasMore = false;
-          }
+        const id = el.getAttr("id");
+        if (id) {
+          this.iqs[id](el);
+          delete this.iqs[id];
         }
-        this.ongoingIq = false;
       }
       this._log("Stanza!", el.toString());
     }
@@ -2616,13 +3244,13 @@ var SmuleChat = class {
   //#endregion Internal events
   //#region Logging
   _log(...args) {
-    console.log(this.isLive ? "[SmuleLiveChat]" : "[SmuleChat]", ...args);
+    console.log("[SmuleChat]", ...args);
   }
   _warn(...args) {
-    console.warn(this.isLive ? "[SmuleLiveChat]" : "[SmuleChat]", ...args);
+    console.warn("[SmuleChat]", ...args);
   }
   _error(...args) {
-    console.error(this.isLive ? "[SmuleLiveChat]" : "[SmuleChat]", ...args);
+    console.error("[SmuleChat]", ...args);
   }
   //#endregion Logging
 };
@@ -2631,7 +3259,7 @@ var SmuleChat = class {
 import { readFileSync } from "fs";
 import * as crypto from "crypto";
 import "@xmpp/jid";
-var APP_VERSION = "12.0.9";
+var APP_VERSION = "12.6.9";
 var SmuleDigest;
 ((SmuleDigest2) => {
   const SALT = `c2250918de500e32c37842f2d25d4d8210992a0ae96a7f36c4c9703cc675d02b92968bc4fa7feada`;
@@ -3175,13 +3803,37 @@ var Smule = class {
        * Creates a new spark chat
        * @param address The JID address of the chat partner
        * @param type Whether the JID address is an individual or a group
-       * @returns idk
        */
       create: async (address, type = "ACCT") => {
         const req = await this.internal._createRequest(SmuleUrls.SparkChatUpdate, { add: [{ name: address, type }], remove: [] });
+        this.internal._handleNon200(req);
+      },
+      /**
+       * Deletes an existing spark chat
+       * @param address The JID address of the chat partner
+       * @param type Whether the JID address is an individual or a group
+       */
+      delete: async (address, type = "ACCT") => {
+        const req = await this.internal._createRequest(SmuleUrls.SparkChatUpdate, { remove: [{ name: address, type }], add: [] });
+        this.internal._handleNon200(req);
+      },
+      /**
+       * Fetches your existing chats
+       * @param type Whether an individual or a group
+       * @returns Your inbox and your message requests
+       */
+      fetchInboxes: async (type = "ACCT") => {
+        const req = await this.internal._createRequest(SmuleUrls.SparkChatList, { type, limit: 200 });
         if (!this.internal._handleNon200(req)) return;
         return this.internal._getResponseData(req);
       },
+      /**
+       * Marks you as offline to your chats
+       */
+      markOffline: async () => {
+        const req = await this.internal._createRequest(SmuleUrls.SparkChatOffline, {});
+        this.internal._handleNon200(req);
+      },
       /**
        * Creates a connection to the XMPP chat server
        */
@@ -4352,9 +5004,9 @@ var Smule = class {
        * @param to The user to send the message to
        * @param message The message body
        */
-      sendTextMessage: async (to, message) => {
+      sendTextMessage: async (message) => {
         if (!this.liveChatSession) return;
-        await this.liveChatSession.sendTextMessage(to, message);
+        await this.liveChatSession.sendTextMessage(message);
       },
       /**
        * Fetch all loaded chats
@@ -4367,27 +5019,47 @@ var Smule = class {
       fetchUsers: () => {
         if (!this.liveChatSession) return;
         return this.liveChatSession.fetchUsers();
-      },
-      /**
-       * Loads the entire message history
-       * @param limit How many messages
-       * @param before Messages before this
-       * @param after Messages after this
-       * @param user The chat partner
-       * 
-       * @remarks This currently recurses until it loads ALL archived messages.
-       *          This means that it will take a long time to load all messages.
-       * @remarks Filtering by a specific user may not work yet
-       */
-      loadMessageHistory: async (limit = 50, before = null, after = null, user) => {
-        if (!this.liveChatSession) return;
-        await this.liveChatSession.loadMessageHistory(limit, before, after, user);
       }
     },
+    /**
+     * Fetches ("syncs") a livestream (campfire) so you can connect to it
+     * 
+     * @param campfireId The campfire's id
+     * @returns Data regarding the campfire and the streaming details
+     */
     fetch: async (campfireId) => {
       const req = await this.internal._createRequest(SmuleUrls.CfireSync, { campfireId });
       if (!this.internal._handleNon200(req)) return;
       return this.internal._getResponseData(req);
+    },
+    /**
+     * Fetches gifts that have been sent to a live
+     * 
+     * @param campfireId The campfire's id
+     * @param cursor The starting point
+     * @param limit How many results
+     * @returns A list of gifts data
+     */
+    fetchRecentGifts: async (campfireId, cursor = "start", limit = 10) => {
+      const req = await this.internal._createRequest(SmuleUrls.GiftRecentTransactions, { campfireId, cursor, limit, animationVersion: "V2", extraGiftTypes: ["SYSTEM"], previewVersion: "PNG", type: "CFIRE" });
+      if (!this.internal._handleNon200(req)) return;
+      return this.internal._getResponseData(req);
+    },
+    /**
+     * Sign up as available to sing
+     * @param campfireId The livestream's id
+     */
+    joinToSing: async (campfireId) => {
+      const req = await this.internal._createRequest(SmuleUrls.CfireSignupAdd, { campfireId, message: "I'm available to sing" });
+      this.internal._handleNon200(req);
+    },
+    /**
+     * Revoke your availability to sing
+     * @param campfireId The livestream's id
+     */
+    revokeJoinToSing: async (campfireId) => {
+      const req = await this.internal._createRequest(SmuleUrls.CfireSignupRemove, { campfireId });
+      this.internal._handleNon200(req);
     }
   };
   groups = {