rdapper 0.1.1 → 0.2.0

package/dist/types.d.ts

@@ -1,83 +0,0 @@
-export type LookupSource = "rdap" | "whois";
-export interface RegistrarInfo {
-    name?: string;
-    ianaId?: string;
-    url?: string;
-    email?: string;
-    phone?: string;
-}
-export interface Contact {
-    type: "registrant" | "admin" | "tech" | "billing" | "abuse" | "registrar" | "reseller" | "unknown";
-    name?: string;
-    organization?: string;
-    email?: string | string[];
-    phone?: string | string[];
-    fax?: string | string[];
-    street?: string[];
-    city?: string;
-    state?: string;
-    postalCode?: string;
-    country?: string;
-    countryCode?: string;
-}
-export interface Nameserver {
-    host: string;
-    ipv4?: string[];
-    ipv6?: string[];
-}
-export interface StatusEvent {
-    status: string;
-    description?: string;
-    raw?: string;
-}
-export interface DomainRecord {
-    domain: string;
-    tld: string;
-    isRegistered: boolean;
-    isIDN?: boolean;
-    unicodeName?: string;
-    punycodeName?: string;
-    registry?: string;
-    registrar?: RegistrarInfo;
-    reseller?: string;
-    statuses?: StatusEvent[];
-    creationDate?: string;
-    updatedDate?: string;
-    expirationDate?: string;
-    deletionDate?: string;
-    transferLock?: boolean;
-    dnssec?: {
-        enabled: boolean;
-        dsRecords?: Array<{
-            keyTag?: number;
-            algorithm?: number;
-            digestType?: number;
-            digest?: string;
-        }>;
-    };
-    nameservers?: Nameserver[];
-    contacts?: Contact[];
-    whoisServer?: string;
-    rdapServers?: string[];
-    rawRdap?: unknown;
-    rawWhois?: string;
-    source: LookupSource;
-    fetchedAt: string;
-    warnings?: string[];
-}
-export interface LookupOptions {
-    timeoutMs?: number;
-    rdapOnly?: boolean;
-    whoisOnly?: boolean;
-    followWhoisReferral?: boolean;
-    customBootstrapUrl?: string;
-    whoisHints?: Record<string, string>;
-    includeRaw?: boolean;
-    signal?: AbortSignal;
-}
-export interface LookupResult {
-    ok: boolean;
-    record?: DomainRecord;
-    error?: string;
-}
-export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/whois/client.d.ts

@@ -1,10 +0,0 @@
-import type { LookupOptions } from "../types.js";
-export interface WhoisQueryResult {
-    serverQueried: string;
-    text: string;
-}
-/**
- * Perform a WHOIS query against an RFC 3912 server over TCP 43.
- * Returns the raw text and the server used.
- */
-export declare function whoisQuery(server: string, query: string, options?: LookupOptions): Promise<WhoisQueryResult>;

package/dist/whois/client.js

@@ -1,46 +0,0 @@
-import { createConnection } from "node:net";
-import { withTimeout } from "../lib/async.js";
-import { DEFAULT_TIMEOUT_MS } from "../lib/constants.js";
-/**
- * Perform a WHOIS query against an RFC 3912 server over TCP 43.
- * Returns the raw text and the server used.
- */
-export async function whoisQuery(server, query, options) {
-    const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const port = 43;
-    const host = server.replace(/^whois:\/\//i, "");
-    const text = await withTimeout(queryTcp(host, port, query, options), timeoutMs, "WHOIS timeout");
-    return { serverQueried: server, text };
-}
-// Low-level WHOIS TCP client. Some registries require CRLF after the domain query.
-function queryTcp(host, port, query, options) {
-    return new Promise((resolve, reject) => {
-        const socket = createConnection({ host, port });
-        let data = "";
-        let done = false;
-        const cleanup = () => {
-            if (done)
-                return;
-            done = true;
-            socket.destroy();
-        };
-        socket.setTimeout((options?.timeoutMs ?? DEFAULT_TIMEOUT_MS) - 1000, () => {
-            cleanup();
-            reject(new Error("WHOIS socket timeout"));
-        });
-        socket.on("error", (err) => {
-            cleanup();
-            reject(err);
-        });
-        socket.on("data", (chunk) => {
-            data += chunk.toString("utf8");
-        });
-        socket.on("end", () => {
-            cleanup();
-            resolve(data);
-        });
-        socket.on("connect", () => {
-            socket.write(`${query}\r\n`);
-        });
-    });
-}

package/dist/whois/discovery.d.ts

@@ -1,24 +0,0 @@
-import type { LookupOptions } from "../types.js";
-/**
- * Parse the IANA WHOIS response for a TLD and extract the WHOIS server
- * without crossing line boundaries. Some TLDs (e.g. .np) leave the field
- * blank, in which case this returns undefined.
- */
-export declare function parseIanaWhoisServer(text: string): string | undefined;
-/**
- * Parse a likely registration information URL from an IANA WHOIS response.
- * Looks at lines like:
- *   remarks: Registration information: http://example.tld
- *   url: https://registry.example
- */
-export declare function parseIanaRegistrationInfoUrl(text: string): string | undefined;
-/** Fetch raw IANA WHOIS text for a TLD (best-effort). */
-export declare function getIanaWhoisTextForTld(tld: string, options?: LookupOptions): Promise<string | undefined>;
-/**
- * Best-effort discovery of the authoritative WHOIS server for a TLD via IANA root DB.
- */
-export declare function ianaWhoisServerForTld(tld: string, options?: LookupOptions): Promise<string | undefined>;
-/**
- * Extract registrar referral WHOIS server from a WHOIS response, if present.
- */
-export declare function extractWhoisReferral(text: string): string | undefined;

package/dist/whois/discovery.js

@@ -1,99 +0,0 @@
-import { whoisQuery } from "./client.js";
-import { WHOIS_TLD_EXCEPTIONS } from "./servers.js";
-/**
- * Parse the IANA WHOIS response for a TLD and extract the WHOIS server
- * without crossing line boundaries. Some TLDs (e.g. .np) leave the field
- * blank, in which case this returns undefined.
- */
-export function parseIanaWhoisServer(text) {
-    // Search lines in priority order: whois, refer, whois server
-    const fields = ["whois", "refer", "whois server"];
-    const lines = String(text).split(/\r?\n/);
-    for (const field of fields) {
-        for (const raw of lines) {
-            const line = raw.trimEnd();
-            // Match beginning of line, allowing leading spaces, case-insensitive
-            const re = new RegExp(`^\\s*${field}\\s*:\\s*(.*?)$`, "i");
-            const m = line.match(re);
-            if (m) {
-                const value = (m[1] || "").trim();
-                if (value)
-                    return value;
-            }
-        }
-    }
-    return undefined;
-}
-/**
- * Parse a likely registration information URL from an IANA WHOIS response.
- * Looks at lines like:
- *   remarks: Registration information: http://example.tld
- *   url: https://registry.example
- */
-export function parseIanaRegistrationInfoUrl(text) {
-    const lines = String(text).split(/\r?\n/);
-    for (const raw of lines) {
-        const line = raw.trim();
-        if (!/^\s*(remarks|url|website)\s*:/i.test(line))
-            continue;
-        const urlMatch = line.match(/https?:\/\/\S+/i);
-        if (urlMatch?.[0])
-            return urlMatch[0];
-    }
-    return undefined;
-}
-/** Fetch raw IANA WHOIS text for a TLD (best-effort). */
-export async function getIanaWhoisTextForTld(tld, options) {
-    try {
-        const res = await whoisQuery("whois.iana.org", tld.toLowerCase(), options);
-        return res.text;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Best-effort discovery of the authoritative WHOIS server for a TLD via IANA root DB.
- */
-export async function ianaWhoisServerForTld(tld, options) {
-    const key = tld.toLowerCase();
-    // 1) Explicit hint override
-    const hint = options?.whoisHints?.[key];
-    if (hint)
-        return normalizeServer(hint);
-    // 2) IANA WHOIS authoritative discovery over TCP 43
-    try {
-        const res = await whoisQuery("whois.iana.org", key, options);
-        const txt = res.text;
-        const server = parseIanaWhoisServer(txt);
-        if (server)
-            return normalizeServer(server);
-    }
-    catch {
-        // fallthrough to exceptions/guess
-    }
-    // 3) Curated exceptions
-    const exception = WHOIS_TLD_EXCEPTIONS[key];
-    if (exception)
-        return normalizeServer(exception);
-    return undefined;
-}
-/**
- * Extract registrar referral WHOIS server from a WHOIS response, if present.
- */
-export function extractWhoisReferral(text) {
-    const patterns = [
-        /^Registrar WHOIS Server:\s*(.+)$/im,
-        /^Whois Server:\s*(.+)$/im,
-        /^ReferralServer:\s*whois:\/\/(.+)$/im,
-    ];
-    for (const re of patterns) {
-        const m = text.match(re);
-        if (m?.[1])
-            return m[1].trim();
-    }
-    return undefined;
-}
-function normalizeServer(server) {
-    return server.replace(/^whois:\/\//i, "").replace(/\/$/, "");
-}

package/dist/whois/normalize.d.ts

@@ -1,6 +0,0 @@
-import type { DomainRecord } from "../types.js";
-/**
- * Convert raw WHOIS text into our normalized DomainRecord.
- * Heuristics cover many gTLD and ccTLD formats; exact fields vary per registry.
- */
-export declare function normalizeWhois(domain: string, tld: string, whoisText: string, whoisServer: string | undefined, fetchedAtISO: string, includeRaw?: boolean): DomainRecord;

package/dist/whois/normalize.js

@@ -1,214 +0,0 @@
-import { toISO } from "../lib/dates.js";
-import { isWhoisAvailable } from "../lib/domain.js";
-import { parseKeyValueLines, uniq } from "../lib/text.js";
-/**
- * Convert raw WHOIS text into our normalized DomainRecord.
- * Heuristics cover many gTLD and ccTLD formats; exact fields vary per registry.
- */
-export function normalizeWhois(domain, tld, whoisText, whoisServer, fetchedAtISO, includeRaw = false) {
-    const map = parseKeyValueLines(whoisText);
-    // Date extraction across common synonyms
-    const creationDate = anyValue(map, [
-        "creation date",
-        "created on",
-        "registered on",
-        "domain registration date",
-        "domain create date",
-        "created",
-        "registered",
-    ]);
-    const updatedDate = anyValue(map, [
-        "updated date",
-        "last updated",
-        "last modified",
-        "modified",
-    ]);
-    const expirationDate = anyValue(map, [
-        "registry expiry date",
-        "expiry date",
-        "expiration date",
-        "paid-till",
-        "expires on",
-        "renewal date",
-    ]);
-    // Registrar info (thin registries like .com/.net require referral follow for full data)
-    const registrar = (() => {
-        const name = anyValue(map, [
-            "registrar",
-            "sponsoring registrar",
-            "registrar name",
-        ]);
-        const ianaId = anyValue(map, ["registrar iana id", "iana id"]);
-        const url = anyValue(map, [
-            "registrar url",
-            "url of the registrar",
-            "referrer",
-        ]);
-        const abuseEmail = anyValue(map, [
-            "registrar abuse contact email",
-            "abuse contact email",
-        ]);
-        const abusePhone = anyValue(map, [
-            "registrar abuse contact phone",
-            "abuse contact phone",
-        ]);
-        if (!name && !ianaId && !url && !abuseEmail && !abusePhone)
-            return undefined;
-        return {
-            name: name || undefined,
-            ianaId: ianaId || undefined,
-            url: url || undefined,
-            email: abuseEmail || undefined,
-            phone: abusePhone || undefined,
-        };
-    })();
-    // Statuses: multiple entries are expected; keep raw
-    const statusLines = map["domain status"] || map.status || [];
-    const statuses = statusLines.length
-        ? statusLines.map((line) => ({ status: line.split(/\s+/)[0], raw: line }))
-        : undefined;
-    // Nameservers: also appear as "nserver" on some ccTLDs (.de, .ru) and as "name server"
-    const nsLines = [
-        ...(map["name server"] || []),
-        ...(map.nameserver || []),
-        ...(map["name servers"] || []),
-        ...(map.nserver || []),
-    ];
-    const nameservers = nsLines.length
-        ? uniq(nsLines
-            .map((line) => line.trim())
-            .filter(Boolean)
-            .map((line) => {
-            // Common formats: "ns1.example.com" or "ns1.example.com 192.0.2.1" or "ns1.example.com 2001:db8::1"
-            const parts = line.split(/\s+/);
-            const host = parts.shift()?.toLowerCase() || "";
-            const ipv4 = [];
-            const ipv6 = [];
-            for (const p of parts) {
-                if (/^\d+\.\d+\.\d+\.\d+$/.test(p))
-                    ipv4.push(p);
-                else if (/^[0-9a-f:]+$/i.test(p))
-                    ipv6.push(p);
-            }
-            if (!host)
-                return undefined;
-            const ns = { host };
-            if (ipv4.length)
-                ns.ipv4 = ipv4;
-            if (ipv6.length)
-                ns.ipv6 = ipv6;
-            return ns;
-        })
-            .filter((x) => !!x))
-        : undefined;
-    // Contacts: best-effort parse common keys
-    const contacts = collectContacts(map);
-    const dnssecRaw = (map.dnssec?.[0] || "").toLowerCase();
-    const dnssec = dnssecRaw
-        ? { enabled: /signed|yes|true/.test(dnssecRaw) }
-        : undefined;
-    // Simple lock derivation from statuses
-    const transferLock = !!statuses?.some((s) => /transferprohibited/i.test(s.status));
-    const record = {
-        domain,
-        tld,
-        isRegistered: !isWhoisAvailable(whoisText),
-        isIDN: /(^|\.)xn--/i.test(domain),
-        unicodeName: undefined,
-        punycodeName: undefined,
-        registry: undefined,
-        registrar,
-        reseller: anyValue(map, ["reseller"]) || undefined,
-        statuses,
-        creationDate: toISO(creationDate || undefined),
-        updatedDate: toISO(updatedDate || undefined),
-        expirationDate: toISO(expirationDate || undefined),
-        deletionDate: undefined,
-        transferLock,
-        dnssec,
-        nameservers,
-        contacts,
-        whoisServer,
-        rdapServers: undefined,
-        rawRdap: undefined,
-        rawWhois: includeRaw ? whoisText : undefined,
-        source: "whois",
-        fetchedAt: fetchedAtISO,
-        warnings: undefined,
-    };
-    return record;
-}
-function anyValue(map, keys) {
-    for (const k of keys) {
-        const v = map[k];
-        if (v?.length)
-            return v[0];
-    }
-    return undefined;
-}
-function collectContacts(map) {
-    const roles = [
-        { role: "registrant", prefix: "registrant" },
-        { role: "admin", prefix: "admin" },
-        { role: "tech", prefix: "tech" },
-        { role: "billing", prefix: "billing" },
-        { role: "abuse", prefix: "abuse" },
-    ];
-    const contacts = [];
-    for (const r of roles) {
-        const name = anyValue(map, [
-            `${r.prefix} name`,
-            `${r.prefix} contact name`,
-            `${r.prefix}`,
-        ]);
-        const org = anyValue(map, [`${r.prefix} organization`, `${r.prefix} org`]);
-        const email = anyValue(map, [
-            `${r.prefix} email`,
-            `${r.prefix} contact email`,
-            `${r.prefix} e-mail`,
-        ]);
-        const phone = anyValue(map, [
-            `${r.prefix} phone`,
-            `${r.prefix} contact phone`,
-            `${r.prefix} telephone`,
-        ]);
-        const fax = anyValue(map, [`${r.prefix} fax`, `${r.prefix} facsimile`]);
-        const street = multi(map, [`${r.prefix} street`, `${r.prefix} address`]);
-        const city = anyValue(map, [`${r.prefix} city`]);
-        const state = anyValue(map, [
-            `${r.prefix} state`,
-            `${r.prefix} province`,
-            `${r.prefix} state/province`,
-        ]);
-        const postalCode = anyValue(map, [
-            `${r.prefix} postal code`,
-            `${r.prefix} postcode`,
-            `${r.prefix} zip`,
-        ]);
-        const country = anyValue(map, [`${r.prefix} country`]);
-        if (name || org || email || phone || street?.length) {
-            contacts.push({
-                type: r.role,
-                name: name || undefined,
-                organization: org || undefined,
-                email: email || undefined,
-                phone: phone || undefined,
-                fax: fax || undefined,
-                street: street,
-                city: city || undefined,
-                state: state || undefined,
-                postalCode: postalCode || undefined,
-                country: country || undefined,
-            });
-        }
-    }
-    return contacts.length ? contacts : undefined;
-}
-function multi(map, keys) {
-    for (const k of keys) {
-        const v = map[k];
-        if (v?.length)
-            return v;
-    }
-    return undefined;
-}

package/dist/whois/servers.d.ts

@@ -1 +0,0 @@
-export declare const WHOIS_TLD_EXCEPTIONS: Record<string, string>;

package/dist/whois/servers.js

@@ -1,64 +0,0 @@
-// Curated authoritative WHOIS servers by TLD (exceptions to default/referral logic)
-// Source of truth checked against IANA delegation records; prefer RDAP first.
-export const WHOIS_TLD_EXCEPTIONS = {
-    // gTLDs (port-43 still available at registry)
-    com: "whois.verisign-grs.com",
-    net: "whois.verisign-grs.com",
-    org: "whois.publicinterestregistry.org", // PIR
-    biz: "whois.nic.biz",
-    name: "whois.nic.name",
-    edu: "whois.educause.edu",
-    gov: "whois.nic.gov", // was whois.dotgov.gov
-    // ccTLDs & other TLDs with working port-43 WHOIS
-    de: "whois.denic.de",
-    jp: "whois.jprs.jp",
-    fr: "whois.nic.fr",
-    it: "whois.nic.it",
-    pl: "whois.dns.pl",
-    nl: "whois.domain-registry.nl",
-    be: "whois.dns.be",
-    se: "whois.iis.se",
-    no: "whois.norid.no",
-    fi: "whois.fi",
-    cz: "whois.nic.cz",
-    es: "whois.nic.es",
-    br: "whois.registro.br",
-    ca: "whois.cira.ca",
-    dk: "whois.punktum.dk", // was whois.dk-hostmaster.dk
-    hk: "whois.hkirc.hk",
-    sg: "whois.sgnic.sg",
-    in: "whois.nixiregistry.in", // was whois.registry.in
-    nz: "whois.irs.net.nz", // was whois.srs.net.nz
-    ch: "whois.nic.ch",
-    li: "whois.nic.li",
-    io: "whois.nic.io",
-    ai: "whois.nic.ai",
-    ru: "whois.tcinet.ru",
-    su: "whois.tcinet.ru",
-    us: "whois.nic.us",
-    co: "whois.nic.co",
-    me: "whois.nic.me",
-    tv: "whois.nic.tv",
-    cc: "ccwhois.verisign-grs.com",
-    eu: "whois.eu",
-    au: "whois.auda.org.au",
-    kr: "whois.kr",
-    tw: "whois.twnic.net.tw",
-    uk: "whois.nic.uk",
-    nu: "whois.iis.nu",
-    "xn--p1ai": "whois.tcinet.ru", // .рф
-    // CentralNic-operated public SLD zones (still WHOIS @ centralnic)
-    "uk.com": "whois.centralnic.com",
-    "uk.net": "whois.centralnic.com",
-    "gb.com": "whois.centralnic.com",
-    "gb.net": "whois.centralnic.com",
-    "eu.com": "whois.centralnic.com",
-    "us.com": "whois.centralnic.com",
-    "se.com": "whois.centralnic.com",
-    "de.com": "whois.centralnic.com",
-    "br.com": "whois.centralnic.com",
-    "ru.com": "whois.centralnic.com",
-    "cn.com": "whois.centralnic.com",
-    "sa.com": "whois.centralnic.com",
-    "co.com": "whois.centralnic.com",
-};