advanced-tls-client 1.0.0 → 1.0.1

package/dist/index.js

@@ -0,0 +1,1143 @@
+"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.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 gunzip = (0, util_1.promisify)(zlib.gunzip);
+const brotliDecompress = (0, util_1.promisify)(zlib.brotliDecompress);
+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: [
+                    `GREASE_${grease1.toString(16)}`,
+                    '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'
+                ],
+                extensions: [
+                    grease2,
+                    0xfe0d,
+                    0x001b,
+                    0x002b,
+                    0x0010,
+                    0x0023,
+                    0x002d,
+                    0x000b,
+                    0xff01,
+                    0x0005,
+                    0x000a,
+                    0x0017,
+                    0x0000,
+                    0x44cd,
+                    0x0033,
+                    0x0012,
+                    0x000d,
+                    grease3
+                ],
+                supportedGroups: [
+                    `GREASE_${grease4.toString(16)}`,
+                    'X25519Kyber768',
+                    'X25519',
+                    'prime256v1',
+                    'secp384r1'
+                ],
+                signatureAlgorithms: [
+                    'ecdsa_secp256r1_sha256',
+                    'rsa_pss_rsae_sha256',
+                    'rsa_pkcs1_sha256',
+                    'ecdsa_secp384r1_sha384',
+                    'rsa_pss_rsae_sha384',
+                    'rsa_pkcs1_sha384',
+                    'rsa_pss_rsae_sha512',
+                    'rsa_pkcs1_sha512'
+                ],
+                supportedVersions: [
+                    `GREASE_${grease2.toString(16)}`,
+                    'TLSv1.3',
+                    'TLSv1.2'
+                ],
+                ecPointFormats: [0x00],
+                alpnProtocols: ['h2', 'http/1.1'],
+                pskKeyExchangeModes: [0x01],
+                compressionMethods: [0x00],
+                grease: true,
+                recordSizeLimit: 16385,
+                certificateCompression: [0x02],
+                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: [
+                    `GREASE_${grease1.toString(16)}`,
+                    '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'
+                ],
+                extensions: [
+                    grease2,
+                    0x0000,
+                    0x0017,
+                    0xff01,
+                    0x000a,
+                    0x000b,
+                    0x0023,
+                    0x0010,
+                    0x0005,
+                    0x000d,
+                    0x0012,
+                    0x0033,
+                    0x002d,
+                    0x002b,
+                    0x001b,
+                    0x0015,
+                    grease3
+                ],
+                supportedGroups: [
+                    `GREASE_${grease4.toString(16)}`,
+                    'X25519Kyber768',
+                    'X25519',
+                    'prime256v1',
+                    'secp384r1'
+                ],
+                signatureAlgorithms: [
+                    'ecdsa_secp256r1_sha256',
+                    'rsa_pss_rsae_sha256',
+                    'rsa_pkcs1_sha256',
+                    'ecdsa_secp384r1_sha384',
+                    'rsa_pss_rsae_sha384',
+                    'rsa_pkcs1_sha384',
+                    'rsa_pss_rsae_sha512',
+                    'rsa_pkcs1_sha512'
+                ],
+                supportedVersions: [
+                    `GREASE_${grease2.toString(16)}`,
+                    'TLSv1.3',
+                    'TLSv1.2'
+                ],
+                ecPointFormats: [0x00],
+                alpnProtocols: ['h2', 'http/1.1'],
+                pskKeyExchangeModes: [0x01],
+                compressionMethods: [0x00],
+                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: [
+                    `GREASE_${grease1.toString(16)}`,
+                    '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'
+                ],
+                extensions: [
+                    grease2,
+                    0x0000,
+                    0x0017,
+                    0xff01,
+                    0x000a,
+                    0x000b,
+                    0x0023,
+                    0x0010,
+                    0x0005,
+                    0x000d,
+                    0x0012,
+                    0x0033,
+                    0x002d,
+                    0x002b,
+                    0x001b,
+                    0x0015,
+                    grease3
+                ],
+                supportedGroups: [
+                    `GREASE_${grease4.toString(16)}`,
+                    'X25519Kyber768',
+                    'X25519',
+                    'prime256v1',
+                    'secp384r1'
+                ],
+                signatureAlgorithms: [
+                    'ecdsa_secp256r1_sha256',
+                    'rsa_pss_rsae_sha256',
+                    'rsa_pkcs1_sha256',
+                    'ecdsa_secp384r1_sha384',
+                    'rsa_pss_rsae_sha384',
+                    'rsa_pkcs1_sha384',
+                    'rsa_pss_rsae_sha512',
+                    'rsa_pkcs1_sha512'
+                ],
+                supportedVersions: [
+                    `GREASE_${grease2.toString(16)}`,
+                    'TLSv1.3',
+                    'TLSv1.2'
+                ],
+                ecPointFormats: [0x00],
+                alpnProtocols: ['h2', 'http/1.1'],
+                pskKeyExchangeModes: [0x01],
+                compressionMethods: [0x00],
+                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: [
+                    'TLS_AES_128_GCM_SHA256',
+                    'TLS_CHACHA20_POLY1305_SHA256',
+                    'TLS_AES_256_GCM_SHA384',
+                    'ECDHE-ECDSA-AES128-GCM-SHA256',
+                    'ECDHE-RSA-AES128-GCM-SHA256',
+                    'ECDHE-ECDSA-CHACHA20-POLY1305',
+                    'ECDHE-RSA-CHACHA20-POLY1305',
+                    'ECDHE-ECDSA-AES256-GCM-SHA384',
+                    'ECDHE-RSA-AES256-GCM-SHA384',
+                    'ECDHE-ECDSA-AES256-SHA',
+                    'ECDHE-ECDSA-AES128-SHA',
+                    'ECDHE-RSA-AES128-SHA',
+                    'ECDHE-RSA-AES256-SHA',
+                    'AES128-GCM-SHA256',
+                    'AES256-GCM-SHA384',
+                    'AES128-SHA',
+                    'AES256-SHA'
+                ],
+                extensions: [0x0000, 0x0017, 0xff01, 0x000a, 0x000b, 0x0023, 0x0010, 0x0005, 0x0022, 0x0033, 0x002b, 0x000d, 0x002d, 0x0029, 0x0015],
+                supportedGroups: ['X25519', 'prime256v1', 'secp384r1', 'secp521r1', 'ffdhe2048', 'ffdhe3072'],
+                signatureAlgorithms: [
+                    'ecdsa_secp256r1_sha256',
+                    'ecdsa_secp384r1_sha384',
+                    'ecdsa_secp521r1_sha512',
+                    'rsa_pss_rsae_sha256',
+                    'rsa_pss_rsae_sha384',
+                    'rsa_pss_rsae_sha512',
+                    'rsa_pkcs1_sha256',
+                    'rsa_pkcs1_sha384',
+                    'rsa_pkcs1_sha512',
+                    'ecdsa_sha1',
+                    'rsa_pkcs1_sha1'
+                ],
+                supportedVersions: ['TLSv1.3', 'TLSv1.2'],
+                ecPointFormats: [0x00],
+                alpnProtocols: ['h2', 'http/1.1'],
+                pskKeyExchangeModes: [0x01],
+                compressionMethods: [0x00],
+                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 }
+            },
+            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: [
+                    `GREASE_${grease1.toString(16)}`,
+                    'TLS_AES_128_GCM_SHA256',
+                    'TLS_AES_256_GCM_SHA384',
+                    'TLS_CHACHA20_POLY1305_SHA256',
+                    'ECDHE-ECDSA-AES256-GCM-SHA384',
+                    'ECDHE-ECDSA-AES128-GCM-SHA256',
+                    'ECDHE-ECDSA-CHACHA20-POLY1305',
+                    'ECDHE-RSA-AES256-GCM-SHA384',
+                    'ECDHE-RSA-AES128-GCM-SHA256',
+                    'ECDHE-RSA-CHACHA20-POLY1305',
+                    'ECDHE-ECDSA-AES256-SHA',
+                    'ECDHE-ECDSA-AES128-SHA',
+                    'ECDHE-RSA-AES256-SHA',
+                    'ECDHE-RSA-AES128-SHA',
+                    'AES256-GCM-SHA384',
+                    'AES128-GCM-SHA256',
+                    'AES256-SHA',
+                    'AES128-SHA',
+                    'ECDHE-ECDSA-DES-CBC3-SHA',
+                    'ECDHE-RSA-DES-CBC3-SHA',
+                    'DES-CBC3-SHA'
+                ],
+                extensions: [
+                    grease2,
+                    0x0000,
+                    0x0017,
+                    0xff01,
+                    0x000a,
+                    0x000b,
+                    0x0010,
+                    0x0005,
+                    0x000d,
+                    0x0012,
+                    0x0033,
+                    0x002d,
+                    0x002b,
+                    0x0015
+                ],
+                supportedGroups: ['X25519', 'prime256v1', 'secp384r1', 'secp521r1'],
+                signatureAlgorithms: [
+                    'ecdsa_secp256r1_sha256',
+                    'rsa_pss_rsae_sha256',
+                    'rsa_pkcs1_sha256',
+                    'ecdsa_secp384r1_sha384',
+                    'ecdsa_sha1',
+                    'rsa_pss_rsae_sha384',
+                    'rsa_pss_rsae_sha384',
+                    'rsa_pkcs1_sha384',
+                    'rsa_pss_rsae_sha512',
+                    'rsa_pkcs1_sha512',
+                    'rsa_pkcs1_sha1'
+                ],
+                supportedVersions: ['TLSv1.3', 'TLSv1.2', 'TLSv1.1', 'TLSv1.0'],
+                ecPointFormats: [0x00],
+                alpnProtocols: ['h2', 'http/1.1'],
+                pskKeyExchangeModes: [0x01],
+                compressionMethods: [0x00],
+                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']
+            },
+            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();
+    }
+}
+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, expires: options.expires, path: options.path || '/', domain });
+    }
+    getCookies(domain, path = '/') {
+        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 (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('=');
+                if (key.toLowerCase() === 'expires')
+                    options.expires = new Date(val);
+                else if (key.toLowerCase() === 'path')
+                    options.path = 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.profile = profile;
+        this.timing = { socket: 0, lookup: 0, connect: 0, secureConnect: 0, response: 0, end: 0, total: 0 };
+    }
+    convertCipherSuite(suite) {
+        const cipherMap = {
+            'TLS_AES_128_GCM_SHA256': 'TLS_AES_128_GCM_SHA256',
+            'TLS_AES_256_GCM_SHA384': 'TLS_AES_256_GCM_SHA384',
+            'TLS_CHACHA20_POLY1305_SHA256': 'TLS_CHACHA20_POLY1305_SHA256',
+            'ECDHE-ECDSA-AES128-GCM-SHA256': 'ECDHE-ECDSA-AES128-GCM-SHA256',
+            'ECDHE-RSA-AES128-GCM-SHA256': 'ECDHE-RSA-AES128-GCM-SHA256',
+            'ECDHE-ECDSA-AES256-GCM-SHA384': 'ECDHE-ECDSA-AES256-GCM-SHA384',
+            'ECDHE-RSA-AES256-GCM-SHA384': 'ECDHE-RSA-AES256-GCM-SHA384',
+            'ECDHE-ECDSA-CHACHA20-POLY1305': 'ECDHE-ECDSA-CHACHA20-POLY1305',
+            'ECDHE-RSA-CHACHA20-POLY1305': 'ECDHE-RSA-CHACHA20-POLY1305',
+            'ECDHE-RSA-AES128-SHA': 'ECDHE-RSA-AES128-SHA',
+            'ECDHE-RSA-AES256-SHA': 'ECDHE-RSA-AES256-SHA',
+            'AES128-GCM-SHA256': 'AES128-GCM-SHA256',
+            'AES256-GCM-SHA384': 'AES256-GCM-SHA384',
+            'AES128-SHA': 'AES128-SHA',
+            'AES256-SHA': 'AES256-SHA'
+        };
+        if (suite.startsWith('GREASE_'))
+            return '';
+        return cipherMap[suite] || suite;
+    }
+    convertSupportedGroup(group) {
+        const groupMap = {
+            'X25519Kyber768': 'X25519',
+            'X25519': 'X25519',
+            'prime256v1': 'prime256v1',
+            'secp384r1': 'secp384r1'
+        };
+        if (group.startsWith('GREASE_'))
+            return '';
+        return groupMap[group] || group;
+    }
+    async connect(hostname, port) {
+        this.hostname = hostname;
+        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.setKeepAlive(true, 60000);
+            this.socket.setNoDelay(true);
+            this.timing.socket = Date.now() - this.startTime;
+            this.socket.on('lookup', () => {
+                this.timing.lookup = Date.now() - this.startTime;
+            });
+            this.socket.connect(port, hostname, () => {
+                this.timing.connect = Date.now() - this.startTime;
+                const ciphers = this.profile.tls.cipherSuites
+                    .map(suite => this.convertCipherSuite(suite))
+                    .filter(suite => suite !== '')
+                    .join(':');
+                const curves = this.profile.tls.supportedGroups
+                    .map(group => this.convertSupportedGroup(group))
+                    .filter(group => group !== '')
+                    .join(':');
+                const tlsOptions = {
+                    socket: this.socket,
+                    servername: hostname,
+                    ALPNProtocols: this.profile.tls.alpnProtocols,
+                    ciphers: ciphers,
+                    minVersion: 'TLSv1.2',
+                    maxVersion: 'TLSv1.3',
+                    ecdhCurve: curves,
+                    sigalgs: this.profile.tls.signatureAlgorithms.join(':'),
+                    rejectUnauthorized: false,
+                    requestCert: false,
+                    honorCipherOrder: true,
+                    sessionTimeout: 300
+                };
+                this.tlsSocket = tls.connect(tlsOptions);
+                this.tlsSocket.on('secureConnect', () => {
+                    clearTimeout(timeout);
+                    this.timing.secureConnect = Date.now() - 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.removeAllListeners();
+            this.tlsSocket.destroy();
+            this.tlsSocket = null;
+        }
+        if (this.socket && !this.socket.destroyed) {
+            this.socket.removeAllListeners();
+            this.socket.destroy();
+            this.socket = null;
+        }
+    }
+    isConnected() {
+        return this.tlsSocket !== null && !this.tlsSocket.destroyed;
+    }
+    getSocket() {
+        return this.tlsSocket;
+    }
+    getHostname() {
+        return this.hostname;
+    }
+}
+class HTTP2ClientManager {
+    constructor(tlsSocket, profile, hostname) {
+        this.client = null;
+        this.tlsSocket = tlsSocket;
+        this.profile = profile;
+        this.hostname = hostname;
+    }
+    async createSession() {
+        return new Promise((resolve, reject) => {
+            const settingsMap = {};
+            this.profile.http2.settingsOrder.forEach(settingId => {
+                switch (settingId) {
+                    case 1:
+                        settingsMap.headerTableSize = this.profile.http2.headerTableSize;
+                        break;
+                    case 2:
+                        settingsMap.enablePush = this.profile.http2.enablePush === 1;
+                        break;
+                    case 3:
+                        if (this.profile.http2.maxConcurrentStreams !== undefined) {
+                            settingsMap.maxConcurrentStreams = this.profile.http2.maxConcurrentStreams;
+                        }
+                        break;
+                    case 4:
+                        settingsMap.initialWindowSize = this.profile.http2.initialWindowSize;
+                        break;
+                    case 5:
+                        if (this.profile.http2.maxFrameSize !== undefined) {
+                            settingsMap.maxFrameSize = this.profile.http2.maxFrameSize;
+                        }
+                        break;
+                    case 6:
+                        if (this.profile.http2.maxHeaderListSize !== undefined) {
+                            settingsMap.maxHeaderListSize = this.profile.http2.maxHeaderListSize;
+                        }
+                        break;
+                }
+            });
+            const settings = {
+                createConnection: () => this.tlsSocket,
+                settings: settingsMap
+            };
+            this.client = http2.connect(`https://${this.hostname}`, settings);
+            this.client.on('connect', () => {
+                resolve(this.client);
+            });
+            this.client.on('error', reject);
+        });
+    }
+    request(path, headers) {
+        if (!this.client)
+            throw new Error('HTTP2 session not established');
+        const orderedHeaders = {};
+        this.profile.http2.pseudoHeaderOrder.forEach(pseudo => {
+            if (headers[pseudo]) {
+                orderedHeaders[pseudo] = headers[pseudo];
+            }
+        });
+        if (this.profile.http2.headerOrder) {
+            this.profile.http2.headerOrder.forEach(headerName => {
+                if (headers[headerName] && !headerName.startsWith(':')) {
+                    orderedHeaders[headerName] = headers[headerName];
+                }
+            });
+            Object.keys(headers).forEach(key => {
+                if (!key.startsWith(':') && !orderedHeaders[key]) {
+                    orderedHeaders[key] = headers[key];
+                }
+            });
+        }
+        else {
+            Object.assign(orderedHeaders, headers);
+        }
+        const requestOptions = { ...orderedHeaders };
+        if (this.profile.http2.priorityFrames && this.profile.http2.priorityFrames.length > 0) {
+            const priority = this.profile.http2.priorityFrames[0];
+            if (priority.weight)
+                requestOptions.weight = priority.weight;
+            if (priority.exclusive !== undefined)
+                requestOptions.exclusive = priority.exclusive;
+            if (priority.dependency !== undefined && priority.dependency !== 0)
+                requestOptions.parent = priority.dependency;
+        }
+        const stream = this.client.request(requestOptions);
+        if (this.profile.http2.headerPriority) {
+            try {
+                stream.priority({
+                    parent: this.profile.http2.headerPriority.streamDep,
+                    weight: this.profile.http2.headerPriority.weight,
+                    exclusive: this.profile.http2.headerPriority.exclusive
+                });
+            }
+            catch (e) { }
+        }
+        return stream;
+    }
+    getClient() {
+        return this.client;
+    }
+    isConnected() {
+        return this.client !== null && !this.client.destroyed;
+    }
+    destroy() {
+        if (this.client && !this.client.destroyed) {
+            this.client.close();
+            this.client = null;
+        }
+    }
+}
+class AdvancedTLSClient {
+    constructor(profileName) {
+        this.sessionCache = new Map();
+        this.cookieJar = new CookieJar();
+        this.maxCachedSessions = 10;
+        this.sessionTimeout = 300000;
+        this.cleanupInterval = null;
+        this.profile = profileName ? ProfileRegistry.get(profileName) : ProfileRegistry.latest;
+        this.startSessionCleanup();
+    }
+    startSessionCleanup() {
+        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);
+        if (this.cleanupInterval.unref) {
+            this.cleanupInterval.unref();
+        }
+    }
+    async request(url, options = {}) {
+        const maxRedirects = options.maxRedirects ?? 5;
+        const followRedirects = options.followRedirects !== false;
+        let redirectCount = 0;
+        let currentUrl = url;
+        let response;
+        while (true) {
+            response = await this.performRequest(currentUrl, options);
+            if (followRedirects && [301, 302, 303, 307, 308].includes(response.statusCode)) {
+                if (redirectCount >= maxRedirects) {
+                    throw new Error(`Too many redirects (max: ${maxRedirects})`);
+                }
+                const locationHeader = response.headers['location'];
+                if (!locationHeader)
+                    break;
+                const location = Array.isArray(locationHeader) ? locationHeader[0] : locationHeader;
+                currentUrl = new URL(location, currentUrl).toString();
+                redirectCount++;
+                if ([301, 302, 303].includes(response.statusCode)) {
+                    options.method = 'GET';
+                    delete options.body;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        return response;
+    }
+    async performRequest(url, options = {}) {
+        const parsedUrl = new URL(url);
+        const hostname = parsedUrl.hostname;
+        const port = parsedUrl.port ? parseInt(parsedUrl.port) : 443;
+        const path = parsedUrl.pathname + parsedUrl.search;
+        const cacheKey = `${hostname}:${port}`;
+        let session = this.sessionCache.get(cacheKey);
+        if (!session || !this.isSessionAlive(session)) {
+            if (session) {
+                session.http2Manager.destroy();
+                session.tlsManager.destroy();
+                this.sessionCache.delete(cacheKey);
+            }
+            const tlsManager = new TLSSocketManager(this.profile);
+            const tlsSocket = await tlsManager.connect(hostname, port);
+            const http2Manager = new HTTP2ClientManager(tlsSocket, this.profile, hostname);
+            await http2Manager.createSession();
+            session = { tlsManager, http2Manager, lastUsed: Date.now() };
+            if (this.sessionCache.size >= this.maxCachedSessions) {
+                const oldestKey = Array.from(this.sessionCache.entries())
+                    .sort((a, b) => a[1].lastUsed - b[1].lastUsed)[0][0];
+                const oldest = this.sessionCache.get(oldestKey);
+                oldest.http2Manager.destroy();
+                oldest.tlsManager.destroy();
+                this.sessionCache.delete(oldestKey);
+            }
+            this.sessionCache.set(cacheKey, session);
+        }
+        session.lastUsed = Date.now();
+        const headers = this.buildHeaders(hostname, path, options);
+        const stream = session.http2Manager.request(path, headers);
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let responseHeaders = {};
+            let statusCode = 0;
+            stream.on('response', (headers) => {
+                responseHeaders = headers;
+                statusCode = Number(headers[':status']);
+                const setCookieHeaders = headers['set-cookie'];
+                if (setCookieHeaders) {
+                    const cookieArray = Array.isArray(setCookieHeaders) ? setCookieHeaders : [setCookieHeaders];
+                    this.cookieJar.parseSetCookie(hostname, cookieArray);
+                }
+            });
+            stream.on('data', (chunk) => chunks.push(chunk));
+            stream.on('end', async () => {
+                stream.removeAllListeners();
+                let body = Buffer.concat(chunks);
+                const timing = session.tlsManager.getTiming();
+                timing.end = Date.now();
+                timing.total = timing.end - (Date.now() - timing.end);
+                if (options.decompress !== false) {
+                    const encoding = responseHeaders['content-encoding'];
+                    if (encoding === 'gzip')
+                        body = await gunzip(body);
+                    else if (encoding === 'br')
+                        body = await brotliDecompress(body);
+                }
+                let text;
+                let json;
+                try {
+                    text = body.toString('utf-8');
+                    if ((responseHeaders['content-type'] || '').includes('application/json')) {
+                        json = JSON.parse(text);
+                    }
+                }
+                catch (e) { }
+                const ja3 = this.generateJA3();
+                resolve({
+                    statusCode,
+                    headers: responseHeaders,
+                    body,
+                    text,
+                    json,
+                    timing,
+                    fingerprints: {
+                        ja3,
+                        ja3Hash: crypto.createHash('md5').update(ja3).digest('hex'),
+                        akamai: `1:${this.profile.http2.headerTableSize};2:${this.profile.http2.enablePush};4:${this.profile.http2.initialWindowSize};6:${this.profile.http2.maxHeaderListSize ?? ''}|00|0|m,a,s,p`
+                    }
+                });
+            });
+            stream.on('error', (err) => {
+                stream.removeAllListeners();
+                reject(err);
+            });
+            if (options.body) {
+                const bodyBuffer = Buffer.isBuffer(options.body) ? options.body : Buffer.from(options.body);
+                stream.write(bodyBuffer);
+            }
+            stream.end();
+        });
+    }
+    generateJA3() {
+        const version = '771';
+        const ciphers = this.profile.tls.cipherSuites
+            .filter(c => !c.startsWith('GREASE_'))
+            .map(c => {
+            const map = {
+                'TLS_AES_128_GCM_SHA256': '4865',
+                'TLS_AES_256_GCM_SHA384': '4866',
+                'TLS_CHACHA20_POLY1305_SHA256': '4867',
+                'ECDHE-ECDSA-AES128-GCM-SHA256': '49195',
+                'ECDHE-RSA-AES128-GCM-SHA256': '49199',
+                'ECDHE-ECDSA-AES256-GCM-SHA384': '49196',
+                'ECDHE-RSA-AES256-GCM-SHA384': '49200',
+                'ECDHE-ECDSA-CHACHA20-POLY1305': '52393',
+                'ECDHE-RSA-CHACHA20-POLY1305': '52392',
+                'ECDHE-RSA-AES128-SHA': '49171',
+                'ECDHE-RSA-AES256-SHA': '49172',
+                'AES128-GCM-SHA256': '156',
+                'AES256-GCM-SHA384': '157',
+                'AES128-SHA': '47',
+                'AES256-SHA': '53'
+            };
+            return map[c] || '0';
+        }).join('-');
+        const extensions = this.profile.tls.extensions
+            .filter(e => typeof e === 'number')
+            .join('-');
+        const groups = this.profile.tls.supportedGroups
+            .filter(g => !g.startsWith('GREASE_'))
+            .map(g => {
+            const map = {
+                'X25519': '29',
+                'prime256v1': '23',
+                'secp384r1': '24',
+                'secp521r1': '25',
+                'X25519Kyber768': '25497'
+            };
+            return map[g] || '0';
+        }).join('-');
+        const ecFormats = this.profile.tls.ecPointFormats.join('-');
+        return `${version},${ciphers},${extensions},${groups},${ecFormats}`;
+    }
+    buildHeaders(hostname, path, options) {
+        const method = (options.method || 'GET').toUpperCase();
+        const headers = {
+            ':method': method,
+            ':authority': hostname,
+            ':scheme': 'https',
+            ':path': path
+        };
+        const defaultHeaders = {
+            'sec-ch-ua': this.profile.secChUa,
+            'sec-ch-ua-mobile': this.profile.secChUaMobile,
+            'sec-ch-ua-platform': this.profile.secChUaPlatform,
+            'upgrade-insecure-requests': this.profile.upgradeInsecureRequests || '1',
+            'user-agent': this.profile.userAgent,
+            'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+            'sec-fetch-site': this.profile.secFetchSite,
+            'sec-fetch-mode': this.profile.secFetchMode,
+            'sec-fetch-dest': this.profile.secFetchDest,
+            'accept-encoding': 'gzip, deflate, br, zstd',
+            'accept-language': this.profile.acceptLanguage || 'en-US,en;q=0.9'
+        };
+        if (this.profile.priority) {
+            defaultHeaders['priority'] = this.profile.priority;
+        }
+        if (this.profile.http2.headerOrder) {
+            this.profile.http2.headerOrder.forEach(headerName => {
+                if (defaultHeaders[headerName]) {
+                    headers[headerName] = defaultHeaders[headerName];
+                }
+            });
+        }
+        Object.keys(defaultHeaders).forEach(key => {
+            if (!headers[key]) {
+                headers[key] = defaultHeaders[key];
+            }
+        });
+        const cookies = options.cookies
+            ? Object.entries(options.cookies).map(([k, v]) => `${k}=${v}`).join('; ')
+            : this.cookieJar.getCookies(hostname, path);
+        if (cookies)
+            headers['cookie'] = cookies;
+        if (options.headers)
+            Object.assign(headers, options.headers);
+        if (method === 'POST' || method === 'PUT' || method === 'PATCH') {
+            if (!headers['content-type'])
+                headers['content-type'] = 'application/x-www-form-urlencoded';
+            if (options.body) {
+                const bodyLength = Buffer.isBuffer(options.body) ? options.body.length : Buffer.byteLength(options.body);
+                headers['content-length'] = bodyLength.toString();
+            }
+        }
+        return headers;
+    }
+    isSessionAlive(session) {
+        try {
+            return session.http2Manager.isConnected();
+        }
+        catch {
+            return false;
+        }
+    }
+    getCookies(domain) {
+        return this.cookieJar.getCookies(domain);
+    }
+    setCookie(domain, name, value, options) {
+        this.cookieJar.setCookie(domain, name, value, options);
+    }
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.sessionCache.forEach(session => {
+            try {
+                session.http2Manager.destroy();
+                session.tlsManager.destroy();
+            }
+            catch (e) { }
+        });
+        this.sessionCache.clear();
+    }
+}
+exports.AdvancedTLSClient = AdvancedTLSClient;