123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
export type BootstrapServiceRegistry = {    version: string; // e.g. "1.0"    publication: string; // e.g. "YYYY-MM-DDTHH:MM:SSZ"    description: string; // e.g. "Some text"    services: BootstrapService[];};
export type BootstrapService = [Entry[], ServiceURL[]];
export type Entry = string;
export type ServiceURL = string;
export function getDNSBootstrapFile(): Promise<BootstrapServiceRegistry> {    const DNS_BOOTSTRAP_FILE_URL = "https://data.iana.org/rdap/dns.json";    return fetch(DNS_BOOTSTRAP_FILE_URL).then((response) => response.json());}
export function getBootstrapServiceForTLD(    tld: string,    bootstrapFile: BootstrapServiceRegistry,): BootstrapService | undefined {    return bootstrapFile.services.find((service) => service[0].includes(tld));}
export function getServiceURLs(bootstrapService: BootstrapService): ServiceURL[] {    return bootstrapService[1];}
export function queryServiceForDomain(serviceURL: ServiceURL, domain: string): Promise<Response> {    return fetch(`${serviceURL}domain/${domain}`);}
export function checkDomainAvailability(serviceURL: ServiceURL, domain: string): Promise<boolean> {    return queryServiceForDomain(serviceURL, domain).then((response) => {        if (response.ok) {            return false;        } else if (response.status === 404) {            return true;        } else {            throw response;        }    });}
const ALL_POSSIBLE_CHARACTERS = "abcdefghijklmnopqrstuvwxyz0123456789-".split("");const POSSIBLE_ALPHABET_CHARACTERS = "abcdefghijklmnopqrstuvwxyz".split("");const POSSIBLE_NUMBER_CHARACTERS = "0123456789".split("");
export function findDomainNamesMatchingPattern(pattern: string): string[] {    // The author chose to filter out domains which are fundamentally invalid from the results    // to prevent reporting false positives to the user    return _findDomainNamesMatchingPattern(pattern).filter(        (domainName) =>            // Domain names cannot start or end with a hyphen ("-")            domainName.at(0) !== "-" &&            domainName.at(domainName.indexOf(".") - 1) !== "-" &&            // Domain names cannot contain consecutive hyphens ("-")            !domainName.includes("--") &&            // Domain names must only consist of the 26 letters of the ISO basic Latin alphabet            // in a case insensitive manner, numbers and hyphens ("-")            //            // Since domain names are separated from their top-level domain with a period character            // ("."), we ignore those while checking for the validity of the domain name.            domainName                .split("")                .every(                    (char) => char === "." || ALL_POSSIBLE_CHARACTERS.includes(char.toLowerCase()),                ),    );}
function _findDomainNamesMatchingPattern(pattern: string): string[] {    const indexOfFirstAsterisk = pattern.indexOf("*");    const indexOfFirstQuestionMark = pattern.indexOf("?");    const indexOfFirstNumberSign = pattern.indexOf("#");
    const wildcardIndexes = [        indexOfFirstAsterisk,        indexOfFirstQuestionMark,        indexOfFirstNumberSign,    ];
    if (Math.max(...wildcardIndexes) === -1) {        // No wildcard was found        return [pattern];    }
    const firstWildcardIndex = Math.min(...wildcardIndexes.filter((n) => n != -1));    const replacementCharacters = firstWildcardIndex === indexOfFirstQuestionMark        ? POSSIBLE_ALPHABET_CHARACTERS        : firstWildcardIndex === indexOfFirstNumberSign        ? POSSIBLE_NUMBER_CHARACTERS        : ALL_POSSIBLE_CHARACTERS;
    // Replace the first wildcard with all possible characters that could take its place and recurse    return replacementCharacters.flatMap((character) =>        _findDomainNamesMatchingPattern(            replaceIndexInString(pattern, character, firstWildcardIndex),        )    );}
export function queryServiceForDomainOrRetry(    serviceURL: ServiceURL,    domain: string,    // The choice of 100 ms as a default for timeouts is almost arbitrary.    //    // The program was tested for performance on a ~700 queries long test set for the .net TLD    // with no chunks or chunks of size 50 and the following timeout settings:    //    // - 1 ms    // - 10 ms    // - 50 ms    // - 100 ms    // - 500 ms    // - 1000 ms    //    // Performance differences were within the margin of error for all of the timeout settings with    // the exception of the 1000 ms timeout tests which were slower by around 10 %.    //    // Since no conclusion could be taken from a performance point of view on the basis of these    // tests, the author chose 100 ms as a good middle ground between minimizing the performance    // impact of a failed request on a small query set and limiting unnecessary requests to the    // RDAP services.    waitMs = 100,): Promise<Response> {    return resolveOrRetry(() => queryServiceForDomain(serviceURL, domain), waitMs);}
export function checkDomainAvailabilityOrRetry(    serviceURL: ServiceURL,    domain: string,    waitMs = 100,): Promise<boolean> {    return resolveOrRetry(() => checkDomainAvailability(serviceURL, domain), waitMs);}
export function queryServiceForDomainsAsync(    serviceURL: ServiceURL,    domains: string[],): Promise<Response[]> {    return Promise.all(domains.map((domain) => queryServiceForDomainOrRetry(serviceURL, domain)));}
export function checkDomainsAvailabilityAsync(    serviceURL: ServiceURL,    domains: string[],): Promise<boolean[]> {    return Promise.all(domains.map((domain) => checkDomainAvailabilityOrRetry(serviceURL, domain)));}
export function queryServiceForDomainsSequential(    serviceURL: ServiceURL,    domains: string[],): Promise<Response[]> {    return sequentialize(domains.map((domain) => () => queryServiceForDomain(serviceURL, domain)));}
export function checkDomainsAvailabilitySequential(    serviceURL: ServiceURL,    domains: string[],): Promise<boolean[]> {    return sequentialize(        domains.map((domain) => () => checkDomainAvailability(serviceURL, domain)),    );}
export function splitIntoChunks<T>(arr: T[], maxChunkSize: number): T[][] {    const result = [];    const numberOfChunks = Math.ceil(arr.length / maxChunkSize);    for (let i = 0; i < numberOfChunks; i++) {        result.push(arr.slice(maxChunkSize * i, maxChunkSize * (i + 1)));    }    return result;}
function resolveOrRetry<T>(f: () => Promise<T>, waitMs: number): Promise<T> {    return f().catch(() => sleep(waitMs).then(() => resolveOrRetry(f, waitMs)));}
function sleep(ms: number) {    return new Promise((resolve) => setTimeout(resolve, ms));}
function sequentialize<T>(fs: (() => Promise<T>)[]): Promise<T[]> {    const results: T[] = [];    return fs        .reduce(            (p, f) =>                p.then(f).then((response) => {                    results.push(response);                }),            Promise.resolve(),        )        .then(() => results);}
function replaceIndexInString(original: string, replacement: string, index: number): string {    return original.substring(0, index) + replacement + original.substring(index + 1);}