@laplace.live/ws 6.3.5 → 6.3.6

package/dist/browser.d.ts

@@ -1,19 +1,11 @@
-import { L as Live, I as Inflates, a as LiveOptions, K as KeepLive } from './common-BGRg5uk7.js';
-export { r as relayEvent } from './common-BGRg5uk7.js';
-import { EventEmitter } from 'events';
+import { L as Live, I as Inflates, a as LiveOptions, K as KeepLive } from './common-D1XOmtU3.js';
+export { D as DataEvent, E as EventEvent } from './common-D1XOmtU3.js';
 
 type WSOptions = LiveOptions & {
     address?: string;
 };
-declare class WSWrapper extends EventEmitter {
-    ws: WebSocket;
-    constructor(address: string, inflates: Inflates);
-    get readyState(): number;
-    send(data: Buffer): void;
-    close(code?: number, reason?: string): void;
-}
 declare class LiveWSBase extends Live {
-    ws: WSWrapper;
+    ws: WebSocket;
     constructor(inflates: Inflates, roomid: number, { address, ...options }?: WSOptions);
 }
 

package/dist/browser.js

@@ -1,45 +1,60 @@
-// src/common.ts
-import { EventEmitter } from "events";
-
 // 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 = buffer.readInt32BE(i);
+    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 body = buf.slice(16);
-      const protocol = buf.readInt16BE(6);
-      const operation = buf.readInt32BE(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(String(body));
-      }
-      if (protocol === 1 && body.length === 4) {
-        data = body.readUIntBE(0, 4);
-      }
-      if (protocol === 2) {
-        data = await decoder(await inflateAsync2(body));
-      }
-      if (protocol === 3) {
-        data = await decoder(await brotliDecompressAsync2(body));
-      }
-      return { buf, type, protocol, data };
-    }));
+    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;
@@ -49,42 +64,47 @@ var makeDecoder = ({ inflateAsync: inflateAsync2, brotliDecompressAsync: brotliD
   };
   return decoder;
 };
-var encoder = (type, { Buffer: Buffer2 }, body = "") => {
-  const blank = Buffer2.alloc(16);
+var encoder = (type, body = "") => {
   if (typeof body !== "string") {
     body = JSON.stringify(body);
   }
-  const head = Buffer2.from(blank);
-  const buffer = Buffer2.from(body);
-  head.writeInt32BE(buffer.length + head.length, 0);
-  head.writeInt16BE(16, 4);
-  head.writeInt16BE(1, 6);
+  const head = new Uint8Array(16);
+  const headView = new DataView(head.buffer, head.byteOffset, head.byteLength);
+  const buffer = textEncoder.encode(body);
+  headView.setInt32(0, buffer.length + head.length);
+  headView.setInt16(4, 16);
+  headView.setInt16(6, 1);
   if (type === "heartbeat") {
-    head.writeInt32BE(2, 8);
+    headView.setInt32(8, 2);
   }
   if (type === "join") {
-    head.writeInt32BE(7, 8);
+    headView.setInt32(8, 7);
   }
-  head.writeInt32BE(1, 12);
-  return Buffer2.concat([head, buffer]);
+  headView.setInt32(12, 1);
+  return concatUint8Arrays([head, buffer]);
 };
 
 // src/common.ts
-var relayEvent = /* @__PURE__ */ Symbol("relay");
-var NiceEventEmitter = class extends EventEmitter {
-  emit(eventName, ...params) {
-    super.emit(eventName, ...params);
-    super.emit(relayEvent, eventName, ...params);
-    return true;
+var DataEvent = class extends Event {
+  data;
+  constructor(type, data) {
+    super(type);
+    this.data = data;
   }
 };
-var Live = class extends NiceEventEmitter {
+var EventEvent = class extends Event {
+  event;
+  constructor(event) {
+    super("event");
+    this.event = event;
+  }
+};
+var Live = class extends EventTarget {
   roomid;
   online;
   live;
   closed;
   timeout;
-  inflates;
   send;
   close;
   constructor(inflates2, roomid, {
@@ -100,7 +120,6 @@ var Live = class extends NiceEventEmitter {
       throw new Error(`roomid ${roomid} must be Number not NaN`);
     }
     super();
-    this.inflates = inflates2;
     this.roomid = roomid;
     this.online = 0;
     this.live = false;
@@ -112,37 +131,39 @@ var Live = class extends NiceEventEmitter {
       this.closed = true;
       close();
     };
-    this.on("message", async (buffer) => {
-      const packs = await makeDecoder(inflates2)(buffer);
+    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.emit("live");
-          this.send(encoder("heartbeat", inflates2));
+          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.emit("heartbeat", this.online);
+          this.dispatchEvent(new DataEvent("heartbeat", this.online));
         }
         if (type === "message") {
-          this.emit("msg", data);
-          const cmd = data.cmd || data.msg && data.msg.cmd;
+          this.dispatchEvent(new DataEvent("msg", data));
+          const cmd = data.cmd || data.msg?.cmd;
           if (cmd) {
             if (cmd.includes("DANMU_MSG")) {
-              this.emit("DANMU_MSG", data);
+              this.dispatchEvent(new DataEvent("DANMU_MSG", data));
             } else {
-              this.emit(cmd, data);
+              this.dispatchEvent(new DataEvent(cmd, data));
             }
           }
         }
       });
     });
-    this.on("open", () => {
+    this.addEventListener("open", () => {
       if (authBody) {
         if (typeof authBody === "object") {
-          authBody = encoder("join", inflates2, authBody);
+          authBody = encoder("join", authBody);
         }
         this.send(authBody);
       } else {
@@ -153,27 +174,34 @@ var Live = class extends NiceEventEmitter {
         if (buvid) {
           hi.buvid = buvid;
         }
-        const buf = encoder("join", inflates2, hi);
+        const buf = encoder("join", hi);
         this.send(buf);
       }
     });
-    this.on("close", () => {
+    this.addEventListener("close", () => {
       clearTimeout(this.timeout);
     });
-    this.on("_error", (error) => {
+    this.addEventListener("_error", () => {
       this.close();
-      this.emit("error", error);
+      this.dispatchEvent(new Event("error"));
     });
   }
+  dispatchEvent(event) {
+    const result = super.dispatchEvent(event);
+    super.dispatchEvent(new EventEvent(event));
+    return result;
+  }
   heartbeat() {
-    this.send(encoder("heartbeat", this.inflates));
+    this.send(encoder("heartbeat"));
   }
   getOnline() {
     this.heartbeat();
-    return new Promise((resolve) => this.once("heartbeat", resolve));
+    return new Promise(
+      (resolve) => this.addEventListener("heartbeat", (e) => resolve(e.data), { once: true })
+    );
   }
 };
-var KeepLive = class extends EventEmitter {
+var KeepLive = class extends EventTarget {
   params;
   closed;
   interval;
@@ -190,6 +218,11 @@ var KeepLive = class extends EventEmitter {
     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();
@@ -198,27 +231,32 @@ var KeepLive = class extends EventEmitter {
     const connection = this.connection;
     let timeout = setTimeout(() => {
       connection.close();
-      connection.emit("timeout");
+      connection.dispatchEvent(new Event("timeout"));
     }, this.timeout);
-    connection.on(relayEvent, (eventName, ...params) => {
-      if (eventName !== "error") {
-        this.emit(eventName, ...params);
+    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.on("error", (e) => this.emit("e", e));
-    connection.on("close", () => {
+    connection.addEventListener("error", () => this.dispatchEvent(new Event("e")));
+    connection.addEventListener("close", () => {
       if (!this.closed) {
         setTimeout(() => this.connect(), this.interval);
       }
     });
-    connection.on("heartbeat", () => {
+    connection.addEventListener("heartbeat", () => {
       clearTimeout(timeout);
       timeout = setTimeout(() => {
         connection.close();
-        connection.emit("timeout");
+        connection.dispatchEvent(new Event("timeout"));
       }, this.timeout);
     });
-    connection.on("close", () => {
+    connection.addEventListener("close", () => {
       clearTimeout(timeout);
     });
   }
@@ -244,7 +282,6 @@ var KeepLive = class extends EventEmitter {
 };
 
 // src/inflate/browser.ts
-import { Buffer } from "buffer";
 import { inflate } from "pako";
 
 // src/inflate/brotli.ts
@@ -2029,38 +2066,15 @@ var makeBrotliDecode = () => {
 var BrotliDecode = makeBrotliDecode();
 
 // src/inflate/browser.ts
-var inflateAsync = (d) => Buffer.from(inflate(d));
-var brotliDecompressAsync = (d) => Buffer.from(BrotliDecode(Int8Array.from(d)));
-var inflates = { inflateAsync, brotliDecompressAsync, Buffer };
+var inflateAsync = (d) => inflate(d);
+var brotliDecompressAsync = (d) => Uint8Array.from(BrotliDecode(Int8Array.from(d)));
+var inflates = { inflateAsync, brotliDecompressAsync };
 
 // src/ws-client.ts
-import { EventEmitter as EventEmitter2 } from "events";
-var WSWrapper = class extends EventEmitter2 {
-  ws;
-  constructor(address, inflates2) {
-    super();
-    const ws = new WebSocket(address);
-    this.ws = ws;
-    ws.binaryType = "arraybuffer";
-    ws.onopen = () => this.emit("open");
-    ws.onmessage = ({ data }) => this.emit("message", inflates2.Buffer.from(data));
-    ws.onerror = () => this.emit("error");
-    ws.onclose = () => this.emit("close");
-  }
-  get readyState() {
-    return this.ws.readyState;
-  }
-  send(data) {
-    this.ws.send(data);
-  }
-  close(code, reason) {
-    this.ws.close(code, reason);
-  }
-};
 var LiveWSBase = class extends Live {
   ws;
   constructor(inflates2, roomid, { address = "wss://broadcastlv.chat.bilibili.com/sub", ...options } = {}) {
-    const ws = new WSWrapper(address, inflates2);
+    const ws = new WebSocket(address);
     const send = (data) => {
       if (ws.readyState === 1) {
         ws.send(data);
@@ -2068,10 +2082,14 @@ var LiveWSBase = class extends Live {
     };
     const close = () => this.ws.close();
     super(inflates2, roomid, { send, close, ...options });
-    ws.on("open", (...params) => this.emit("open", ...params));
-    ws.on("message", (data) => this.emit("message", data));
-    ws.on("close", (code, reason) => this.emit("close", code, reason));
-    ws.on("error", (error) => this.emit("_error", error));
+    ws.binaryType = "arraybuffer";
+    ws.addEventListener("open", (e) => this.dispatchEvent(new Event(e.type)));
+    ws.addEventListener(
+      "message",
+      (e) => this.dispatchEvent(new DataEvent("message", new Uint8Array(e.data)))
+    );
+    ws.addEventListener("close", (e) => this.dispatchEvent(new Event(e.type)));
+    ws.addEventListener("error", () => this.dispatchEvent(new Event("_error")));
     this.ws = ws;
   }
 };
@@ -2088,7 +2106,8 @@ var KeepLiveWS = class extends KeepLive {
   }
 };
 export {
+  DataEvent,
+  EventEvent,
   KeepLiveWS,
-  LiveWS,
-  relayEvent
+  LiveWS
 };

package/dist/{common-BGRg5uk7.d.ts → common-D1XOmtU3.d.ts}

@@ -1,9 +1,6 @@
-import { EventEmitter } from 'events';
-
 type Inflates = {
-    inflateAsync: (b: Buffer) => Buffer | Promise<Buffer>;
-    brotliDecompressAsync: (b: Buffer) => Buffer | Promise<Buffer>;
-    Buffer: typeof Buffer;
+    inflateAsync: (b: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+    brotliDecompressAsync: (b: Uint8Array) => Uint8Array | Promise<Uint8Array>;
 };
 
 type LiveOptions = {
@@ -13,27 +10,31 @@ type LiveOptions = {
     uid?: number;
     buvid?: string;
 };
-declare const relayEvent: unique symbol;
-declare class NiceEventEmitter extends EventEmitter {
-    emit(eventName: string | symbol, ...params: any[]): boolean;
+declare class DataEvent<T> extends Event {
+    data: T;
+    constructor(type: string, data: T);
+}
+declare class EventEvent extends Event {
+    event: Event;
+    constructor(event: Event);
 }
-declare class Live extends NiceEventEmitter {
+declare class Live extends EventTarget {
     roomid: number;
     online: number;
     live: boolean;
     closed: boolean;
     timeout: ReturnType<typeof setTimeout>;
-    inflates: Inflates;
-    send: (data: Buffer) => void;
+    send: (data: Uint8Array) => void;
     close: () => void;
     constructor(inflates: Inflates, roomid: number, { send, close, protover, key, authBody, uid, buvid, }: {
-        send: (data: Buffer) => void;
+        send: (data: Uint8Array) => void;
         close: () => void;
     } & LiveOptions);
+    dispatchEvent(event: Event): boolean;
     heartbeat(): void;
     getOnline(): Promise<number>;
 }
-declare class KeepLive<Base extends typeof Live> extends EventEmitter {
+declare class KeepLive<Base extends typeof Live> extends EventTarget {
     params: ConstructorParameters<Base>;
     closed: boolean;
     interval: number;
@@ -41,13 +42,14 @@ declare class KeepLive<Base extends typeof Live> extends EventEmitter {
     connection: InstanceType<Base>;
     Base: Base;
     constructor(Base: Base, ...params: ConstructorParameters<Base>);
+    dispatchEvent(event: Event): boolean;
     connect(reconnect?: boolean): void;
     get online(): number;
     get roomid(): number;
     close(): void;
     heartbeat(): void;
     getOnline(): Promise<number>;
-    send(data: Buffer): void;
+    send(data: Uint8Array): void;
 }
 
-export { type Inflates as I, KeepLive as K, Live as L, type LiveOptions as a, relayEvent as r };
+export { DataEvent as D, EventEvent as E, type Inflates as I, KeepLive as K, Live as L, type LiveOptions as a };

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-import { L as Live, I as Inflates, a as LiveOptions, K as KeepLive } from './common-BGRg5uk7.js';
-export { r as relayEvent } from './common-BGRg5uk7.js';
+import { L as Live, I as Inflates, a as LiveOptions, K as KeepLive } from './common-D1XOmtU3.js';
+export { D as DataEvent, E as EventEvent } from './common-D1XOmtU3.js';
 import { Socket } from 'node:net';
 import { Agent } from 'node:http';
-import { EventEmitter } from 'events';
 import WS from 'ws';
 
 type TCPOptions = LiveOptions & {
@@ -11,7 +10,7 @@ type TCPOptions = LiveOptions & {
 };
 declare class LiveTCPBase extends Live {
     socket: Socket;
-    buffer: Buffer;
+    buf: Buffer;
     i: number;
     constructor(inflates: Inflates, roomid: number, { host, port, ...options }?: TCPOptions);
     splitBuffer(): void;
@@ -21,15 +20,8 @@ type WSOptions = LiveOptions & {
     address?: string;
     agent?: Agent;
 };
-declare class WSWrapper extends EventEmitter {
-    ws: WS;
-    constructor(address: string, ...args: any[]);
-    get readyState(): 0 | 1 | 3 | 2;
-    send(data: Buffer): void;
-    close(code?: number, data?: string): void;
-}
 declare class LiveWSBase extends Live {
-    ws: WSWrapper;
+    ws: WS;
     constructor(inflates: Inflates, roomid: number, { address, agent, ...options }?: WSOptions);
 }
 

package/dist/index.js

@@ -1,45 +1,60 @@
-// src/common.ts
-import { EventEmitter } from "events";
-
 // 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 = buffer.readInt32BE(i);
+    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 body = buf.slice(16);
-      const protocol = buf.readInt16BE(6);
-      const operation = buf.readInt32BE(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(String(body));
-      }
-      if (protocol === 1 && body.length === 4) {
-        data = body.readUIntBE(0, 4);
-      }
-      if (protocol === 2) {
-        data = await decoder(await inflateAsync2(body));
-      }
-      if (protocol === 3) {
-        data = await decoder(await brotliDecompressAsync2(body));
-      }
-      return { buf, type, protocol, data };
-    }));
+    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;
@@ -49,42 +64,47 @@ var makeDecoder = ({ inflateAsync: inflateAsync2, brotliDecompressAsync: brotliD
   };
   return decoder;
 };
-var encoder = (type, { Buffer: Buffer3 }, body = "") => {
-  const blank = Buffer3.alloc(16);
+var encoder = (type, body = "") => {
   if (typeof body !== "string") {
     body = JSON.stringify(body);
   }
-  const head = Buffer3.from(blank);
-  const buffer = Buffer3.from(body);
-  head.writeInt32BE(buffer.length + head.length, 0);
-  head.writeInt16BE(16, 4);
-  head.writeInt16BE(1, 6);
+  const head = new Uint8Array(16);
+  const headView = new DataView(head.buffer, head.byteOffset, head.byteLength);
+  const buffer = textEncoder.encode(body);
+  headView.setInt32(0, buffer.length + head.length);
+  headView.setInt16(4, 16);
+  headView.setInt16(6, 1);
   if (type === "heartbeat") {
-    head.writeInt32BE(2, 8);
+    headView.setInt32(8, 2);
   }
   if (type === "join") {
-    head.writeInt32BE(7, 8);
+    headView.setInt32(8, 7);
   }
-  head.writeInt32BE(1, 12);
-  return Buffer3.concat([head, buffer]);
+  headView.setInt32(12, 1);
+  return concatUint8Arrays([head, buffer]);
 };
 
 // src/common.ts
-var relayEvent = /* @__PURE__ */ Symbol("relay");
-var NiceEventEmitter = class extends EventEmitter {
-  emit(eventName, ...params) {
-    super.emit(eventName, ...params);
-    super.emit(relayEvent, eventName, ...params);
-    return true;
+var DataEvent = class extends Event {
+  data;
+  constructor(type, data) {
+    super(type);
+    this.data = data;
   }
 };
-var Live = class extends NiceEventEmitter {
+var EventEvent = class extends Event {
+  event;
+  constructor(event) {
+    super("event");
+    this.event = event;
+  }
+};
+var Live = class extends EventTarget {
   roomid;
   online;
   live;
   closed;
   timeout;
-  inflates;
   send;
   close;
   constructor(inflates2, roomid, {
@@ -100,7 +120,6 @@ var Live = class extends NiceEventEmitter {
       throw new Error(`roomid ${roomid} must be Number not NaN`);
     }
     super();
-    this.inflates = inflates2;
     this.roomid = roomid;
     this.online = 0;
     this.live = false;
@@ -112,37 +131,39 @@ var Live = class extends NiceEventEmitter {
       this.closed = true;
       close();
     };
-    this.on("message", async (buffer) => {
-      const packs = await makeDecoder(inflates2)(buffer);
+    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.emit("live");
-          this.send(encoder("heartbeat", inflates2));
+          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.emit("heartbeat", this.online);
+          this.dispatchEvent(new DataEvent("heartbeat", this.online));
         }
         if (type === "message") {
-          this.emit("msg", data);
-          const cmd = data.cmd || data.msg && data.msg.cmd;
+          this.dispatchEvent(new DataEvent("msg", data));
+          const cmd = data.cmd || data.msg?.cmd;
           if (cmd) {
             if (cmd.includes("DANMU_MSG")) {
-              this.emit("DANMU_MSG", data);
+              this.dispatchEvent(new DataEvent("DANMU_MSG", data));
             } else {
-              this.emit(cmd, data);
+              this.dispatchEvent(new DataEvent(cmd, data));
             }
           }
         }
       });
     });
-    this.on("open", () => {
+    this.addEventListener("open", () => {
       if (authBody) {
         if (typeof authBody === "object") {
-          authBody = encoder("join", inflates2, authBody);
+          authBody = encoder("join", authBody);
         }
         this.send(authBody);
       } else {
@@ -153,27 +174,34 @@ var Live = class extends NiceEventEmitter {
         if (buvid) {
           hi.buvid = buvid;
         }
-        const buf = encoder("join", inflates2, hi);
+        const buf = encoder("join", hi);
         this.send(buf);
       }
     });
-    this.on("close", () => {
+    this.addEventListener("close", () => {
       clearTimeout(this.timeout);
     });
-    this.on("_error", (error) => {
+    this.addEventListener("_error", () => {
       this.close();
-      this.emit("error", error);
+      this.dispatchEvent(new Event("error"));
     });
   }
+  dispatchEvent(event) {
+    const result = super.dispatchEvent(event);
+    super.dispatchEvent(new EventEvent(event));
+    return result;
+  }
   heartbeat() {
-    this.send(encoder("heartbeat", this.inflates));
+    this.send(encoder("heartbeat"));
   }
   getOnline() {
     this.heartbeat();
-    return new Promise((resolve) => this.once("heartbeat", resolve));
+    return new Promise(
+      (resolve) => this.addEventListener("heartbeat", (e) => resolve(e.data), { once: true })
+    );
   }
 };
-var KeepLive = class extends EventEmitter {
+var KeepLive = class extends EventTarget {
   params;
   closed;
   interval;
@@ -190,6 +218,11 @@ var KeepLive = class extends EventEmitter {
     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();
@@ -198,27 +231,32 @@ var KeepLive = class extends EventEmitter {
     const connection = this.connection;
     let timeout = setTimeout(() => {
       connection.close();
-      connection.emit("timeout");
+      connection.dispatchEvent(new Event("timeout"));
     }, this.timeout);
-    connection.on(relayEvent, (eventName, ...params) => {
-      if (eventName !== "error") {
-        this.emit(eventName, ...params);
+    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.on("error", (e) => this.emit("e", e));
-    connection.on("close", () => {
+    connection.addEventListener("error", () => this.dispatchEvent(new Event("e")));
+    connection.addEventListener("close", () => {
       if (!this.closed) {
         setTimeout(() => this.connect(), this.interval);
       }
     });
-    connection.on("heartbeat", () => {
+    connection.addEventListener("heartbeat", () => {
       clearTimeout(timeout);
       timeout = setTimeout(() => {
         connection.close();
-        connection.emit("timeout");
+        connection.dispatchEvent(new Event("timeout"));
       }, this.timeout);
     });
-    connection.on("close", () => {
+    connection.addEventListener("close", () => {
       clearTimeout(timeout);
     });
   }
@@ -246,16 +284,17 @@ var KeepLive = class extends EventEmitter {
 // src/inflate/node.ts
 import { promisify } from "util";
 import { brotliDecompress, inflate } from "zlib";
-import { Buffer as Buffer2 } from "buffer";
-var inflateAsync = promisify(inflate);
-var brotliDecompressAsync = promisify(brotliDecompress);
-var inflates = { inflateAsync, brotliDecompressAsync, Buffer: Buffer2 };
+var _inflate = promisify(inflate);
+var _brotli = promisify(brotliDecompress);
+var inflateAsync = (b) => _inflate(b);
+var brotliDecompressAsync = (b) => _brotli(b);
+var inflates = { inflateAsync, brotliDecompressAsync };
 
 // src/tcp.ts
 import net from "net";
 var LiveTCPBase = class extends Live {
   socket;
-  buffer;
+  buf;
   i;
   constructor(inflates2, roomid, { host = "broadcastlv.chat.bilibili.com", port = 2243, ...options } = {}) {
     const socket = net.connect(port, host);
@@ -265,59 +304,37 @@ var LiveTCPBase = class extends Live {
     const close = () => this.socket.end();
     super(inflates2, roomid, { send, close, ...options });
     this.i = 0;
-    this.buffer = Buffer.alloc(0);
-    socket.on("ready", () => this.emit("open"));
-    socket.on("close", () => this.emit("close"));
-    socket.on("error", (...params) => this.emit("_error", ...params));
+    this.buf = Buffer.alloc(0);
+    socket.on("ready", () => this.dispatchEvent(new Event("open")));
+    socket.on("close", () => this.dispatchEvent(new Event("close")));
+    socket.on("error", () => this.dispatchEvent(new Event("_error")));
     socket.on("data", (buffer) => {
-      this.buffer = Buffer.concat([this.buffer, buffer]);
+      this.buf = Buffer.concat([this.buf, buffer]);
       this.splitBuffer();
     });
     this.socket = socket;
   }
   splitBuffer() {
-    while (this.buffer.length >= 4 && this.buffer.readInt32BE(0) <= this.buffer.length) {
-      const size = this.buffer.readInt32BE(0);
-      const pack = this.buffer.slice(0, size);
-      this.buffer = this.buffer.slice(size);
+    while (this.buf.length >= 4 && this.buf.readInt32BE(0) <= this.buf.length) {
+      const size = this.buf.readInt32BE(0);
+      const pack = this.buf.slice(0, size);
+      this.buf = this.buf.slice(size);
       this.i++;
       if (this.i > 5) {
         this.i = 0;
-        this.buffer = Buffer.from(this.buffer);
+        this.buf = Buffer.from(this.buf);
       }
-      this.emit("message", pack);
+      this.dispatchEvent(new DataEvent("message", pack));
     }
   }
 };
 
 // src/ws-node.ts
-import { EventEmitter as EventEmitter2 } from "events";
 import WS from "ws";
-var WSWrapper = class extends EventEmitter2 {
-  ws;
-  constructor(address, ...args) {
-    super();
-    const ws = new WS(address, ...args);
-    this.ws = ws;
-    ws.onopen = () => this.emit("open");
-    ws.onmessage = ({ data }) => this.emit("message", data);
-    ws.onerror = () => this.emit("error");
-    ws.onclose = () => this.emit("close");
-  }
-  get readyState() {
-    return this.ws.readyState;
-  }
-  send(data) {
-    this.ws.send(data);
-  }
-  close(code, data) {
-    this.ws.close(code, data);
-  }
-};
 var LiveWSBase = class extends Live {
   ws;
   constructor(inflates2, roomid, { address = "wss://broadcastlv.chat.bilibili.com/sub", agent, ...options } = {}) {
-    const ws = new WSWrapper(address, { agent });
+    const ws = new WS(address, { agent });
     const send = (data) => {
       if (ws.readyState === 1) {
         ws.send(data);
@@ -325,10 +342,10 @@ var LiveWSBase = class extends Live {
     };
     const close = () => this.ws.close();
     super(inflates2, roomid, { send, close, ...options });
-    ws.on("open", (...params) => this.emit("open", ...params));
-    ws.on("message", (data) => this.emit("message", data));
-    ws.on("close", (code, reason) => this.emit("close", code, reason));
-    ws.on("error", (error) => this.emit("_error", error));
+    ws.on("open", () => this.dispatchEvent(new Event("open")));
+    ws.on("message", (data) => this.dispatchEvent(new DataEvent("message", data)));
+    ws.on("close", () => this.dispatchEvent(new Event("close")));
+    ws.on("error", () => this.dispatchEvent(new Event("_error")));
     this.ws = ws;
   }
 };
@@ -367,11 +384,12 @@ var KeepLiveTCP = class extends KeepLive {
   }
 };
 export {
+  DataEvent,
+  EventEvent,
   KeepLiveTCP,
   KeepLiveWS,
   LiveTCP,
   LiveWS,
   getConf,
-  getRoomid,
-  relayEvent
+  getRoomid
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laplace.live/ws",
-  "version": "6.3.5",
+  "version": "6.3.6",
   "description": "Bilibili Live WebSocket/TCP API",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,8 +60,6 @@
     "provenance": true
   },
   "dependencies": {
-    "buffer": "^6.0.3",
-    "events": "^3.3.0",
     "pako": "^2.1.0",
     "ws": "^8.19.0"
   },