rdapper 0.10.4 → 0.12.0

package/dist/index.d.mts

@@ -0,0 +1,410 @@
+import { parse } from "tldts";
+
+//#region src/types.d.ts
+
+/**
+ * The data source used to retrieve domain information.
+ *
+ * - `rdap`: Data was retrieved via RDAP (Registration Data Access Protocol)
+ * - `whois`: Data was retrieved via WHOIS (port 43)
+ */
+type LookupSource = "rdap" | "whois";
+/**
+ * Domain registrar information.
+ *
+ * Contains identifying details about the registrar responsible for the domain registration.
+ * Fields may be incomplete depending on the data source and registry policies.
+ */
+interface RegistrarInfo {
+  /** Registrar name (e.g., "GoDaddy.com, LLC") */
+  name?: string;
+  /** IANA-assigned registrar ID */
+  ianaId?: string;
+  /** Registrar website URL */
+  url?: string;
+  /** Registrar contact email address */
+  email?: string;
+  /** Registrar contact phone number */
+  phone?: string;
+}
+/**
+ * Contact information for various roles associated with a domain.
+ *
+ * Contacts may represent individuals or organizations responsible for different
+ * aspects of domain management. Availability and completeness of contact data
+ * varies by TLD, registrar, and privacy policies (GDPR, WHOIS privacy services).
+ */
+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;
+}
+/**
+ * DNS nameserver information.
+ *
+ * Represents a nameserver authoritative for the domain, including its hostname
+ * and optional glue records (IP addresses).
+ */
+interface Nameserver {
+  /** Nameserver hostname (e.g., "ns1.example.com") */
+  host: string;
+  /** IPv4 glue records, if provided */
+  ipv4?: string[];
+  /** IPv6 glue records, if provided */
+  ipv6?: string[];
+}
+/**
+ * Domain status information.
+ *
+ * Represents EPP status codes and registry-specific statuses that indicate
+ * the operational state and restrictions on a domain.
+ *
+ * Common EPP statuses include: clientTransferProhibited, serverHold,
+ * serverDeleteProhibited, etc.
+ *
+ * @see {@link https://www.icann.org/resources/pages/epp-status-codes-2014-06-16-en ICANN EPP Status Codes}
+ */
+interface StatusEvent {
+  /** Normalized status code (e.g., "clientTransferProhibited") */
+  status: string;
+  /** Human-readable description of the status, if available */
+  description?: string;
+  /** Original raw status string from the source */
+  raw?: string;
+}
+/**
+ * Normalized domain registration record.
+ *
+ * This is the primary data structure returned by domain lookups. It provides a unified
+ * view of domain registration data regardless of whether the information was obtained
+ * via RDAP or WHOIS.
+ *
+ * Field availability varies by:
+ * - TLD and registry policies
+ * - Data source (RDAP typically more structured than WHOIS)
+ * - Privacy protections (GDPR, WHOIS privacy services)
+ * - Registrar practices
+ *
+ * @example
+ * ```ts
+ * import { lookup } from 'rdapper';
+ *
+ * const { ok, record } = await lookup('example.com');
+ * if (ok && record) {
+ *   console.log(record.registrar?.name);  // "Example Registrar, Inc."
+ *   console.log(record.isRegistered);      // true
+ *   console.log(record.source);            // "rdap"
+ * }
+ * ```
+ */
+interface DomainRecord {
+  /** Normalized domain name */
+  domain: string;
+  /** Terminal TLD */
+  tld: string;
+  /** Whether the domain is registered */
+  isRegistered: boolean;
+  /** Whether the domain is internationalized (IDN) */
+  isIDN?: boolean;
+  /** Unicode name */
+  unicodeName?: string;
+  /** Punycode name */
+  punycodeName?: string;
+  /** Registry operator */
+  registry?: string;
+  /** Registrar */
+  registrar?: RegistrarInfo;
+  /** Reseller (if applicable) */
+  reseller?: string;
+  /** EPP status codes */
+  statuses?: StatusEvent[];
+  /** Creation date in ISO 8601 */
+  creationDate?: string;
+  /** Updated date in ISO 8601 */
+  updatedDate?: string;
+  /** Expiration date in ISO 8601 */
+  expirationDate?: string;
+  /** Deletion date in ISO 8601 */
+  deletionDate?: string;
+  /** Transfer lock */
+  transferLock?: boolean;
+  /** DNSSEC data (if available) */
+  dnssec?: {
+    enabled: boolean;
+    dsRecords?: Array<{
+      keyTag?: number;
+      algorithm?: number;
+      digestType?: number;
+      digest?: string;
+    }>;
+  };
+  /** Nameservers */
+  nameservers?: Nameserver[];
+  /** Contacts (registrant, admin, tech, billing, abuse, etc.) */
+  contacts?: Contact[];
+  /** Best guess as to whether registrant is redacted based on keywords */
+  privacyEnabled?: boolean;
+  /** Authoritative WHOIS queried (if any) */
+  whoisServer?: string;
+  /** RDAP base URLs tried */
+  rdapServers?: string[];
+  /** Raw RDAP JSON */
+  rawRdap?: unknown;
+  /** Raw WHOIS text (last authoritative) */
+  rawWhois?: string;
+  /** Which source produced data */
+  source: LookupSource;
+  /** Warnings generated during lookup */
+  warnings?: string[];
+}
+/**
+ * RDAP bootstrap JSON format as published by IANA at https://data.iana.org/rdap/dns.json
+ *
+ * This interface describes the structure of the RDAP bootstrap registry, which maps
+ * top-level domains to their authoritative RDAP servers.
+ *
+ * @example
+ * ```json
+ * {
+ *   "version": "1.0",
+ *   "publication": "2025-01-15T12:00:00Z",
+ *   "description": "RDAP Bootstrap file for DNS top-level domains",
+ *   "services": [
+ *     [["com", "net"], ["https://rdap.verisign.com/com/v1/"]],
+ *     [["org"], ["https://rdap.publicinterestregistry.org/"]]
+ *   ]
+ * }
+ * ```
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7484 RFC 7484 - Finding the Authoritative RDAP Service}
+ */
+interface BootstrapData {
+  /** Bootstrap file format version */
+  version: string;
+  /** ISO 8601 timestamp of when this bootstrap data was published */
+  publication: string;
+  /** Optional human-readable description of the bootstrap file */
+  description?: string;
+  /**
+   * Service mappings array. Each entry is a tuple of [TLDs, base URLs]:
+   * - First element: array of TLD strings (e.g., ["com", "net"])
+   * - Second element: array of RDAP base URL strings (e.g., ["https://rdap.verisign.com/com/v1/"])
+   */
+  services: string[][][];
+}
+/**
+ * Configuration options for domain lookups.
+ *
+ * Controls the lookup behavior, including which protocols to use (RDAP/WHOIS),
+ * timeout settings, referral following, and caching options.
+ *
+ * @example
+ * ```ts
+ * import { lookup } from 'rdapper';
+ *
+ * // RDAP-only lookup for edge runtime compatibility
+ * const result = await lookup('example.com', {
+ *   rdapOnly: true,
+ *   timeoutMs: 10000
+ * });
+ *
+ * // Cached bootstrap data for high-volume scenarios
+ * const cachedBootstrap = await getFromCache();
+ * const result = await lookup('example.com', {
+ *   customBootstrapData: cachedBootstrap,
+ *   includeRaw: true
+ * });
+ * ```
+ */
+interface LookupOptions {
+  /** Total timeout budget */
+  timeoutMs?: number;
+  /** Don't fall back to WHOIS */
+  rdapOnly?: boolean;
+  /** Don't attempt RDAP */
+  whoisOnly?: boolean;
+  /** Follow referral server (default true) */
+  followWhoisReferral?: boolean;
+  /** Maximum registrar WHOIS referral hops (default 2) */
+  maxWhoisReferralHops?: number;
+  /** Follow RDAP related/entity links (default true) */
+  rdapFollowLinks?: boolean;
+  /** Maximum RDAP related link fetches (default 2) */
+  maxRdapLinkHops?: number;
+  /** RDAP link rels to consider (default ["related","entity","registrar","alternate"]) */
+  rdapLinkRels?: string[];
+  /**
+   * Pre-loaded RDAP bootstrap data to use instead of fetching from IANA.
+   *
+   * Pass your own cached version of https://data.iana.org/rdap/dns.json to control
+   * caching behavior and avoid redundant network requests. This is useful when you want
+   * to cache the bootstrap data in Redis, memory, filesystem, or any other caching layer.
+   *
+   * If provided, this takes precedence over `customBootstrapUrl` and the default IANA URL.
+   *
+   * @example
+   * ```ts
+   * import { lookup, type BootstrapData } from 'rdapper';
+   *
+   * // Fetch and cache the bootstrap data yourself
+   * const bootstrapData: BootstrapData = await fetchFromCache()
+   *   ?? await fetchAndCache('https://data.iana.org/rdap/dns.json');
+   *
+   * // Pass the cached data to rdapper
+   * const result = await lookup('example.com', {
+   *   customBootstrapData: bootstrapData
+   * });
+   * ```
+   *
+   * @see {@link BootstrapData} for the expected data structure
+   */
+  customBootstrapData?: BootstrapData;
+  /** Override IANA bootstrap URL (ignored if customBootstrapData is provided) */
+  customBootstrapUrl?: string;
+  /**
+   * Custom fetch implementation to use for all HTTP requests.
+   *
+   * Provides complete control over how HTTP requests are made, enabling advanced use cases:
+   * - **Caching**: Cache bootstrap data, RDAP responses, and related link responses
+   * - **Logging**: Log all outgoing requests and responses for monitoring
+   * - **Retry Logic**: Implement custom retry strategies with exponential backoff
+   * - **Rate Limiting**: Control request frequency to respect API limits
+   * - **Proxies/Auth**: Route requests through proxies or add authentication headers
+   * - **Testing**: Inject mock responses for testing without network calls
+   *
+   * The custom fetch will be used for:
+   * - RDAP bootstrap registry requests (unless `customBootstrapData` is provided)
+   * - RDAP domain lookup requests
+   * - RDAP related/entity link requests
+   *
+   * If not provided, the global `fetch` function is used (Node.js 18+ or browser).
+   *
+   * @example
+   * ```ts
+   * import { lookup } from 'rdapper';
+   *
+   * // Example 1: Simple in-memory cache
+   * const cache = new Map<string, Response>();
+   * const cachedFetch: typeof fetch = async (input, init) => {
+   *   const key = typeof input === 'string' ? input : input.toString();
+   *   if (cache.has(key)) return cache.get(key)!.clone();
+   *   const response = await fetch(input, init);
+   *   cache.set(key, response.clone());
+   *   return response;
+   * };
+   *
+   * await lookup('example.com', { customFetch: cachedFetch });
+   *
+   * // Example 2: Request logging
+   * const loggingFetch: typeof fetch = async (input, init) => {
+   *   const url = typeof input === 'string' ? input : input.toString();
+   *   console.log('[Fetch]', url);
+   *   const response = await fetch(input, init);
+   *   console.log('[Response]', response.status, url);
+   *   return response;
+   * };
+   *
+   * await lookup('example.com', { customFetch: loggingFetch });
+   * ```
+   *
+   * @see {@link FetchLike} for the expected function signature
+   */
+  customFetch?: FetchLike;
+  /** Override/add authoritative WHOIS per TLD */
+  whoisHints?: Record<string, string>;
+  /** Include rawRdap/rawWhois in results (default false) */
+  includeRaw?: boolean;
+  /** Optional cancellation signal */
+  signal?: AbortSignal;
+}
+/**
+ * Result of a domain lookup operation.
+ *
+ * Provides a structured response indicating success or failure, with either
+ * a normalized domain record or an error message.
+ *
+ * @example
+ * ```ts
+ * import { lookup } from 'rdapper';
+ *
+ * const result = await lookup('example.com');
+ * if (result.ok) {
+ *   console.log('Domain:', result.record.domain);
+ *   console.log('Registered:', result.record.isRegistered);
+ * } else {
+ *   console.error('Lookup failed:', result.error);
+ * }
+ * ```
+ */
+interface LookupResult {
+  /** Whether the lookup completed successfully */
+  ok: boolean;
+  /** The normalized domain record, present when ok is true */
+  record?: DomainRecord;
+  /** Error message describing why the lookup failed, present when ok is false */
+  error?: string;
+}
+/**
+ * Fetch-compatible function signature.
+ *
+ * Used internally for dependency injection and testing. Matches the signature
+ * of the global `fetch` function available in Node.js 18+ and browsers.
+ */
+type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
+//#endregion
+//#region src/lib/domain.d.ts
+type ParseOptions = Parameters<typeof parse>[1];
+/**
+ * Parse a domain into its parts. Passes options to `tldts.parse()`.
+ * @see https://github.com/remusao/tldts/blob/master/packages/tldts-core/src/options.ts
+ */
+declare function getDomainParts(domain: string, opts?: ParseOptions): ReturnType<typeof parse>;
+/**
+ * Get the TLD (ICANN-only public suffix) of a domain. Passes options to `tldts.parse()`.
+ * @see https://github.com/remusao/tldts/blob/master/packages/tldts-core/src/options.ts
+ */
+declare function getDomainTld(domain: string, opts?: ParseOptions): string | null;
+/**
+ * Basic domain validity check (hostname-like), not performing DNS or RDAP.
+ */
+declare function isLikelyDomain(value: string): boolean;
+/**
+ * Normalize arbitrary input (domain or URL) to its registrable domain (eTLD+1).
+ * Passes options to `tldts.parse()`.
+ * Returns null when the input is not a valid ICANN domain (e.g., invalid TLD, IPs)
+ * @see https://github.com/remusao/tldts/blob/master/packages/tldts-core/src/options.ts
+ */
+declare function toRegistrableDomain(input: string, opts?: ParseOptions): string | null;
+//#endregion
+//#region src/index.d.ts
+/**
+ * High-level lookup that prefers RDAP and falls back to WHOIS.
+ * Ensures a standardized DomainRecord, independent of the source.
+ */
+declare function lookup(domain: string, opts?: LookupOptions): Promise<LookupResult>;
+/**
+ * Determine if a domain appears available (not registered).
+ * Performs a lookup and resolves to a boolean. Rejects on lookup error.
+ */
+declare function isAvailable(domain: string, opts?: LookupOptions): Promise<boolean>;
+/**
+ * Determine if a domain appears registered.
+ * Performs a lookup and resolves to a boolean. Rejects on lookup error.
+ */
+declare function isRegistered(domain: string, opts?: LookupOptions): Promise<boolean>;
+/**
+ * @deprecated Use `lookup` instead.
+ */
+declare const lookupDomain: typeof lookup;
+//#endregion
+export { BootstrapData, Contact, DomainRecord, FetchLike, LookupOptions, LookupResult, LookupSource, Nameserver, RegistrarInfo, StatusEvent, getDomainParts, getDomainTld, isAvailable, isLikelyDomain, isRegistered, lookup, lookupDomain, toRegistrableDomain };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/lib/domain.ts","../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;AAMA;AAQA;AAoBA;AA6BiB,KAzDL,YAAA,GAyDe,MAAA,GAAA,OAAA;AAoB3B;AAkCA;;;;;AA4Ca,UAnJI,aAAA,CAmJJ;EAYH;EAAY,IAAA,CAAA,EAAA,MAAA;EA0BL;EAuCA,MAAA,CAAA,EAAA,MAAA;EA0CO;EAmDR,GAAA,CAAA,EAAA,MAAA;EAED;EAIJ,KAAA,CAAA,EAAA,MAAA;EAAW;EAsBL,KAAA,CAAA,EAAA,MAAA;AAejB;;;;;;;;UApViB,OAAA;EChCZ,IAAA,EAAA,YAAY,GAAA,OAAqB,GAAA,MAAlB,GAAA,SAAU,GAAA,OAAA,GAAA,WAAA,GAAA,UAAA,GAAA,SAAA;EAMd,IAAA,CAAA,EAAA,MAAA;EAEP,YAAA,CAAA,EAAA,MAAA;EACY,KAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA;EAAlB,KAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA;EAAU,GAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA;EAQG,MAAA,CAAA,EAAA,MAAY,EAAA;EAcZ,IAAA,CAAA,EAAA,MAAA;EAuBA,KAAA,CAAA,EAAA,MAAA;;;;AClChB;;;;;AAyGA;AAaA;AAYa,UFzFI,UAAA,CEyFiB;;;;;;;;;;;;;;;;;;;UFrEjB,WAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAkCA,YAAA;;;;;;;;;;;;;;;;cAgBH;;;;aAID;;;;;;;;;;;;;;gBAcG;;;;;;;;gBAQA;;aAEH;;;;;;;;;;;;UAYH;;;;;;;;;;;;;;;;;;;;;;;;;UA0BO,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAuCA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA0CO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAmDR;;eAED;;;;WAIJ;;;;;;;;;;;;;;;;;;;;;UAsBM,YAAA;;;;WAIN;;;;;;;;;;KAWC,SAAA,oBACM,YACT,gBACJ,QAAQ;;;KCvXR,YAAA,GAAe,kBAAkB;;ADItC;AAQA;AAoBA;AA6BiB,iBCvDD,cAAA,CDuDW,MAAA,EAAA,MAAA,EAAA,IAAA,CAAA,ECrDlB,YDqDkB,CAAA,ECpDxB,UDoDwB,CAAA,OCpDN,KDoDM,CAAA;AAoB3B;AAkCA;;;AAkCgB,iBCpIA,YAAA,CDoIA,MAAA,EAAA,MAAA,EAAA,IAAA,CAAA,EClIP,YDkIO,CAAA,EAAA,MAAA,GAAA,IAAA;;;;AAsBM,iBC5IN,cAAA,CD4IM,KAAA,EAAA,MAAA,CAAA,EAAA,OAAA;AAiEtB;;;;;;AAyHiB,iBC/SD,mBAAA,CDmTO,KAAA,EAAA,MAAA,EAAA,IAAA,CAAA,ECjTd,YDiTc,CAAA,EAAA,MAAA,GAAA,IAAA;;;;;AArWvB;AAQA;AAoBiB,iBEZK,MAAA,CFYE,MAAA,EAAA,MAAA,EAAA,IAAA,CAAA,EEVf,aFUe,CAAA,EETrB,OFSqB,CETb,YFSa,CAAA;AA6BxB;AAoBA;AAkCA;;AAoBa,iBEVS,WAAA,CFUT,MAAA,EAAA,MAAA,EAAA,IAAA,CAAA,EERJ,aFQI,CAAA,EEPV,OFOU,CAAA,OAAA,CAAA;;;;;AAoCS,iBEjCA,YAAA,CFiCA,MAAA,EAAA,MAAA,EAAA,IAAA,CAAA,EE/Bb,aF+Ba,CAAA,EE9BnB,OF8BmB,CAAA,OAAA,CAAA;AA0BtB;AAuCA;;AA6FgB,cEnLH,YFmLG,EAAA,OEnLS,MFmLT"}

package/dist/{index.js → index.mjs}

@@ -60,26 +60,91 @@ function withTimeout(promise, timeoutMs, reason = "Timeout") {
 
 //#endregion
 //#region src/lib/constants.ts
-const DEFAULT_TIMEOUT_MS = 15e3;
+/**
+* The timeout for HTTP requests in milliseconds. Defaults to 10 seconds.
+*/
+const DEFAULT_TIMEOUT_MS = 1e4;
+/**
+* The default URL for the IANA RDAP bootstrap file.
+*
+* @see {@link https://data.iana.org/rdap/dns.json IANA RDAP Bootstrap File (dns.json)}
+*/
+const DEFAULT_BOOTSTRAP_URL = "https://data.iana.org/rdap/dns.json";
+
+//#endregion
+//#region src/lib/fetch.ts
+/**
+* Resolve the fetch implementation to use for HTTP requests.
+*
+* Returns the custom fetch from options if provided, otherwise falls back
+* to the global fetch function. This centralized helper ensures consistent
+* fetch resolution across all RDAP HTTP operations.
+*
+* Used internally by:
+* - Bootstrap registry fetching (`src/rdap/bootstrap.ts`)
+* - RDAP domain lookups (`src/rdap/client.ts`)
+* - RDAP related/entity link requests (`src/rdap/merge.ts`)
+*
+* @param options - Any object that may contain a custom fetch implementation
+* @returns The fetch function to use for HTTP requests
+*
+* @example
+* ```ts
+* import { resolveFetch } from './lib/fetch';
+*
+* const fetchFn = resolveFetch(options);
+* const response = await fetchFn('https://example.com/api', { method: 'GET' });
+* ```
+*/
+function resolveFetch(options) {
+	return options?.customFetch ?? fetch;
+}
 
 //#endregion
 //#region src/rdap/bootstrap.ts
 /**
 * Resolve RDAP base URLs for a given TLD using IANA's bootstrap registry.
 * Returns zero or more base URLs (always suffixed with a trailing slash).
+*
+* Bootstrap data is resolved in the following priority order:
+* 1. `options.customBootstrapData` - pre-loaded bootstrap data (no fetch)
+* 2. `options.customBootstrapUrl` - custom URL to fetch bootstrap data from
+* 3. Default IANA URL - https://data.iana.org/rdap/dns.json
+*
+* @param tld - The top-level domain to look up (e.g., "com", "co.uk")
+* @param options - Optional lookup options including custom bootstrap data/URL
+* @returns Array of RDAP base URLs for the TLD, or empty array if none found
 */
 async function getRdapBaseUrlsForTld(tld, options) {
-	const bootstrapUrl = options?.customBootstrapUrl ?? "https://data.iana.org/rdap/dns.json";
-	const res = await withTimeout(fetch(bootstrapUrl, {
-		method: "GET",
-		headers: { accept: "application/json" },
-		signal: options?.signal
-	}), options?.timeoutMs ?? DEFAULT_TIMEOUT_MS, "RDAP bootstrap timeout");
-	if (!res.ok) return [];
-	const data = await res.json();
+	let data;
+	if (options && "customBootstrapData" in options) {
+		const provided = options.customBootstrapData;
+		if (!provided || typeof provided !== "object") throw new Error("Invalid customBootstrapData: expected an object. See BootstrapData type for required structure.");
+		if (!Array.isArray(provided.services)) throw new Error("Invalid customBootstrapData: missing or invalid \"services\" array. See BootstrapData type for required structure.");
+		provided.services.forEach((svc, idx) => {
+			if (!Array.isArray(svc) || svc.length < 2 || !Array.isArray(svc[0]) || !Array.isArray(svc[1])) throw new Error(`Invalid customBootstrapData: services[${idx}] must be a tuple of [string[], string[]].`);
+		});
+		data = provided;
+	} else {
+		const fetchFn = resolveFetch(options);
+		const bootstrapUrl = options?.customBootstrapUrl ?? DEFAULT_BOOTSTRAP_URL;
+		try {
+			const res = await withTimeout(fetchFn(bootstrapUrl, {
+				method: "GET",
+				headers: { accept: "application/json" },
+				signal: options?.signal
+			}), options?.timeoutMs ?? DEFAULT_TIMEOUT_MS, "RDAP bootstrap timeout");
+			if (!res.ok) return [];
+			data = await res.json();
+		} catch (err) {
+			if (err instanceof Error && err.name === "AbortError") throw err;
+			return [];
+		}
+	}
 	const target = tld.toLowerCase();
 	const bases = [];
 	for (const svc of data.services) {
+		if (!svc[0] || !svc[1]) continue;
 		const tlds = svc[0].map((x) => x.toLowerCase());
 		const urls = svc[1];
 		if (tlds.includes(target)) for (const u of urls) {
@@ -98,7 +163,7 @@ async function getRdapBaseUrlsForTld(tld, options) {
 */
 async function fetchRdapDomain(domain, baseUrl, options) {
 	const url = new URL(`domain/${encodeURIComponent(domain)}`, baseUrl).toString();
-	const res = await withTimeout(fetch(url, {
+	const res = await withTimeout(resolveFetch(options)(url, {
 		method: "GET",
 		headers: { accept: "application/rdap+json, application/json" },
 		signal: options?.signal
@@ -201,7 +266,7 @@ async function fetchAndMergeRdapRelated(domain, baseDoc, opts) {
 	};
 }
 async function fetchRdapUrl(url, options) {
-	const res = await withTimeout(fetch(url, {
+	const res = await withTimeout(resolveFetch(options)(url, {
 		method: "GET",
 		headers: { accept: "application/rdap+json, application/json" },
 		signal: options?.signal
@@ -287,6 +352,7 @@ function parseDateWithRegex(m, _re) {
 	try {
 		if (m[0].includes(":")) {
 			const [_$1, y, mo, d, hh, mm, ss, offH, offM] = m;
+			if (!y || !mo || !d || !hh || !mm || !ss) return void 0;
 			let dt = Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(hh), Number(mm), Number(ss));
 			if (offH) {
 				const sign = offH.startsWith("-") ? -1 : 1;
@@ -299,11 +365,13 @@ function parseDateWithRegex(m, _re) {
 		}
 		if (m[0].includes("-")) {
 			const [_$1, dd$1, monStr$1, yyyy$1] = m;
+			if (!monStr$1 || !dd$1 || !yyyy$1) return void 0;
 			if (/^\d+$/.test(monStr$1)) return new Date(Date.UTC(Number(yyyy$1), Number(monStr$1) - 1, Number(dd$1)));
 			const mon$1 = monthMap[monStr$1.toLowerCase()];
 			return new Date(Date.UTC(Number(yyyy$1), mon$1, Number(dd$1)));
 		}
 		const [_, monStr, dd, yyyy] = m;
+		if (!monStr || !dd || !yyyy) return void 0;
 		const mon = monthMap[monStr.toLowerCase()];
 		return new Date(Date.UTC(Number(yyyy), mon, Number(dd)));
 	} catch {}
@@ -362,7 +430,7 @@ function parseKeyValueLines(text) {
 		const line = rawLine.replace(/\s+$/, "");
 		if (!line.trim()) continue;
 		const bracket = line.match(/^\s*\[([^\]]+)\]\s*(.*)$/);
-		if (bracket) {
+		if (bracket?.[1] !== void 0 && bracket?.[2] !== void 0) {
 			const key = bracket[1].trim().toLowerCase();
 			const value = bracket[2].trim();
 			const list = map.get(key) ?? [];
@@ -450,7 +518,7 @@ function normalizeRdap(inputDomain, tld, rdap, rdapServersTried, includeRaw = fa
 	const updatedDate = toISO(asDateLike(byAction("last changed")?.eventDate) ?? asDateLike(doc.lastChangedDate));
 	const expirationDate = toISO(asDateLike(byAction("expiration")?.eventDate) ?? asDateLike(doc.expirationDate));
 	const deletionDate = toISO(asDateLike(byAction("deletion")?.eventDate) ?? asDateLike(doc.deletionDate));
-	const transferLock = !!statuses?.some((s) => /transferprohibited/i.test(s.status));
+	const transferLock = !!statuses?.some((s) => /transfer[-\s]*prohibited/i.test(s.status));
 	const whoisServer = asString(doc.port43);
 	return {
 		domain: unicodeName || ldhName || inputDomain,
@@ -865,16 +933,25 @@ const WHOIS_AVAILABLE_PATTERNS = [
 	/\bnot found\b/i,
 	/\bno entries found\b/i,
 	/\bno data found\b/i,
+	/\bno information available\b/i,
+	/\bno information was found\b/i,
+	/\bno data was found\b/i,
 	/\bavailable for registration\b/i,
 	/\bdomain\s+available\b/i,
 	/\bdomain status[:\s]+available\b/i,
 	/\bobject does not exist\b/i,
 	/\bthe queried object does not exist\b/i,
 	/\bqueried object does not exist\b/i,
+	/\bdoes not exist\b/i,
 	/\breturned 0 objects\b/i,
+	/\bnot been registered\b/i,
+	/\bunassignable\b/i,
+	/\bis free\b/i,
 	/\bstatus:\s*free\b/i,
 	/\bstatus:\s*available\b/i,
 	/\bno object found\b/i,
+	/\bobject_not_found\b/i,
+	/\bno se encuentra registrado\b/i,
 	/\bnicht gefunden\b/i,
 	/\bpending release\b/i
 ];
@@ -976,10 +1053,13 @@ function normalizeWhois(domain, tld, whoisText, whoisServer, includeRaw = false)
 		};
 	})();
 	const statusLines = map["domain status"] || map.status || map.flags || map.state || map["registration status"] || map.eppstatus || [];
-	const statuses = statusLines.length ? statusLines.map((line) => ({
-		status: line.split(/\s+/)[0],
-		raw: line
-	})) : void 0;
+	const statuses = statusLines.length ? statusLines.map((line) => {
+		const status = line.split(/\s+/)[0];
+		return status ? {
+			status,
+			raw: line
+		} : null;
+	}).filter((s) => s !== null) : void 0;
 	const nsLines = [
 		...map["name server"] || [],
 		...map.nameserver || [],
@@ -1015,7 +1095,7 @@ function normalizeWhois(domain, tld, whoisText, whoisServer, includeRaw = false)
 	const privacyEnabled = !!(registrant && [registrant.name, registrant.organization].filter(Boolean).some(isPrivacyName));
 	const dnssecRaw = (map.dnssec?.[0] || "").toLowerCase();
 	const dnssec = dnssecRaw ? { enabled: /signed|yes|true/.test(dnssecRaw) } : void 0;
-	const transferLock = !!statuses?.some((s) => /transferprohibited/i.test(s.status));
+	const transferLock = !!statuses?.some((s) => /transfer[-\s]*prohibited/i.test(s.raw || s.status || ""));
 	return {
 		domain,
 		tld,
@@ -1266,6 +1346,10 @@ async function lookup(domain, opts) {
 			};
 		}
 		const [first, ...rest] = chain.map((r) => normalizeWhois(domain, tld, r.text, r.serverQueried, !!opts?.includeRaw));
+		if (!first) return {
+			ok: false,
+			error: "No WHOIS data retrieved"
+		};
 		return {
 			ok: true,
 			record: rest.length ? mergeWhoisRecords(first, rest) : first
@@ -1301,4 +1385,5 @@ async function isRegistered(domain, opts) {
 const lookupDomain = lookup;
 
 //#endregion
-export { getDomainParts, getDomainTld, isAvailable, isLikelyDomain, isRegistered, lookup, lookupDomain, toRegistrableDomain };
+export { getDomainParts, getDomainTld, isAvailable, isLikelyDomain, isRegistered, lookup, lookupDomain, toRegistrableDomain };
+//# sourceMappingURL=index.mjs.map