@laplace.live/ws 6.3.5 → 6.3.7

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 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,10 +285,15 @@ 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/browser.ts
-import { Buffer } from "buffer";
 import { inflate } from "pako";
 
 // src/inflate/brotli.ts
@@ -2029,38 +2078,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 +2094,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 +2118,8 @@ var KeepLiveWS = class extends KeepLive {
   }
 };
 export {
+  DataEvent,
+  EventEvent,
   KeepLiveWS,
-  LiveWS,
-  relayEvent
+  LiveWS
 };

package/dist/common-DWwvds2J.d.ts

@@ -0,0 +1,59 @@
+type Inflates = {
+    inflateAsync: (b: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+    brotliDecompressAsync: (b: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+};
+
+type LiveOptions = {
+    protover?: 1 | 2 | 3;
+    key?: string;
+    authBody?: any;
+    uid?: number;
+    buvid?: string;
+};
+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 EventTarget {
+    roomid: number;
+    online: number;
+    live: boolean;
+    closed: boolean;
+    timeout: ReturnType<typeof setTimeout>;
+    send: (data: Uint8Array) => void;
+    close: () => void;
+    constructor(inflates: Inflates, roomid: number, { send, close, protover, key, authBody, uid, buvid, }: {
+        send: (data: Uint8Array) => void;
+        close: () => void;
+    } & LiveOptions);
+    dispatchEvent(event: Event): boolean;
+    heartbeat(): void;
+    getOnline(): Promise<number>;
+    on<T = unknown>(type: string, listener: (event: DataEvent<T>) => void, options?: boolean | AddEventListenerOptions): void;
+    off<T = unknown>(type: string, listener: (event: DataEvent<T>) => void, options?: boolean | EventListenerOptions): void;
+}
+declare class KeepLive<Base extends typeof Live> extends EventTarget {
+    params: ConstructorParameters<Base>;
+    closed: boolean;
+    interval: number;
+    timeout: number;
+    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: Uint8Array): void;
+    on<T = unknown>(type: string, listener: (event: DataEvent<T>) => void, options?: boolean | AddEventListenerOptions): void;
+    off<T = unknown>(type: string, listener: (event: DataEvent<T>) => void, options?: boolean | EventListenerOptions): void;
+}
+
+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-DWwvds2J.js';
+export { D as DataEvent, E as EventEvent } from './common-DWwvds2J.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);
 }