advanced-tls-client 3.0.1 → 3.0.2

package/dist/index.d.ts

@@ -139,7 +139,7 @@ declare class AdvancedTLSClient {
     private cleanupInterval;
     private defaults;
     constructor(profileName?: string);
-    setup(uri: string, options: RequestOptions): any;
+    private setup;
     request(uri: string, data?: any, options?: RequestOptions, callback?: Function): Promise<FullResponse | PassThrough>;
     private generateJA3;
     private buildMultipart;
@@ -147,4 +147,4 @@ declare class AdvancedTLSClient {
     private flatten;
     destroy(): void;
 }
-export { AdvancedTLSClient, ProfileRegistry, FullResponse };
+export { AdvancedTLSClient, ProfileRegistry };

package/dist/index.js

@@ -36,7 +36,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProfileRegistry = exports.AdvancedTLSClient = void 0;
 const tls = __importStar(require("tls"));
 const net = __importStar(require("net"));
-const https = __importStar(require("https"));
 const http2 = __importStar(require("http2"));
 const crypto = __importStar(require("crypto"));
 const events_1 = require("events");
@@ -46,9 +45,9 @@ const stream_1 = require("stream");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const url = __importStar(require("url"));
-const gunzip = (0, util_1.promisify)(zlib.gunzip);
-const brotliDecompress = (0, util_1.promisify)(zlib.brotliDecompress);
-const inflate = (0, util_1.promisify)(zlib.inflate);
+const brotliDecompressAsync = (0, util_1.promisify)(zlib.brotliDecompress);
+const gunzipAsync = (0, util_1.promisify)(zlib.gunzip);
+const inflateAsync = (0, util_1.promisify)(zlib.inflate);
 const GREASE_VALUES = [0x0a0a, 0x1a1a, 0x2a2a, 0x3a3a, 0x4a4a, 0x5a5a, 0x6a6a, 0x7a7a, 0x8a8a, 0x9a9a, 0xaaaa, 0xbaba, 0xcaca, 0xdada, 0xeaea, 0xfafa];
 class ProfileRegistry {
     static getGrease() {
@@ -675,16 +674,15 @@ class CookieJar {
         }
     }
 }
-var Protocol;
-(function (Protocol) {
-    Protocol["HTTP1"] = "http1";
-    Protocol["HTTP2"] = "http2";
-})(Protocol || (Protocol = {}));
+const Protocol = {
+    HTTP1: 'http1',
+    HTTP2: 'http2'
+};
 class UnifiedClientManager extends events_1.EventEmitter {
     constructor(tlsSocket, profile, hostname, cookieJar) {
         super();
         this.http2Client = null;
-        this.negotiatedProtocol = Protocol.HTTP1;
+        this.negotiatedProtocol = 'http1';
         this.tlsSocket = tlsSocket;
         this.profile = profile;
         this.hostname = hostname;
@@ -693,17 +691,17 @@ class UnifiedClientManager extends events_1.EventEmitter {
     async initialize() {
         const alpn = this.tlsSocket.alpnProtocol;
         if (alpn === 'h2') {
-            this.negotiatedProtocol = Protocol.HTTP2;
+            this.negotiatedProtocol = 'http2';
             await this.createHttp2Session();
         }
         else {
-            this.negotiatedProtocol = Protocol.HTTP1;
+            this.negotiatedProtocol = 'http1';
         }
     }
     async createHttp2Session() {
         return new Promise((resolve, reject) => {
             const settings = {};
-            this.profile.http2.settingsOrder.forEach(id => {
+            this.profile.http2.settingsOrder.forEach((id) => {
                 switch (id) {
                     case 1:
                         settings.headerTableSize = this.profile.http2.headerTableSize;
@@ -711,17 +709,9 @@ class UnifiedClientManager extends events_1.EventEmitter {
                     case 2:
                         settings.enablePush = this.profile.http2.enablePush === 1;
                         break;
-                    case 3:
-                        if (this.profile.http2.maxConcurrentStreams)
-                            settings.maxConcurrentStreams = this.profile.http2.maxConcurrentStreams;
-                        break;
                     case 4:
                         settings.initialWindowSize = this.profile.http2.initialWindowSize;
                         break;
-                    case 5:
-                        if (this.profile.http2.maxFrameSize)
-                            settings.maxFrameSize = this.profile.http2.maxFrameSize;
-                        break;
                     case 6:
                         if (this.profile.http2.maxHeaderListSize)
                             settings.maxHeaderListSize = this.profile.http2.maxHeaderListSize;
@@ -732,7 +722,7 @@ class UnifiedClientManager extends events_1.EventEmitter {
                 createConnection: () => this.tlsSocket,
                 settings
             });
-            this.http2Client.once('connect', () => resolve());
+            this.http2Client.once('connect', resolve);
             this.http2Client.once('error', reject);
             this.http2Client.once('timeout', () => reject(new Error('HTTP/2 session timeout')));
         });
@@ -749,7 +739,7 @@ class UnifiedClientManager extends events_1.EventEmitter {
         delete cleanHeaders['Upgrade'];
         delete cleanHeaders['transfer-encoding'];
         delete cleanHeaders['Transfer-Encoding'];
-        if (this.negotiatedProtocol === Protocol.HTTP2 && this.http2Client && !this.http2Client.destroyed) {
+        if (this.negotiatedProtocol === 'http2' && this.http2Client && !this.http2Client.destroyed) {
             await this.requestHttp2(path, options, timingStart, cleanHeaders, post_data, out, callback);
         }
         else {
@@ -757,8 +747,6 @@ class UnifiedClientManager extends events_1.EventEmitter {
         }
     }
     async requestHttp2(path, options, timingStart, headers, post_data, out, callback) {
-        if (!this.http2Client || this.http2Client.destroyed)
-            throw new Error('HTTP/2 session not available');
         const reqHeaders = {
             ':method': options.method?.toUpperCase() || 'GET',
             ':authority': this.hostname,
@@ -774,87 +762,113 @@ class UnifiedClientManager extends events_1.EventEmitter {
             ja3Hash: crypto.createHash('md5').update(this.generateJA3()).digest('hex'),
             akamai: `1:${this.profile.http2.headerTableSize};2:${this.profile.http2.enablePush};4:${this.profile.http2.initialWindowSize};6:${this.profile.http2.maxHeaderListSize ?? ''}|00|0|m,a,s,p`
         };
-        stream.once('response', (hdrs) => {
-            response.statusCode = hdrs[':status'];
-            response.headers = hdrs;
-            if (hdrs['set-cookie'])
-                this.cookieJar.parseSetCookie(this.hostname, hdrs['set-cookie']);
-            response.timing.response = Date.now() - timingStart;
-            out.emit('header', response.statusCode, hdrs);
-            out.emit('headers', hdrs);
-        });
         const chunks = [];
         const rawChunks = [];
-        stream.on('data', (chunk) => {
-            // Convert string to Buffer if needed
-            const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-            rawChunks.push(bufferChunk);
-            chunks.push(bufferChunk);
-            out.write(bufferChunk);
-        });
-        stream.once('end', async () => {
+        let finished = false;
+        const finish = async (error) => {
+            if (finished)
+                return;
+            finished = true;
+            stream.removeAllListeners();
+            if (error) {
+                out.emit('error', error);
+                if (callback)
+                    setImmediate(() => callback(error));
+                return;
+            }
             let body = Buffer.concat(chunks);
             response.bytes = body.length;
             response.raw = Buffer.concat(rawChunks);
             if (options.decompress !== false && response.headers) {
-                const encodingHeader = response.headers['content-encoding'];
-                const encoding = Array.isArray(encodingHeader) ? encodingHeader[0]?.toLowerCase() : typeof encodingHeader === 'string' ? encodingHeader.toLowerCase() : undefined;
+                const encoding = response.headers['content-encoding']?.toLowerCase();
                 if (encoding) {
                     try {
                         if (encoding.includes('gzip'))
-                            body = await gunzip(body);
+                            body = await gunzipAsync(body);
                         else if (encoding.includes('br'))
-                            body = await brotliDecompress(body);
+                            body = await brotliDecompressAsync(body);
                         else if (encoding.includes('deflate'))
-                            body = await inflate(body);
-                    }
-                    catch (e) {
-                        console.error('Decompression error:', e);
+                            body = await inflateAsync(body);
                     }
+                    catch { }
                 }
             }
             response.body = body;
             try {
                 response.text = body.toString('utf-8');
-                const contentTypeHeader = response.headers['content-type'];
-                const ct = Array.isArray(contentTypeHeader) ? contentTypeHeader[0] : typeof contentTypeHeader === 'string' ? contentTypeHeader : undefined;
-                if (ct && ct.includes('application/json')) {
+                if (response.headers['content-type']?.includes('application/json')) {
                     response.json = JSON.parse(response.text);
                 }
             }
             catch { }
             response.timing.end = Date.now() - timingStart;
             response.timing.total = response.timing.end;
-            out.end();
+            if (!out.writableEnded && !out.destroyed)
+                out.end();
             if (callback)
-                callback(null, response, response.body);
+                setImmediate(() => callback(null, response, response.body));
+        };
+        stream.once('response', (hdrs) => {
+            response.statusCode = hdrs[':status'];
+            response.headers = hdrs;
+            if (hdrs['set-cookie'])
+                this.cookieJar.parseSetCookie(this.hostname, hdrs['set-cookie']);
+            response.timing.response = Date.now() - timingStart;
+            out.emit('header', response.statusCode, hdrs);
+            out.emit('headers', hdrs);
         });
-        stream.once('error', (err) => {
-            out.emit('err', err);
-            if (callback)
-                callback(err);
+        stream.on('data', (chunk) => {
+            if (finished || out.destroyed || out.writableEnded)
+                return;
+            const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            rawChunks.push(bufferChunk);
+            chunks.push(bufferChunk);
+            if (!out.write(bufferChunk))
+                stream.pause();
         });
+        out.on('drain', () => stream.resume());
+        stream.once('end', finish);
+        stream.once('error', finish);
         if (post_data) {
-            if (Buffer.isBuffer(post_data) || typeof post_data === 'string')
-                stream.end(post_data);
-            else if (post_data instanceof stream_1.Readable)
-                post_data.pipe(stream);
+            if (Buffer.isBuffer(post_data) || typeof post_data === 'string') {
+                if (!stream.closed && !stream.destroyed && stream.writable) {
+                    try {
+                        stream.write(post_data);
+                    }
+                    catch { }
+                }
+                setImmediate(() => {
+                    if (!stream.closed && !stream.destroyed && stream.writable) {
+                        stream.end();
+                    }
+                });
+            }
+            else if (post_data instanceof stream_1.Readable) {
+                post_data.pipe(stream, { end: true });
+                post_data.on('error', err => stream.destroy(err));
+            }
+            else {
+                setImmediate(() => {
+                    if (stream.writable)
+                        stream.end();
+                });
+            }
         }
         else {
-            stream.end();
+            setImmediate(() => {
+                if (stream.writable)
+                    stream.end();
+            });
         }
     }
     async requestHttp1(path, options, timingStart, headers, post_data, out, callback) {
         const reqOptions = {
             method: options.method?.toUpperCase() || 'GET',
             path,
-            headers: {
-                host: this.hostname,
-                ...headers
-            },
+            headers: { host: this.hostname, ...headers },
             createConnection: () => this.tlsSocket
         };
-        const req = https.request(reqOptions);
+        const req = require('https').request(reqOptions);
         const response = new events_1.EventEmitter();
         response.timing = { socket: timingStart, lookup: 0, connect: 0, secureConnect: 0, response: 0, end: 0, total: 0 };
         response.fingerprints = {
@@ -862,6 +876,54 @@ class UnifiedClientManager extends events_1.EventEmitter {
             ja3Hash: crypto.createHash('md5').update(this.generateJA3()).digest('hex'),
             akamai: ''
         };
+        const chunks = [];
+        const rawChunks = [];
+        let finished = false;
+        const finish = async (error, res) => {
+            if (finished)
+                return;
+            finished = true;
+            req.removeAllListeners();
+            if (res)
+                res.removeAllListeners();
+            if (error) {
+                out.emit('error', error);
+                if (callback)
+                    setImmediate(() => callback(error));
+                return;
+            }
+            let body = Buffer.concat(chunks);
+            response.bytes = body.length;
+            response.raw = Buffer.concat(rawChunks);
+            if (options.decompress !== false && res?.headers) {
+                const encoding = (res.headers['content-encoding'] || '').toLowerCase();
+                if (encoding) {
+                    try {
+                        if (encoding.includes('gzip'))
+                            body = await gunzipAsync(body);
+                        else if (encoding.includes('br'))
+                            body = await brotliDecompressAsync(body);
+                        else if (encoding.includes('deflate'))
+                            body = await inflateAsync(body);
+                    }
+                    catch { }
+                }
+            }
+            response.body = body;
+            try {
+                response.text = body.toString('utf-8');
+                if (res.headers['content-type']?.includes('application/json')) {
+                    response.json = JSON.parse(response.text);
+                }
+            }
+            catch { }
+            response.timing.end = Date.now() - timingStart;
+            response.timing.total = response.timing.end;
+            if (!out.writableEnded && !out.destroyed)
+                out.end();
+            if (callback)
+                setImmediate(() => callback(null, response, response.body));
+        };
         req.once('response', (res) => {
             response.statusCode = res.statusCode;
             response.headers = res.headers;
@@ -870,68 +932,29 @@ class UnifiedClientManager extends events_1.EventEmitter {
             response.timing.response = Date.now() - timingStart;
             out.emit('header', response.statusCode, res.headers);
             out.emit('headers', res.headers);
-            const chunks = [];
-            const rawChunks = [];
             res.on('data', (chunk) => {
-                // Convert string to Buffer if needed
+                if (finished || out.destroyed || out.writableEnded)
+                    return;
                 const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                 rawChunks.push(bufferChunk);
                 chunks.push(bufferChunk);
                 out.write(bufferChunk);
             });
-            res.once('end', async () => {
-                let body = Buffer.concat(chunks);
-                response.bytes = body.length;
-                response.raw = Buffer.concat(rawChunks);
-                if (options.decompress !== false) {
-                    const encodingHeader = res.headers['content-encoding'];
-                    const encoding = Array.isArray(encodingHeader) ? encodingHeader[0]?.toLowerCase() : typeof encodingHeader === 'string' ? encodingHeader.toLowerCase() : undefined;
-                    if (encoding) {
-                        try {
-                            if (encoding.includes('gzip'))
-                                body = await gunzip(body);
-                            else if (encoding.includes('br'))
-                                body = await brotliDecompress(body);
-                            else if (encoding.includes('deflate'))
-                                body = await inflate(body);
-                        }
-                        catch (e) {
-                            console.error('Decompression error:', e);
-                        }
-                    }
-                }
-                response.body = body;
-                try {
-                    response.text = body.toString('utf-8');
-                    const contentTypeHeader = res.headers['content-type'];
-                    const ct = Array.isArray(contentTypeHeader) ? contentTypeHeader[0] : typeof contentTypeHeader === 'string' ? contentTypeHeader : undefined;
-                    if (ct && ct.includes('application/json')) {
-                        response.json = JSON.parse(response.text);
-                    }
-                }
-                catch { }
-                response.timing.end = Date.now() - timingStart;
-                response.timing.total = response.timing.end;
-                out.end();
-                if (callback)
-                    callback(null, response, response.body);
-            });
-            res.once('error', (err) => {
-                out.emit('err', err);
-                if (callback)
-                    callback(err);
-            });
-        });
-        req.once('error', (err) => {
-            out.emit('err', err);
-            if (callback)
-                callback(err);
+            res.once('end', () => finish(null, res));
+            res.once('error', finish);
         });
+        req.once('error', finish);
         if (post_data) {
-            if (Buffer.isBuffer(post_data) || typeof post_data === 'string')
-                req.end(post_data);
-            else if (post_data instanceof stream_1.Readable)
+            if (Buffer.isBuffer(post_data) || typeof post_data === 'string') {
+                req.write(post_data);
+                req.end();
+            }
+            else if (post_data instanceof stream_1.Readable) {
                 post_data.pipe(req);
+            }
+            else {
+                req.end();
+            }
         }
         else {
             req.end();
@@ -939,9 +962,9 @@ class UnifiedClientManager extends events_1.EventEmitter {
     }
     generateJA3() {
         const version = '771';
-        const ciphers = this.profile.tls.cipherSuites.filter(c => c < 0xff00).join('-');
-        const extensions = this.profile.tls.extensions.filter(e => typeof e === 'number' && e < 0xff00).join('-');
-        const curves = this.profile.tls.supportedGroups.filter(g => g < 0xff00).join('-');
+        const ciphers = this.profile.tls.cipherSuites.filter((c) => c < 0xff00).join('-');
+        const extensions = this.profile.tls.extensions.filter((e) => typeof e === 'number' && e < 0xff00).join('-');
+        const curves = this.profile.tls.supportedGroups.filter((g) => g < 0xff00).join('-');
         const ecPoints = this.profile.tls.ecPointFormats.join('-');
         return `${version},${ciphers},${extensions},${curves},${ecPoints}`;
     }
@@ -950,9 +973,6 @@ class UnifiedClientManager extends events_1.EventEmitter {
             this.http2Client.destroy();
         this.http2Client = null;
     }
-    getProtocol() {
-        return this.negotiatedProtocol;
-    }
 }
 class TLSSocketManager extends events_1.EventEmitter {
     constructor(profile, proxy) {
@@ -983,6 +1003,7 @@ class TLSSocketManager extends events_1.EventEmitter {
             if (this.proxy) {
                 const proxyUrl = new url.URL(this.proxy);
                 this.socket = net.connect(+proxyUrl.port || 80, proxyUrl.hostname, () => {
+                    this.timing.connect = Date.now() - this.startTime;
                     let request = `CONNECT ${hostname}:${port} HTTP/1.1\r\nHost: ${hostname}:${port}\r\n`;
                     if (proxyUrl.username && proxyUrl.password) {
                         const auth = Buffer.from(`${decodeURIComponent(proxyUrl.username)}:${decodeURIComponent(proxyUrl.password)}`).toString('base64');
@@ -992,14 +1013,19 @@ class TLSSocketManager extends events_1.EventEmitter {
                     this.socket.write(request);
                 });
                 let response = '';
-                this.socket.on('data', (chunk) => {
+                const onData = (chunk) => {
                     response += chunk.toString();
                     if (response.includes('\r\n\r\n')) {
-                        if (!response.startsWith('HTTP/1.1 200'))
+                        this.socket.removeListener('data', onData);
+                        if (!response.startsWith('HTTP/1.1 200')) {
+                            clearTimeout(timeout);
+                            this.destroy();
                             return reject(new Error('Proxy failed: ' + response.split('\r\n')[0]));
+                        }
                         this.proceedWithTLS(resolve, reject, timeout);
                     }
-                });
+                };
+                this.socket.on('data', onData);
             }
             else {
                 this.socket = new net.Socket();
@@ -1176,7 +1202,7 @@ class AdvancedTLSClient {
             if (options.multipart) {
                 const boundary = options.boundary || this.defaults.boundary;
                 post_data = await this.buildMultipart(data, boundary);
-                config.headers['content-type'] = 'multipart/form-data; boundary=' + boundary;
+                config.headers['content-type'] = `multipart/form-data; boundary=${boundary}`;
             }
             else if (data instanceof stream_1.Readable) {
                 post_data = data;
@@ -1202,78 +1228,63 @@ class AdvancedTLSClient {
         const cookies = this.cookieJar.getCookies(hostname, parsed.pathname, parsed.protocol === 'https:');
         if (cookies)
             config.headers['cookie'] = cookies;
-        // MODE LEGACY: Jika ada callback, kembalikan stream
+        if (options.stream === true) {
+            session.clientManager.request(path, options, startTime, config.headers, post_data, out);
+            return out;
+        }
         if (callback) {
-            await session.clientManager.request(path, options, startTime, config.headers, post_data, out, callback);
+            const typedCallback = callback;
+            session.clientManager.request(path, options, startTime, config.headers, post_data, out, typedCallback).catch(err => {
+                if (typedCallback)
+                    typedCallback(err);
+            });
             return out;
         }
-        // MODE BARU: Kembalikan object response lengkap
         return new Promise((resolve, reject) => {
             let statusCode = 0;
             let headers = {};
             const chunks = [];
-            out.on('header', (status, hdrs) => {
-                statusCode = status;
-                headers = hdrs;
-            });
-            out.on('headers', (hdrs) => {
-                headers = hdrs;
-            });
-            out.on('data', (chunk) => {
-                chunks.push(chunk);
-            });
-            out.once('end', async () => {
+            let done = false;
+            const complete = async (err) => {
+                if (done)
+                    return;
+                done = true;
+                if (err)
+                    return reject(err);
                 let body = Buffer.concat(chunks);
-                // Auto-decompress jika diminta
                 if (options.decompress !== false && headers) {
-                    const encodingHeader = headers['content-encoding'];
-                    const encoding = Array.isArray(encodingHeader)
-                        ? encodingHeader[0]?.toLowerCase()
-                        : typeof encodingHeader === 'string'
-                            ? encodingHeader.toLowerCase()
-                            : undefined;
+                    const encoding = headers['content-encoding']?.toLowerCase();
                     if (encoding) {
                         try {
                             if (encoding.includes('gzip'))
-                                body = await gunzip(body);
+                                body = await gunzipAsync(body);
                             else if (encoding.includes('br'))
-                                body = await brotliDecompress(body);
+                                body = await brotliDecompressAsync(body);
                             else if (encoding.includes('deflate'))
-                                body = await inflate(body);
-                        }
-                        catch (e) {
-                            console.error('Decompression failed:', e);
+                                body = await inflateAsync(body);
                         }
+                        catch { }
                     }
                 }
                 const text = body.toString('utf-8');
-                let parsedJson = undefined;
-                const contentType = headers['content-type'];
-                const ct = Array.isArray(contentType)
-                    ? contentType[0]
-                    : typeof contentType === 'string'
-                        ? contentType
-                        : undefined;
-                if (ct && ct.includes('application/json')) {
+                let parsedJson;
+                const ct = headers['content-type']?.toLowerCase();
+                if (ct?.includes('application/json')) {
                     try {
                         parsedJson = JSON.parse(text);
                     }
                     catch { }
                 }
-                // Generate fingerprints
-                const ja3 = this.generateJA3();
-                const ja3Hash = crypto.createHash('md5').update(ja3).digest('hex');
-                const akamai = `1:${this.profile.http2.headerTableSize};2:${this.profile.http2.enablePush};4:${this.profile.http2.initialWindowSize};6:${this.profile.http2.maxHeaderListSize ?? ''}|00|0|m,a,s,p`;
-                const fullResponse = {
+                resolve({
                     statusCode,
                     headers,
                     body,
                     text,
                     json: parsedJson,
                     fingerprints: {
-                        ja3,
-                        ja3Hash,
-                        akamai
+                        ja3: this.generateJA3(),
+                        ja3Hash: crypto.createHash('md5').update(this.generateJA3()).digest('hex'),
+                        akamai: `1:${this.profile.http2.headerTableSize};2:${this.profile.http2.enablePush};4:${this.profile.http2.initialWindowSize};6:${this.profile.http2.maxHeaderListSize ?? ''}|00|0|m,a,s,p`
                     },
                     timing: {
                         socket: startTime,
@@ -1284,19 +1295,26 @@ class AdvancedTLSClient {
                         end: Date.now() - startTime,
                         total: Date.now() - startTime
                     }
-                };
-                resolve(fullResponse);
+                });
+            };
+            out.on('header', (status, hdrs) => {
+                statusCode = status;
+                headers = hdrs;
             });
-            out.once('error', (err) => reject(err));
-            // Jalankan request
-            session.clientManager.request(path, options, startTime, config.headers, post_data, out).catch(reject);
+            out.on('data', (chunk) => {
+                if (!done)
+                    chunks.push(chunk);
+            });
+            out.once('end', () => complete());
+            out.once('error', complete);
+            session.clientManager.request(path, options, startTime, config.headers, post_data, out).catch(complete);
         });
     }
     generateJA3() {
         const version = '771';
-        const ciphers = this.profile.tls.cipherSuites.filter(c => c < 0xff00).join('-');
-        const extensions = this.profile.tls.extensions.filter(e => typeof e === 'number' && e < 0xff00).join('-');
-        const curves = this.profile.tls.supportedGroups.filter(g => g < 0xff00).join('-');
+        const ciphers = this.profile.tls.cipherSuites.filter((c) => c < 0xff00).join('-');
+        const extensions = this.profile.tls.extensions.filter((e) => typeof e === 'number' && e < 0xff00).join('-');
+        const curves = this.profile.tls.supportedGroups.filter((g) => g < 0xff00).join('-');
         const ecPoints = this.profile.tls.ecPointFormats.join('-');
         return `${version},${ciphers},${extensions},${curves},${ecPoints}`;
     }
@@ -1318,30 +1336,18 @@ class AdvancedTLSClient {
                     done();
                     continue;
                 }
-                if (Buffer.isBuffer(value)) {
-                    const part = { buffer: value, content_type: 'application/octet-stream' };
-                    this.generateMultipart(key, part, boundary).then(section => {
-                        body += section;
-                        done();
-                    });
-                }
-                else {
-                    const part = (value.buffer || value.file || value.content_type) ? value : { value: value };
-                    this.generateMultipart(key, part, boundary).then(section => {
-                        body += section;
-                        done();
-                    });
-                }
+                const part = Buffer.isBuffer(value) ? { buffer: value, content_type: 'application/octet-stream' } : (value.buffer || value.file || value.content_type) ? value : { value };
+                this.generateMultipart(key, part, boundary).then(section => { body += section; done(); });
             }
         });
     }
     async generateMultipart(name, part, boundary) {
-        let return_part = '--' + boundary + '\r\n';
-        return_part += 'Content-Disposition: form-data; name="' + name + '"';
+        let return_part = `--${boundary}\r\n`;
+        return_part += `Content-Disposition: form-data; name="${name}"`;
         const append = (data, filename) => {
             if (data) {
-                return_part += '; filename="' + encodeURIComponent(filename) + '"\r\n';
-                return_part += 'Content-Type: ' + (part.content_type || 'application/octet-stream') + '\r\n\r\n';
+                return_part += `; filename="${encodeURIComponent(filename)}"\r\n`;
+                return_part += `Content-Type: ${part.content_type || 'application/octet-stream'}\r\n\r\n`;
                 return_part += data.toString('binary');
             }
             return return_part + '\r\n';
@@ -1354,19 +1360,20 @@ class AdvancedTLSClient {
             return append(data, filename);
         }
         else {
-            return_part += '\r\n\r\n';
-            return_part += String(part.value || '');
-            return return_part + '\r\n';
+            return_part += '\r\n\r\n' + String(part.value || '') + '\r\n';
+            return return_part;
         }
     }
     flatten(object, into = {}, prefix) {
         for (const key in object) {
-            const prefix_key = prefix ? prefix + '[' + key + ']' : key;
+            const prefix_key = prefix ? `${prefix}[${key}]` : key;
             const prop = object[key];
-            if (prop && typeof prop === 'object' && !(prop.buffer || prop.file || prop.content_type))
+            if (prop && typeof prop === 'object' && !(prop.buffer || prop.file || prop.content_type)) {
                 this.flatten(prop, into, prefix_key);
-            else
+            }
+            else {
                 into[prefix_key] = prop;
+            }
         }
         return into;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "advanced-tls-client",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {