advanced-tls-client 1.0.0 → 1.0.2

package/dist/index.js

@@ -0,0 +1,1037 @@
+"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.ProfileRegistry = exports.AdvancedTLSClient = void 0;
+const tls = __importStar(require("tls"));
+const net = __importStar(require("net"));
+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 gunzip = (0, util_1.promisify)(zlib.gunzip);
+const brotliDecompress = (0, util_1.promisify)(zlib.brotliDecompress);
+const inflate = (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() {
+        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,
+                maxHeaderListSize: 262144,
+                maxFrameSize: 16384,
+                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();
+    }
+    setCookie(domain, name, value, options = {}) {
+        if (!this.cookies.has(domain))
+            this.cookies.set(domain, new Map());
+        this.cookies.get(domain).set(name, { value, ...options, path: options.path || '/', domain });
+    }
+    getCookies(domain, path = '/', secure = true) {
+        const domainCookies = this.cookies.get(domain);
+        if (!domainCookies)
+            return '';
+        const validCookies = [];
+        const now = new Date();
+        for (const [name, cookie] of domainCookies) {
+            if (cookie.expires && cookie.expires < now) {
+                domainCookies.delete(name);
+                continue;
+            }
+            if (cookie.secure && !secure)
+                continue;
+            if (path.startsWith(cookie.path))
+                validCookies.push(`${name}=${cookie.value}`);
+        }
+        return validCookies.join('; ');
+    }
+    parseSetCookie(domain, setCookieHeaders) {
+        for (const header of setCookieHeaders) {
+            const parts = header.split(';').map(p => p.trim());
+            const [nameValue] = parts;
+            const [name, value] = nameValue.split('=');
+            const options = { path: '/' };
+            for (let i = 1; i < parts.length; i++) {
+                const [key, val] = parts[i].split('=');
+                const lowerKey = key.toLowerCase();
+                if (lowerKey === 'expires')
+                    options.expires = new Date(val);
+                else if (lowerKey === 'path')
+                    options.path = val;
+                else if (lowerKey === 'secure')
+                    options.secure = true;
+                else if (lowerKey === 'httponly')
+                    options.httpOnly = true;
+                else if (lowerKey === 'samesite')
+                    options.sameSite = val;
+            }
+            this.setCookie(domain, name, value, options);
+        }
+    }
+}
+class TLSSocketManager extends events_1.EventEmitter {
+    constructor(profile) {
+        super();
+        this.socket = null;
+        this.tlsSocket = null;
+        this.startTime = 0;
+        this.hostname = '';
+        this.port = 443;
+        this.profile = profile;
+        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);
+            this.socket = new net.Socket();
+            this.socket.setNoDelay(true);
+            this.socket.setKeepAlive(true, 60000);
+            this.socket.on('lookup', () => {
+                this.timing.lookup = Date.now() - this.startTime;
+            });
+            this.socket.connect(port, hostname, () => {
+                this.timing.connect = Date.now() - this.startTime;
+                const validCiphers = this.profile.tls.cipherSuites
+                    .filter(c => c < 0xff00)
+                    .map(c => {
+                    const hex = c.toString(16).toUpperCase();
+                    return hex.length === 3 ? `0${hex}` : hex;
+                });
+                const cipherList = [
+                    'TLS_AES_128_GCM_SHA256',
+                    'TLS_AES_256_GCM_SHA384',
+                    'TLS_CHACHA20_POLY1305_SHA256',
+                    'ECDHE-ECDSA-AES128-GCM-SHA256',
+                    'ECDHE-RSA-AES128-GCM-SHA256',
+                    'ECDHE-ECDSA-AES256-GCM-SHA384',
+                    'ECDHE-RSA-AES256-GCM-SHA384',
+                    'ECDHE-ECDSA-CHACHA20-POLY1305',
+                    'ECDHE-RSA-CHACHA20-POLY1305',
+                    'ECDHE-RSA-AES128-SHA',
+                    'ECDHE-RSA-AES256-SHA',
+                    'AES128-GCM-SHA256',
+                    'AES256-GCM-SHA384',
+                    'AES128-SHA',
+                    'AES256-SHA'
+                ].join(':');
+                const tlsOptions = {
+                    socket: this.socket,
+                    servername: hostname,
+                    ALPNProtocols: this.profile.tls.alpnProtocols,
+                    ciphers: cipherList,
+                    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);
+                });
+            });
+            this.socket.on('error', (err) => {
+                clearTimeout(timeout);
+                this.destroy();
+                reject(err);
+            });
+            this.socket.on('timeout', () => {
+                clearTimeout(timeout);
+                this.destroy();
+                reject(new Error('Socket timeout'));
+            });
+        });
+    }
+    getTiming() {
+        return { ...this.timing, total: Date.now() - this.startTime };
+    }
+    destroy() {
+        if (this.tlsSocket && !this.tlsSocket.destroyed) {
+            this.tlsSocket.destroy();
+        }
+        if (this.socket && !this.socket.destroyed) {
+            this.socket.destroy();
+        }
+        this.tlsSocket = null;
+        this.socket = null;
+    }
+    getSocket() {
+        return this.tlsSocket;
+    }
+}
+class HTTP2ClientManager extends events_1.EventEmitter {
+    constructor(tlsSocket, profile, hostname, cookieJar) {
+        super();
+        this.client = null;
+        this.tlsSocket = tlsSocket;
+        this.profile = profile;
+        this.hostname = hostname;
+        this.cookieJar = cookieJar;
+    }
+    async createSession() {
+        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.client = http2.connect(`https://${this.hostname}`, {
+                createConnection: () => this.tlsSocket,
+                settings
+            });
+            this.client.once('connect', () => resolve(this.client));
+            this.client.once('error', reject);
+            this.client.once('timeout', () => reject(new Error('HTTP/2 session timeout')));
+        });
+    }
+    async request(path, options = {}, timingStart) {
+        if (!this.client || this.client.destroyed) {
+            throw new Error('HTTP/2 session not established or destroyed');
+        }
+        const headers = {
+            ':method': options.method?.toUpperCase() || 'GET',
+            ':authority': this.hostname,
+            ':scheme': 'https',
+            ':path': path
+        };
+        const defaultHeaders = {
+            'user-agent': this.profile.userAgent,
+            'sec-ch-ua': this.profile.secChUa,
+            'sec-ch-ua-mobile': this.profile.secChUaMobile,
+            'sec-ch-ua-platform': this.profile.secChUaPlatform,
+            'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
+            'accept-language': this.profile.acceptLanguage || 'en-US,en;q=0.9',
+            'accept-encoding': 'gzip, deflate, br, zstd',
+            'sec-fetch-site': this.profile.secFetchSite,
+            'sec-fetch-mode': this.profile.secFetchMode,
+            'sec-fetch-dest': this.profile.secFetchDest,
+        };
+        if (this.profile.upgradeInsecureRequests)
+            defaultHeaders['upgrade-insecure-requests'] = '1';
+        if (this.profile.priority)
+            defaultHeaders['priority'] = this.profile.priority;
+        if (this.profile.http2.headerOrder.length > 0) {
+            this.profile.http2.headerOrder.forEach(name => {
+                if (defaultHeaders[name])
+                    headers[name] = defaultHeaders[name];
+            });
+        }
+        Object.assign(headers, defaultHeaders);
+        const cookies = this.cookieJar.getCookies(this.hostname, path);
+        if (cookies)
+            headers['cookie'] = cookies;
+        if (options.headers)
+            Object.assign(headers, options.headers);
+        if (options.body && (options.method || 'GET').toUpperCase() !== 'GET') {
+            if (!headers['content-type'])
+                headers['content-type'] = 'application/x-www-form-urlencoded';
+            if (typeof options.body === 'string') {
+                headers['content-length'] = Buffer.byteLength(options.body).toString();
+            }
+            else if (Buffer.isBuffer(options.body)) {
+                headers['content-length'] = options.body.length.toString();
+            }
+        }
+        const stream = this.client.request(headers);
+        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 chunks = [];
+        stream.once('response', (headers, flags) => {
+            response.statusCode = headers[':status'];
+            response.headers = headers;
+            const setCookies = headers['set-cookie'];
+            if (setCookies) {
+                const cookies = Array.isArray(setCookies) ? setCookies : [setCookies];
+                this.cookieJar.parseSetCookie(this.hostname, cookies);
+            }
+            response.timing.response = Date.now() - timingStart;
+        });
+        stream.on('data', (chunk) => chunks.push(chunk));
+        stream.once('end', async () => {
+            let body = Buffer.concat(chunks);
+            if (options.decompress !== false) {
+                const encoding = response.headers['content-encoding']?.toLowerCase();
+                try {
+                    if (encoding === 'gzip')
+                        body = await gunzip(body);
+                    else if (encoding === 'br')
+                        body = await brotliDecompress(body);
+                    else if (encoding === 'deflate')
+                        body = await inflate(body);
+                }
+                catch (e) { }
+            }
+            response.body = body;
+            try {
+                response.text = body.toString('utf-8');
+                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;
+            response.emit('complete', response);
+        });
+        stream.once('error', (err) => response.emit('error', err));
+        stream.once('close', () => response.emit('close'));
+        if (options.body) {
+            if (Buffer.isBuffer(options.body) || typeof options.body === 'string') {
+                stream.end(options.body);
+            }
+            else if (options.body instanceof stream_1.Readable) {
+                options.body.pipe(stream);
+            }
+        }
+        else {
+            stream.end();
+        }
+        return new Promise((resolve, reject) => {
+            response.once('complete', () => resolve(response));
+            response.once('error', 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}`;
+    }
+    destroy() {
+        if (this.client && !this.client.destroyed) {
+            this.client.destroy();
+        }
+        this.client = null;
+    }
+}
+class AdvancedTLSClient {
+    constructor(profileName) {
+        this.sessionCache = new Map();
+        this.cookieJar = new CookieJar();
+        this.maxCachedSessions = 10;
+        this.sessionTimeout = 300000;
+        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.http2Manager.destroy();
+                    session.tlsManager.destroy();
+                    this.sessionCache.delete(key);
+                }
+            }
+        }, 60000);
+    }
+    async request(url, options = {}) {
+        const parsed = new URL(url);
+        const hostname = parsed.hostname;
+        const port = parsed.port ? +parsed.port : 443;
+        const path = parsed.pathname + parsed.search;
+        const cacheKey = `${hostname}:${port}`;
+        let session = this.sessionCache.get(cacheKey);
+        const startTime = Date.now();
+        if (!session || session.tlsManager.getSocket()?.destroyed) {
+            const tlsManager = new TLSSocketManager(this.profile);
+            const tlsSocket = await tlsManager.connect(hostname, port);
+            const http2Manager = new HTTP2ClientManager(tlsSocket, this.profile, hostname, this.cookieJar);
+            await http2Manager.createSession();
+            session = { tlsManager, http2Manager, 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].http2Manager.destroy();
+                oldest[1].tlsManager.destroy();
+                this.sessionCache.delete(oldest[0]);
+            }
+        }
+        session.lastUsed = Date.now();
+        options.headers = options.headers || {};
+        options.headers['user-agent'] = this.profile.userAgent;
+        options.headers['accept-language'] = this.profile.acceptLanguage || 'en-US,en;q=0.9';
+        options.headers['accept-encoding'] = 'gzip, deflate, br';
+        options.headers['accept'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8';
+        options.headers['sec-ch-ua'] = this.profile.secChUa;
+        options.headers['sec-ch-ua-mobile'] = this.profile.secChUaMobile;
+        options.headers['sec-ch-ua-platform'] = this.profile.secChUaPlatform;
+        options.headers['sec-fetch-site'] = this.profile.secFetchSite;
+        options.headers['sec-fetch-mode'] = this.profile.secFetchMode;
+        options.headers['sec-fetch-dest'] = this.profile.secFetchDest;
+        if (this.profile.upgradeInsecureRequests)
+            options.headers['upgrade-insecure-requests'] = this.profile.upgradeInsecureRequests;
+        if (this.profile.priority)
+            options.headers['priority'] = this.profile.priority;
+        const cookies = this.cookieJar.getCookies(hostname, parsed.pathname, parsed.protocol === 'https:');
+        if (cookies)
+            options.headers['cookie'] = cookies;
+        let response = await session.http2Manager.request(path, options, startTime);
+        if (options.followRedirects !== false && [301, 302, 303, 307, 308].includes(response.statusCode) && (options.maxRedirects ?? 5) > 0) {
+            options.maxRedirects = (options.maxRedirects ?? 5) - 1;
+            const location = response.headers['location'];
+            if (location) {
+                const redirectUrl = new URL(location, url).toString();
+                return this.request(redirectUrl, options);
+            }
+        }
+        return response;
+    }
+    destroy() {
+        clearInterval(this.cleanupInterval);
+        this.sessionCache.forEach(s => {
+            s.http2Manager.destroy();
+            s.tlsManager.destroy();
+        });
+        this.sessionCache.clear();
+    }
+}
+exports.AdvancedTLSClient = AdvancedTLSClient;