@laplace.live/ws 7.0.0 → 7.0.2

package/dist/browser.js

@@ -1,293 +1,3 @@
-// src/buffer.ts
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder();
-function concatUint8Arrays(arrs) {
-  let totalLength = 0;
-  for (const arr of arrs) totalLength += arr.length;
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const arr of arrs) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-var cutBuffer = (buffer) => {
-  const bufferPacks = [];
-  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-  let size;
-  for (let i = 0; i < buffer.length; i += size) {
-    size = view.getInt32(i);
-    bufferPacks.push(buffer.slice(i, i + size));
-  }
-  return bufferPacks;
-};
-var makeDecoder = ({ inflateAsync: inflateAsync2, brotliDecompressAsync: brotliDecompressAsync2 }) => {
-  const decoder = async (buffer) => {
-    const packs = await Promise.all(
-      cutBuffer(buffer).map(async (buf) => {
-        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-        const body = buf.slice(16);
-        const protocol = view.getInt16(6);
-        const operation = view.getInt32(8);
-        let type = "unknow";
-        if (operation === 3) {
-          type = "heartbeat";
-        } else if (operation === 5) {
-          type = "message";
-        } else if (operation === 8) {
-          type = "welcome";
-        }
-        let data;
-        if (protocol === 0) {
-          data = JSON.parse(textDecoder.decode(body));
-        }
-        if (protocol === 1 && body.length === 4) {
-          const bodyView = new DataView(body.buffer, body.byteOffset, body.byteLength);
-          data = bodyView.getUint32(0);
-        }
-        if (protocol === 2) {
-          data = await decoder(await inflateAsync2(body));
-        }
-        if (protocol === 3) {
-          data = await decoder(await brotliDecompressAsync2(body));
-        }
-        return { buf, type, protocol, data };
-      })
-    );
-    return packs.flatMap((pack) => {
-      if (pack.protocol === 2 || pack.protocol === 3) {
-        return pack.data;
-      }
-      return pack;
-    });
-  };
-  return decoder;
-};
-var encoder = (type, body = "") => {
-  const encoded = typeof body === "string" ? body : JSON.stringify(body);
-  const head = new Uint8Array(16);
-  const headView = new DataView(head.buffer, head.byteOffset, head.byteLength);
-  const buffer = textEncoder.encode(encoded);
-  headView.setInt32(0, buffer.length + head.length);
-  headView.setInt16(4, 16);
-  headView.setInt16(6, 1);
-  if (type === "heartbeat") {
-    headView.setInt32(8, 2);
-  }
-  if (type === "join") {
-    headView.setInt32(8, 7);
-  }
-  headView.setInt32(12, 1);
-  return concatUint8Arrays([head, buffer]);
-};
-
-// src/common.ts
-var DataEvent = class extends Event {
-  data;
-  constructor(type, data) {
-    super(type);
-    this.data = data;
-  }
-};
-var EventEvent = class extends Event {
-  event;
-  constructor(event) {
-    super("event");
-    this.event = event;
-  }
-};
-var Live = class extends EventTarget {
-  roomid;
-  online;
-  live;
-  closed;
-  timeout;
-  send;
-  close;
-  constructor(inflates2, roomid, {
-    send,
-    close,
-    protover = 3,
-    key,
-    authBody,
-    uid = 0,
-    buvid
-  }) {
-    if (typeof roomid !== "number" || Number.isNaN(roomid)) {
-      throw new Error(`roomid ${roomid} must be Number not NaN`);
-    }
-    super();
-    this.roomid = roomid;
-    this.online = 0;
-    this.live = false;
-    this.closed = false;
-    this.timeout = setTimeout(() => {
-    }, 0);
-    this.send = send;
-    this.close = () => {
-      this.closed = true;
-      close();
-    };
-    const decode = makeDecoder(inflates2);
-    this.addEventListener("message", async (e) => {
-      const buffer = e.data;
-      const packs = await decode(buffer);
-      packs.forEach(({ type, data }) => {
-        if (type === "welcome") {
-          this.live = true;
-          this.dispatchEvent(new Event("live"));
-          this.send(encoder("heartbeat"));
-        }
-        if (type === "heartbeat") {
-          this.online = data;
-          clearTimeout(this.timeout);
-          this.timeout = setTimeout(() => this.heartbeat(), 1e3 * 30);
-          this.dispatchEvent(new DataEvent("heartbeat", this.online));
-        }
-        if (type === "message") {
-          this.dispatchEvent(new DataEvent("msg", data));
-          const cmd = data.cmd || data.msg?.cmd;
-          if (cmd) {
-            if (cmd.includes("DANMU_MSG")) {
-              this.dispatchEvent(new DataEvent("DANMU_MSG", data));
-            } else {
-              this.dispatchEvent(new DataEvent(cmd, data));
-            }
-          }
-        }
-      });
-    });
-    this.addEventListener("open", () => {
-      if (authBody) {
-        this.send(authBody instanceof Uint8Array ? authBody : encoder("join", authBody));
-      } else {
-        const hi = { uid, roomid, protover, platform: "web", type: 2 };
-        if (key) {
-          hi.key = key;
-        }
-        if (buvid) {
-          hi.buvid = buvid;
-        }
-        const buf = encoder("join", hi);
-        this.send(buf);
-      }
-    });
-    this.addEventListener("close", () => {
-      clearTimeout(this.timeout);
-    });
-    this.addEventListener("_error", () => {
-      this.close();
-      this.dispatchEvent(new Event("error"));
-    });
-  }
-  dispatchEvent(event) {
-    const result = super.dispatchEvent(event);
-    super.dispatchEvent(new EventEvent(event));
-    return result;
-  }
-  heartbeat() {
-    this.send(encoder("heartbeat"));
-  }
-  getOnline() {
-    this.heartbeat();
-    return new Promise(
-      (resolve) => this.addEventListener("heartbeat", (e) => resolve(e.data), { once: true })
-    );
-  }
-  on(type, listener, options) {
-    this.addEventListener(type, listener, options);
-  }
-  off(type, listener, options) {
-    this.removeEventListener(type, listener, options);
-  }
-};
-var KeepLive = class extends EventTarget {
-  params;
-  closed;
-  interval;
-  timeout;
-  connection;
-  Base;
-  constructor(Base, ...params) {
-    super();
-    this.params = params;
-    this.closed = false;
-    this.interval = 100;
-    this.timeout = 45 * 1e3;
-    this.connection = new Base(...this.params);
-    this.Base = Base;
-    this.connect(false);
-  }
-  dispatchEvent(event) {
-    const result = super.dispatchEvent(event);
-    super.dispatchEvent(new EventEvent(event));
-    return result;
-  }
-  connect(reconnect = true) {
-    if (reconnect) {
-      this.connection.close();
-      this.connection = new this.Base(...this.params);
-    }
-    const connection = this.connection;
-    let timeout = setTimeout(() => {
-      connection.close();
-      connection.dispatchEvent(new Event("timeout"));
-    }, this.timeout);
-    connection.addEventListener("event", (e) => {
-      const evt = e.event;
-      if (evt.type !== "error") {
-        if (evt instanceof DataEvent) {
-          this.dispatchEvent(new DataEvent(evt.type, evt.data));
-        } else {
-          this.dispatchEvent(new Event(evt.type));
-        }
-      }
-    });
-    connection.addEventListener("error", () => this.dispatchEvent(new Event("e")));
-    connection.addEventListener("close", () => {
-      if (!this.closed) {
-        setTimeout(() => this.connect(), this.interval);
-      }
-    });
-    connection.addEventListener("heartbeat", () => {
-      clearTimeout(timeout);
-      timeout = setTimeout(() => {
-        connection.close();
-        connection.dispatchEvent(new Event("timeout"));
-      }, this.timeout);
-    });
-    connection.addEventListener("close", () => {
-      clearTimeout(timeout);
-    });
-  }
-  get online() {
-    return this.connection.online;
-  }
-  get roomid() {
-    return this.connection.roomid;
-  }
-  close() {
-    this.closed = true;
-    this.connection.close();
-  }
-  heartbeat() {
-    return this.connection.heartbeat();
-  }
-  getOnline() {
-    return this.connection.getOnline();
-  }
-  send(data) {
-    return this.connection.send(data);
-  }
-  on(type, listener, options) {
-    this.addEventListener(type, listener, options);
-  }
-  off(type, listener, options) {
-    this.removeEventListener(type, listener, options);
-  }
-};
-
 // src/inflate/browser.ts
 import { inflate } from "pako";
 
@@ -1993,92 +1703,461 @@ var makeBrotliDecode = () => {
     flipBuffer(dictionaryData);
     setData(asReadOnlyBuffer(dictionaryData), dictionarySizeBits);
   }
-  function min(a, b) {
-    return a <= b ? a : b;
+  function min(a, b) {
+    return a <= b ? a : b;
+  }
+  function copyBytes(dst, target, src, start, end) {
+    dst.set(src.slice(start, end), target);
+  }
+  function readInput(src, dst, offset, length) {
+    if (src == null) return -1;
+    let end = min(src.offset + length, src.data.length);
+    let bytesRead = end - src.offset;
+    dst.set(src.data.subarray(src.offset, end), offset);
+    src.offset += bytesRead;
+    return bytesRead;
+  }
+  function closeInput(src) {
+    return 0;
+  }
+  function asReadOnlyBuffer(src) {
+    return src;
+  }
+  function isReadOnly(src) {
+    return 1;
+  }
+  function isDirect(src) {
+    return 1;
+  }
+  function flipBuffer(buffer) {
+  }
+  function toUsAsciiBytes(src) {
+    let n = src.length;
+    let result = new Int8Array(n);
+    for (let i = 0; i < n; ++i) {
+      result[i] = src.charCodeAt(i);
+    }
+    return result;
+  }
+  function decode(bytes, options) {
+    let s = new State();
+    initState(s, new InputStream(bytes));
+    if (options) {
+      let customDictionary = (
+        /** @type {?Int8Array} */
+        options["customDictionary"]
+      );
+      if (customDictionary) attachDictionaryChunk(s, customDictionary);
+    }
+    let totalOutput = 0;
+    let chunks = [];
+    while (true) {
+      let chunk = new Int8Array(16384);
+      chunks.push(chunk);
+      s.output = chunk;
+      s.outputOffset = 0;
+      s.outputLength = 16384;
+      s.outputUsed = 0;
+      decompress(s);
+      totalOutput += s.outputUsed;
+      if (s.outputUsed < 16384) break;
+    }
+    close(s);
+    let result = new Int8Array(totalOutput);
+    let offset = 0;
+    for (let i = 0; i < chunks.length; ++i) {
+      let chunk = chunks[i];
+      let end = min(totalOutput, offset + 16384);
+      let len = end - offset;
+      if (len < 16384) {
+        result.set(chunk.subarray(0, len), offset);
+      } else {
+        result.set(chunk, offset);
+      }
+      offset += len;
+    }
+    return result;
+  }
+  return decode;
+};
+var BrotliDecode = makeBrotliDecode();
+
+// src/inflate/browser.ts
+var inflateAsync = (d) => inflate(d);
+var brotliDecompressAsync = (d) => Uint8Array.from(BrotliDecode(Int8Array.from(d)));
+var inflates = { inflateAsync, brotliDecompressAsync };
+
+// src/events.ts
+var LaplaceRawEvent = class extends Event {
+  data;
+  constructor(type, data) {
+    super(type);
+    this.data = data;
+  }
+};
+
+// src/keep-live.ts
+var KeepLive = class extends EventTarget {
+  /** @internal Stored constructor arguments for reconnection. */
+  params;
+  /** `true` after {@link close} has been called; prevents further reconnects. */
+  closed;
+  /** Delay in milliseconds before attempting a reconnect. */
+  interval;
+  /** Maximum milliseconds to wait for a heartbeat before forcing a reconnect. */
+  timeout;
+  /** The current underlying connection instance. */
+  connection;
+  /** @internal The base class constructor used to create new connections. */
+  Base;
+  constructor(Base, ...params) {
+    super();
+    this.params = params;
+    this.closed = false;
+    this.interval = 100;
+    this.timeout = 45 * 1e3;
+    this.connection = new Base(...this.params);
+    this.Base = Base;
+    this.connect(false);
+  }
+  /**
+   * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
+   * for every event, enabling catch-all listeners.
+   */
+  dispatchEvent(event) {
+    const result = super.dispatchEvent(event);
+    super.dispatchEvent(new LaplaceRawEvent("event", event));
+    return result;
+  }
+  /**
+   * Wire up event forwarding and timeout handling on the current connection.
+   * When `reconnect` is `true`, the previous connection is closed and a fresh
+   * one is created from the stored constructor parameters.
+   *
+   * @param reconnect - Whether to tear down and recreate the connection first.
+   */
+  connect(reconnect = true) {
+    if (reconnect) {
+      this.connection.close();
+      this.connection = new this.Base(...this.params);
+    }
+    const connection = this.connection;
+    let timeout = setTimeout(() => {
+      connection.close();
+      connection.dispatchEvent(new Event("timeout"));
+    }, this.timeout);
+    connection.addEventListener("event", (e) => {
+      const evt = e.data;
+      if (evt.type !== "error") {
+        if (evt instanceof LaplaceRawEvent) {
+          this.dispatchEvent(new LaplaceRawEvent(evt.type, evt.data));
+        } else {
+          this.dispatchEvent(new Event(evt.type));
+        }
+      }
+    });
+    connection.addEventListener("error", () => this.dispatchEvent(new Event("e")));
+    connection.addEventListener("close", () => {
+      if (!this.closed) {
+        setTimeout(() => this.connect(), this.interval);
+      }
+    });
+    connection.addEventListener("heartbeat", () => {
+      clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        connection.close();
+        connection.dispatchEvent(new Event("timeout"));
+      }, this.timeout);
+    });
+    connection.addEventListener("close", () => {
+      clearTimeout(timeout);
+    });
+  }
+  /** Latest known online viewer count from the underlying connection. */
+  get online() {
+    return this.connection.online;
+  }
+  /** The live room ID. */
+  get roomid() {
+    return this.connection.roomid;
+  }
+  /** Permanently close the connection and stop reconnecting. */
+  close() {
+    this.closed = true;
+    this.connection.close();
+  }
+  /** Send a heartbeat packet to the server. */
+  heartbeat() {
+    return this.connection.heartbeat();
   }
-  function copyBytes(dst, target, src, start, end) {
-    dst.set(src.slice(start, end), target);
+  /**
+   * Send a heartbeat and resolve with the online viewer count from the
+   * next heartbeat response.
+   * @returns A promise that resolves with the current online count.
+   */
+  getOnline() {
+    return this.connection.getOnline();
   }
-  function readInput(src, dst, offset, length) {
-    if (src == null) return -1;
-    let end = min(src.offset + length, src.data.length);
-    let bytesRead = end - src.offset;
-    dst.set(src.data.subarray(src.offset, end), offset);
-    src.offset += bytesRead;
-    return bytesRead;
+  /**
+   * Send raw binary data through the underlying connection.
+   * @param data - The binary packet to send.
+   */
+  send(data) {
+    return this.connection.send(data);
   }
-  function closeInput(src) {
-    return 0;
+  /**
+   * Subscribe to an event type with a typed {@link LaplaceRawEvent} listener.
+   *
+   * @typeParam T - Expected data type carried by the event.
+   * @param type     - Event name (e.g. `"heartbeat"`, `"msg"`, `"DANMU_MSG"`).
+   * @param listener - Callback receiving a {@link LaplaceRawEvent LaplaceRawEvent\<T\>}.
+   * @param options  - Standard `addEventListener` options.
+   */
+  on(type, listener, options) {
+    this.addEventListener(type, listener, options);
   }
-  function asReadOnlyBuffer(src) {
-    return src;
+  /**
+   * Unsubscribe a previously registered listener.
+   *
+   * @typeParam T - Data type matching the original subscription.
+   * @param type     - Event name.
+   * @param listener - The same function reference passed to {@link on}.
+   * @param options  - Standard `removeEventListener` options.
+   */
+  off(type, listener, options) {
+    this.removeEventListener(type, listener, options);
   }
-  function isReadOnly(src) {
-    return 1;
+};
+
+// src/buffer.ts
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function concatUint8Arrays(arrs) {
+  let totalLength = 0;
+  for (const arr of arrs) totalLength += arr.length;
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrs) {
+    result.set(arr, offset);
+    offset += arr.length;
   }
-  function isDirect(src) {
-    return 1;
+  return result;
+}
+var cutBuffer = (buffer) => {
+  const bufferPacks = [];
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  let size;
+  for (let i = 0; i < buffer.length; i += size) {
+    size = view.getInt32(i);
+    bufferPacks.push(buffer.slice(i, i + size));
   }
-  function flipBuffer(buffer) {
+  return bufferPacks;
+};
+var makeDecoder = ({ inflateAsync: inflateAsync2, brotliDecompressAsync: brotliDecompressAsync2 }) => {
+  const decoder = async (buffer) => {
+    const packs = await Promise.all(
+      cutBuffer(buffer).map(async (buf) => {
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        const body = buf.slice(16);
+        const protocol = view.getInt16(6);
+        const operation = view.getInt32(8);
+        let type = "unknow";
+        if (operation === 3) {
+          type = "heartbeat";
+        } else if (operation === 5) {
+          type = "message";
+        } else if (operation === 8) {
+          type = "welcome";
+        }
+        let data;
+        if (protocol === 0) {
+          data = JSON.parse(textDecoder.decode(body));
+        }
+        if (protocol === 1 && body.length === 4) {
+          const bodyView = new DataView(body.buffer, body.byteOffset, body.byteLength);
+          data = bodyView.getUint32(0);
+        }
+        if (protocol === 2) {
+          data = await decoder(await inflateAsync2(body));
+        }
+        if (protocol === 3) {
+          data = await decoder(await brotliDecompressAsync2(body));
+        }
+        return { buf, type, protocol, data };
+      })
+    );
+    return packs.flatMap((pack) => {
+      if (pack.protocol === 2 || pack.protocol === 3) {
+        return pack.data;
+      }
+      return pack;
+    });
+  };
+  return decoder;
+};
+var encoder = (type, body = "") => {
+  const encoded = typeof body === "string" ? body : JSON.stringify(body);
+  const head = new Uint8Array(16);
+  const headView = new DataView(head.buffer, head.byteOffset, head.byteLength);
+  const buffer = textEncoder.encode(encoded);
+  headView.setInt32(0, buffer.length + head.length);
+  headView.setInt16(4, 16);
+  headView.setInt16(6, 1);
+  if (type === "heartbeat") {
+    headView.setInt32(8, 2);
   }
-  function toUsAsciiBytes(src) {
-    let n = src.length;
-    let result = new Int8Array(n);
-    for (let i = 0; i < n; ++i) {
-      result[i] = src.charCodeAt(i);
-    }
-    return result;
+  if (type === "join") {
+    headView.setInt32(8, 7);
   }
-  function decode(bytes, options) {
-    let s = new State();
-    initState(s, new InputStream(bytes));
-    if (options) {
-      let customDictionary = (
-        /** @type {?Int8Array} */
-        options["customDictionary"]
-      );
-      if (customDictionary) attachDictionaryChunk(s, customDictionary);
-    }
-    let totalOutput = 0;
-    let chunks = [];
-    while (true) {
-      let chunk = new Int8Array(16384);
-      chunks.push(chunk);
-      s.output = chunk;
-      s.outputOffset = 0;
-      s.outputLength = 16384;
-      s.outputUsed = 0;
-      decompress(s);
-      totalOutput += s.outputUsed;
-      if (s.outputUsed < 16384) break;
+  headView.setInt32(12, 1);
+  return concatUint8Arrays([head, buffer]);
+};
+
+// src/live.ts
+var Live = class extends EventTarget {
+  /** The live room ID this instance is connected to. */
+  roomid;
+  /** Latest known online viewer count, updated on each heartbeat. */
+  online;
+  /** `true` after the server acknowledges the join (`welcome` packet). */
+  live;
+  /** `true` after {@link close} has been called. */
+  closed;
+  /** @internal Handle for the heartbeat interval timer. */
+  timeout;
+  /** Send raw binary data over the underlying transport. */
+  send;
+  /** Gracefully close the connection and set {@link closed} to `true`. */
+  close;
+  constructor(inflates2, roomid, {
+    send,
+    close,
+    protover = 3,
+    key,
+    authBody,
+    uid = 0,
+    buvid
+  }) {
+    if (typeof roomid !== "number" || Number.isNaN(roomid)) {
+      throw new Error(`roomid ${roomid} must be Number not NaN`);
     }
-    close(s);
-    let result = new Int8Array(totalOutput);
-    let offset = 0;
-    for (let i = 0; i < chunks.length; ++i) {
-      let chunk = chunks[i];
-      let end = min(totalOutput, offset + 16384);
-      let len = end - offset;
-      if (len < 16384) {
-        result.set(chunk.subarray(0, len), offset);
+    super();
+    this.roomid = roomid;
+    this.online = 0;
+    this.live = false;
+    this.closed = false;
+    this.timeout = setTimeout(() => {
+    }, 0);
+    this.send = send;
+    this.close = () => {
+      this.closed = true;
+      close();
+    };
+    const decode = makeDecoder(inflates2);
+    this.addEventListener("message", async (e) => {
+      const buffer = e.data;
+      const packs = await decode(buffer);
+      packs.forEach(({ type, data }) => {
+        if (type === "welcome") {
+          this.live = true;
+          this.dispatchEvent(new Event("live"));
+          this.send(encoder("heartbeat"));
+        }
+        if (type === "heartbeat") {
+          this.online = data;
+          clearTimeout(this.timeout);
+          this.timeout = setTimeout(() => this.heartbeat(), 1e3 * 30);
+          this.dispatchEvent(new LaplaceRawEvent("heartbeat", this.online));
+        }
+        if (type === "message") {
+          this.dispatchEvent(new LaplaceRawEvent("msg", data));
+          const cmd = data.cmd || data.msg?.cmd;
+          if (cmd) {
+            if (cmd.includes("DANMU_MSG")) {
+              this.dispatchEvent(new LaplaceRawEvent("DANMU_MSG", data));
+            } else {
+              this.dispatchEvent(new LaplaceRawEvent(cmd, data));
+            }
+          }
+        }
+      });
+    });
+    this.addEventListener("open", () => {
+      if (authBody) {
+        this.send(authBody instanceof Uint8Array ? authBody : encoder("join", authBody));
       } else {
-        result.set(chunk, offset);
+        const hi = { uid, roomid, protover, platform: "web", type: 2 };
+        if (key) {
+          hi.key = key;
+        }
+        if (buvid) {
+          hi.buvid = buvid;
+        }
+        const buf = encoder("join", hi);
+        this.send(buf);
       }
-      offset += len;
-    }
+    });
+    this.addEventListener("close", () => {
+      clearTimeout(this.timeout);
+    });
+    this.addEventListener("_error", () => {
+      this.close();
+      this.dispatchEvent(new Event("error"));
+    });
+  }
+  /**
+   * Overridden to also dispatch a `LaplaceRawEvent<Event>` with type `"event"`
+   * for every event, enabling catch-all listeners.
+   */
+  dispatchEvent(event) {
+    const result = super.dispatchEvent(event);
+    super.dispatchEvent(new LaplaceRawEvent("event", event));
     return result;
   }
-  return decode;
+  /** Send a heartbeat packet to the server. */
+  heartbeat() {
+    this.send(encoder("heartbeat"));
+  }
+  /**
+   * Send a heartbeat and resolve with the online viewer count from the
+   * next heartbeat response.
+   * @returns A promise that resolves with the current online count.
+   */
+  getOnline() {
+    this.heartbeat();
+    return new Promise(
+      (resolve) => this.addEventListener("heartbeat", (e) => resolve(e.data), { once: true })
+    );
+  }
+  /**
+   * Subscribe to an event type with a typed {@link LaplaceRawEvent} listener.
+   * Convenience wrapper around {@link EventTarget.addEventListener}.
+   *
+   * @typeParam T - Expected data type carried by the event.
+   * @param type     - Event name (e.g. `"heartbeat"`, `"msg"`, `"DANMU_MSG"`).
+   * @param listener - Callback receiving a {@link LaplaceRawEvent LaplaceRawEvent\<T\>}.
+   * @param options  - Standard `addEventListener` options.
+   */
+  on(type, listener, options) {
+    this.addEventListener(type, listener, options);
+  }
+  /**
+   * Unsubscribe a previously registered listener.
+   * Convenience wrapper around {@link EventTarget.removeEventListener}.
+   *
+   * @typeParam T - Data type matching the original subscription.
+   * @param type     - Event name.
+   * @param listener - The same function reference passed to {@link on}.
+   * @param options  - Standard `removeEventListener` options.
+   */
+  off(type, listener, options) {
+    this.removeEventListener(type, listener, options);
+  }
 };
-var BrotliDecode = makeBrotliDecode();
-
-// src/inflate/browser.ts
-var inflateAsync = (d) => inflate(d);
-var brotliDecompressAsync = (d) => Uint8Array.from(BrotliDecode(Int8Array.from(d)));
-var inflates = { inflateAsync, brotliDecompressAsync };
 
 // src/ws.ts
 var LiveWSBase = class extends Live {
+  /** The underlying native WebSocket instance. */
   ws;
   constructor(inflates2, roomid, { address = "wss://broadcastlv.chat.bilibili.com/sub", ...options } = {}) {
     const ws = new WebSocket(address);
@@ -2093,7 +2172,7 @@ var LiveWSBase = class extends Live {
     ws.addEventListener("open", (e) => this.dispatchEvent(new Event(e.type)));
     ws.addEventListener(
       "message",
-      (e) => this.dispatchEvent(new DataEvent("message", new Uint8Array(e.data)))
+      (e) => this.dispatchEvent(new LaplaceRawEvent("message", new Uint8Array(e.data)))
     );
     ws.addEventListener("close", (e) => this.dispatchEvent(new Event(e.type)));
     ws.addEventListener("error", () => this.dispatchEvent(new Event("_error")));
@@ -2113,8 +2192,7 @@ var KeepLiveWS = class extends KeepLive {
   }
 };
 export {
-  DataEvent,
-  EventEvent,
   KeepLiveWS,
+  LaplaceRawEvent,
   LiveWS
 };