@putuofc/fastp 0.0.1 → 3.0.1

package/dist/index.js

@@ -33,27 +33,589 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FastProxiedClient = void 0;
+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");
 const zlib = __importStar(require("zlib"));
 const util_1 = require("util");
 const stream_1 = require("stream");
-const url_1 = require("url");
-const events_1 = require("events");
+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 PROXIES = [
-    'https://snowy-hill-f293.apis8.workers.dev/',
-    'https://polished-resonance-0c97.apis9.workers.dev/',
-    'https://mute-wind-ee8d.apis10.workers.dev/',
-    'https://billowing-hall-ebe5.proxyserver2.workers.dev/',
-    'https://dark-shadow-1776.apis7.workers.dev/',
-    'https://aged-breeze-9d12.apis4.workers.dev/'
-];
-function getRandomProxy() {
-    return PROXIES[Math.floor(Math.random() * PROXIES.length)];
+const GREASE_VALUES = [0x0a0a, 0x1a1a, 0x2a2a, 0x3a3a, 0x4a4a, 0x5a5a, 0x6a6a, 0x7a7a, 0x8a8a, 0x9a9a, 0xaaaa, 0xbaba, 0xcaca, 0xdada, 0xeaea, 0xfafa];
+class ProfileRegistry {
+    static getGrease() {
+        return GREASE_VALUES[Math.floor(Math.random() * GREASE_VALUES.length)];
+    }
+    static chromeMobile143Android() {
+        const grease1 = this.getGrease();
+        const grease2 = this.getGrease();
+        const grease3 = this.getGrease();
+        const grease4 = this.getGrease();
+        return {
+            name: 'chrome_mobile_143_android',
+            version: '143.0.0.0',
+            tls: {
+                cipherSuites: [
+                    grease1,
+                    4865,
+                    4866,
+                    4867,
+                    49195,
+                    49199,
+                    49196,
+                    49200,
+                    52393,
+                    52392,
+                    49171,
+                    49172,
+                    156,
+                    157,
+                    47,
+                    53
+                ],
+                extensions: [
+                    grease2,
+                    65037,
+                    27,
+                    43,
+                    16,
+                    35,
+                    45,
+                    11,
+                    65281,
+                    5,
+                    10,
+                    23,
+                    0,
+                    17513,
+                    51,
+                    18,
+                    13,
+                    grease3
+                ],
+                supportedGroups: [
+                    grease4,
+                    25497,
+                    29,
+                    23,
+                    24
+                ],
+                signatureAlgorithms: [
+                    1027,
+                    2052,
+                    1025,
+                    1283,
+                    2053,
+                    1281,
+                    2054,
+                    1537
+                ],
+                supportedVersions: [
+                    grease2,
+                    772,
+                    771
+                ],
+                ecPointFormats: [0],
+                alpnProtocols: ['h2', 'http/1.1'],
+                pskKeyExchangeModes: [1],
+                compressionMethods: [0],
+                grease: true,
+                recordSizeLimit: 16385,
+                certificateCompression: [2],
+                ocspStapling: true,
+                signedCertificateTimestamp: true
+            },
+            http2: {
+                windowUpdate: 15663105,
+                headerTableSize: 65536,
+                enablePush: 0,
+                initialWindowSize: 6291456,
+                maxFrameSize: 16384,
+                maxHeaderListSize: 262144,
+                settingsOrder: [1, 2, 4, 6],
+                connectionPreface: Buffer.from('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'),
+                priorityFrames: [
+                    {
+                        streamId: 0,
+                        weight: 256,
+                        dependency: 0,
+                        exclusive: true
+                    }
+                ],
+                pseudoHeaderOrder: [':method', ':authority', ':scheme', ':path'],
+                headerOrder: [
+                    'sec-ch-ua',
+                    'sec-ch-ua-mobile',
+                    'sec-ch-ua-platform',
+                    'upgrade-insecure-requests',
+                    'user-agent',
+                    'accept',
+                    'sec-fetch-site',
+                    'sec-fetch-mode',
+                    'sec-fetch-dest',
+                    'accept-encoding',
+                    'accept-language',
+                    'priority'
+                ]
+            },
+            userAgent: 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36',
+            secChUa: '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+            secChUaPlatform: '"Android"',
+            secChUaMobile: '?1',
+            secFetchSite: 'none',
+            secFetchMode: 'navigate',
+            secFetchDest: 'document',
+            upgradeInsecureRequests: '1',
+            acceptLanguage: 'id,en-US;q=0.9,en;q=0.8,ms;q=0.7,ja;q=0.6,zh-CN;q=0.5,zh;q=0.4',
+            priority: 'u=0, i'
+        };
+    }
+    static chrome133PSK() {
+        const grease1 = this.getGrease();
+        const grease2 = this.getGrease();
+        const grease3 = this.getGrease();
+        const grease4 = this.getGrease();
+        return {
+            name: 'chrome_133_psk',
+            version: '133.0.0.0',
+            tls: {
+                cipherSuites: [
+                    grease1,
+                    4865,
+                    4866,
+                    4867,
+                    49195,
+                    49199,
+                    49196,
+                    49200,
+                    52393,
+                    52392,
+                    49171,
+                    49172,
+                    156,
+                    157,
+                    47,
+                    53
+                ],
+                extensions: [
+                    grease2,
+                    0,
+                    23,
+                    65281,
+                    10,
+                    11,
+                    35,
+                    16,
+                    5,
+                    13,
+                    18,
+                    51,
+                    45,
+                    43,
+                    27,
+                    21,
+                    grease3
+                ],
+                supportedGroups: [
+                    grease4,
+                    25497,
+                    29,
+                    23,
+                    24
+                ],
+                signatureAlgorithms: [
+                    1027,
+                    2052,
+                    1025,
+                    1283,
+                    2053,
+                    1281,
+                    2054,
+                    1537
+                ],
+                supportedVersions: [
+                    grease2,
+                    772,
+                    771
+                ],
+                ecPointFormats: [0],
+                alpnProtocols: ['h2', 'http/1.1'],
+                pskKeyExchangeModes: [1],
+                compressionMethods: [0],
+                grease: true,
+                recordSizeLimit: 16385
+            },
+            http2: {
+                windowUpdate: 15663105,
+                headerTableSize: 65536,
+                enablePush: 0,
+                initialWindowSize: 6291456,
+                maxFrameSize: 16384,
+                maxHeaderListSize: 262144,
+                settingsOrder: [1, 2, 4, 6],
+                connectionPreface: Buffer.from('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'),
+                priorityFrames: [
+                    {
+                        streamId: 0,
+                        weight: 256,
+                        dependency: 0,
+                        exclusive: true
+                    }
+                ],
+                pseudoHeaderOrder: [':method', ':authority', ':scheme', ':path'],
+                headerOrder: [
+                    'cache-control',
+                    'sec-ch-ua',
+                    'sec-ch-ua-mobile',
+                    'sec-ch-ua-platform',
+                    'upgrade-insecure-requests',
+                    'user-agent',
+                    'accept',
+                    'sec-fetch-site',
+                    'sec-fetch-mode',
+                    'sec-fetch-user',
+                    'sec-fetch-dest',
+                    'accept-encoding',
+                    'accept-language'
+                ]
+            },
+            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+            secChUa: '"Google Chrome";v="133", "Chromium";v="133", "Not_A Brand";v="24"',
+            secChUaPlatform: '"Windows"',
+            secChUaMobile: '?0',
+            secFetchSite: 'none',
+            secFetchMode: 'navigate',
+            secFetchDest: 'document'
+        };
+    }
+    static chrome133() {
+        const grease1 = this.getGrease();
+        const grease2 = this.getGrease();
+        const grease3 = this.getGrease();
+        const grease4 = this.getGrease();
+        return {
+            name: 'chrome_133',
+            version: '133.0.0.0',
+            tls: {
+                cipherSuites: [
+                    grease1,
+                    4865,
+                    4866,
+                    4867,
+                    49195,
+                    49199,
+                    49196,
+                    49200,
+                    52393,
+                    52392,
+                    49171,
+                    49172,
+                    156,
+                    157,
+                    47,
+                    53
+                ],
+                extensions: [
+                    grease2,
+                    0,
+                    23,
+                    65281,
+                    10,
+                    11,
+                    35,
+                    16,
+                    5,
+                    13,
+                    18,
+                    51,
+                    45,
+                    43,
+                    27,
+                    21,
+                    grease3
+                ],
+                supportedGroups: [
+                    grease4,
+                    25497,
+                    29,
+                    23,
+                    24
+                ],
+                signatureAlgorithms: [
+                    1027,
+                    2052,
+                    1025,
+                    1283,
+                    2053,
+                    1281,
+                    2054,
+                    1537
+                ],
+                supportedVersions: [
+                    grease2,
+                    772,
+                    771
+                ],
+                ecPointFormats: [0],
+                alpnProtocols: ['h2', 'http/1.1'],
+                pskKeyExchangeModes: [1],
+                compressionMethods: [0],
+                grease: true,
+                recordSizeLimit: 16385
+            },
+            http2: {
+                windowUpdate: 15663105,
+                headerTableSize: 65536,
+                enablePush: 0,
+                initialWindowSize: 6291456,
+                maxFrameSize: 16384,
+                maxHeaderListSize: 262144,
+                settingsOrder: [1, 2, 4, 6],
+                connectionPreface: Buffer.from('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'),
+                priorityFrames: [
+                    {
+                        streamId: 0,
+                        weight: 256,
+                        dependency: 0,
+                        exclusive: true
+                    }
+                ],
+                pseudoHeaderOrder: [':method', ':authority', ':scheme', ':path'],
+                headerOrder: [
+                    'cache-control',
+                    'sec-ch-ua',
+                    'sec-ch-ua-mobile',
+                    'sec-ch-ua-platform',
+                    'upgrade-insecure-requests',
+                    'user-agent',
+                    'accept',
+                    'sec-fetch-site',
+                    'sec-fetch-mode',
+                    'sec-fetch-user',
+                    'sec-fetch-dest',
+                    'accept-encoding',
+                    'accept-language'
+                ]
+            },
+            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+            secChUa: '"Google Chrome";v="133", "Chromium";v="133", "Not_A Brand";v="24"',
+            secChUaPlatform: '"Windows"',
+            secChUaMobile: '?0',
+            secFetchSite: 'none',
+            secFetchMode: 'navigate',
+            secFetchDest: 'document'
+        };
+    }
+    static firefox117() {
+        return {
+            name: 'firefox_117',
+            version: '117.0',
+            tls: {
+                cipherSuites: [
+                    4865,
+                    4867,
+                    4866,
+                    49195,
+                    49199,
+                    52393,
+                    52392,
+                    49196,
+                    49200,
+                    159,
+                    158,
+                    49161,
+                    49162,
+                    156,
+                    157,
+                    47,
+                    53
+                ],
+                extensions: [0, 23, 65281, 10, 11, 35, 16, 5, 34, 51, 43, 13, 45, 28, 21],
+                supportedGroups: [
+                    29,
+                    23,
+                    24,
+                    25,
+                    256,
+                    257
+                ],
+                signatureAlgorithms: [
+                    1027,
+                    1283,
+                    1539,
+                    2052,
+                    2053,
+                    2054,
+                    1025,
+                    1281,
+                    1537,
+                    513,
+                    515
+                ],
+                supportedVersions: [
+                    772,
+                    771
+                ],
+                ecPointFormats: [0],
+                alpnProtocols: ['h2', 'http/1.1'],
+                pskKeyExchangeModes: [1],
+                compressionMethods: [0],
+                grease: false
+            },
+            http2: {
+                windowUpdate: 12517377,
+                headerTableSize: 65536,
+                enablePush: 0,
+                initialWindowSize: 131072,
+                maxFrameSize: 16384,
+                settingsOrder: [1, 4, 5],
+                connectionPreface: Buffer.from('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'),
+                priorityFrames: [
+                    { streamId: 3, weight: 200, dependency: 0, exclusive: false },
+                    { streamId: 5, weight: 100, dependency: 0, exclusive: false },
+                    { streamId: 7, weight: 0, dependency: 0, exclusive: false },
+                    { streamId: 9, weight: 0, dependency: 7, exclusive: false },
+                    { streamId: 11, weight: 0, dependency: 3, exclusive: false },
+                    { streamId: 13, weight: 240, dependency: 0, exclusive: false }
+                ],
+                pseudoHeaderOrder: [':method', ':path', ':authority', ':scheme'],
+                headerPriority: { streamDep: 13, exclusive: false, weight: 41 },
+                headerOrder: []
+            },
+            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:117.0) Gecko/20100101 Firefox/117.0',
+            secChUa: '',
+            secChUaPlatform: '',
+            secChUaMobile: '',
+            secFetchSite: 'none',
+            secFetchMode: 'navigate',
+            secFetchDest: 'document'
+        };
+    }
+    static safariIOS18() {
+        const grease1 = this.getGrease();
+        const grease2 = this.getGrease();
+        return {
+            name: 'safari_ios_18_0',
+            version: '18.0',
+            tls: {
+                cipherSuites: [
+                    grease1,
+                    4865,
+                    4866,
+                    4867,
+                    49196,
+                    49195,
+                    52393,
+                    49200,
+                    49199,
+                    52392,
+                    159,
+                    158,
+                    49162,
+                    49161,
+                    157,
+                    156,
+                    53,
+                    47,
+                    49188,
+                    49187,
+                    60
+                ],
+                extensions: [
+                    grease2,
+                    0,
+                    23,
+                    65281,
+                    10,
+                    11,
+                    16,
+                    5,
+                    13,
+                    18,
+                    51,
+                    45,
+                    43,
+                    21
+                ],
+                supportedGroups: [
+                    29,
+                    23,
+                    24,
+                    25
+                ],
+                signatureAlgorithms: [
+                    1027,
+                    2052,
+                    1025,
+                    1283,
+                    513,
+                    2053,
+                    2053,
+                    1281,
+                    2054,
+                    1537,
+                    515
+                ],
+                supportedVersions: [
+                    772,
+                    771,
+                    770,
+                    769
+                ],
+                ecPointFormats: [0],
+                alpnProtocols: ['h2', 'http/1.1'],
+                pskKeyExchangeModes: [1],
+                compressionMethods: [0],
+                grease: true
+            },
+            http2: {
+                windowUpdate: 10420225,
+                headerTableSize: 4096,
+                enablePush: 0,
+                maxConcurrentStreams: 100,
+                initialWindowSize: 2097152,
+                maxFrameSize: 16384,
+                settingsOrder: [2, 3, 4, 8, 9],
+                connectionPreface: Buffer.from('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'),
+                priorityFrames: [],
+                pseudoHeaderOrder: [':method', ':scheme', ':authority', ':path'],
+                headerOrder: []
+            },
+            userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1',
+            secChUa: '',
+            secChUaPlatform: '',
+            secChUaMobile: '?1',
+            secFetchSite: 'none',
+            secFetchMode: 'navigate',
+            secFetchDest: 'document'
+        };
+    }
+    static get(name) {
+        switch (name.toLowerCase()) {
+            case 'chrome_mobile_143_android': return this.chromeMobile143Android();
+            case 'chrome_133_psk': return this.chrome133PSK();
+            case 'chrome_133': return this.chrome133();
+            case 'firefox_117': return this.firefox117();
+            case 'safari_ios_18_0': return this.safariIOS18();
+            default: return this.chrome133();
+        }
+    }
+    static get latest() {
+        return this.chrome133();
+    }
+    static get latestMobile() {
+        return this.chromeMobile143Android();
+    }
 }
+exports.ProfileRegistry = ProfileRegistry;
 class CookieJar {
     constructor() {
         this.cookies = new Map();
@@ -82,97 +644,595 @@ class CookieJar {
         return validCookies.join('; ');
     }
     parseSetCookie(domain, setCookieHeaders) {
-        const headers = Array.isArray(setCookieHeaders) ? setCookieHeaders : [setCookieHeaders];
+        if (!setCookieHeaders)
+            return;
+        const headers = Array.isArray(setCookieHeaders) ? setCookieHeaders : typeof setCookieHeaders === 'string' ? [setCookieHeaders] : [];
         for (const header of headers) {
-            if (!header)
-                continue;
             const parts = header.split(';').map(p => p.trim());
             const [nameValue] = parts;
             if (!nameValue)
                 continue;
-            const [name, value = ''] = nameValue.split('=', 2);
+            const [name, value = ''] = nameValue.split('=');
             const options = { path: '/' };
             for (let i = 1; i < parts.length; i++) {
-                const [key, val = ''] = parts[i].split('=', 2);
+                const part = parts[i];
+                if (!part)
+                    continue;
+                const [key, val] = part.split('=');
                 const lowerKey = key.toLowerCase();
-                if (lowerKey === 'expires')
+                if (lowerKey === 'expires' && val)
                     options.expires = new Date(val);
-                else if (lowerKey === 'path')
+                else if (lowerKey === 'path' && val)
                     options.path = val;
                 else if (lowerKey === 'secure')
                     options.secure = true;
                 else if (lowerKey === 'httponly')
                     options.httpOnly = true;
-                else if (lowerKey === 'samesite')
+                else if (lowerKey === 'samesite' && val)
                     options.sameSite = val;
             }
             this.setCookie(domain, name, value, options);
         }
     }
-    clear() {
-        this.cookies.clear();
-    }
 }
-class FastProxiedClient {
-    constructor() {
-        this.cookieJar = new CookieJar();
+var Protocol;
+(function (Protocol) {
+    Protocol["HTTP1"] = "http1";
+    Protocol["HTTP2"] = "http2";
+})(Protocol || (Protocol = {}));
+class UnifiedClientManager extends events_1.EventEmitter {
+    constructor(tlsSocket, profile, hostname, cookieJar) {
+        super();
+        this.http2Client = null;
+        this.negotiatedProtocol = Protocol.HTTP1;
+        this.tlsSocket = tlsSocket;
+        this.profile = profile;
+        this.hostname = hostname;
+        this.cookieJar = cookieJar;
     }
-    async request(url, options = {}) {
-        const targetUrl = new url_1.URL(url);
-        const proxyBase = getRandomProxy();
-        const proxyUrl = new url_1.URL(proxyBase + url);
-        const startTime = Date.now();
-        const headers = {
-            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-            'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
-            'accept-language': 'en-US,en;q=0.9',
-            'accept-encoding': 'gzip, deflate, br, zstd',
-            ...options.headers
+    async initialize() {
+        const alpn = this.tlsSocket.alpnProtocol;
+        if (alpn === 'h2') {
+            this.negotiatedProtocol = Protocol.HTTP2;
+            await this.createHttp2Session();
+        }
+        else {
+            this.negotiatedProtocol = Protocol.HTTP1;
+        }
+    }
+    async createHttp2Session() {
+        return new Promise((resolve, reject) => {
+            const settings = {};
+            this.profile.http2.settingsOrder.forEach(id => {
+                switch (id) {
+                    case 1:
+                        settings.headerTableSize = this.profile.http2.headerTableSize;
+                        break;
+                    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;
+                        break;
+                }
+            });
+            this.http2Client = http2.connect(`https://${this.hostname}`, {
+                createConnection: () => this.tlsSocket,
+                settings
+            });
+            this.http2Client.once('connect', () => resolve());
+            this.http2Client.once('error', reject);
+            this.http2Client.once('timeout', () => reject(new Error('HTTP/2 session timeout')));
+        });
+    }
+    async request(path, options, timingStart, headers, post_data, out, callback) {
+        const cleanHeaders = { ...headers };
+        delete cleanHeaders['connection'];
+        delete cleanHeaders['Connection'];
+        delete cleanHeaders['keep-alive'];
+        delete cleanHeaders['Keep-Alive'];
+        delete cleanHeaders['proxy-connection'];
+        delete cleanHeaders['Proxy-Connection'];
+        delete cleanHeaders['upgrade'];
+        delete cleanHeaders['Upgrade'];
+        delete cleanHeaders['transfer-encoding'];
+        delete cleanHeaders['Transfer-Encoding'];
+        if (this.negotiatedProtocol === Protocol.HTTP2 && this.http2Client && !this.http2Client.destroyed) {
+            await this.requestHttp2(path, options, timingStart, cleanHeaders, post_data, out, callback);
+        }
+        else {
+            await this.requestHttp1(path, options, timingStart, cleanHeaders, post_data, out, callback);
+        }
+    }
+    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,
+            ':scheme': 'https',
+            ':path': path,
+            ...headers
+        };
+        const stream = this.http2Client.request(reqHeaders);
+        const response = new events_1.EventEmitter();
+        response.timing = { socket: timingStart, lookup: 0, connect: 0, secureConnect: 0, response: 0, end: 0, total: 0 };
+        response.fingerprints = {
+            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`
         };
-        const cookieString = this.cookieJar.getCookies(targetUrl.hostname, targetUrl.pathname, true);
-        if (cookieString) {
-            headers['cookie'] = headers['cookie'] ? `${headers['cookie']}; ${cookieString}` : cookieString;
+        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 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;
+                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 = response.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);
+        });
+        stream.once('error', (err) => {
+            out.emit('err', err);
+            if (callback)
+                callback(err);
+        });
+        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 (options.cookies) {
-            const manualCookies = Object.entries(options.cookies).map(([k, v]) => `${k}=${v}`).join('; ');
-            headers['cookie'] = headers['cookie'] ? `${headers['cookie']}; ${manualCookies}` : manualCookies;
+        else {
+            stream.end();
         }
+    }
+    async requestHttp1(path, options, timingStart, headers, post_data, out, callback) {
         const reqOptions = {
             method: options.method?.toUpperCase() || 'GET',
-            headers,
-            timeout: options.timeout || 30000
+            path,
+            headers: {
+                host: this.hostname,
+                ...headers
+            },
+            createConnection: () => this.tlsSocket
         };
-        return new Promise((resolve, reject) => {
-            const req = https.request(proxyUrl.toString(), reqOptions, async (res) => {
-                const response = new events_1.EventEmitter();
-                response.statusCode = res.statusCode || 500;
-                response.headers = res.headers;
-                response.timing = {
-                    socket: startTime,
-                    lookup: startTime,
-                    connect: startTime,
-                    secureConnect: startTime,
-                    response: Date.now() - startTime,
-                    end: 0,
-                    total: 0
-                };
-                response.fingerprints = { ja3: '', ja3Hash: '', akamai: '' };
-                if (res.headers['set-cookie']) {
-                    this.cookieJar.parseSetCookie(targetUrl.hostname, res.headers['set-cookie']);
+        const req = 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 = {
+            ja3: this.generateJA3(),
+            ja3Hash: crypto.createHash('md5').update(this.generateJA3()).digest('hex'),
+            akamai: ''
+        };
+        req.once('response', (res) => {
+            response.statusCode = res.statusCode;
+            response.headers = res.headers;
+            if (res.headers['set-cookie'])
+                this.cookieJar.parseSetCookie(this.hostname, res.headers['set-cookie']);
+            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
+                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);
+                    }
                 }
-                if (options.stream) {
-                    response.body = res;
-                    response.timing.end = Date.now() - startTime;
-                    response.timing.total = response.timing.end;
-                    resolve(response);
-                    return;
+                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);
+        });
+        if (post_data) {
+            if (Buffer.isBuffer(post_data) || typeof post_data === 'string')
+                req.end(post_data);
+            else if (post_data instanceof stream_1.Readable)
+                post_data.pipe(req);
+        }
+        else {
+            req.end();
+        }
+    }
+    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 ecPoints = this.profile.tls.ecPointFormats.join('-');
+        return `${version},${ciphers},${extensions},${curves},${ecPoints}`;
+    }
+    destroy() {
+        if (this.http2Client && !this.http2Client.destroyed)
+            this.http2Client.destroy();
+        this.http2Client = null;
+    }
+    getProtocol() {
+        return this.negotiatedProtocol;
+    }
+}
+class TLSSocketManager extends events_1.EventEmitter {
+    constructor(profile, proxy) {
+        super();
+        this.socket = null;
+        this.tlsSocket = null;
+        this.startTime = 0;
+        this.hostname = '';
+        this.port = 443;
+        this.profile = profile;
+        this.proxy = proxy;
+        this.timing = { socket: 0, lookup: 0, connect: 0, secureConnect: 0, response: 0, end: 0, total: 0 };
+    }
+    async connect(hostname, port = 443) {
+        this.hostname = hostname;
+        this.port = port;
+        this.startTime = Date.now();
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.destroy();
+                reject(new Error('Connection timeout'));
+            }, 30000);
+            const handleError = (err) => {
+                clearTimeout(timeout);
+                this.destroy();
+                reject(err);
+            };
+            if (this.proxy) {
+                const proxyUrl = new url.URL(this.proxy);
+                this.socket = net.connect(+proxyUrl.port || 80, proxyUrl.hostname, () => {
+                    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');
+                        request += `Proxy-Authorization: Basic ${auth}\r\n`;
+                    }
+                    request += '\r\n';
+                    this.socket.write(request);
+                });
+                let response = '';
+                this.socket.on('data', (chunk) => {
+                    response += chunk.toString();
+                    if (response.includes('\r\n\r\n')) {
+                        if (!response.startsWith('HTTP/1.1 200'))
+                            return reject(new Error('Proxy failed: ' + response.split('\r\n')[0]));
+                        this.proceedWithTLS(resolve, reject, timeout);
+                    }
+                });
+            }
+            else {
+                this.socket = new net.Socket();
+                this.socket.setNoDelay(true);
+                this.socket.setKeepAlive(true, 60000);
+                this.socket.once('lookup', () => {
+                    this.timing.lookup = Date.now() - this.startTime;
+                });
+                this.socket.connect(port, hostname, () => {
+                    this.timing.connect = Date.now() - this.startTime;
+                    this.proceedWithTLS(resolve, reject, timeout);
+                });
+            }
+            this.socket.on('error', handleError);
+            this.socket.on('timeout', () => handleError(new Error('Socket timeout')));
+        });
+    }
+    proceedWithTLS(resolve, reject, timeout) {
+        const validCiphers = [
+            'TLS_AES_256_GCM_SHA384',
+            'TLS_CHACHA20_POLY1305_SHA256',
+            'TLS_AES_128_GCM_SHA256',
+            'ECDHE-ECDSA-AES256-GCM-SHA384',
+            'ECDHE-RSA-AES256-GCM-SHA384',
+            'ECDHE-ECDSA-CHACHA20-POLY1305',
+            'ECDHE-RSA-CHACHA20-POLY1305',
+            'ECDHE-ECDSA-AES128-GCM-SHA256',
+            'ECDHE-RSA-AES128-GCM-SHA256',
+            'ECDHE-ECDSA-AES256-SHA',
+            'ECDHE-RSA-AES256-SHA',
+            'ECDHE-ECDSA-AES128-SHA',
+            'ECDHE-RSA-AES128-SHA',
+            'AES256-GCM-SHA384',
+            'AES128-GCM-SHA256',
+            'AES256-SHA',
+            'AES128-SHA'
+        ].join(':');
+        const tlsOptions = {
+            socket: this.socket,
+            servername: this.hostname,
+            ALPNProtocols: this.profile.tls.alpnProtocols,
+            ciphers: validCiphers,
+            minVersion: 'TLSv1.2',
+            maxVersion: 'TLSv1.3',
+            rejectUnauthorized: false,
+            requestCert: false,
+            honorCipherOrder: true,
+            sessionTimeout: 300
+        };
+        this.tlsSocket = tls.connect(tlsOptions);
+        this.tlsSocket.once('secureConnect', () => {
+            clearTimeout(timeout);
+            this.timing.secureConnect = Date.now() - this.startTime;
+            this.timing.socket = this.startTime;
+            resolve(this.tlsSocket);
+        });
+        this.tlsSocket.on('error', (err) => {
+            clearTimeout(timeout);
+            this.destroy();
+            reject(err);
+        });
+    }
+    getTiming() {
+        return { ...this.timing, total: Date.now() - this.startTime };
+    }
+    destroy() {
+        this.tlsSocket?.destroy();
+        this.socket?.destroy();
+        this.tlsSocket = null;
+        this.socket = null;
+    }
+    getSocket() {
+        return this.tlsSocket;
+    }
+}
+class AdvancedTLSClient {
+    constructor(profileName) {
+        this.sessionCache = new Map();
+        this.cookieJar = new CookieJar();
+        this.maxCachedSessions = 10;
+        this.sessionTimeout = 300000;
+        this.defaults = {
+            boundary: '--------------------SIPUTZXCOMPANY',
+            encoding: 'utf8',
+            parse_response: 'all',
+            proxy: null,
+            agent: null,
+            headers: {},
+            accept: '*/*',
+            user_agent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+            open_timeout: 10000,
+            response_timeout: 0,
+            read_timeout: 0,
+            follow_max: 0,
+            stream_length: -1,
+            signal: null,
+            compressed: false,
+            decode_response: true,
+            parse_cookies: true,
+            follow_set_cookies: false,
+            follow_set_referer: false,
+            follow_keep_method: false,
+            follow_if_same_host: false,
+            follow_if_same_protocol: false,
+            follow_if_same_location: false,
+            use_proxy_from_env_var: true
+        };
+        this.profile = ProfileRegistry.get(profileName || 'chrome_133');
+        this.cleanupInterval = setInterval(() => {
+            const now = Date.now();
+            for (const [key, session] of this.sessionCache) {
+                if (now - session.lastUsed > this.sessionTimeout) {
+                    session.clientManager.destroy();
+                    session.tlsManager.destroy();
+                    this.sessionCache.delete(key);
                 }
-                const chunks = [];
-                res.on('data', chunk => chunks.push(chunk));
-                res.on('end', async () => {
-                    let body = Buffer.concat(chunks);
-                    if (options.decompress !== false) {
-                        const encoding = (res.headers['content-encoding'] || '').toString().toLowerCase();
+            }
+        }, 60000);
+    }
+    setup(uri, options) {
+        const config = {
+            headers: { ...options.headers },
+            proxy: options.proxy || this.defaults.proxy,
+            decompress: options.decompress !== undefined ? options.decompress : true
+        };
+        config.headers['user-agent'] = this.profile.userAgent;
+        config.headers['accept-language'] = this.profile.acceptLanguage || 'en-US,en;q=0.9';
+        config.headers['accept-encoding'] = 'gzip, deflate, br';
+        config.headers['accept'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8';
+        config.headers['sec-ch-ua'] = this.profile.secChUa;
+        config.headers['sec-ch-ua-mobile'] = this.profile.secChUaMobile;
+        config.headers['sec-ch-ua-platform'] = this.profile.secChUaPlatform;
+        config.headers['sec-fetch-site'] = this.profile.secFetchSite;
+        config.headers['sec-fetch-mode'] = this.profile.secFetchMode;
+        config.headers['sec-fetch-dest'] = this.profile.secFetchDest;
+        if (this.profile.upgradeInsecureRequests)
+            config.headers['upgrade-insecure-requests'] = this.profile.upgradeInsecureRequests;
+        if (this.profile.priority)
+            config.headers['priority'] = this.profile.priority;
+        return config;
+    }
+    async request(uri, data, options = {}, callback) {
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
+        }
+        const parsed = new url.URL(uri);
+        const hostname = parsed.hostname;
+        const port = parsed.port ? +parsed.port : 443;
+        const path = parsed.pathname + parsed.search;
+        const cacheKey = `${hostname}:${port}`;
+        const startTime = Date.now();
+        const out = new stream_1.PassThrough();
+        let session = this.sessionCache.get(cacheKey);
+        if (!session || session.tlsManager.getSocket()?.destroyed) {
+            const tlsManager = new TLSSocketManager(this.profile, options.proxy);
+            const tlsSocket = await tlsManager.connect(hostname, port);
+            const clientManager = new UnifiedClientManager(tlsSocket, this.profile, hostname, this.cookieJar);
+            await clientManager.initialize();
+            session = { tlsManager, clientManager, lastUsed: Date.now() };
+            this.sessionCache.set(cacheKey, session);
+            if (this.sessionCache.size > this.maxCachedSessions) {
+                const oldest = [...this.sessionCache.entries()].sort((a, b) => a[1].lastUsed - b[1].lastUsed)[0];
+                oldest[1].clientManager.destroy();
+                oldest[1].tlsManager.destroy();
+                this.sessionCache.delete(oldest[0]);
+            }
+        }
+        session.lastUsed = Date.now();
+        const config = this.setup(uri, options);
+        let post_data = null;
+        let json = options.json || (options.json !== false && config.headers['content-type']?.includes('application/json'));
+        if (data) {
+            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;
+            }
+            else if (data instanceof stream_1.Readable) {
+                post_data = data;
+            }
+            else if (Buffer.isBuffer(data)) {
+                post_data = data;
+            }
+            else if (typeof data === 'string') {
+                post_data = data;
+            }
+            else if (json) {
+                post_data = JSON.stringify(data);
+                config.headers['content-type'] = 'application/json; charset=utf-8';
+            }
+            else {
+                post_data = new URLSearchParams(data).toString();
+                config.headers['content-type'] = 'application/x-www-form-urlencoded';
+            }
+            if (post_data && (typeof post_data === 'string' || Buffer.isBuffer(post_data))) {
+                config.headers['content-length'] = Buffer.byteLength(post_data).toString();
+            }
+        }
+        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 (callback) {
+            await session.clientManager.request(path, options, startTime, config.headers, post_data, out, callback);
+            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 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;
+                    if (encoding) {
                         try {
                             if (encoding.includes('gzip'))
                                 body = await gunzip(body);
@@ -181,55 +1241,142 @@ class FastProxiedClient {
                             else if (encoding.includes('deflate'))
                                 body = await inflate(body);
                         }
-                        catch (e) { }
-                    }
-                    response.body = body;
-                    try {
-                        response.text = body.toString('utf-8');
+                        catch (e) {
+                            console.error('Decompression failed:', e);
+                        }
                     }
-                    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')) {
                     try {
-                        if ((res.headers['content-type'] || '').includes('application/json')) {
-                            response.json = JSON.parse(response.text);
-                        }
+                        parsedJson = JSON.parse(text);
                     }
                     catch { }
-                    response.timing.end = Date.now() - startTime;
-                    response.timing.total = response.timing.end;
-                    if (options.followRedirects !== false &&
-                        [301, 302, 303, 307, 308].includes(response.statusCode) &&
-                        (options.maxRedirects ?? 10) > 0) {
-                        const location = res.headers['location'];
-                        if (location) {
-                            const newUrl = new url_1.URL(location, url).toString();
-                            const newOptions = { ...options, maxRedirects: (options.maxRedirects ?? 10) - 1 };
-                            return this.request(newUrl, newOptions).then(resolve).catch(reject);
-                        }
+                }
+                // 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 = {
+                    statusCode,
+                    headers,
+                    body,
+                    text,
+                    json: parsedJson,
+                    fingerprints: {
+                        ja3,
+                        ja3Hash,
+                        akamai
+                    },
+                    timing: {
+                        socket: startTime,
+                        lookup: 0,
+                        connect: 0,
+                        secureConnect: 0,
+                        response: Date.now() - startTime,
+                        end: Date.now() - startTime,
+                        total: Date.now() - startTime
                     }
-                    resolve(response);
-                });
-                res.on('error', reject);
-            });
-            req.on('error', reject);
-            req.on('timeout', () => {
-                req.destroy();
-                reject(new Error('Request timeout'));
+                };
+                resolve(fullResponse);
             });
-            if (options.body) {
-                if (typeof options.body === 'string' || Buffer.isBuffer(options.body)) {
-                    req.end(options.body);
+            out.once('error', (err) => reject(err));
+            // Jalankan request
+            session.clientManager.request(path, options, startTime, config.headers, post_data, out).catch(reject);
+        });
+    }
+    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 ecPoints = this.profile.tls.ecPointFormats.join('-');
+        return `${version},${ciphers},${extensions},${curves},${ecPoints}`;
+    }
+    async buildMultipart(data, boundary) {
+        return new Promise((resolve, reject) => {
+            let body = '';
+            const object = this.flatten(data);
+            const count = Object.keys(object).length;
+            if (count === 0)
+                return reject(new Error('Empty multipart body'));
+            let doneCount = count;
+            const done = () => {
+                if (--doneCount === 0)
+                    resolve(Buffer.from(body + '--' + boundary + '--\r\n'));
+            };
+            for (const key in object) {
+                const value = object[key];
+                if (value === null || typeof value === 'undefined') {
+                    done();
+                    continue;
                 }
-                else if (options.body instanceof stream_1.Readable) {
-                    options.body.pipe(req);
+                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();
+                    });
                 }
-            }
-            else {
-                req.end();
             }
         });
     }
+    async generateMultipart(name, part, boundary) {
+        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 += data.toString('binary');
+            }
+            return return_part + '\r\n';
+        };
+        if ((part.file || part.buffer) && part.content_type) {
+            const filename = part.filename || (part.file ? path.basename(part.file) : name);
+            if (part.buffer)
+                return append(part.buffer, filename);
+            const data = await fs.promises.readFile(part.file);
+            return append(data, filename);
+        }
+        else {
+            return_part += '\r\n\r\n';
+            return_part += String(part.value || '');
+            return return_part + '\r\n';
+        }
+    }
+    flatten(object, into = {}, prefix) {
+        for (const key in object) {
+            const prefix_key = prefix ? prefix + '[' + key + ']' : key;
+            const prop = object[key];
+            if (prop && typeof prop === 'object' && !(prop.buffer || prop.file || prop.content_type))
+                this.flatten(prop, into, prefix_key);
+            else
+                into[prefix_key] = prop;
+        }
+        return into;
+    }
     destroy() {
-        this.cookieJar.clear();
+        clearInterval(this.cleanupInterval);
+        this.sessionCache.forEach(s => {
+            s.clientManager.destroy();
+            s.tlsManager.destroy();
+        });
+        this.sessionCache.clear();
     }
 }
-exports.FastProxiedClient = FastProxiedClient;
+exports.AdvancedTLSClient = AdvancedTLSClient;