@cleandns/whois-rdap 1.0.52 → 1.0.55

package/dist/index.test.js

@@ -0,0 +1,360 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+// Import polyfills first
+import "./polyfills.js";
+import { validateDomain } from "./utils/validateDomain.js";
+import { escapeRegex } from "./utils/escapeRegex.js";
+import { toArray } from "./utils/toArray.js";
+// ============================================================================
+// toArray utility tests
+// ============================================================================
+describe("toArray utility function", () => {
+    it("returns empty array for null", () => {
+        assert.deepStrictEqual(toArray(null), []);
+    });
+    it("returns empty array for undefined", () => {
+        assert.deepStrictEqual(toArray(undefined), []);
+    });
+    it("returns same array if already an array", () => {
+        const arr = [1, 2, 3];
+        assert.deepStrictEqual(toArray(arr), arr);
+    });
+    it("converts object to array of values", () => {
+        const obj = { a: 1, b: 2, c: 3 };
+        assert.deepStrictEqual(toArray(obj), [1, 2, 3]);
+    });
+    it("handles empty array", () => {
+        assert.deepStrictEqual(toArray([]), []);
+    });
+    it("handles empty object", () => {
+        assert.deepStrictEqual(toArray({}), []);
+    });
+    it("handles nested arrays", () => {
+        const arr = [[1, 2], [3, 4]];
+        assert.deepStrictEqual(toArray(arr), [[1, 2], [3, 4]]);
+    });
+    it("handles array-like objects with numeric keys", () => {
+        const obj = { "0": "a", "1": "b", "2": "c" };
+        assert.deepStrictEqual(toArray(obj), ["a", "b", "c"]);
+    });
+});
+describe("toArray handles RDAP edge cases (issue #16)", () => {
+    it("handles entities as object instead of array", () => {
+        const entities = {
+            "0": { roles: ["registrar"], handle: "123" },
+            "1": { roles: ["abuse"], handle: "456" },
+        };
+        const result = toArray(entities);
+        assert.strictEqual(Array.isArray(result), true);
+        assert.strictEqual(result.length, 2);
+        assert.deepStrictEqual(result[0], { roles: ["registrar"], handle: "123" });
+    });
+    it("handles nested entities being null", () => {
+        const result = toArray(null);
+        assert.deepStrictEqual(result, []);
+    });
+    it("handles nested entities being undefined", () => {
+        const result = toArray(undefined);
+        assert.deepStrictEqual(result, []);
+    });
+});
+// ============================================================================
+// escapeRegex utility tests (ReDoS prevention)
+// ============================================================================
+describe("escapeRegex utility function", () => {
+    it("escapes special regex characters", () => {
+        const input = "test.*+?^${}()|[]\\";
+        const escaped = escapeRegex(input);
+        assert.strictEqual(escaped, "test\\.\\*\\+\\?\\^\\$\\{\\}\\(\\)\\|\\[\\]\\\\");
+    });
+    it("leaves normal strings unchanged", () => {
+        const input = "GoDaddy Inc";
+        const escaped = escapeRegex(input);
+        assert.strictEqual(escaped, "GoDaddy Inc");
+    });
+    it("handles empty string", () => {
+        const escaped = escapeRegex("");
+        assert.strictEqual(escaped, "");
+    });
+    it("handles string with only special characters", () => {
+        const input = ".*+";
+        const escaped = escapeRegex(input);
+        assert.strictEqual(escaped, "\\.\\*\\+");
+    });
+    it("escaped string can be used safely in RegExp", () => {
+        const malicious = "test(.*)+$";
+        const escaped = escapeRegex(malicious);
+        // Should not throw when creating RegExp
+        const regex = new RegExp(escaped, "i");
+        // The escaped string should match literally
+        assert.strictEqual(regex.test("test(.*)+$"), true);
+        assert.strictEqual(regex.test("testABC"), false);
+    });
+});
+// ============================================================================
+// validateDomain utility tests
+// ============================================================================
+describe("validateDomain utility function", () => {
+    it("accepts valid domain", () => {
+        const result = validateDomain("example.com");
+        assert.strictEqual(result, "example.com");
+    });
+    it("trims whitespace", () => {
+        const result = validateDomain("  example.com  ");
+        assert.strictEqual(result, "example.com");
+    });
+    it("converts to lowercase", () => {
+        const result = validateDomain("EXAMPLE.COM");
+        assert.strictEqual(result, "example.com");
+    });
+    it("throws on empty string", () => {
+        assert.throws(() => validateDomain(""), /non-empty string/);
+    });
+    it("throws on whitespace-only string", () => {
+        assert.throws(() => validateDomain("   "), /non-empty string/);
+    });
+    it("throws on null", () => {
+        assert.throws(() => validateDomain(null), /non-empty string/);
+    });
+    it("throws on undefined", () => {
+        assert.throws(() => validateDomain(undefined), /non-empty string/);
+    });
+    it("throws on domain too long", () => {
+        const longDomain = "a".repeat(254) + ".com";
+        assert.throws(() => validateDomain(longDomain), /too long/);
+    });
+    it("accepts domain at max length", () => {
+        const maxDomain = "a".repeat(249) + ".com"; // 253 chars
+        const result = validateDomain(maxDomain);
+        assert.strictEqual(result.length, 253);
+    });
+});
+// ============================================================================
+// vcardArray safety checks (issue #12)
+// ============================================================================
+describe("vcardArray safety checks (issue #12)", () => {
+    it("Array.isArray correctly identifies arrays", () => {
+        const vcardArray = ["vcard", [["fn", {}, "text", "Test"]]];
+        assert.strictEqual(Array.isArray(vcardArray[1]), true);
+        assert.strictEqual(typeof vcardArray[1].find, "function");
+    });
+    it("Array.isArray returns false for non-arrays", () => {
+        const vcardArray = ["vcard", "not-an-array"];
+        assert.strictEqual(Array.isArray(vcardArray[1]), false);
+    });
+    it("Array.isArray returns false for undefined", () => {
+        const vcardArray = ["vcard"];
+        assert.strictEqual(Array.isArray(vcardArray[1]), false);
+    });
+    it("safe access pattern prevents TypeError", () => {
+        const vcardArray = ["vcard"];
+        const hasFn = vcardArray && Array.isArray(vcardArray[1]) && vcardArray[1].find((el) => el[0] === 'fn');
+        assert.strictEqual(hasFn, false);
+    });
+    it("safe access pattern works with valid data", () => {
+        const vcardArray = ["vcard", [["fn", {}, "text", "Test Registrar"]]];
+        const hasFn = vcardArray && Array.isArray(vcardArray[1]) && vcardArray[1].find((el) => el[0] === 'fn');
+        assert.deepStrictEqual(hasFn, ["fn", {}, "text", "Test Registrar"]);
+    });
+});
+// ============================================================================
+// debug module integration (issue #13)
+// ============================================================================
+describe("debug module integration (issue #13)", () => {
+    it("debug module is importable", async () => {
+        const createDebug = (await import("debug")).default;
+        assert.strictEqual(typeof createDebug, "function");
+    });
+    it("debug instance can be created", async () => {
+        const createDebug = (await import("debug")).default;
+        const debug = createDebug("test:namespace");
+        assert.strictEqual(typeof debug, "function");
+    });
+    it("debug function can be called without error", async () => {
+        const createDebug = (await import("debug")).default;
+        const debug = createDebug("test:namespace");
+        // Should not throw
+        debug("test message %s", "arg");
+    });
+});
+// ============================================================================
+// findTimestamps anti-pattern fix (commit comment)
+// ============================================================================
+describe("findTimestamps behavior", () => {
+    it("properly extracts timestamps from events array", () => {
+        var _a, _b, _c;
+        // This tests the fix for the anti-pattern where events.find was used with side effects
+        const events = [
+            { eventAction: "registration", eventDate: "2020-01-01T00:00:00Z" },
+            { eventAction: "last changed", eventDate: "2023-06-15T12:00:00Z" },
+            { eventAction: "expiration", eventDate: "2025-01-01T00:00:00Z" },
+        ];
+        // The function should properly iterate and extract all timestamps
+        // without relying on side effects in find()
+        const created = (_a = events.find(ev => ev.eventAction === "registration")) === null || _a === void 0 ? void 0 : _a.eventDate;
+        const updated = (_b = events.find(ev => ev.eventAction === "last changed")) === null || _b === void 0 ? void 0 : _b.eventDate;
+        const expires = (_c = events.find(ev => ev.eventAction === "expiration")) === null || _c === void 0 ? void 0 : _c.eventDate;
+        assert.strictEqual(created, "2020-01-01T00:00:00Z");
+        assert.strictEqual(updated, "2023-06-15T12:00:00Z");
+        assert.strictEqual(expires, "2025-01-01T00:00:00Z");
+    });
+    it("handles events with invalid dates", () => {
+        const events = [
+            { eventAction: "registration", eventDate: "invalid-date" },
+            { eventAction: "registration", eventDate: "2020-01-01T00:00:00Z" },
+        ];
+        // Should skip invalid dates and find valid one
+        let validDate = null;
+        for (const ev of events) {
+            if (ev.eventAction === "registration" && ev.eventDate) {
+                const d = new Date(ev.eventDate);
+                if (!isNaN(d.valueOf())) {
+                    validDate = d;
+                    break;
+                }
+            }
+        }
+        assert.notStrictEqual(validDate, null);
+        assert.strictEqual(validDate === null || validDate === void 0 ? void 0 : validDate.toISOString(), "2020-01-01T00:00:00.000Z");
+    });
+    it("handles +0000Z date format", () => {
+        const dateStr = "2020-01-01T00:00:00+0000Z";
+        const normalized = dateStr.replace(/\+0000Z$/, "Z");
+        const d = new Date(normalized);
+        assert.strictEqual(isNaN(d.valueOf()), false);
+        assert.strictEqual(d.toISOString(), "2020-01-01T00:00:00.000Z");
+    });
+});
+// ============================================================================
+// findInObject null safety
+// ============================================================================
+describe("findInObject null safety", () => {
+    it("handles null input", async () => {
+        const { findInObject } = await import("./utils/findInObject.js");
+        const result = findInObject(null, () => true, (el) => el, "fallback");
+        assert.strictEqual(result, "fallback");
+    });
+    it("handles undefined input", async () => {
+        const { findInObject } = await import("./utils/findInObject.js");
+        const result = findInObject(undefined, () => true, (el) => el, "fallback");
+        assert.strictEqual(result, "fallback");
+    });
+    it("handles object with null values", async () => {
+        const { findInObject } = await import("./utils/findInObject.js");
+        const obj = { a: null, b: { c: "found" } };
+        const result = findInObject(obj, (el) => el === "found", (el) => el, "fallback");
+        assert.strictEqual(result, "found");
+    });
+    it("finds nested value", async () => {
+        const { findInObject } = await import("./utils/findInObject.js");
+        const obj = { a: { b: { c: ["fn", {}, "text", "Test"] } } };
+        const result = findInObject(obj, (el) => Array.isArray(el) && el[0] === "fn", (el) => el[3], "fallback");
+        assert.strictEqual(result, "Test");
+    });
+});
+// ============================================================================
+// IP response parsing null safety
+// ============================================================================
+describe("IP response parsing", () => {
+    it("handles missing port43 field", async () => {
+        const { parseIpResponse } = await import("./ip.js");
+        const response = {
+            found: false,
+            registrar: { id: 0, name: null },
+        };
+        const rdap = {
+            handle: "NET-1-0-0-0-1",
+            startAddress: "1.0.0.0",
+            endAddress: "1.255.255.255",
+            // port43 is missing
+        };
+        // Should not throw
+        parseIpResponse("1.0.0.1", rdap, response);
+        assert.strictEqual(response.registrar.name, "");
+    });
+    it("handles port43 without expected pattern", async () => {
+        const { parseIpResponse } = await import("./ip.js");
+        const response = {
+            found: false,
+            registrar: { id: 0, name: null },
+        };
+        const rdap = {
+            handle: "NET-1-0-0-0-1",
+            port43: "whois-server", // No dots
+        };
+        // Should not throw
+        parseIpResponse("1.0.0.1", rdap, response);
+        assert.strictEqual(response.registrar.name, "");
+    });
+    it("extracts registry from valid port43", async () => {
+        const { parseIpResponse } = await import("./ip.js");
+        const response = {
+            found: false,
+            registrar: { id: 0, name: null },
+        };
+        const rdap = {
+            handle: "NET-1-0-0-0-1",
+            port43: "whois.arin.net",
+        };
+        parseIpResponse("1.0.0.1", rdap, response);
+        assert.strictEqual(response.registrar.name, "ARIN");
+    });
+});
+// ============================================================================
+// String.prototype.toWellFormed polyfill tests (Node.js 18 compatibility)
+// ============================================================================
+describe("String.prototype.toWellFormed polyfill", () => {
+    it("toWellFormed is available as a function", () => {
+        assert.strictEqual(typeof "".toWellFormed, "function");
+    });
+    it("returns same string for well-formed input", () => {
+        const str = "Hello, World!";
+        assert.strictEqual(str.toWellFormed(), str);
+    });
+    it("handles empty string", () => {
+        assert.strictEqual("".toWellFormed(), "");
+    });
+    it("handles valid surrogate pairs (emoji)", () => {
+        const emoji = "😀"; // U+1F600 = \uD83D\uDE00
+        assert.strictEqual(emoji.toWellFormed(), emoji);
+    });
+    it("replaces lone high surrogate with U+FFFD", () => {
+        const loneHigh = "abc\uD800def";
+        assert.strictEqual(loneHigh.toWellFormed(), "abc\uFFFDdef");
+    });
+    it("replaces lone low surrogate with U+FFFD", () => {
+        const loneLow = "abc\uDC00def";
+        assert.strictEqual(loneLow.toWellFormed(), "abc\uFFFDdef");
+    });
+    it("replaces lone high surrogate at end", () => {
+        const str = "test\uD800";
+        assert.strictEqual(str.toWellFormed(), "test\uFFFD");
+    });
+    it("handles multiple lone surrogates", () => {
+        const str = "\uD800\uD800";
+        assert.strictEqual(str.toWellFormed(), "\uFFFD\uFFFD");
+    });
+    it("preserves valid surrogate pairs among lone surrogates", () => {
+        const str = "\uD800\uD83D\uDE00\uDC00"; // lone high, valid pair, lone low
+        assert.strictEqual(str.toWellFormed(), "\uFFFD😀\uFFFD");
+    });
+});
+describe("String.prototype.isWellFormed polyfill", () => {
+    it("isWellFormed is available as a function", () => {
+        assert.strictEqual(typeof "".isWellFormed, "function");
+    });
+    it("returns true for well-formed strings", () => {
+        assert.strictEqual("Hello".isWellFormed(), true);
+        assert.strictEqual("".isWellFormed(), true);
+        assert.strictEqual("😀".isWellFormed(), true);
+    });
+    it("returns false for lone high surrogate", () => {
+        assert.strictEqual("test\uD800".isWellFormed(), false);
+    });
+    it("returns false for lone low surrogate", () => {
+        assert.strictEqual("test\uDC00".isWellFormed(), false);
+    });
+    it("returns true for valid surrogate pair", () => {
+        assert.strictEqual("\uD83D\uDE00".isWellFormed(), true);
+    });
+});

package/dist/ip.js

@@ -1,7 +1,14 @@
 export function parseIpResponse(ip, rdap, response) {
     var _a, _b, _c;
     response.found = Boolean(rdap.handle);
-    const registry = rdap.port43 ? rdap.port43.match(/\.(\w+)\./)[1].toUpperCase() : '';
+    // Safely extract registry from port43 with null check
+    let registry = '';
+    if (rdap.port43) {
+        const match = rdap.port43.match(/\.(\w+)\./);
+        if (match) {
+            registry = match[1].toUpperCase();
+        }
+    }
     const realRdapServer = (_c = (_b = (_a = rdap.links) === null || _a === void 0 ? void 0 : _a.find(({ rel }) => rel === 'self')) === null || _b === void 0 ? void 0 : _b.value) === null || _c === void 0 ? void 0 : _c.replace(/\/ip\/.*/, '/ip/');
     response.server = realRdapServer || 'https://rdap.org/ip/';
     response.identity = {

package/dist/polyfills.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Polyfills for Node.js 18 compatibility.
+ * String.prototype.toWellFormed was added in Node.js 20.
+ */
+declare global {
+    interface String {
+        toWellFormed(): string;
+        isWellFormed(): boolean;
+    }
+}
+export {};

package/dist/polyfills.js

@@ -0,0 +1,64 @@
+/**
+ * Polyfills for Node.js 18 compatibility.
+ * String.prototype.toWellFormed was added in Node.js 20.
+ */
+// Polyfill for String.prototype.toWellFormed (ES2024)
+// Replaces lone surrogates with U+FFFD (replacement character)
+if (typeof String.prototype.toWellFormed !== 'function') {
+    String.prototype.toWellFormed = function () {
+        const str = String(this);
+        const len = str.length;
+        let result = '';
+        for (let i = 0; i < len; i++) {
+            const code = str.charCodeAt(i);
+            // Check for lone surrogates
+            if (code >= 0xD800 && code <= 0xDBFF) {
+                // High surrogate
+                if (i + 1 < len) {
+                    const next = str.charCodeAt(i + 1);
+                    if (next >= 0xDC00 && next <= 0xDFFF) {
+                        // Valid surrogate pair
+                        result += str[i] + str[i + 1];
+                        i++;
+                        continue;
+                    }
+                }
+                // Lone high surrogate - replace with U+FFFD
+                result += '\uFFFD';
+            }
+            else if (code >= 0xDC00 && code <= 0xDFFF) {
+                // Lone low surrogate - replace with U+FFFD
+                result += '\uFFFD';
+            }
+            else {
+                result += str[i];
+            }
+        }
+        return result;
+    };
+}
+// Polyfill for String.prototype.isWellFormed (ES2024)
+if (typeof String.prototype.isWellFormed !== 'function') {
+    String.prototype.isWellFormed = function () {
+        const str = String(this);
+        const len = str.length;
+        for (let i = 0; i < len; i++) {
+            const code = str.charCodeAt(i);
+            if (code >= 0xD800 && code <= 0xDBFF) {
+                // High surrogate - check for valid pair
+                if (i + 1 >= len)
+                    return false;
+                const next = str.charCodeAt(i + 1);
+                if (next < 0xDC00 || next > 0xDFFF)
+                    return false;
+                i++; // Skip the low surrogate
+            }
+            else if (code >= 0xDC00 && code <= 0xDFFF) {
+                // Lone low surrogate
+                return false;
+            }
+        }
+        return true;
+    };
+}
+export {};

package/dist/port43.js

@@ -4,6 +4,10 @@ import { Socket } from "net";
 import { port43servers, port43parsers } from "./port43servers.js";
 import { ianaToRegistrarCache } from "./utils/ianaIdToRegistrar.js";
 import { normalizeWhoisStatus } from "./whoisStatus.js";
+import createDebug from "debug";
+import { escapeRegex } from "./utils/escapeRegex.js";
+// Debug logger - enable with DEBUG=whois:* environment variable
+const debug = createDebug("whois:port43");
 export function determinePort43Domain(actor) {
     const parsed = parseDomain(actor);
     if (parsed.type === ParseResultType.Listed) {
@@ -30,7 +34,7 @@ export async function port43(actor, _fetch) {
         ? opts.query.replace("$addr", domain)
         : `${domain}\r\n`;
     const port = (opts === null || opts === void 0 ? void 0 : opts.port) || 43;
-    // console.log(`looking up ${domain} on ${server}`);
+    debug("looking up %s on %s:%d", domain, server, port);
     const response = {
         found: true,
         statusCode: 200,
@@ -73,7 +77,7 @@ export async function port43(actor, _fetch) {
         }
     }
     catch (error) {
-        console.warn({ port, server, query, error: error.message });
+        debug("port43 lookup error: %O", { port, server, query, error: error.message });
         response.found = false;
         response.statusCode = 500;
         response.error = error.message || "Unknown error during port 43 lookup";
@@ -82,7 +86,6 @@ export async function port43(actor, _fetch) {
         return response;
     }
     port43response = port43response.replace(/^[ \t]+/gm, "");
-    // console.log(port43response);
     let m;
     if (m = port43response.match(/^%*\s*(NOT FOUND|No match|NO OBJECT FOUND|No entries found|No Data Found|Domain is available for registration|No information available|Status: free)\b/im)) {
         response.found = false;
@@ -112,10 +115,6 @@ export async function port43(actor, _fetch) {
     !response.reseller &&
         (m = port43response.match(/^(?:Reseller(?: Name)?|reseller_name|reseller):[ \t]*(\S.+)/im)) &&
         (response.reseller = m[1].trim());
-    // console.log(port43response)
-    // Updated Date: 2024-11-21T13:42:54Z
-    // Creation Date: 2017-12-16T02:11:08Z
-    // Registry Expiry Date: 2031-07-10T02:11:08Z
     !response.ts.updated &&
         (m = port43response.match(/^(?:Last Modified|Updated Date|Last updated on|domain_datelastmodified|last-update|modified|last modified)\.*:[ \t]*(\S.+)/im)) &&
         (response.ts.updated = new Date(reformatDate(m[1])) || null);
@@ -169,6 +168,7 @@ export async function port43(actor, _fetch) {
         response.ts.updated = null;
     if (response.ts.expires && !response.ts.expires.valueOf())
         response.ts.expires = null;
+    // Match registrar name against IANA cache using escaped regex to prevent ReDoS
     if (response.registrar.id === 0 && response.registrar.name !== "") {
         for (const [id, { name }] of ianaToRegistrarCache.entries()) {
             if (name === response.registrar.name) {
@@ -177,19 +177,33 @@ export async function port43(actor, _fetch) {
             }
         }
     }
-    if (response.registrar.id === 0 && response.registrar.name !== "") {
+    if (response.registrar.id === 0 && response.registrar.name && response.registrar.name !== "") {
+        const escapedName = escapeRegex(response.registrar.name);
         for (const [id, { name }] of ianaToRegistrarCache.entries()) {
-            if (name.match(new RegExp(`\\b${response.registrar.name}\\b`, "i"))) {
-                response.registrar.id = id;
-                break;
+            try {
+                if (name.match(new RegExp(`\\b${escapedName}\\b`, "i"))) {
+                    response.registrar.id = id;
+                    break;
+                }
+            }
+            catch (_o) {
+                // Skip if regex still fails for some reason
+                continue;
             }
         }
     }
     if (response.registrar.id === 0 && response.registrar.name) {
+        const escapedName = escapeRegex(response.registrar.name.replace(/,.*/, ""));
         for (const [id, { name }] of ianaToRegistrarCache.entries()) {
-            if (name.match(new RegExp(`\\b${response.registrar.name.replace(/,.*/, "")}\\b`, "i"))) {
-                response.registrar.id = id;
-                break;
+            try {
+                if (name.match(new RegExp(`\\b${escapedName}\\b`, "i"))) {
+                    response.registrar.id = id;
+                    break;
+                }
+            }
+            catch (_p) {
+                // Skip if regex still fails for some reason
+                continue;
             }
         }
     }

package/dist/utils/escapeRegex.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Escapes special regex characters in a string.
+ * Prevents ReDoS attacks when using user input in RegExp constructor.
+ */
+export declare function escapeRegex(str: string): string;

package/dist/utils/escapeRegex.js

@@ -0,0 +1,7 @@
+/**
+ * Escapes special regex characters in a string.
+ * Prevents ReDoS attacks when using user input in RegExp constructor.
+ */
+export function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/utils/findInObject.js

@@ -3,15 +3,25 @@ export function findInObject(obj, condition, extractor, fallback) {
     return found === undefined ? fallback : extractor(found);
 }
 function _findInObject(obj, condition) {
+    // Handle null/undefined
+    if (obj === null || obj === undefined) {
+        return undefined;
+    }
     for (const key in obj) {
-        if (condition(obj[key])) {
-            return obj[key];
+        // Skip inherited properties
+        if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+            continue;
+        }
+        const value = obj[key];
+        if (condition(value)) {
+            return value;
         }
-        if (typeof obj[key] === "object") {
-            const result = _findInObject(obj[key], condition);
+        if (value !== null && typeof value === "object") {
+            const result = _findInObject(value, condition);
             if (result !== undefined) {
                 return result;
             }
         }
     }
+    return undefined;
 }

package/dist/utils/findNameservers.d.ts

@@ -0,0 +1 @@
+export declare function findNameservers(values: any[]): string[];

package/dist/utils/findNameservers.js

@@ -0,0 +1,15 @@
+export function findNameservers(values) {
+    let nameservers = [];
+    if (Array.isArray(values)) {
+        nameservers = values;
+    }
+    else if (typeof values === "object") {
+        nameservers = Object.values(values);
+    }
+    return nameservers
+        .map((ns) => { var _a; return ns.ldhName || ns.ldnName || ((_a = ns.ipAddresses) === null || _a === void 0 ? void 0 : _a.v4); })
+        .flat()
+        .filter((ns) => ns)
+        .map((ns) => (ns.stringValue || ns).toLocaleLowerCase())
+        .sort();
+}

package/dist/utils/findStatus.d.ts

@@ -0,0 +1 @@
+export declare function findStatus(statuses: string | string[], domain: string): string[];

package/dist/utils/findStatus.js

@@ -0,0 +1,10 @@
+import { normalizeWhoisStatus } from "../whoisStatus.js";
+export function findStatus(statuses, domain) {
+    return (Array.isArray(statuses)
+        ? statuses
+        : statuses && typeof statuses === "object"
+            ? Object.keys(statuses)
+            : typeof statuses === "string"
+                ? statuses.trim().split(/\s*,\s*/)
+                : []).map((status) => normalizeWhoisStatus(status));
+}

package/dist/utils/findTimestamps.d.ts

@@ -0,0 +1,6 @@
+import { WhoisTimestampFields } from "../../whois.js";
+/**
+ * Extracts timestamps from RDAP events array.
+ * Properly iterates through events and breaks when a match is found.
+ */
+export declare function findTimestamps(values: any[]): Record<WhoisTimestampFields, Date | null>;