recker 1.0.26 → 1.0.27

package/dist/browser/utils/streaming.js

@@ -0,0 +1,84 @@
+import { Readable, PassThrough } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+export function webToNodeStream(webStream) {
+    const reader = webStream.getReader();
+    return new Readable({
+        async read() {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    this.push(null);
+                }
+                else {
+                    this.push(value);
+                }
+            }
+            catch (error) {
+                this.destroy(error);
+            }
+        },
+        destroy(error, callback) {
+            reader.cancel().finally(() => callback(error));
+        }
+    });
+}
+export function nodeToWebStream(nodeStream) {
+    return new ReadableStream({
+        start(controller) {
+            nodeStream.on('data', (chunk) => {
+                controller.enqueue(new Uint8Array(chunk));
+            });
+            nodeStream.on('end', () => {
+                controller.close();
+            });
+            nodeStream.on('error', (err) => {
+                controller.error(err);
+            });
+        },
+        cancel() {
+            nodeStream.destroy();
+        }
+    });
+}
+export function trackStreamProgress(stream, options = {}) {
+    const { onProgress, total } = options;
+    let loaded = 0;
+    const startTime = Date.now();
+    let lastUpdate = startTime;
+    const passThrough = new PassThrough();
+    stream.on('data', (chunk) => {
+        loaded += chunk.length;
+        const now = Date.now();
+        if (onProgress && now - lastUpdate > 100) {
+            const percent = total ? (loaded / total) * 100 : undefined;
+            onProgress({ loaded, total, percent });
+            lastUpdate = now;
+        }
+    });
+    stream.on('end', () => {
+        if (onProgress) {
+            const percent = total ? 100 : undefined;
+            onProgress({ loaded, total, percent });
+        }
+    });
+    stream.pipe(passThrough);
+    return passThrough;
+}
+export async function pipeStream(source, destination, options = {}) {
+    const tracked = options.onProgress
+        ? trackStreamProgress(source, options)
+        : source;
+    await pipeline(tracked, destination);
+}
+export function createUploadStream(source) {
+    const passThrough = new PassThrough();
+    source.pipe(passThrough);
+    source.on('error', (err) => passThrough.destroy(err));
+    return {
+        stream: nodeToWebStream(passThrough),
+        promise: new Promise((resolve, reject) => {
+            passThrough.on('finish', resolve);
+            passThrough.on('error', reject);
+        })
+    };
+}

package/dist/browser/utils/try-fn.d.ts

@@ -0,0 +1,3 @@
+export declare function tryFn<T>(fnOrPromise: (() => Promise<T>) | Promise<T> | (() => T) | T): Promise<[boolean, Error | null, T | undefined]> | [boolean, Error | null, T | undefined];
+export declare function tryFnSync<T>(fn: () => T): [boolean, Error | null, T | undefined];
+export default tryFn;

package/dist/browser/utils/try-fn.js

@@ -0,0 +1,59 @@
+import { ReckerError } from '../core/errors.js';
+export function tryFn(fnOrPromise) {
+    if (fnOrPromise == null) {
+        const err = new ReckerError('fnOrPromise cannot be null or undefined', undefined, undefined, ['Pass a valid function or promise to tryFn.', 'Check the caller to ensure an undefined value is not passed.']);
+        err.stack = new Error().stack;
+        return [false, err, undefined];
+    }
+    if (typeof fnOrPromise === 'function') {
+        try {
+            const result = fnOrPromise();
+            if (result == null) {
+                return [true, null, result];
+            }
+            if (typeof result.then === 'function') {
+                return result
+                    .then((data) => [true, null, data])
+                    .catch((error) => {
+                    if (error instanceof Error &&
+                        Object.isExtensible(error)) {
+                        const desc = Object.getOwnPropertyDescriptor(error, 'stack');
+                        if (!desc || (desc.writable && desc.configurable)) {
+                            try {
+                            }
+                            catch (_) { }
+                        }
+                    }
+                    return [false, wrapUnknownError(error, 'Function threw an error'), undefined];
+                });
+            }
+            return [true, null, result];
+        }
+        catch (error) {
+            return [false, wrapUnknownError(error, 'Function threw an error'), undefined];
+        }
+    }
+    if (typeof fnOrPromise.then === 'function') {
+        return Promise.resolve(fnOrPromise)
+            .then((data) => [true, null, data])
+            .catch((error) => {
+            return [false, wrapUnknownError(error, 'Promise rejected'), undefined];
+        });
+    }
+    return [true, null, fnOrPromise];
+}
+export function tryFnSync(fn) {
+    try {
+        const result = fn();
+        return [true, null, result];
+    }
+    catch (err) {
+        return [false, wrapUnknownError(err, 'Synchronous function threw an error'), undefined];
+    }
+}
+export default tryFn;
+function wrapUnknownError(err, context) {
+    if (err instanceof Error)
+        return err;
+    return new ReckerError(`${context}: ${String(err)}`, undefined, undefined, ['Inspect the original value being thrown.', 'Ensure errors are instances of Error or ReckerError.', 'Add contextual information when throwing custom errors.']);
+}

package/dist/browser/utils/user-agent.d.ts

@@ -0,0 +1,44 @@
+export declare function getDefaultUserAgent(): string;
+export declare const USER_AGENT_PRESETS: {
+    readonly chrome_windows: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+    readonly chrome_mac: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+    readonly chrome_linux: "Mozilla/5.0 (X11; Linux x8664) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+    readonly firefox_windows: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0";
+    readonly firefox_mac: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0";
+    readonly firefox_linux: "Mozilla/5.0 (X11; Linux x8664; rv:121.0) Gecko/20100101 Firefox/121.0";
+    readonly safari_mac: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15";
+    readonly edge_windows: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0";
+    readonly edge_mac: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0";
+    readonly opera_windows: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 OPR/105.0.0.0";
+    readonly opera_mac: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 OPR/105.0.0.0";
+    readonly safari_iphone: "Mozilla/5.0 (iPhone; CPU iPhone OS 170 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1";
+    readonly safari_ipad: "Mozilla/5.0 (iPad; CPU OS 170 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1";
+    readonly chrome_ios: "Mozilla/5.0 (iPhone; CPU iPhone OS 170 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/120.0.6099.119 Mobile/15E148 Safari/604.1";
+    readonly chrome_android: "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.144 Mobile Safari/537.36";
+    readonly chrome_android_tablet: "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.144 Safari/537.36";
+    readonly firefox_android: "Mozilla/5.0 (Android 14; Mobile; rv:121.0) Gecko/121.0 Firefox/121.0";
+    readonly samsung_browser: "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/23.0 Chrome/115.0.0.0 Mobile Safari/537.36";
+    readonly googlebot: "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
+    readonly googlebot_mobile: "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.144 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
+    readonly recker: string;
+};
+export type UserAgentPreset = keyof typeof USER_AGENT_PRESETS;
+export declare function getUserAgent(preset: UserAgentPreset): string;
+export declare const USER_AGENT_CATEGORIES: {
+    readonly desktop: {
+        readonly chrome: readonly ["chrome_windows", "chrome_mac", "chrome_linux"];
+        readonly firefox: readonly ["firefox_windows", "firefox_mac", "firefox_linux"];
+        readonly safari: readonly ["safari_mac"];
+        readonly edge: readonly ["edge_windows", "edge_mac"];
+        readonly opera: readonly ["opera_windows", "opera_mac"];
+    };
+    readonly mobile: {
+        readonly ios: readonly ["safari_iphone", "safari_ipad", "chrome_ios"];
+        readonly android: readonly ["chrome_android", "chrome_android_tablet", "firefox_android", "samsung_browser"];
+    };
+    readonly bot: readonly ["googlebot", "googlebot_mobile"];
+    readonly default: readonly ["recker"];
+};
+export declare function getRandomUserAgent(category: string): string;
+export declare function detectDeviceType(userAgent: string): 'desktop' | 'mobile' | 'tablet' | 'bot' | 'unknown';
+export declare function isMobile(userAgent: string): boolean;

package/dist/browser/utils/user-agent.js

@@ -0,0 +1,100 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+let RECKER_VERSION = '1.0.0';
+try {
+    const pkgPath = join(process.cwd(), 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    if (pkg.name === 'recker' && pkg.version) {
+        RECKER_VERSION = pkg.version;
+    }
+}
+catch {
+}
+export function getDefaultUserAgent() {
+    return `recker/${RECKER_VERSION}`;
+}
+export const USER_AGENT_PRESETS = {
+    chrome_windows: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    chrome_mac: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    chrome_linux: 'Mozilla/5.0 (X11; Linux x8664) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    firefox_windows: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+    firefox_mac: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0',
+    firefox_linux: 'Mozilla/5.0 (X11; Linux x8664; rv:121.0) Gecko/20100101 Firefox/121.0',
+    safari_mac: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15',
+    edge_windows: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0',
+    edge_mac: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0',
+    opera_windows: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 OPR/105.0.0.0',
+    opera_mac: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 OPR/105.0.0.0',
+    safari_iphone: 'Mozilla/5.0 (iPhone; CPU iPhone OS 170 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1',
+    safari_ipad: 'Mozilla/5.0 (iPad; CPU OS 170 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1',
+    chrome_ios: 'Mozilla/5.0 (iPhone; CPU iPhone OS 170 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/120.0.6099.119 Mobile/15E148 Safari/604.1',
+    chrome_android: 'Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.144 Mobile Safari/537.36',
+    chrome_android_tablet: 'Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.144 Safari/537.36',
+    firefox_android: 'Mozilla/5.0 (Android 14; Mobile; rv:121.0) Gecko/121.0 Firefox/121.0',
+    samsung_browser: 'Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/23.0 Chrome/115.0.0.0 Mobile Safari/537.36',
+    googlebot: 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)',
+    googlebot_mobile: 'Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.144 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)',
+    recker: getDefaultUserAgent(),
+};
+export function getUserAgent(preset) {
+    return USER_AGENT_PRESETS[preset];
+}
+export const USER_AGENT_CATEGORIES = {
+    desktop: {
+        chrome: ['chrome_windows', 'chrome_mac', 'chrome_linux'],
+        firefox: ['firefox_windows', 'firefox_mac', 'firefox_linux'],
+        safari: ['safari_mac'],
+        edge: ['edge_windows', 'edge_mac'],
+        opera: ['opera_windows', 'opera_mac'],
+    },
+    mobile: {
+        ios: ['safari_iphone', 'safari_ipad', 'chrome_ios'],
+        android: ['chrome_android', 'chrome_android_tablet', 'firefox_android', 'samsung_browser'],
+    },
+    bot: ['googlebot', 'googlebot_mobile'],
+    default: ['recker'],
+};
+export function getRandomUserAgent(category) {
+    const parts = category.split('.');
+    let presets = [];
+    if (parts.length === 1) {
+        const cat = USER_AGENT_CATEGORIES[parts[0]];
+        if (Array.isArray(cat)) {
+            presets = cat;
+        }
+        else if (typeof cat === 'object') {
+            presets = Object.values(cat).flat();
+        }
+    }
+    else if (parts.length === 2) {
+        const cat = USER_AGENT_CATEGORIES[parts[0]];
+        if (typeof cat === 'object' && parts[1] in cat) {
+            presets = cat[parts[1]];
+        }
+    }
+    if (presets.length === 0) {
+        return getDefaultUserAgent();
+    }
+    const randomIndex = Math.floor(Math.random() * presets.length);
+    return getUserAgent(presets[randomIndex]);
+}
+export function detectDeviceType(userAgent) {
+    const ua = userAgent.toLowerCase();
+    if (ua.includes('bot') || ua.includes('crawler') || ua.includes('spider')) {
+        return 'bot';
+    }
+    if (ua.includes('ipad') || (ua.includes('tablet')) || (ua.includes('android') && !ua.includes('mobile'))) {
+        return 'tablet';
+    }
+    if (ua.includes('mobile') || ua.includes('iphone')) {
+        return 'mobile';
+    }
+    if (ua.includes('windows') || ua.includes('macintosh') || (ua.includes('linux') && !ua.includes('android'))) {
+        return 'desktop';
+    }
+    return 'unknown';
+}
+export function isMobile(userAgent) {
+    const type = detectDeviceType(userAgent);
+    return type === 'mobile' || type === 'tablet';
+}

package/dist/browser/utils/whois.d.ts

@@ -0,0 +1,32 @@
+export interface WhoisOptions {
+    server?: string;
+    port?: number;
+    timeout?: number;
+    follow?: boolean;
+}
+export interface WhoisResult {
+    raw: string;
+    query: string;
+    server: string;
+    data: Record<string, string | string[]>;
+}
+export declare function whois(query: string, options?: WhoisOptions): Promise<WhoisResult>;
+export declare function isDomainAvailable(domain: string, options?: WhoisOptions): Promise<boolean>;
+export interface WhoisClientOptions {
+    server?: string;
+    port?: number;
+    timeout?: number;
+    follow?: boolean;
+    debug?: boolean;
+}
+export declare class WhoisClient {
+    private options;
+    constructor(options?: WhoisClientOptions);
+    private log;
+    lookup(query: string, options?: WhoisOptions): Promise<WhoisResult>;
+    isAvailable(domain: string): Promise<boolean>;
+    getRegistrar(domain: string): Promise<string | null>;
+    getExpiration(domain: string): Promise<Date | null>;
+    getNameServers(domain: string): Promise<string[]>;
+}
+export declare function createWhois(options?: WhoisClientOptions): WhoisClient;

package/dist/browser/utils/whois.js

@@ -0,0 +1,246 @@
+import { createConnection } from 'net';
+import { ReckerError } from '../core/errors.js';
+const DEFAULT_SERVERS = {
+    'com': 'whois.verisign-grs.com',
+    'net': 'whois.verisign-grs.com',
+    'org': 'whois.pir.org',
+    'info': 'whois.afilias.net',
+    'biz': 'whois.biz',
+    'us': 'whois.nic.us',
+    'uk': 'whois.nic.uk',
+    'ca': 'whois.cira.ca',
+    'de': 'whois.denic.de',
+    'fr': 'whois.afnic.fr',
+    'au': 'whois.aunic.net',
+    'jp': 'whois.jprs.jp',
+    'cn': 'whois.cnnic.cn',
+    'ru': 'whois.tcinet.ru',
+    'br': 'whois.registro.br',
+    'eu': 'whois.eu',
+    'io': 'whois.nic.io',
+    'co': 'whois.nic.co',
+    'me': 'whois.nic.me',
+    'tv': 'whois.nic.tv',
+    'cc': 'whois.nic.cc',
+    'ws': 'whois.website.ws',
+    'mobi': 'whois.dotmobiregistry.net',
+    'asia': 'whois.nic.asia',
+    'tel': 'whois.nic.tel',
+    'pro': 'whois.registrypro.pro',
+    'aero': 'whois.aero',
+    'cat': 'whois.cat',
+    'coop': 'whois.nic.coop',
+    'jobs': 'whois.nic.jobs',
+    'museum': 'whois.museum',
+    'travel': 'whois.nic.travel',
+    'xxx': 'whois.nic.xxx',
+    'app': 'whois.nic.google',
+    'dev': 'whois.nic.google',
+    'ai': 'whois.nic.ai',
+};
+function extractTLD(domain) {
+    const parts = domain.toLowerCase().split('.');
+    return parts[parts.length - 1];
+}
+function getWhoisServer(query, customServer) {
+    if (customServer) {
+        return customServer;
+    }
+    const ipv4Pattern = /^(\d{1,3}\.){3}\d{1,3}$/;
+    const ipv6Pattern = /^([0-9a-fA-F]{0,4}:){2,7}[0-9a-fA-F]{0,4}$/;
+    if (ipv4Pattern.test(query) || ipv6Pattern.test(query)) {
+        return 'whois.arin.net';
+    }
+    const tld = extractTLD(query);
+    return DEFAULT_SERVERS[tld] || 'whois.iana.org';
+}
+function parseWhoisData(raw) {
+    const data = {};
+    const lines = raw.split('\n');
+    for (const line of lines) {
+        if (line.startsWith('%') || line.startsWith('#') || !line.trim()) {
+            continue;
+        }
+        const colonIndex = line.indexOf(':');
+        if (colonIndex === -1) {
+            continue;
+        }
+        const key = line.substring(0, colonIndex).trim().toLowerCase();
+        const value = line.substring(colonIndex + 1).trim();
+        if (!key || !value) {
+            continue;
+        }
+        if (data[key]) {
+            if (Array.isArray(data[key])) {
+                data[key].push(value);
+            }
+            else {
+                data[key] = [data[key], value];
+            }
+        }
+        else {
+            data[key] = value;
+        }
+    }
+    return data;
+}
+function extractReferralServer(raw) {
+    const lines = raw.toLowerCase().split('\n');
+    for (const line of lines) {
+        if (line.includes('whois server:') || line.includes('referral url:')) {
+            const match = line.match(/whois\.[\w.-]+/);
+            if (match) {
+                return match[0];
+            }
+        }
+    }
+    return null;
+}
+async function queryWhoisServer(server, query, port, timeout) {
+    return new Promise((resolve, reject) => {
+        let response = '';
+        let socket = null;
+        const timeoutId = setTimeout(() => {
+            socket?.destroy();
+            reject(new ReckerError(`WHOIS query timed out after ${timeout}ms`, undefined, undefined, [
+                'Increase the WHOIS timeout for slower registries.',
+                'Check network connectivity to the WHOIS server.',
+                'Retry the query; some registries respond slowly under load.'
+            ]));
+        }, timeout);
+        socket = createConnection({ host: server, port }, () => {
+            socket.write(query + '\r\n');
+        });
+        socket.on('data', (chunk) => {
+            response += chunk.toString('utf-8');
+        });
+        socket.on('end', () => {
+            clearTimeout(timeoutId);
+            resolve(response);
+        });
+        socket.on('error', (error) => {
+            clearTimeout(timeoutId);
+            const errorDetail = error.message || error.code || 'Connection failed';
+            const err = new ReckerError(`WHOIS query failed: ${errorDetail}`, undefined, undefined, [
+                'Verify the WHOIS server is reachable and correct.',
+                'Check network/firewall settings blocking WHOIS port 43.',
+                'Retry the query; transient network issues can occur.'
+            ]);
+            err.code = error.code;
+            reject(err);
+        });
+        socket.on('close', (hadError) => {
+            clearTimeout(timeoutId);
+            if (hadError && !response) {
+                const err = new ReckerError('WHOIS connection closed unexpectedly', undefined, undefined, [
+                    'The WHOIS server may be rate limiting requests.',
+                    'Try again in a few seconds.',
+                    'Some TLDs have unreliable WHOIS servers.'
+                ]);
+                err.code = 'ECONNRESET';
+                reject(err);
+            }
+        });
+    });
+}
+export async function whois(query, options = {}) {
+    const { server: customServer, port = 43, timeout = 10000, follow = true, } = options;
+    const cleanQuery = query.trim().toLowerCase();
+    let server = getWhoisServer(cleanQuery, customServer);
+    let raw = await queryWhoisServer(server, cleanQuery, port, timeout);
+    if (follow && !customServer) {
+        const referralServer = extractReferralServer(raw);
+        if (referralServer && referralServer !== server) {
+            server = referralServer;
+            raw = await queryWhoisServer(server, cleanQuery, port, timeout);
+        }
+    }
+    const data = parseWhoisData(raw);
+    return {
+        raw,
+        query: cleanQuery,
+        server,
+        data,
+    };
+}
+export async function isDomainAvailable(domain, options) {
+    try {
+        const result = await whois(domain, options);
+        const rawLower = result.raw.toLowerCase();
+        const notFoundIndicators = [
+            'no match',
+            'not found',
+            'no entries found',
+            'no data found',
+            'status: available',
+            'status: free',
+        ];
+        return notFoundIndicators.some(indicator => rawLower.includes(indicator));
+    }
+    catch (error) {
+        return false;
+    }
+}
+export class WhoisClient {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            server: options.server ?? '',
+            port: options.port ?? 43,
+            timeout: options.timeout ?? 10000,
+            follow: options.follow ?? true,
+            debug: options.debug ?? false,
+        };
+    }
+    log(message, ...args) {
+        if (this.options.debug) {
+            console.log(`[WHOIS] ${message}`, ...args);
+        }
+    }
+    async lookup(query, options) {
+        this.log(`Looking up: ${query}`);
+        const start = Date.now();
+        const result = await whois(query, {
+            server: options?.server ?? (this.options.server || undefined),
+            port: options?.port ?? this.options.port,
+            timeout: options?.timeout ?? this.options.timeout,
+            follow: options?.follow ?? this.options.follow,
+        });
+        this.log(`Lookup completed in ${Date.now() - start}ms from ${result.server}`);
+        return result;
+    }
+    async isAvailable(domain) {
+        this.log(`Checking availability: ${domain}`);
+        return isDomainAvailable(domain, {
+            server: this.options.server || undefined,
+            port: this.options.port,
+            timeout: this.options.timeout,
+            follow: this.options.follow,
+        });
+    }
+    async getRegistrar(domain) {
+        const result = await this.lookup(domain);
+        return result.data['registrar'] ||
+            result.data['sponsoring registrar'] ||
+            null;
+    }
+    async getExpiration(domain) {
+        const result = await this.lookup(domain);
+        const expiry = result.data['registry expiry date'] ||
+            result.data['expiration date'] ||
+            result.data['expiry date'];
+        if (expiry) {
+            const date = new Date(expiry);
+            return isNaN(date.getTime()) ? null : date;
+        }
+        return null;
+    }
+    async getNameServers(domain) {
+        const result = await this.lookup(domain);
+        const ns = result.data['name server'] || result.data['nserver'] || [];
+        return Array.isArray(ns) ? ns : [ns];
+    }
+}
+export function createWhois(options) {
+    return new WhoisClient(options);
+}

package/dist/browser/websocket/client.d.ts

@@ -0,0 +1,65 @@
+import { EventEmitter } from 'events';
+import type { TLSOptions, ProxyOptions } from '../types/index.js';
+import type { Dispatcher } from 'undici';
+import { Readable } from 'node:stream';
+export interface WebSocketOptions {
+    protocols?: string | string[];
+    headers?: Record<string, string>;
+    dispatcher?: Dispatcher;
+    proxy?: ProxyOptions | string;
+    tls?: TLSOptions;
+    perMessageDeflate?: boolean;
+    reconnect?: boolean;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+    heartbeatInterval?: number;
+    heartbeatTimeout?: number;
+}
+export interface WebSocketMessage {
+    data: string | Buffer;
+    isBinary: boolean;
+}
+export declare class ReckerWebSocket extends EventEmitter {
+    private ws;
+    private url;
+    private options;
+    private reconnectAttempts;
+    private reconnectTimer?;
+    private heartbeatTimer?;
+    private isClosed;
+    private isReconnecting;
+    private pongWatchdog?;
+    private backoff;
+    private closedByUser;
+    constructor(url: string, options?: WebSocketOptions);
+    connect(): Promise<void>;
+    send(data: string | Buffer | ArrayBuffer | ArrayBufferView, options?: {
+        awaitDrain?: boolean;
+        highWaterMark?: number;
+    }): Promise<void>;
+    sendStream(stream: Readable, options?: {
+        awaitDrain?: boolean;
+        highWaterMark?: number;
+    }): Promise<void>;
+    sendJSON(data: any): void;
+    close(code?: number, reason?: string): void;
+    ping(): void;
+    get readyState(): number;
+    get isConnected(): boolean;
+    toReadable(): Readable | null;
+    pipeFrom(source: Readable, options?: {
+        awaitDrain?: boolean;
+        highWaterMark?: number;
+    }): Promise<void>;
+    pipeTo(destination: NodeJS.WritableStream): Promise<void>;
+    [Symbol.asyncIterator](): AsyncGenerator<WebSocketMessage>;
+    private attemptReconnect;
+    private clearReconnectTimer;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private startPongWatchdog;
+    private stopPongWatchdog;
+    private getBufferedAmount;
+    private waitForDrain;
+}
+export declare function createWebSocket(url: string, options?: WebSocketOptions): ReckerWebSocket;