Merge branch 'main' into main

2026-05-22 12:25:40 +00:00 · 2024-11-11 08:04:59 +01:00
parent 14f8590162 8e8e3d6f4d
commit 4cfa6530ce
22 changed files with 2895 additions and 237 deletions
@@ -40,7 +40,7 @@ jobs:
                  source-directory: "raw-api"
                  destination-github-username: is-a-dev
                  destination-repository-name: raw-api
-                  user-email: actions@github.com
+                  user-email: "actions@github.com"
                  user-name: "GitHub Actions"
              env:
                  API_TOKEN_GITHUB: ${{ secrets.BOT }}
@@ -29,14 +29,18 @@ for (var subdomain in domains) {
    // Handle A records
    if (domainData.record.A) {
        for (var a in domainData.record.A) {
-            records.push(A(subdomainName, IP(domainData.record.A[a]), proxyState));
+            records.push(
+                A(subdomainName, IP(domainData.record.A[a]), proxyState)
+            );
        }
    }

    // Handle AAAA records
    if (domainData.record.AAAA) {
        for (var aaaa in domainData.record.AAAA) {
-            records.push(AAAA(subdomainName, domainData.record.AAAA[aaaa], proxyState));
+            records.push(
+                AAAA(subdomainName, domainData.record.AAAA[aaaa], proxyState)
+            );
        }
    }

@@ -44,7 +48,14 @@ for (var subdomain in domains) {
    if (domainData.record.CAA) {
        for (var caa in domainData.record.CAA) {
            var caaRecord = domainData.record.CAA[caa];
-            records.push(CAA(subdomainName, caaRecord.flags, caaRecord.tag, caaRecord.value));
+            records.push(
+                CAA(
+                    subdomainName,
+                    caaRecord.flags,
+                    caaRecord.tag,
+                    caaRecord.value
+                )
+            );
        }
    }

@@ -52,9 +63,13 @@ for (var subdomain in domains) {
    if (domainData.record.CNAME) {
        // Allow CNAME record on root
        if (subdomainName === "@") {
-            records.push(ALIAS(subdomainName, domainData.record.CNAME + ".", proxyState));
+            records.push(
+                ALIAS(subdomainName, domainData.record.CNAME + ".", proxyState)
+            );
        } else {
-            records.push(CNAME(subdomainName, domainData.record.CNAME + ".", proxyState));
+            records.push(
+                CNAME(subdomainName, domainData.record.CNAME + ".", proxyState)
+            );
        }
    }

@@ -63,7 +78,13 @@ for (var subdomain in domains) {
        for (var ds in domainData.record.DS) {
            var dsRecord = domainData.record.DS[ds];
            records.push(
-                DS(subdomainName, dsRecord.key_tag, dsRecord.algorithm, dsRecord.digest_type, dsRecord.digest)
+                DS(
+                    subdomainName,
+                    dsRecord.key_tag,
+                    dsRecord.algorithm,
+                    dsRecord.digest_type,
+                    dsRecord.digest
+                )
            );
        }
    }
@@ -71,7 +92,13 @@ for (var subdomain in domains) {
    // Handle MX records
    if (domainData.record.MX) {
        for (var mx in domainData.record.MX) {
-            records.push(MX(subdomainName, 10 + parseInt(mx), domainData.record.MX[mx] + "."));
+            records.push(
+                MX(
+                    subdomainName,
+                    10 + parseInt(mx),
+                    domainData.record.MX[mx] + "."
+                )
+            );
        }
    }

@@ -87,7 +114,13 @@ for (var subdomain in domains) {
        for (var srv in domainData.record.SRV) {
            var srvRecord = domainData.record.SRV[srv];
            records.push(
-                SRV(subdomainName, srvRecord.priority, srvRecord.weight, srvRecord.port, srvRecord.target + ".")
+                SRV(
+                    subdomainName,
+                    srvRecord.priority,
+                    srvRecord.weight,
+                    srvRecord.port,
+                    srvRecord.target + "."
+                )
            );
        }
    }
@@ -5,6 +5,5 @@
  },
  "record": {
    "URL": "https://shockbs.is-a.dev/"
-  },
-  "proxied": true
+  }
 }
@@ -0,0 +1,10 @@
+{
+  "owner": {
+    "username": "akk1to",
+    "email": "akk1to.dev@gmail.com",
+    "discord": "727497287777124414"
+  },
+  "record": {
+    "TXT": ["dh=e1e17c98197b35ff9ed4eef8a473fa86fa3106b8"]
+  }
+}
@@ -0,0 +1,9 @@
+{
+  "owner": {
+    "username": "xzrci",
+    "email": ""
+  },
+  "record": {
+    "TXT": ["vc-domain-verify=jake.is-a.dev,1075ab07de85fa87e8cd"]
+  }
+}
@@ -0,0 +1,9 @@
+{
+    "owner": {
+      "username": "notreallyprince",
+      "email": "prince30112001@gmail.com"
+    },
+    "record": {
+      "TXT": "vc-domain-verify=princeprajapati.is-a.dev,9b919407776e11ecff7a"
+    }
+  }
@@ -0,0 +1,9 @@
+{
+  "owner": {
+    "username": "ukinon",
+    "email": "arfianoj@gmail.com"
+  },
+  "record": {
+    "TXT": ["vc-domain-verify=ukino.is-a.dev,abcf9c3157f2470d8c51"]
+  }
+}
@@ -5,6 +5,6 @@
    "email": "abiapp2024@gmail.com"
  },
  "record": {
-    "CNAME": "abiapp789.github.io"
+    "CNAME": "trytodownloadme.rf.gd"
  }
 }
@@ -0,0 +1,11 @@
+{
+        "owner": {
+           "username": "IacopoSb",
+           "discord": "442322290206703628",
+           "OWL": "eyJlbmMiOiJBMTI4Q0JDLUhTMjU2IiwiYWxnIjoiUlNBLU9BRVAiLCJraWQiOiJaa1VsRmRqVThiUEstLXVVM2JJR09PVHFYYVFFS1ZINFVXOW53MTR6WTJnIn0.Hn0wg5RpzADaJvecwSHu8KpOj-Z_oG7i08e9Z62Give15eiaNXJzezQ9d7noux00NeBYHyoAWfBB5IQ4_XXWy75cLfR2N0A80Lod8D9f6zaWhH6HOcKrauCVolIJBBrzMfTXkWpi-yt74WFtQtfkjlOYren1QB6T_EqyLps5kEJxM08Vubn49m7ckSkNh2bRNJ5NfprPwjrGrHwrdsQqCDiVWn7SL7Dp-Qs-9X1m6nsbyr4shb1BA9X3embdAeL34Yq4GMaIje2tj991jpzq0lW1wGDAZweffw2cJf4xtzC1V0BBWPJDm3ye8eWWrhyOlOmVmK5xqduHk_GJ4jB__g.C50OguoaaY8-9Y9OheaUJw.pc_1FvYpLmydbLCQBa262CG2ROnCFJl-oxfguFWsFv7xDqFr5dRyEZVdEkO8J1UxQFAbO4fm3uEKV1JXDPqdl-6xZF9cpsEkOTZ72Gb2PiY.hYU41zXsd0lJbcQwO59cwA"
+        },
+
+         "record": {
+            "NS": ["marge.ns.cloudflare.com", "dan.ns.cloudflare.com"]
+        }
+}
@@ -1,11 +1,9 @@
 {
-  "description": "Jake's personal website and blog.",
-  "repo": "https://github.com/j-eo/j-eo.github.io",
  "owner": {
-    "username": "j-eo",
-    "email": "website-contact.nem2h@silomails.com"
+    "username": "xzrci",
+    "email": ""
  },
  "record": {
-    "CNAME": "jakeanto.pages.dev"
+    "CNAME": "xzrci.vercel.app"
  }
 }
@@ -1,7 +1,7 @@
 {
  "owner": {
-    "username": "InterJadify",
-    "email": "",
+    "username": "lungustefan",
+    "email": "hi@lungustefan.ro",
    "discord": "753179409682399332",
    "OWL": "eyJlbmMiOiJBMTI4Q0JDLUhTMjU2IiwiYWxnIjoiUlNBLU9BRVAiLCJraWQiOiJaa1VsRmRqVThiUEstLXVVM2JJR09PVHFYYVFFS1ZINFVXOW53MTR6WTJnIn0.ZerVkVuk5RE7iT8ymXVcKhUkihyAdAbufacrfxq1u7NKQ4Hd0_PbY5FYDAR5uuVd-sCe7fOztiSKV7f9q1OI4HNGDqQxiaWqzom_lQsrIMW-gWUDsBG4Vo8gsq0wrw2th797i-JfsXy2crWaeXlX7X1kROV5KZhGwlSusnUrMp3jlN-uUM3b4hxUyEs3grbh4BiZ9CWShm-kLUs572OBpMigXh3aO0DcUl-BdYdlpSEdRQe8zwylJbFnetxG3qBaMcciGwImixY6V4qaqFwH18isGjDknsHB2WvXM8ekMZmSxgMyRtv1VRSbC22grzMeBazgWoj3x65KU3Z8C7KNmw.w-d8n6WalLAvFcWHqlRkcw.W7GJTwpNRB9pUehhfBXVlkOR1knSNSjvJWeDViV6u2h6AyBdwyaAyILEQzC5ishw0f209VgdyaCqocC7nJp_ZjWjAfcyw0ICLiUXM37Sn3Q.xQOo4RjPMh6dBbWiF1Polw"
  },
@@ -0,0 +1,17 @@
+{
+  "owner": {
+    "username": "matte-oss",
+    "email": "7sz8jlw6h@mozmail.com"
+  },
+  "record": {
+    "MX": [
+      "mx.zoho.eu",
+      "mx2.zoho.eu",
+      "mx3.zoho.eu"
+    ],
+    "TXT": [
+      "v=spf1 include:zohomail.eu ~all",
+      "v=DKIM1; k=rsa; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCBdKJ9pgi76G8kOhX1v4hDt3jros0cBQMLMeKc8L6F8iLBUz78XwP4qRO/1sfdl1vSavi+KsybaNotnLfA2+vA+txPzR/zUEdPWTZhz/Q7iQqo7AuX8hZDY2emDA/0wAkSVAQ1i/KKmSnnR1q6RvJcjPmVCW2gjpw9MOfCwt7PAwIDAQAB"
+    ]
+  }
+}
@@ -0,0 +1,9 @@
+{
+  "owner": {
+    "username": "matte-oss",
+    "email": "7sz8jlw6h@mozmail.co"
+  },
+  "record": {
+    "CNAME": "hashnode.network"
+  }
+}
@@ -0,0 +1,9 @@
+{
+    "owner": {
+      "username": "notreallyprince",
+      "email": "prince30112001@gmail.com"
+    },
+    "record": {
+      "CNAME": "princexd.vercel.app"
+    }
+  }
@@ -0,0 +1,11 @@
+{
+    "owner": {
+        "username": "qxb3",
+        "email": "qxbthree@gmail.com"
+    },
+    "record": {
+        "A": [
+            "75.2.60.5"
+        ]
+    }
+}
@@ -0,0 +1,8 @@
+{
+  "owner": {
+    "username": "ukinon"
+  },
+  "record": {
+    "CNAME": "ukino.vercel.app"
+  }
+}
@@ -26,14 +26,14 @@ const hostnameRegex = /^(?=.{1,253}$)(?:(?:[_a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-z
 const domainsPath = path.resolve("domains");
 const files = fs.readdirSync(domainsPath);

-const validateRequiredFields = (t, obj, requiredFields, file) => {
+function validateRequiredFields(t, obj, requiredFields, file) {
    Object.keys(requiredFields).forEach((key) => {
        t.true(obj.hasOwnProperty(key), `${file}: Missing required field: ${key}`);
        t.is(typeof obj[key], requiredFields[key], `${file}: Field ${key} should be of type ${requiredFields[key]}`);
    });
-};
+}

-const validateOptionalFields = (t, obj, optionalFields, file) => {
+function validateOptionalFields(t, obj, optionalFields, file) {
    Object.keys(optionalFields).forEach((key) => {
        if (obj.hasOwnProperty(key)) {
            t.is(
@@ -43,7 +43,7 @@ const validateOptionalFields = (t, obj, optionalFields, file) => {
            );
        }
    });
-};
+}

 t("All files should be valid JSON", (t) => {
    files.forEach((file) => {
@@ -0,0 +1,25 @@
+const t = require("ava");
+const fs = require("fs-extra");
+const path = require("path");
+
+const requiredRecordsToProxy = ["A", "AAAA", "CNAME"];
+// URL records are not listed here because they are proxied by default, so they don't need the proxied flag
+
+function validateProxiedRecords(t, data, file) {
+    if (data.proxied) {
+        const hasProxiedRecord = Object.keys(data.record).some((key) => requiredRecordsToProxy.includes(key));
+
+        t.true(hasProxiedRecord, `${file}: Proxied is true but there are no records that can be proxied`);
+    }
+}
+
+const domainsPath = path.resolve("domains");
+const files = fs.readdirSync(domainsPath);
+
+t("Domains with proxy enabled should have have at least one record that can be proxied", (t) => {
+    files.forEach((file) => {
+        const domain = fs.readJsonSync(path.join(domainsPath, file));
+
+        validateProxiedRecords(t, domain, file);
+    });
+});
@@ -2,22 +2,90 @@ const t = require("ava");
 const fs = require("fs-extra");
 const path = require("path");

-const {
-    checkCNAME,
-    checkNSAndDS,
-    validateHostname,
-    validateIPv4,
-    validateIPv6,
-    validateSpecialRecords,
-    validateTXT,
-    validateURL
-} = require("../utils/records");
-
 const validRecordTypes = ["A", "AAAA", "CAA", "CNAME", "DS", "MX", "NS", "SRV", "TXT", "URL"];

+const hostnameRegex = /^(?=.{1,253}$)(?:(?:[_a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)\.)+[a-zA-Z]{2,63}$/;
+const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}$/;
+const ipv6Regex =
+    /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,7}:$|^(?:[0-9a-fA-F]{1,4}:){0,6}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$/;
+
 const domainsPath = path.resolve("domains");
 const files = fs.readdirSync(domainsPath);

+function expandIPv6(ip) {
+    // Split into segments by ":"
+    let segments = ip.split(":");
+
+    // Count the number of segments that are empty due to "::" shorthand
+    const emptyIndex = segments.indexOf("");
+    if (emptyIndex !== -1) {
+        // Calculate how many "0000" segments are missing
+        const nonEmptySegments = segments.filter((seg) => seg !== "");
+        const missingSegments = 8 - nonEmptySegments.length;
+
+        // Insert the missing "0000" segments into the position of the empty segment
+        segments = [
+            ...nonEmptySegments.slice(0, emptyIndex),
+            ...Array(missingSegments).fill("0000"),
+            ...nonEmptySegments.slice(emptyIndex)
+        ];
+    }
+
+    // Expand each segment to 4 characters, padding with leading zeros
+    const expandedSegments = segments.map((segment) => segment.padStart(4, "0"));
+
+    // Join the segments back together
+    return expandedSegments.join(":");
+}
+
+function isPublicIPv4(ip, proxied) {
+    const parts = ip.split(".").map(Number);
+
+    // Validate IPv4 address format
+    if (parts.length !== 4 || parts.some((part) => isNaN(part) || part < 0 || part > 255)) {
+        return false;
+    }
+
+    // Exception for 192.0.2.1, assuming the domain is proxied
+    if (ip === "192.0.2.1" && proxied) {
+        return true;
+    }
+
+    // Check for private and reserved IPv4 ranges
+    return !(
+        // Private ranges
+        (
+            parts[0] === 10 ||
+            (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) ||
+            (parts[0] === 192 && parts[1] === 168) ||
+            // Reserved or special-use ranges
+            (parts[0] === 100 && parts[1] >= 64 && parts[1] <= 127) || // Carrier-grade NAT
+            (parts[0] === 169 && parts[1] === 254) || // Link-local
+            (parts[0] === 192 && parts[1] === 0 && parts[2] === 0) || // IETF Protocol Assignments
+            (parts[0] === 192 && parts[1] === 0 && parts[2] === 2) || // Documentation (TEST-NET-1)
+            (parts[0] === 198 && parts[1] === 18) || // Network Interconnect Devices
+            (parts[0] === 198 && parts[1] === 51 && parts[2] === 100) || // Documentation (TEST-NET-2)
+            (parts[0] === 203 && parts[1] === 0 && parts[2] === 113) || // Documentation (TEST-NET-3)
+            parts[0] >= 224
+        ) // Multicast and reserved ranges
+    );
+}
+
+function isPublicIPv6(ip) {
+    const normalizedIP = ip.toLowerCase();
+
+    // Check for private or special-use IPv6 ranges
+    return !(
+        (
+            normalizedIP.startsWith("fc") || // Unique Local Address (ULA)
+            normalizedIP.startsWith("fd") || // Unique Local Address (ULA)
+            normalizedIP.startsWith("fe80") || // Link-local
+            normalizedIP.startsWith("::1") || // Loopback address (::1)
+            normalizedIP.startsWith("2001:db8")
+        ) // Documentation range
+    );
+}
+
 t("All files should have valid record types", (t) => {
    files.forEach((file) => {
        const data = fs.readJsonSync(path.join(domainsPath, file));
@@ -27,14 +95,30 @@ t("All files should have valid record types", (t) => {
            t.true(validRecordTypes.includes(key), `${file}: Invalid record type: ${key}`);
        });

-        checkCNAME(t, file, recordKeys);
-        checkNSAndDS(t, file, recordKeys);
+        // CNAME records cannot be combined with any other record type
+        if (recordKeys.includes("CNAME")) {
+            t.is(recordKeys.length, Number(1), `${file}: CNAME records cannot be combined with other records`);
+        }
+
+        // NS records cannot be combined with any other record type, except for DS records
+        if (recordKeys.includes("NS")) {
+            t.true(
+                recordKeys.length === 1 || (recordKeys.length === 2 && recordKeys.includes("DS")),
+                `${file}: NS records cannot be combined with other records, except for DS records`
+            );
+        }
+
+        // DS records must be combined with NS records
+        if (recordKeys.includes("DS")) {
+            t.true(recordKeys.includes("NS"), `${file}: DS records must be combined with NS records`);
+        }
    });
 });

 t("All files should not have duplicate record keys", (t) => {
    files.forEach((file) => {
        const data = fs.readJsonSync(path.join(domainsPath, file));
+
        const recordKeys = Object.keys(data.record);
        const uniqueRecordKeys = new Set(recordKeys);

@@ -45,34 +129,199 @@ t("All files should not have duplicate record keys", (t) => {
 t("All files should have valid record values", (t) => {
    files.forEach((file) => {
        const data = fs.readJsonSync(path.join(domainsPath, file));
+
        Object.keys(data.record).forEach((key) => {
            const value = data.record[key];

+            // *: string[]
            if (["A", "AAAA", "MX", "NS"].includes(key)) {
                t.true(Array.isArray(value), `${file}: Record value should be an array for ${key}`);

-                value.forEach((record) =>
-                    t.true(typeof record === "string", `${file}: Record value should be a string for ${key}`)
-                );
+                value.forEach((record) => {
+                    t.true(typeof record === "string", `${file}: Record value should be a string for ${key}`);
+                });

-                if (key === "A") validateIPv4(t, file, key, value, data);
-                if (key === "AAAA") validateIPv6(t, file, key, value);
-                if (["MX", "NS"].includes(key)) validateHostname(t, file, key, value);
-            } else if (["CNAME", "URL"].includes(key)) {
+                // A: string[]
+                if (key === "A") {
+                    value.forEach((record) => {
+                        t.regex(
+                            record,
+                            ipv4Regex,
+                            `${file}: Record value should be a valid IPv4 address for ${key} at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+
+                        t.true(
+                            isPublicIPv4(record, data.proxied),
+                            `${file}: Record value should be a public IPv4 address for ${key} at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+                    });
+                }
+
+                // AAAA: string[]
+                if (key === "AAAA") {
+                    value.forEach((record) => {
+                        t.regex(
+                            expandIPv6(record),
+                            ipv6Regex,
+                            `${file}: Record value should be a valid IPv6 address for ${key} at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+
+                        t.true(
+                            isPublicIPv6(record),
+                            `${file}: Record value should be a public IPv6 address for ${key} at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+                    });
+                }
+
+                // *: string[]
+                if (["MX", "NS"].includes(key)) {
+                    value.forEach((record) => {
+                        t.regex(
+                            record,
+                            hostnameRegex,
+                            `${file}: Record value should be a valid hostname for ${key} at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+                    });
+                }
+            }
+
+            // *: string
+            if (["CNAME", "URL"].includes(key)) {
                t.true(typeof value === "string", `${file}: Record value should be a string for ${key}`);

-                if (key === "CNAME") validateHostname(t, file, key, [value]);
-                if (key === "URL") validateURL(t, file, key, value);
-            } else if (["CAA", "DS", "SRV"].includes(key)) {
+                if (key === "CNAME") {
+                    t.regex(value, hostnameRegex, `${file}: Record value should be a valid hostname for ${key}`);
+                }
+
+                if (key === "URL") {
+                    t.notThrows(() => new URL(value), `${file}: Record value should be a valid URL for ${key}`);
+                }
+            }
+
+            // *: {}[]
+            if (["CAA", "DS", "SRV"].includes(key)) {
                t.true(Array.isArray(value), `${file}: Record value should be an array for ${key}`);

-                value.forEach((record) =>
-                    t.true(typeof record === "object", `${file}: Record value should be an object for ${key}`)
-                );
+                value.forEach((record) => {
+                    t.true(
+                        typeof record === "object",
+                        `${file}: Record value should be an object for ${key} at index ${value.indexOf(record)}`
+                    );
+                });

-                validateSpecialRecords(t, file, key, value);
-            } else if (key === "TXT") {
-                validateTXT(t, file, key, value);
+                // CAA: { flags: number, tag: string, value: string }[]
+                if (key === "CAA") {
+                    value.forEach((record) => {
+                        t.true(
+                            typeof record.flags === "number",
+                            `${file}: CAA record value should have a number for flags at index ${value.indexOf(record)}`
+                        );
+
+                        t.true(
+                            typeof record.tag === "string",
+                            `${file}: CAA record value should have a string for tag at index ${value.indexOf(record)}`
+                        );
+
+                        t.true(
+                            typeof record.value === "string",
+                            `${file}: CAA record value should have a string for value at index ${value.indexOf(record)}`
+                        );
+                    });
+                }
+
+                // DS: { key_tag: number, algorithm: number, digest_type: number, digest: string }[]
+                if (key === "DS") {
+                    value.forEach((record) => {
+                        t.true(
+                            typeof record.key_tag === "number",
+                            `${file}: DS record value should have a number for key_tag at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+
+                        t.true(
+                            typeof record.algorithm === "number",
+                            `${file}: DS record value should have a number for algorithm at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+
+                        t.true(
+                            typeof record.digest_type === "number",
+                            `${file}: DS record value should have a number for digest_type at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+
+                        t.true(
+                            typeof record.digest === "string",
+                            `${file}: DS record value should have a string for digest at index ${value.indexOf(record)}`
+                        );
+                    });
+                }
+
+                // SRV: { priority: number, weight: number, port: number, target: string }[]
+                if (key === "SRV") {
+                    value.forEach((record) => {
+                        t.true(
+                            typeof record.priority === "number",
+                            `${file}: SRV record value should have a number for priority at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+
+                        t.true(
+                            typeof record.weight === "number",
+                            `${file}: SRV record value should have a number for weight at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+
+                        t.true(
+                            typeof record.port === "number",
+                            `${file}: SRV record value should have a number for port at index ${value.indexOf(record)}`
+                        );
+
+                        t.true(
+                            typeof record.target === "string",
+                            `${file}: SRV record value should have a string for target at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+
+                        t.regex(
+                            value.target,
+                            hostnameRegex,
+                            `${file}: SRV record value should be a valid hostname for target at index ${value.indexOf(
+                                record
+                            )}`
+                        );
+                    });
+                }
+            }
+
+            // TXT: string | string[]
+            if (key === "TXT") {
+                if (Array.isArray(value)) {
+                    value.forEach((record) => {
+                        t.true(
+                            typeof record === "string",
+                            `${file}: Record value should be a string for ${key} at index ${value.indexOf(record)}`
+                        );
+                    });
+                } else {
+                    t.true(typeof value === "string", `${file}: Record value should be a string for ${key}`);
+                }
            }
        });
    });
@@ -1,73 +0,0 @@
-module.exports.expandIPv6 = function (ip) {
-    // Split into segments by ":"
-    let segments = ip.split(":");
-
-    // Count the number of segments that are empty due to "::" shorthand
-    const emptyIndex = segments.indexOf("");
-    if (emptyIndex !== -1) {
-        // Calculate how many "0000" segments are missing
-        const nonEmptySegments = segments.filter((seg) => seg !== "");
-        const missingSegments = 8 - nonEmptySegments.length;
-
-        // Insert the missing "0000" segments into the position of the empty segment
-        segments = [
-            ...nonEmptySegments.slice(0, emptyIndex),
-            ...Array(missingSegments).fill("0000"),
-            ...nonEmptySegments.slice(emptyIndex)
-        ];
-    }
-
-    // Expand each segment to 4 characters, padding with leading zeros
-    const expandedSegments = segments.map((segment) => segment.padStart(4, "0"));
-
-    // Join the segments back together
-    return expandedSegments.join(":");
-};
-
-module.exports.isPublicIPv4 = function (ip, proxied) {
-    const parts = ip.split(".").map(Number);
-
-    // Validate IPv4 address format
-    if (parts.length !== 4 || parts.some((part) => isNaN(part) || part < 0 || part > 255)) {
-        return false;
-    }
-
-    // Exception for 192.0.2.1, assuming the domain is proxied
-    if (ip === "192.0.2.1" && proxied) {
-        return true;
-    }
-
-    // Check for private and reserved IPv4 ranges
-    return !(
-        // Private ranges
-        (
-            parts[0] === 10 ||
-            (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) ||
-            (parts[0] === 192 && parts[1] === 168) ||
-            // Reserved or special-use ranges
-            (parts[0] === 100 && parts[1] >= 64 && parts[1] <= 127) || // Carrier-grade NAT
-            (parts[0] === 169 && parts[1] === 254) || // Link-local
-            (parts[0] === 192 && parts[1] === 0 && parts[2] === 0) || // IETF Protocol Assignments
-            (parts[0] === 192 && parts[1] === 0 && parts[2] === 2) || // Documentation (TEST-NET-1)
-            (parts[0] === 198 && parts[1] === 18) || // Network Interconnect Devices
-            (parts[0] === 198 && parts[1] === 51 && parts[2] === 100) || // Documentation (TEST-NET-2)
-            (parts[0] === 203 && parts[1] === 0 && parts[2] === 113) || // Documentation (TEST-NET-3)
-            parts[0] >= 224
-        ) // Multicast and reserved ranges
-    );
-};
-
-module.exports.isPublicIPv6 = function (ip) {
-    const normalizedIP = ip.toLowerCase();
-
-    // Check for private or special-use IPv6 ranges
-    return !(
-        (
-            normalizedIP.startsWith("fc") || // Unique Local Address (ULA)
-            normalizedIP.startsWith("fd") || // Unique Local Address (ULA)
-            normalizedIP.startsWith("fe80") || // Link-local
-            normalizedIP.startsWith("::1") || // Loopback address (::1)
-            normalizedIP.startsWith("2001:db8")
-        ) // Documentation range
-    );
-};
@@ -1,112 +0,0 @@
-const { expandIPv6, isPublicIPv4, isPublicIPv6 } = require("./functions");
-
-const hostnameRegex = /^(?=.{1,253}$)(?:(?:[_a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)\.)+[a-zA-Z]{2,63}$/;
-const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}$/;
-const ipv6Regex =
-    /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,7}:$|^(?:[0-9a-fA-F]{1,4}:){0,6}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$/;
-
-// Check CNAME records
-function checkCNAME(t, file, recordKeys) {
-    if (recordKeys.includes("CNAME")) {
-        t.is(recordKeys.length, 1, `${file}: CNAME records cannot be combined with other records`);
-    }
-}
-
-// Check NS and DS records
-function checkNSAndDS(t, file, recordKeys) {
-    if (recordKeys.includes("NS")) {
-        t.true(
-            recordKeys.length === 1 || (recordKeys.length === 2 && recordKeys.includes("DS")),
-            `${file}: NS records cannot be combined with other records, except for DS records`
-        );
-    }
-
-    if (recordKeys.includes("DS")) {
-        t.true(recordKeys.includes("NS"), `${file}: DS records must be combined with NS records`);
-    }
-}
-
-// Validate IPv4 record
-function validateIPv4(t, file, key, value, data) {
-    value.forEach((record) => {
-        t.regex(record, ipv4Regex, `${file}: Record value should be a valid IPv4 address for ${key}`);
-        t.true(isPublicIPv4(record, data.proxied), `${file}: Record value should be a public IPv4 address for ${key}`);
-    });
-}
-
-// Validate IPv6 record
-function validateIPv6(t, file, key, value) {
-    value.forEach((record) => {
-        t.regex(expandIPv6(record), ipv6Regex, `${file}: Record value should be a valid IPv6 address for ${key}`);
-        t.true(isPublicIPv6(record), `${file}: Record value should be a public IPv6 address for ${key}`);
-    });
-}
-
-// Validate hostname record
-function validateHostname(t, file, key, value) {
-    value.forEach((record) => {
-        t.regex(record, hostnameRegex, `${file}: Record value should be a valid hostname for ${key}`);
-    });
-}
-
-// Validate URL record
-function validateURL(t, file, key, value) {
-    try {
-        new URL(value);
-    } catch (error) {
-        t.fail(`${file}: Record value should be a valid URL for ${key}`);
-    }
-}
-
-// Validate special records (CAA, DS, SRV)
-function validateSpecialRecords(t, file, key, value) {
-    if (key === "CAA") {
-        value.forEach((record) => {
-            t.true(typeof record.flags === "number", `${file}: CAA record value should have a number for flags`);
-            t.true(typeof record.tag === "string", `${file}: CAA record value should have a string for tag`);
-            t.true(typeof record.value === "string", `${file}: CAA record value should have a string for value`);
-        });
-    }
-    if (key === "DS") {
-        value.forEach((record) => {
-            t.true(typeof record.key_tag === "number", `${file}: DS record value should have a number for key_tag`);
-            t.true(typeof record.algorithm === "number", `${file}: DS record value should have a number for algorithm`);
-            t.true(
-                typeof record.digest_type === "number",
-                `${file}: DS record value should have a number for digest_type`
-            );
-            t.true(typeof record.digest === "string", `${file}: DS record value should have a string for digest`);
-        });
-    }
-    if (key === "SRV") {
-        value.forEach((record) => {
-            t.true(typeof record.priority === "number", `${file}: SRV record value should have a number for priority`);
-            t.true(typeof record.weight === "number", `${file}: SRV record value should have a number for weight`);
-            t.true(typeof record.port === "number", `${file}: SRV record value should have a number for port`);
-            t.true(typeof record.target === "string", `${file}: SRV record value should have a string for target`);
-            t.regex(record.target, hostnameRegex, `${file}: SRV record value should have a valid hostname for target`);
-        });
-    }
-}
-
-// Validate TXT record
-function validateTXT(t, file, key, value) {
-    if (Array.isArray(value)) {
-        value.forEach((record) =>
-            t.true(typeof record === "string", `${file}: Record value should be a string for ${key}`)
-        );
-    } else {
-        t.true(typeof value === "string", `${file}: Record value should be a string for ${key}`);
-    }
-}
-
-module.exports = {
-    checkCNAME,
-    checkNSAndDS,
-    validateIPv4,
-    validateIPv6,
-    validateHostname,
-    validateURL,
-    validateSpecialRecords,
-    validateTXT
-};