@slicedearth/whoisleuth-cli 1.32.0

package/lib/perceptual-hash.mjs

@@ -0,0 +1,451 @@
+// Perceptual (fuzzy) favicon hashing - complements the exact SHA-256 in
+// lib/favicon.mts. An exact hash only catches a byte-for-byte copied favicon;
+// a lookalike that resized, recompressed, or re-saved the brand's icon (very
+// common - the copy passes through a different tool than the original) slips
+// past it while still being visually identical. A perceptual hash catches
+// those near-clones, with the exact hash retained as the higher-confidence
+// tier.
+//
+// Pure JS, no external dependency and no native bindings, so it runs the same
+// on the serverless (Netlify) and self-hosted (Express) paths. That means
+// decoding the image ourselves: Node has no built-in image decoder, only
+// zlib (used here for PNG inflate). We support the favicon formats that
+// actually occur in practice - PNG, and PNG- or BMP-encoded ICO - and return
+// null for anything else (GIF/JPEG/SVG), which simply falls back to
+// exact-hash-only, exactly as before this module existed.
+//
+// The hash itself is a 64-bit dHash (difference hash): downscale to 9x8
+// grayscale and record, per row, whether each pixel is brighter than its
+// right-hand neighbour. dHash is intentionally robust to scale and to
+// uniform brightness/contrast shifts, which is exactly the resave/recompress
+// case, while staying cheap (no DCT). Output is 16 lowercase hex chars;
+// similarity is the Hamming distance between two such strings.
+import * as zlib from 'node:zlib';
+// Bound the decode work on attacker-controlled image bytes. Real favicons top
+// out around 256x256; anything claiming to be larger is refused rather than
+// decoded (it would also never be a legitimate favicon to compare against).
+const MAX_DIM = 1024;
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+function byteAt(bytes, index) {
+    return bytes[index] ?? 0;
+}
+function isPng(buf) {
+    return buf.length >= 8 && buf.subarray(0, 8).equals(PNG_SIGNATURE);
+}
+// ICO container: reserved(0) + type(1 = icon) as two little-endian uint16s.
+function isIco(buf) {
+    return buf.length >= 6 && buf.readUInt16LE(0) === 0 && buf.readUInt16LE(2) === 1;
+}
+function paethPredictor(a, b, c) {
+    const p = a + b - c;
+    const pa = Math.abs(p - a);
+    const pb = Math.abs(p - b);
+    const pc = Math.abs(p - c);
+    if (pa <= pb && pa <= pc)
+        return a;
+    if (pb <= pc)
+        return b;
+    return c;
+}
+// Decodes the subset of PNG that favicons actually use: 8-bit depth,
+// non-interlaced, colour types 0/2/3/6 (gray, RGB, palette, RGBA). Returns
+// { width, height, pixels } with pixels as RGBA bytes, or null for anything
+// outside that subset (or malformed input). CRCs are intentionally not
+// verified - we're computing a fuzzy hash, not validating integrity.
+function decodePng(buf) {
+    const CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
+    let width = 0;
+    let height = 0;
+    let bitDepth = 0;
+    let colorType = 0;
+    let interlace = 0;
+    let palette = null;
+    let transparency = null;
+    const idatParts = [];
+    let offset = 8;
+    while (offset + 8 <= buf.length) {
+        const length = buf.readUInt32BE(offset);
+        const type = buf.toString('ascii', offset + 4, offset + 8);
+        const dataStart = offset + 8;
+        const dataEnd = dataStart + length;
+        if (dataEnd + 4 > buf.length)
+            break; // truncated chunk
+        const data = buf.subarray(dataStart, dataEnd);
+        if (type === 'IHDR') {
+            width = buf.readUInt32BE(dataStart);
+            height = buf.readUInt32BE(dataStart + 4);
+            bitDepth = byteAt(data, 8);
+            colorType = byteAt(data, 9);
+            interlace = byteAt(data, 12);
+        }
+        else if (type === 'PLTE') {
+            palette = data;
+        }
+        else if (type === 'tRNS') {
+            transparency = data;
+        }
+        else if (type === 'IDAT') {
+            idatParts.push(Buffer.from(data));
+        }
+        else if (type === 'IEND') {
+            break;
+        }
+        offset = dataEnd + 4; // skip the 4-byte CRC
+    }
+    const channels = CHANNELS[colorType];
+    if (!channels || bitDepth !== 8 || interlace !== 0)
+        return null;
+    if (width < 1 || height < 1 || width > MAX_DIM || height > MAX_DIM)
+        return null;
+    if (colorType === 3 && !palette)
+        return null;
+    if (idatParts.length === 0)
+        return null;
+    // A valid non-interlaced 8-bit PNG decompresses to exactly one filter byte
+    // plus one scanline per row. Cap the inflate at that size so a malicious
+    // IDAT can't expand a sub-200KB favicon into hundreds of MB (a zip bomb)
+    // and exhaust the process during concurrent deep scans - dimensions are
+    // already bounded by MAX_DIM above, so this ceiling is a few MB at most.
+    const stride = width * channels;
+    const expandedLength = (stride + 1) * height;
+    let raw;
+    try {
+        raw = zlib.inflateSync(Buffer.concat(idatParts), { maxOutputLength: expandedLength });
+    }
+    catch {
+        return null; // malformed, or output would exceed the expected size
+    }
+    if (raw.length < expandedLength)
+        return null;
+    // Reverse the per-scanline PNG filters into the raw sample bytes.
+    const recon = new Uint8Array(stride * height);
+    let pos = 0;
+    for (let y = 0; y < height; y += 1) {
+        const filterType = byteAt(raw, pos);
+        pos += 1;
+        for (let x = 0; x < stride; x += 1) {
+            const rawVal = byteAt(raw, pos + x);
+            const a = x >= channels ? byteAt(recon, y * stride + x - channels) : 0;
+            const b = y > 0 ? byteAt(recon, (y - 1) * stride + x) : 0;
+            const c = x >= channels && y > 0 ? byteAt(recon, (y - 1) * stride + x - channels) : 0;
+            let value;
+            switch (filterType) {
+                case 0:
+                    value = rawVal;
+                    break;
+                case 1:
+                    value = rawVal + a;
+                    break;
+                case 2:
+                    value = rawVal + b;
+                    break;
+                case 3:
+                    value = rawVal + ((a + b) >> 1);
+                    break;
+                case 4:
+                    value = rawVal + paethPredictor(a, b, c);
+                    break;
+                default: return null;
+            }
+            recon[y * stride + x] = value & 0xff;
+        }
+        pos += stride;
+    }
+    // Expand whatever colour type we decoded into a uniform RGBA buffer.
+    const pixels = new Uint8ClampedArray(width * height * 4);
+    for (let i = 0; i < width * height; i += 1) {
+        const s = i * channels;
+        let r = 0;
+        let g = 0;
+        let b = 0;
+        let alpha = 255;
+        if (colorType === 0) {
+            r = g = b = byteAt(recon, s);
+        }
+        else if (colorType === 4) {
+            r = g = b = byteAt(recon, s);
+            alpha = byteAt(recon, s + 1);
+        }
+        else if (colorType === 2) {
+            r = byteAt(recon, s);
+            g = byteAt(recon, s + 1);
+            b = byteAt(recon, s + 2);
+        }
+        else if (colorType === 6) {
+            r = byteAt(recon, s);
+            g = byteAt(recon, s + 1);
+            b = byteAt(recon, s + 2);
+            alpha = byteAt(recon, s + 3);
+        }
+        else { // palette
+            const idx = byteAt(recon, s);
+            if (!palette || idx * 3 + 2 >= palette.length)
+                return null;
+            r = byteAt(palette, idx * 3);
+            g = byteAt(palette, idx * 3 + 1);
+            b = byteAt(palette, idx * 3 + 2);
+            if (transparency && idx < transparency.length)
+                alpha = byteAt(transparency, idx);
+        }
+        const d = i * 4;
+        pixels[d] = r;
+        pixels[d + 1] = g;
+        pixels[d + 2] = b;
+        pixels[d + 3] = alpha;
+    }
+    return { width, height, pixels };
+}
+// Decodes an uncompressed BMP DIB (the classic favicon.ico payload) - a
+// BITMAPINFOHEADER, an optional palette (for <=8-bit depths), then bottom-up
+// pixel rows. Supports the depths favicons actually ship: 1/4/8-bit
+// palettized and 24/32-bit truecolour. The stored height is doubled (it
+// includes the 1-bpp AND transparency mask); we use the real image height
+// and ignore the mask (opaque is fine for a brightness-based hash).
+function decodeDib(buf) {
+    if (buf.length < 40)
+        return null;
+    const headerSize = buf.readUInt32LE(0);
+    if (headerSize < 40)
+        return null;
+    const width = buf.readInt32LE(4);
+    const rawHeight = buf.readInt32LE(8);
+    const bitCount = buf.readUInt16LE(14);
+    const compression = buf.readUInt32LE(16);
+    if (compression !== 0)
+        return null; // BI_RGB only
+    if (![1, 4, 8, 24, 32].includes(bitCount))
+        return null;
+    const height = Math.floor(Math.abs(rawHeight) / 2) || Math.abs(rawHeight);
+    if (width < 1 || height < 1 || width > MAX_DIM || height > MAX_DIM)
+        return null;
+    // Palette (BGRA quads) for indexed depths, sitting between the header and
+    // the pixel data. biClrUsed (offset 32) overrides the default 2^depth count.
+    let palette = null;
+    let pixelStart = headerSize;
+    if (bitCount <= 8) {
+        const declared = buf.readUInt32LE(32);
+        const paletteCount = declared > 0 ? declared : (1 << bitCount);
+        const paletteBytes = paletteCount * 4;
+        if (headerSize + paletteBytes > buf.length)
+            return null;
+        palette = { start: headerSize, count: paletteCount };
+        pixelStart = headerSize + paletteBytes;
+    }
+    const rowSize = Math.floor((bitCount * width + 31) / 32) * 4; // padded to 4 bytes
+    if (pixelStart + rowSize * height > buf.length)
+        return null;
+    const paletteColor = (index) => {
+        if (!palette || index >= palette.count)
+            return [0, 0, 0];
+        const p = palette.start + index * 4;
+        return [byteAt(buf, p + 2), byteAt(buf, p + 1), byteAt(buf, p)]; // stored BGRA -> RGB
+    };
+    const pixels = new Uint8ClampedArray(width * height * 4);
+    let sawNonzeroAlpha = false;
+    for (let y = 0; y < height; y += 1) {
+        const srcRow = pixelStart + (height - 1 - y) * rowSize; // stored bottom-up
+        for (let x = 0; x < width; x += 1) {
+            let r = 0;
+            let g = 0;
+            let b = 0;
+            let alpha = 255;
+            if (bitCount === 24 || bitCount === 32) {
+                const s = srcRow + x * (bitCount / 8);
+                b = byteAt(buf, s);
+                g = byteAt(buf, s + 1);
+                r = byteAt(buf, s + 2);
+                if (bitCount === 32)
+                    alpha = byteAt(buf, s + 3);
+            }
+            else if (bitCount === 8) {
+                [r, g, b] = paletteColor(byteAt(buf, srcRow + x));
+            }
+            else if (bitCount === 4) {
+                const byte = byteAt(buf, srcRow + (x >> 1));
+                const index = x & 1 ? byte & 0x0f : byte >> 4;
+                [r, g, b] = paletteColor(index);
+            }
+            else { // 1-bit
+                const byte = byteAt(buf, srcRow + (x >> 3));
+                const index = (byte >> (7 - (x & 7))) & 1;
+                [r, g, b] = paletteColor(index);
+            }
+            if (alpha !== 0)
+                sawNonzeroAlpha = true;
+            const d = (y * width + x) * 4;
+            pixels[d] = r;
+            pixels[d + 1] = g;
+            pixels[d + 2] = b;
+            pixels[d + 3] = alpha;
+        }
+    }
+    // Many legacy 32-bit BMP-in-ICO payloads leave the alpha plane all-zero and
+    // rely on the separate 1-bit AND mask for transparency. Trusting those alpha
+    // bytes literally would composite the whole icon to white and hash to a
+    // meaningless all-zero value, so treat a fully-zero alpha plane as opaque.
+    if (bitCount === 32 && !sawNonzeroAlpha) {
+        for (let i = 3; i < pixels.length; i += 4)
+            pixels[i] = 255;
+    }
+    return { width, height, pixels };
+}
+// Decodes an ICO directory, preferring the largest image (best detail for
+// hashing) but falling back to progressively smaller entries when a larger
+// one is in a variant we don't decode (e.g. a 4-bit-palette PNG sub-entry
+// alongside a plain BMP one). A multi-size favicon.ico only needs one usable
+// entry, and any size hashes to nearly the same dHash since it downsamples.
+function decodeIco(buf) {
+    const count = buf.readUInt16LE(4);
+    if (count < 1 || 6 + count * 16 > buf.length)
+        return null;
+    const entries = [];
+    for (let i = 0; i < count; i += 1) {
+        const entry = 6 + i * 16;
+        const w = buf[entry] || 256;
+        const h = buf[entry + 1] || 256;
+        const size = buf.readUInt32LE(entry + 8);
+        const dataOffset = buf.readUInt32LE(entry + 12);
+        if (dataOffset + size > buf.length || size < 1)
+            continue;
+        entries.push({ area: w * h, dataOffset, size });
+    }
+    entries.sort((a, b) => b.area - a.area);
+    for (const { dataOffset, size } of entries) {
+        const payload = buf.subarray(dataOffset, dataOffset + size);
+        const image = isPng(payload) ? decodePng(payload) : decodeDib(payload);
+        if (image)
+            return image;
+    }
+    return null;
+}
+function decodeImage(buf) {
+    if (!Buffer.isBuffer(buf))
+        return null;
+    if (isPng(buf))
+        return decodePng(buf);
+    if (isIco(buf))
+        return decodeIco(buf);
+    return null;
+}
+// Downscales to cols x rows of grayscale luma. Transparency is composited
+// over white first, so a favicon with a transparent background hashes the
+// same way it visually renders on this app's (and most) light surfaces,
+// rather than letting undefined transparent RGB values swing the hash.
+function grayscaleGrid(image, cols, rows) {
+    const { width, height, pixels } = image;
+    const grid = new Float64Array(cols * rows);
+    for (let ty = 0; ty < rows; ty += 1) {
+        const y0 = Math.floor((ty * height) / rows);
+        const y1 = Math.max(y0 + 1, Math.floor(((ty + 1) * height) / rows));
+        for (let tx = 0; tx < cols; tx += 1) {
+            const x0 = Math.floor((tx * width) / cols);
+            const x1 = Math.max(x0 + 1, Math.floor(((tx + 1) * width) / cols));
+            let sum = 0;
+            let n = 0;
+            for (let y = y0; y < y1 && y < height; y += 1) {
+                for (let x = x0; x < x1 && x < width; x += 1) {
+                    const d = (y * width + x) * 4;
+                    const a = byteAt(pixels, d + 3) / 255;
+                    const r = byteAt(pixels, d) * a + 255 * (1 - a);
+                    const g = byteAt(pixels, d + 1) * a + 255 * (1 - a);
+                    const b = byteAt(pixels, d + 2) * a + 255 * (1 - a);
+                    sum += 0.299 * r + 0.587 * g + 0.114 * b;
+                    n += 1;
+                }
+            }
+            grid[ty * cols + tx] = n ? sum / n : 0;
+        }
+    }
+    return grid;
+}
+// dHash only records the *direction* of horizontal brightness changes, so a
+// whole class of icons - a solid-colour square, but also any image whose
+// brightness is monotonic left-to-right or varies only vertically - produces
+// the same all-zero hash regardless of their actual appearance. Two such
+// icons would then read as a perceptual match, falsely scoring risk and
+// clustering unrelated domains. This is a property of the resulting *hash*,
+// not the source image's variance (a bright left-to-right gradient has high
+// variance yet still hashes to all zeros), so it's checked on the bit
+// population of the finished hash: too few or too many set bits carries too
+// little structure to compare safely, so we return no perceptual hash
+// (callers fall back to the exact hash) rather than a collision-prone one.
+// isInformativeHash re-checks this at comparison time too, since a Brand
+// Profile saved before this guard existed may already hold a degenerate hash.
+const MIN_INFORMATIVE_BITS = 10;
+function popcountHex(hex) {
+    let bits = 0;
+    for (let i = 0; i < hex.length; i += 1)
+        bits += POPCOUNT[parseInt(hex.charAt(i), 16)] ?? 0;
+    return bits;
+}
+function isInformativeHash(hex) {
+    if (typeof hex !== 'string' || !HEX_HASH_RE.test(hex))
+        return false;
+    const bits = popcountHex(hex);
+    return bits >= MIN_INFORMATIVE_BITS && bits <= 64 - MIN_INFORMATIVE_BITS;
+}
+// 64-bit dHash over a 9x8 grid -> 16 hex chars, or null when the resulting
+// hash is degenerate (see MIN_INFORMATIVE_BITS). Each row contributes 8 bits:
+// bit set when a cell is brighter than its right-hand neighbour.
+function dHash(image) {
+    const cols = 9;
+    const rows = 8;
+    const grid = grayscaleGrid(image, cols, rows);
+    let hex = '';
+    for (let y = 0; y < rows; y += 1) {
+        let nibble = 0;
+        let bitsInNibble = 0;
+        for (let x = 0; x < cols - 1; x += 1) {
+            const bit = (grid[y * cols + x] ?? 0) > (grid[y * cols + x + 1] ?? 0) ? 1 : 0;
+            nibble = (nibble << 1) | bit;
+            bitsInNibble += 1;
+            if (bitsInNibble === 4) {
+                hex += nibble.toString(16);
+                nibble = 0;
+                bitsInNibble = 0;
+            }
+        }
+    }
+    return isInformativeHash(hex) ? hex : null;
+}
+/**
+ * Computes a perceptual (dHash) hex string for favicon bytes, or null if the
+ * image can't be decoded (unsupported format, malformed, oversized). Never
+ * throws - callers treat null as "no perceptual signal available", falling
+ * back to the exact hash.
+ */
+function faviconPerceptualHash(buf) {
+    try {
+        const image = decodeImage(buf);
+        if (!image)
+            return null;
+        return dHash(image);
+    }
+    catch {
+        return null;
+    }
+}
+// The same bounded decoder is also suitable for fixed-size PNG screenshots
+// produced by the optional local capture package. Keep the generic name as an
+// alias so the evidence contract does not imply that a screenshot is a favicon.
+const imagePerceptualHash = faviconPerceptualHash;
+const HEX_HASH_RE = /^[0-9a-f]{16}$/;
+const POPCOUNT = new Uint8Array(16);
+for (let i = 0; i < 16; i += 1)
+    POPCOUNT[i] = (i & 1) + ((i >> 1) & 1) + ((i >> 2) & 1) + ((i >> 3) & 1);
+/**
+ * Hamming distance (0-64) between two 16-hex dHash strings, or null if either
+ * isn't a well-formed hash. Smaller = more visually similar.
+ */
+function hammingDistanceHex(a, b) {
+    if (typeof a !== 'string' || typeof b !== 'string')
+        return null;
+    if (!HEX_HASH_RE.test(a) || !HEX_HASH_RE.test(b))
+        return null;
+    let distance = 0;
+    for (let i = 0; i < 16; i += 1) {
+        distance += POPCOUNT[parseInt(a.charAt(i), 16) ^ parseInt(b.charAt(i), 16)] ?? 0;
+    }
+    return distance;
+}
+export { faviconPerceptualHash, hammingDistanceHex, imagePerceptualHash };

package/lib/rdap-attempts.mjs

@@ -0,0 +1,34 @@
+import { MAX_RDAP_ENDPOINT_LENGTH } from "./rdap-bootstrap.mjs";
+const MAX_RDAP_ATTEMPT_DETAIL_LENGTH = 240;
+function safeAttemptDetail(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value
+        .replace(/[\u0000-\u001f\u007f]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return normalized ? normalized.slice(0, MAX_RDAP_ATTEMPT_DETAIL_LENGTH) : null;
+}
+export function rdapAttempt(endpoint, outcome, options = {}) {
+    const { status = null, detail = null, selected = false } = options;
+    return {
+        endpoint: String(endpoint).slice(0, MAX_RDAP_ENDPOINT_LENGTH),
+        transportSecurity: /^https:\/\//i.test(endpoint) ? 'https' : 'http',
+        status: Number.isInteger(status) ? status : null,
+        outcome,
+        detail: safeAttemptDetail(detail),
+        selected,
+    };
+}
+export function rdapFailure(outcome, status) {
+    if (outcome === 'invalid_json')
+        return 'returned invalid JSON';
+    if (outcome === 'invalid_response')
+        return 'returned an invalid RDAP object';
+    if (outcome === 'rate_limited')
+        return `returned HTTP ${status}`;
+    if (outcome === 'server_error' || outcome === 'client_error') {
+        return `returned HTTP ${status}`;
+    }
+    return outcome.replaceAll('_', ' ');
+}

package/lib/rdap-bootstrap.mjs

@@ -0,0 +1,173 @@
+// IANA RDAP bootstrap retrieval, bounded stale caching, and authority
+// selection for domain, IP, and ASN queries.
+import { fetchRdapDetailedWithTimeout, } from "./rdap-transport.mjs";
+const BOOTSTRAP_TTL_MS = 60 * 60 * 1000;
+const BOOTSTRAP_STALE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const BOOTSTRAP_KINDS = new Set(['dns', 'ipv4', 'ipv6', 'asn']);
+const BOOTSTRAP_FETCH_TIMEOUT_MS = 7000;
+const MAX_RDAP_ENDPOINT_LENGTH = 2048;
+const bootstrapCache = new Map();
+const bootstrapInflight = new Map();
+function ipv4ToLong(ip) {
+    return ip.split('.').reduce((accumulator, octet) => (accumulator << 8) + (parseInt(octet, 10) & 0xff), 0) >>> 0;
+}
+function ipInCidrV4(ip, cidr) {
+    const [range, bitsString] = cidr.split('/');
+    if (!range)
+        return false;
+    const bits = bitsString !== undefined ? parseInt(bitsString, 10) : 32;
+    const mask = bits === 0 ? 0 : (0xffffffff << (32 - bits)) >>> 0;
+    return (ipv4ToLong(ip) & mask) === (ipv4ToLong(range) & mask);
+}
+function expandIpv6(ip) {
+    let head = ip;
+    let tail = '';
+    if (ip.includes('::')) {
+        const [headPart = '', tailPart = ''] = ip.split('::');
+        head = headPart;
+        tail = tailPart;
+    }
+    const headParts = head ? head.split(':').filter(Boolean) : [];
+    const tailParts = tail ? tail.split(':').filter(Boolean) : [];
+    const missing = 8 - headParts.length - tailParts.length;
+    const parts = ip.includes('::')
+        ? [...headParts, ...Array(Math.max(missing, 0)).fill('0'), ...tailParts]
+        : headParts;
+    while (parts.length < 8)
+        parts.push('0');
+    return parts.slice(0, 8);
+}
+function ipv6ToBigInt(ip) {
+    return expandIpv6(ip).reduce((accumulator, part) => (accumulator << 16n) + BigInt(parseInt(part || '0', 16)), 0n);
+}
+function ipInCidrV6(ip, cidr) {
+    const [range, bitsString] = cidr.split('/');
+    if (!range)
+        return false;
+    const bits = bitsString !== undefined ? parseInt(bitsString, 10) : 128;
+    const full = (1n << 128n) - 1n;
+    const mask = bits === 0 ? 0n : (full << BigInt(128 - bits)) & full;
+    return (ipv6ToBigInt(ip) & mask) === (ipv6ToBigInt(range) & mask);
+}
+function validBootstrap(data) {
+    const record = data && typeof data === 'object' && !Array.isArray(data)
+        ? data
+        : null;
+    return Boolean(record
+        && Array.isArray(record.services) && record.services.length > 0
+        && record.services.every((service) => Array.isArray(service) && service.length >= 2
+            && Array.isArray(service[0]) && service[0].length > 0
+            && service[0].every((entry) => typeof entry === 'string' && entry.length > 0)
+            && Array.isArray(service[1]) && service[1].length > 0
+            && service[1].some((url) => typeof url === 'string' && /^https?:\/\//i.test(url))));
+}
+async function fetchBootstrap(kind, options = {}) {
+    if (!BOOTSTRAP_KINDS.has(kind))
+        throw new Error(`Unsupported RDAP bootstrap kind: ${kind}`);
+    const now = typeof options.now === 'function' ? options.now : Date.now;
+    const fetchUpstream = options.fetchUpstream || fetchRdapDetailedWithTimeout;
+    const cached = bootstrapCache.get(kind);
+    if (cached && now() - cached.fetchedAt < BOOTSTRAP_TTL_MS)
+        return cached.data;
+    const inflight = bootstrapInflight.get(kind);
+    if (inflight)
+        return inflight;
+    const request = (async () => {
+        try {
+            const response = await fetchUpstream(`https://data.iana.org/rdap/${kind}.json`, {}, BOOTSTRAP_FETCH_TIMEOUT_MS);
+            if (!response.ok) {
+                throw new Error(`IANA bootstrap fetch failed for ${kind} (${response.status})`);
+            }
+            let data;
+            try {
+                data = JSON.parse(response.text);
+            }
+            catch {
+                throw new Error(`IANA bootstrap returned invalid JSON for ${kind}`);
+            }
+            if (!validBootstrap(data)) {
+                throw new Error(`IANA bootstrap returned an unexpected format for ${kind}`);
+            }
+            bootstrapCache.set(kind, { data, fetchedAt: now() });
+            return data;
+        }
+        catch (cause) {
+            const fallback = bootstrapCache.get(kind);
+            if (fallback && now() - fallback.fetchedAt <= BOOTSTRAP_STALE_TTL_MS) {
+                return fallback.data;
+            }
+            throw cause;
+        }
+        finally {
+            bootstrapInflight.delete(kind);
+        }
+    })();
+    bootstrapInflight.set(kind, request);
+    return request;
+}
+function clearRdapBootstrapCache() {
+    bootstrapCache.clear();
+    bootstrapInflight.clear();
+}
+function uniqueRdapBases(urls) {
+    const seen = new Set();
+    return (Array.isArray(urls) ? urls : [])
+        .filter((url) => typeof url === 'string'
+        && url.length <= MAX_RDAP_ENDPOINT_LENGTH
+        && !/[\u0000-\u001f\u007f]/.test(url)
+        && /^https?:\/\//i.test(url))
+        .sort((left, right) => Number(/^http:\/\//i.test(left)) - Number(/^http:\/\//i.test(right)))
+        .filter((url) => {
+        const key = url.replace(/\/$/, '').toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+async function findRdapBases(type, value) {
+    if (type === 'domain') {
+        const bootstrap = await fetchBootstrap('dns');
+        const tld = value.split('.').pop()?.toLowerCase() || '';
+        for (const [tlds, urls] of bootstrap.services) {
+            if (tlds.some((entry) => entry.toLowerCase() === tld))
+                return uniqueRdapBases(urls);
+        }
+        return [];
+    }
+    if (type === 'ipv4' || type === 'ipv6') {
+        const bootstrap = await fetchBootstrap(type);
+        const matcher = type === 'ipv4' ? ipInCidrV4 : ipInCidrV6;
+        let best = null;
+        let bestPrefix = -1;
+        for (const [cidrs, urls] of bootstrap.services) {
+            for (const cidr of cidrs) {
+                if (!matcher(value, cidr))
+                    continue;
+                const fallbackPrefix = type === 'ipv4' ? '32' : '128';
+                const prefix = parseInt(cidr.split('/')[1] ?? fallbackPrefix, 10);
+                if (prefix > bestPrefix) {
+                    bestPrefix = prefix;
+                    best = uniqueRdapBases(urls);
+                }
+            }
+        }
+        return best || [];
+    }
+    if (type === 'asn') {
+        const bootstrap = await fetchBootstrap('asn');
+        const number = parseInt(value.replace(/^AS/i, ''), 10);
+        for (const [ranges, urls] of bootstrap.services) {
+            for (const range of ranges) {
+                const [start, end] = range.includes('-')
+                    ? range.split('-').map(Number)
+                    : [Number(range), Number(range)];
+                if (start !== undefined && end !== undefined && number >= start && number <= end) {
+                    return uniqueRdapBases(urls);
+                }
+            }
+        }
+    }
+    return [];
+}
+export { BOOTSTRAP_STALE_TTL_MS, BOOTSTRAP_TTL_MS, MAX_RDAP_ENDPOINT_LENGTH, clearRdapBootstrapCache, fetchBootstrap, findRdapBases, ipv4ToLong, ipv6ToBigInt, uniqueRdapBases, };