@laplace.live/ws 6.3.5 → 6.3.7

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 EventEvent = class extends Event {
+  event;
+  constructor(event) {
+    super("event");
+    this.event = event;
   }
 };
-var Live = class extends NiceEventEmitter {
+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,40 @@ 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 })
+    );
+  }
+  on(type, listener, options) {
+    this.addEventListener(type, listener, options);
+  }
+  off(type, listener, options) {
+    this.removeEventListener(type, listener, options);
   }
 };
-var KeepLive = class extends EventEmitter {
+var KeepLive = class extends EventTarget {
   params;
   closed;
   interval;
@@ -190,6 +224,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 +237,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);
     });
   }
@@ -241,21 +285,28 @@ var KeepLive = class extends EventEmitter {
   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/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 +316,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 +354,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 +396,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.7",
   "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"
   },

package/dist/common-BGRg5uk7.d.ts

@@ -1,53 +0,0 @@
-import { EventEmitter } from 'events';
-
-type Inflates = {
-    inflateAsync: (b: Buffer) => Buffer | Promise<Buffer>;
-    brotliDecompressAsync: (b: Buffer) => Buffer | Promise<Buffer>;
-    Buffer: typeof Buffer;
-};
-
-type LiveOptions = {
-    protover?: 1 | 2 | 3;
-    key?: string;
-    authBody?: any;
-    uid?: number;
-    buvid?: string;
-};
-declare const relayEvent: unique symbol;
-declare class NiceEventEmitter extends EventEmitter {
-    emit(eventName: string | symbol, ...params: any[]): boolean;
-}
-declare class Live extends NiceEventEmitter {
-    roomid: number;
-    online: number;
-    live: boolean;
-    closed: boolean;
-    timeout: ReturnType<typeof setTimeout>;
-    inflates: Inflates;
-    send: (data: Buffer) => void;
-    close: () => void;
-    constructor(inflates: Inflates, roomid: number, { send, close, protover, key, authBody, uid, buvid, }: {
-        send: (data: Buffer) => void;
-        close: () => void;
-    } & LiveOptions);
-    heartbeat(): void;
-    getOnline(): Promise<number>;
-}
-declare class KeepLive<Base extends typeof Live> extends EventEmitter {
-    params: ConstructorParameters<Base>;
-    closed: boolean;
-    interval: number;
-    timeout: number;
-    connection: InstanceType<Base>;
-    Base: Base;
-    constructor(Base: Base, ...params: ConstructorParameters<Base>);
-    connect(reconnect?: boolean): void;
-    get online(): number;
-    get roomid(): number;
-    close(): void;
-    heartbeat(): void;
-    getOnline(): Promise<number>;
-    send(data: Buffer): void;
-}
-
-export { type Inflates as I, KeepLive as K, Live as L, type LiveOptions as a, relayEvent as r };