@d0v3riz/baileys 6.7.21 → 6.7.22

package/lib/Signal/Group/sender-key-message.js

@@ -1,8 +1,10 @@
-/* @ts-ignore */
-import { calculateSignature, verifySignature } from 'libsignal/src/curve.js';
-import { proto } from '../../../WAProto/index.js';
-import { CiphertextMessage } from './ciphertext-message.js';
-export class SenderKeyMessage extends CiphertextMessage {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyMessage = void 0;
+const curve_1 = require("libsignal/src/curve");
+const WAProto_1 = require("../../../WAProto");
+const ciphertext_message_1 = require("./ciphertext-message");
+class SenderKeyMessage extends ciphertext_message_1.CiphertextMessage {
     constructor(keyId, iteration, ciphertext, signatureKey, serialized) {
         super();
         this.SIGNATURE_LENGTH = 64;
@@ -10,7 +12,7 @@ export class SenderKeyMessage extends CiphertextMessage {
             const version = serialized[0];
             const message = serialized.slice(1, serialized.length - this.SIGNATURE_LENGTH);
             const signature = serialized.slice(-1 * this.SIGNATURE_LENGTH);
-            const senderKeyMessage = proto.SenderKeyMessage.decode(message).toJSON();
+            const senderKeyMessage = WAProto_1.proto.SenderKeyMessage.decode(message).toJSON();
             this.serialized = serialized;
             this.messageVersion = (version & 0xff) >> 4;
             this.keyId = senderKeyMessage.id;
@@ -24,7 +26,7 @@ export class SenderKeyMessage extends CiphertextMessage {
         else {
             const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256;
             const ciphertextBuffer = Buffer.from(ciphertext);
-            const message = proto.SenderKeyMessage.encode(proto.SenderKeyMessage.create({
+            const message = WAProto_1.proto.SenderKeyMessage.encode(WAProto_1.proto.SenderKeyMessage.create({
                 id: keyId,
                 iteration: iteration,
                 ciphertext: ciphertextBuffer
@@ -50,12 +52,12 @@ export class SenderKeyMessage extends CiphertextMessage {
     verifySignature(signatureKey) {
         const part1 = this.serialized.slice(0, this.serialized.length - this.SIGNATURE_LENGTH);
         const part2 = this.serialized.slice(-1 * this.SIGNATURE_LENGTH);
-        const res = verifySignature(signatureKey, part1, part2);
+        const res = (0, curve_1.verifySignature)(signatureKey, part1, part2);
         if (!res)
             throw new Error('Invalid signature!');
     }
     getSignature(signatureKey, serialized) {
-        return Buffer.from(calculateSignature(signatureKey, serialized));
+        return Buffer.from((0, curve_1.calculateSignature)(signatureKey, serialized));
     }
     serialize() {
         return this.serialized;
@@ -64,4 +66,4 @@ export class SenderKeyMessage extends CiphertextMessage {
         return 4;
     }
 }
-//# sourceMappingURL=sender-key-message.js.map
+exports.SenderKeyMessage = SenderKeyMessage;

package/lib/Signal/Group/sender-key-name.d.ts

@@ -15,4 +15,3 @@ export declare class SenderKeyName {
     hashCode(): number;
 }
 export {};
-//# sourceMappingURL=sender-key-name.d.ts.map

package/lib/Signal/Group/sender-key-name.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyName = void 0;
 function isNull(str) {
     return str === null || str === '';
 }
@@ -19,7 +22,7 @@ function hashCode(strKey) {
     }
     return hash;
 }
-export class SenderKeyName {
+class SenderKeyName {
     constructor(groupId, sender) {
         this.groupId = groupId;
         this.sender = sender;
@@ -45,4 +48,4 @@ export class SenderKeyName {
         return hashCode(this.groupId) ^ hashCode(this.sender.toString());
     }
 }
-//# sourceMappingURL=sender-key-name.js.map
+exports.SenderKeyName = SenderKeyName;

package/lib/Signal/Group/sender-key-record.d.ts

@@ -1,4 +1,4 @@
-import { SenderKeyState } from './sender-key-state.js';
+import { SenderKeyState } from './sender-key-state';
 export interface SenderKeyStateStructure {
     senderKeyId: number;
     senderChainKey: {
@@ -28,4 +28,3 @@ export declare class SenderKeyRecord {
     serialize(): SenderKeyStateStructure[];
     static deserialize(data: Uint8Array | string | SenderKeyStateStructure[]): SenderKeyRecord;
 }
-//# sourceMappingURL=sender-key-record.d.ts.map

package/lib/Signal/Group/sender-key-record.js

@@ -1,12 +1,15 @@
-import { BufferJSON } from '../../Utils/generics.js';
-import { SenderKeyState } from './sender-key-state.js';
-export class SenderKeyRecord {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyRecord = void 0;
+const generics_1 = require("../../Utils/generics");
+const sender_key_state_1 = require("./sender-key-state");
+class SenderKeyRecord {
     constructor(serialized) {
         this.MAX_STATES = 5;
         this.senderKeyStates = [];
         if (serialized) {
             for (const structure of serialized) {
-                this.senderKeyStates.push(new SenderKeyState(null, null, null, null, null, null, structure));
+                this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(null, null, null, null, null, null, structure));
             }
         }
     }
@@ -20,14 +23,14 @@ export class SenderKeyRecord {
         return this.senderKeyStates.find(state => state.getKeyId() === keyId);
     }
     addSenderKeyState(id, iteration, chainKey, signatureKey) {
-        this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, null, signatureKey));
+        this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(id, iteration, chainKey, null, signatureKey));
         if (this.senderKeyStates.length > this.MAX_STATES) {
             this.senderKeyStates.shift();
         }
     }
     setSenderKeyState(id, iteration, chainKey, keyPair) {
         this.senderKeyStates.length = 0;
-        this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, keyPair));
+        this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(id, iteration, chainKey, keyPair));
     }
     serialize() {
         return this.senderKeyStates.map(state => state.getStructure());
@@ -35,11 +38,11 @@ export class SenderKeyRecord {
     static deserialize(data) {
         let parsed;
         if (typeof data === 'string') {
-            parsed = JSON.parse(data, BufferJSON.reviver);
+            parsed = JSON.parse(data, generics_1.BufferJSON.reviver);
         }
         else if (data instanceof Uint8Array) {
             const str = Buffer.from(data).toString('utf-8');
-            parsed = JSON.parse(str, BufferJSON.reviver);
+            parsed = JSON.parse(str, generics_1.BufferJSON.reviver);
         }
         else {
             parsed = data;
@@ -47,4 +50,4 @@ export class SenderKeyRecord {
         return new SenderKeyRecord(parsed);
     }
 }
-//# sourceMappingURL=sender-key-record.js.map
+exports.SenderKeyRecord = SenderKeyRecord;

package/lib/Signal/Group/sender-key-state.d.ts

@@ -1,5 +1,5 @@
-import { SenderChainKey } from './sender-chain-key.js';
-import { SenderMessageKey } from './sender-message-key.js';
+import { SenderChainKey } from './sender-chain-key';
+import { SenderMessageKey } from './sender-message-key';
 interface SenderChainKeyStructure {
     iteration: number;
     seed: Uint8Array;
@@ -36,4 +36,3 @@ export declare class SenderKeyState {
     getStructure(): SenderKeyStateStructure;
 }
 export {};
-//# sourceMappingURL=sender-key-state.d.ts.map

package/lib/Signal/Group/sender-key-state.js

@@ -1,6 +1,9 @@
-import { SenderChainKey } from './sender-chain-key.js';
-import { SenderMessageKey } from './sender-message-key.js';
-export class SenderKeyState {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyState = void 0;
+const sender_chain_key_1 = require("./sender-chain-key");
+const sender_message_key_1 = require("./sender-message-key");
+class SenderKeyState {
     constructor(id, iteration, chainKey, signatureKeyPair, signatureKeyPublic, signatureKeyPrivate, senderKeyStateStructure) {
         this.MAX_MESSAGE_KEYS = 2000;
         if (senderKeyStateStructure) {
@@ -37,7 +40,7 @@ export class SenderKeyState {
         return this.senderKeyStateStructure.senderKeyId;
     }
     getSenderChainKey() {
-        return new SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed);
+        return new sender_chain_key_1.SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed);
     }
     setSenderChainKey(chainKey) {
         this.senderKeyStateStructure.senderChainKey = {
@@ -85,7 +88,7 @@ export class SenderKeyState {
         if (index !== -1) {
             const messageKey = this.senderKeyStateStructure.senderMessageKeys[index];
             this.senderKeyStateStructure.senderMessageKeys.splice(index, 1);
-            return new SenderMessageKey(messageKey.iteration, messageKey.seed);
+            return new sender_message_key_1.SenderMessageKey(messageKey.iteration, messageKey.seed);
         }
         return null;
     }
@@ -93,4 +96,4 @@ export class SenderKeyState {
         return this.senderKeyStateStructure;
     }
 }
-//# sourceMappingURL=sender-key-state.js.map
+exports.SenderKeyState = SenderKeyState;

package/lib/Signal/Group/sender-message-key.d.ts

@@ -9,4 +9,3 @@ export declare class SenderMessageKey {
     getCipherKey(): Uint8Array;
     getSeed(): Uint8Array;
 }
-//# sourceMappingURL=sender-message-key.d.ts.map

package/lib/Signal/Group/sender-message-key.js

@@ -1,8 +1,10 @@
-/* @ts-ignore */
-import { deriveSecrets } from 'libsignal/src/crypto.js';
-export class SenderMessageKey {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderMessageKey = void 0;
+const crypto_1 = require("libsignal/src/crypto");
+class SenderMessageKey {
     constructor(iteration, seed) {
-        const derivative = deriveSecrets(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'));
+        const derivative = (0, crypto_1.deriveSecrets)(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'));
         const keys = new Uint8Array(32);
         keys.set(new Uint8Array(derivative[0].slice(16)));
         keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16);
@@ -24,4 +26,4 @@ export class SenderMessageKey {
         return this.seed;
     }
 }
-//# sourceMappingURL=sender-message-key.js.map
+exports.SenderMessageKey = SenderMessageKey;

package/lib/Signal/libsignal.d.ts

@@ -1,4 +1,3 @@
-import type { SignalAuthState } from '../Types/index.js';
-import type { SignalRepository } from '../Types/Signal.js';
+import { SignalAuthState } from '../Types';
+import { SignalRepository } from '../Types/Signal';
 export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository;
-//# sourceMappingURL=libsignal.d.ts.map

package/lib/Signal/libsignal.js

@@ -1,29 +1,64 @@
-/* @ts-ignore */
-import * as libsignal from 'libsignal';
-import { generateSignalPubKey } from '../Utils/index.js';
-import { jidDecode } from '../WABinary/index.js';
-import { SenderKeyName } from './Group/sender-key-name.js';
-import { SenderKeyRecord } from './Group/sender-key-record.js';
-import { GroupCipher, GroupSessionBuilder, SenderKeyDistributionMessage } from './Group/index.js';
-export function makeLibSignalRepository(auth) {
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLibSignalRepository = makeLibSignalRepository;
+const libsignal = __importStar(require("libsignal"));
+const Utils_1 = require("../Utils");
+const WABinary_1 = require("../WABinary");
+const sender_key_name_1 = require("./Group/sender-key-name");
+const sender_key_record_1 = require("./Group/sender-key-record");
+const Group_1 = require("./Group");
+function makeLibSignalRepository(auth) {
     const storage = signalStorage(auth);
     return {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
-            const cipher = new GroupCipher(storage, senderName);
+            const cipher = new Group_1.GroupCipher(storage, senderName);
             return cipher.decrypt(msg);
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
-            const builder = new GroupSessionBuilder(storage);
+            const builder = new Group_1.GroupSessionBuilder(storage);
             if (!item.groupId) {
                 throw new Error('Group ID is required for sender key distribution message');
             }
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
-            const senderMsg = new SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+            const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
             const senderNameStr = senderName.toString();
             const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
             if (!senderKey) {
-                await storage.storeSenderKey(senderName, new SenderKeyRecord());
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
             }
             await builder.process(senderName, senderMsg);
         },
@@ -52,14 +87,14 @@ export function makeLibSignalRepository(auth) {
         },
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId);
-            const builder = new GroupSessionBuilder(storage);
+            const builder = new Group_1.GroupSessionBuilder(storage);
             const senderNameStr = senderName.toString();
             const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
             if (!senderKey) {
-                await storage.storeSenderKey(senderName, new SenderKeyRecord());
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
             }
             const senderKeyDistributionMessage = await builder.create(senderName);
-            const session = new GroupCipher(storage, senderName);
+            const session = new Group_1.GroupCipher(storage, senderName);
             const ciphertext = await session.encrypt(data);
             return {
                 ciphertext,
@@ -76,11 +111,11 @@ export function makeLibSignalRepository(auth) {
     };
 }
 const jidToSignalProtocolAddress = (jid) => {
-    const { user, device } = jidDecode(jid);
+    const { user, device } = (0, WABinary_1.jidDecode)(jid);
     return new libsignal.ProtocolAddress(user, device || 0);
 };
 const jidToSignalSenderKeyName = (group, user) => {
-    return new SenderKeyName(group, jidToSignalProtocolAddress(user));
+    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
 };
 function signalStorage({ creds, keys }) {
     return {
@@ -90,7 +125,6 @@ function signalStorage({ creds, keys }) {
                 return libsignal.SessionRecord.deserialize(sess);
             }
         },
-        // TODO: Replace with libsignal.SessionRecord when type exports are added to libsignal
         storeSession: async (id, session) => {
             await keys.set({ session: { [id]: session.serialize() } });
         },
@@ -119,9 +153,9 @@ function signalStorage({ creds, keys }) {
             const keyId = senderKeyName.toString();
             const { [keyId]: key } = await keys.get('sender-key', [keyId]);
             if (key) {
-                return SenderKeyRecord.deserialize(key);
+                return sender_key_record_1.SenderKeyRecord.deserialize(key);
             }
-            return new SenderKeyRecord();
+            return new sender_key_record_1.SenderKeyRecord();
         },
         storeSenderKey: async (senderKeyName, key) => {
             const keyId = senderKeyName.toString();
@@ -133,9 +167,8 @@ function signalStorage({ creds, keys }) {
             const { signedIdentityKey } = creds;
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: generateSignalPubKey(signedIdentityKey.public)
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public)
             };
         }
     };
 }
-//# sourceMappingURL=libsignal.js.map

package/lib/Socket/Client/index.d.ts

@@ -1,3 +1,2 @@
-export * from './types.js';
-export * from './websocket.js';
-//# sourceMappingURL=index.d.ts.map
+export * from './types';
+export * from './websocket';

package/lib/Socket/Client/index.js

@@ -1,3 +1,18 @@
-export * from './types.js';
-export * from './websocket.js';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./websocket"), exports);

package/lib/Socket/Client/types.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events';
 import { URL } from 'url';
-import type { SocketConfig } from '../../Types/index.js';
+import { SocketConfig } from '../../Types';
 export declare abstract class AbstractSocketClient extends EventEmitter {
     url: URL;
     config: SocketConfig;
@@ -13,4 +13,3 @@ export declare abstract class AbstractSocketClient extends EventEmitter {
     abstract close(): Promise<void>;
     abstract send(str: Uint8Array | string, cb?: (err?: Error) => void): boolean;
 }
-//# sourceMappingURL=types.d.ts.map

package/lib/Socket/Client/types.js

@@ -1,6 +1,8 @@
-import { EventEmitter } from 'events';
-import { URL } from 'url';
-export class AbstractSocketClient extends EventEmitter {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSocketClient = void 0;
+const events_1 = require("events");
+class AbstractSocketClient extends events_1.EventEmitter {
     constructor(url, config) {
         super();
         this.url = url;
@@ -8,4 +10,4 @@ export class AbstractSocketClient extends EventEmitter {
         this.setMaxListeners(0);
     }
 }
-//# sourceMappingURL=types.js.map
+exports.AbstractSocketClient = AbstractSocketClient;

package/lib/Socket/Client/websocket.d.ts

@@ -1,5 +1,5 @@
 import WebSocket from '@d0v3riz/ws';
-import { AbstractSocketClient } from './types.js';
+import { AbstractSocketClient } from './types';
 export declare class WebSocketClient extends AbstractSocketClient {
     protected socket: WebSocket | null;
     get isOpen(): boolean;
@@ -10,4 +10,3 @@ export declare class WebSocketClient extends AbstractSocketClient {
     close(): Promise<void>;
     send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean;
 }
-//# sourceMappingURL=websocket.d.ts.map

package/lib/Socket/Client/websocket.js

@@ -1,30 +1,41 @@
-import WebSocket from '@d0v3riz/ws';
-import { DEFAULT_ORIGIN } from '../../Defaults/index.js';
-import { AbstractSocketClient } from './types.js';
-export class WebSocketClient extends AbstractSocketClient {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const ws_1 = __importDefault(require("@d0v3riz/ws"));
+const Defaults_1 = require("../../Defaults");
+const types_1 = require("./types");
+class WebSocketClient extends types_1.AbstractSocketClient {
     constructor() {
         super(...arguments);
         this.socket = null;
     }
     get isOpen() {
-        return this.socket?.readyState === WebSocket.OPEN;
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN;
     }
     get isClosed() {
-        return this.socket === null || this.socket?.readyState === WebSocket.CLOSED;
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSED;
     }
     get isClosing() {
-        return this.socket === null || this.socket?.readyState === WebSocket.CLOSING;
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSING;
     }
     get isConnecting() {
-        return this.socket?.readyState === WebSocket.CONNECTING;
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CONNECTING;
     }
     async connect() {
+        var _a, _b;
         if (this.socket) {
             return;
         }
-        this.socket = new WebSocket(this.url, {
-            origin: DEFAULT_ORIGIN,
-            headers: this.config.options?.headers,
+        this.socket = new ws_1.default(this.url, {
+            origin: Defaults_1.DEFAULT_ORIGIN,
+            headers: (_a = this.config.options) === null || _a === void 0 ? void 0 : _a.headers,
             handshakeTimeout: this.config.connectTimeoutMs,
             timeout: this.config.connectTimeoutMs,
             agent: this.config.agent
@@ -32,7 +43,7 @@ export class WebSocketClient extends AbstractSocketClient {
         this.socket.setMaxListeners(0);
         const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
         for (const event of events) {
-            this.socket?.on(event, (...args) => this.emit(event, ...args));
+            (_b = this.socket) === null || _b === void 0 ? void 0 : _b.on(event, (...args) => this.emit(event, ...args));
         }
     }
     async close() {
@@ -43,8 +54,9 @@ export class WebSocketClient extends AbstractSocketClient {
         this.socket = null;
     }
     send(str, cb) {
-        this.socket?.send(str, cb);
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.send(str, cb);
         return Boolean(this.socket);
     }
 }
-//# sourceMappingURL=websocket.js.map
+exports.WebSocketClient = WebSocketClient;