How I ended up looking at 4000+ .xyz domains and found this shocking fact

import * as request from "request";
import * as fs from "fs";
import { Parser as J2CParser } from "json2csv";
import * as dns from "dns";
import { isNullOrUndefined } from 'util';
import * as parse from "csv-parse";

const indicators = [
    ["domain", "is for sale"],
    ["website", "zum verkauf"],
    ["domains"],
    ["domain name"],
    ["buy", "domain"],
    ["is available", "domain"]
];

const javascript_resale_redirect = [
    "pheenix.com",
    "uniregistry.com",
    "undeveloped.com",
    "eftymarket.com",
    "isunward.com",
    "digitalassets.xyz",
    "domaincostclub.com"
];

let resellers = [
    "www.pheenix.com",
    "uniregistry.com",
    "undeveloped.com",
    "eftymarket.com",
    "isunward.com",
    "digitalassets.xyz",
    "www.domaincostclub.com"
];

let file = fs.readFileSync("wordlist.csv").toString();

parse(file, { columns: true }, async (err, data) => {

    type result_type = {
        word: string,
        domain: string,
        resale: boolean,
        reseller: boolean,
        redirects_to: string | null,
        free: boolean,
        premium: boolean,
        fetch_error: boolean
    };

    let csv_counter = 0;

    let wait_list = new Array<Promise<result_type>>();
    let result = new Array<result_type>();

    for (let word of data) {

        let domain = word.Word.toLowerCase() + ".xyz";
        if (wait_list.length >= 5) {
            let r = await Promise.all(wait_list);
            result = result.concat(r);
            wait_list = new Array();

            let parser = new J2CParser();

            let csv = parser.parse(result);

            fs.writeFileSync(`xyz${csv_counter}.csv`, csv);
            csv_counter++;
            console.log(csv_counter);
        }

        let promise = new Promise<result_type>(resolve => {

            // Check if a DNS entry exists for the domain

            dns.resolve4(domain, async (err, a) => {
                let exists = isNullOrUndefined(err);

                if (exists) {
                    request({
                        url: "http://" + domain,
                        timeout: 5000,
                        headers: { 'Accept': '*/*', 'User-Agent': 'request' }
                    }, (err, response, body) => {

                        if (!err) {
                            if (response.request.uri.host == "gen.xyz") {

                                // Premium domain

                                resolve({
                                    word: word.Word,
                                    domain: domain,
                                    free: true,
                                    premium: true,
                                    redirects_to: "gen.xyz",
                                    resale: false,
                                    reseller: false,
                                    fetch_error: false
                                });
                                return;
                            } else if (resellers.indexOf(response.request.uri.host) != -1) {

                                // Domain definitely for resale

                                resolve({
                                    word: word.Word,
                                    domain: domain,
                                    free: false,
                                    premium: false,
                                    redirects_to: response.request.uri.host,
                                    resale: true,
                                    reseller: true,
                                    fetch_error: false
                                });
                                return;
                            }

                            let redirects_to = null;

                            if (response.request.uri.host != domain) {
                                redirects_to = response.request.uri.host;
                                console.log(`Redirect: ${domain} => ${response.request.uri.host}`)
                            }

                            body = body.toLowerCase();
                            body = body.replace(/&nbsp;/g, " ");
                            body = body.replace(/\/n/g, " ");
                            body = body.replace(/\/r/g, " ");

                            let for_resale = true;

                            for (let indicator of indicators) {
                                for_resale = true;
                                for (let word of indicator) {
                                    for_resale = body.indexOf(word) != -1 && for_resale;
                                }

                                if (for_resale) {
                                    // Domain most likely for sale because of word occurrences

                                    break;
                                }
                            }

                            if (!redirects_to) {

                                for (let redirect of javascript_resale_redirect) {

                                    if (body.indexOf(redirect) != -1) {
                                        for_resale = true;
                                        redirects_to = redirect;
                                        break;
                                    }
                                }
                            }

                            resolve({
                                word: word.Word,
                                domain: domain,
                                free: false,
                                premium: false,
                                redirects_to: redirects_to,
                                resale: for_resale,
                                reseller: false,
                                fetch_error: false
                            });

                        } else {

                            resolve({
                                word: word.Word,
                                domain: domain,
                                free: false,
                                premium: false,
                                redirects_to: null,
                                resale: false,
                                reseller: false,
                                fetch_error: true
                            });
                        }

                    });
                } else {

                    // Check if site is free because no DNS entry exists

                    await new Promise(r => setTimeout(r, 1000));
                    request("https://www.hover.com/api/lookup?q=" + domain, (err, request, body) => {

                        if (!err) {

                            let data = JSON.parse(body);

                            let free = false;
                            let premium = false;

                            if (data.results && data.results.length) {
                                let entry = data.results[0];

                                if (entry.domain == domain) {
                                    free = true;
                                    if (entry.is_premium) {
                                        premium = true;
                                    }
                                }
                            }

                            resolve({
                                word: word.Word,
                                domain: domain,
                                free: free,
                                premium: premium,
                                redirects_to: null,
                                resale: false,
                                reseller: false,
                                fetch_error: false
                            });
                        } else {

                            resolve({
                                word: word.Word,
                                domain: domain,
                                free: false,
                                premium: false,
                                redirects_to: null,
                                resale: false,
                                reseller: false,
                                fetch_error: true
                            });
                        }
                    })
                }
            });
        });

        wait_list.push(promise);
    }

    // Log end result
    console.log(result);


});