aboutsummaryrefslogtreecommitdiff
path: root/src/js/out/modules/node/dns.js
diff options
context:
space:
mode:
Diffstat (limited to 'src/js/out/modules/node/dns.js')
-rw-r--r--src/js/out/modules/node/dns.js535
1 files changed, 535 insertions, 0 deletions
diff --git a/src/js/out/modules/node/dns.js b/src/js/out/modules/node/dns.js
new file mode 100644
index 000000000..bbbc94cba
--- /dev/null
+++ b/src/js/out/modules/node/dns.js
@@ -0,0 +1,535 @@
+var lookup = function(domain, options, callback) {
+ if (typeof options == "function")
+ callback = options;
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ if (typeof options == "number")
+ options = { family: options };
+ dns.lookup(domain, options).then((res) => {
+ if (res.sort((a, b) => a.family - b.family), options?.all)
+ callback(null, res.map(mapLookupAll));
+ else {
+ const [{ address, family }] = res;
+ callback(null, address, family);
+ }
+ }, (error) => {
+ callback(error);
+ });
+}, resolveSrv = function(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveSrv(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+}, resolveTxt = function(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveTxt(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+}, resolveSoa = function(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveSoa(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+}, resolveNaptr = function(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveNaptr(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+}, resolveMx = function(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveMx(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+}, resolveCaa = function(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveCaa(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+}, resolveNs = function(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveNs(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+}, resolvePtr = function(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolvePtr(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+}, resolveCname = function(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveCname(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+}, lookupService = function(address, port, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ callback(null, address, port);
+}, resolve = function(hostname, rrtype, callback) {
+ if (typeof rrtype == "function")
+ callback = rrtype;
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolve(hostname).then((results) => {
+ switch (rrtype?.toLowerCase()) {
+ case "a":
+ case "aaaa":
+ callback(null, hostname, results.map(({ address }) => address));
+ break;
+ default:
+ callback(null, results);
+ break;
+ }
+ }, (error) => {
+ callback(error);
+ });
+}, Resolver = function(options) {
+ return new InternalResolver(options);
+}, setDefaultResultOrder = function() {
+}, setServers = function() {
+}, { dns } = globalThis.Bun, InternalResolver = class Resolver2 {
+ constructor(options) {
+ }
+ cancel() {
+ }
+ getServers() {
+ return [];
+ }
+ resolve(hostname, rrtype, callback) {
+ if (typeof rrtype == "function")
+ callback = rrtype, rrtype = null;
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolve(hostname).then((results) => {
+ switch (rrtype?.toLowerCase()) {
+ case "a":
+ case "aaaa":
+ callback(null, hostname, results.map(mapResolveX));
+ break;
+ default:
+ callback(null, results);
+ break;
+ }
+ }, (error) => {
+ callback(error);
+ });
+ }
+ resolve4(hostname, options, callback) {
+ if (typeof options == "function")
+ callback = options, options = null;
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.lookup(hostname, { family: 4 }).then((addresses) => {
+ callback(null, options?.ttl ? addresses : addresses.map(mapResolveX));
+ }, (error) => {
+ callback(error);
+ });
+ }
+ resolve6(hostname, options, callback) {
+ if (typeof options == "function")
+ callback = options, options = null;
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.lookup(hostname, { family: 6 }).then((addresses) => {
+ callback(null, options?.ttl ? addresses : addresses.map(({ address }) => address));
+ }, (error) => {
+ callback(error);
+ });
+ }
+ resolveAny(hostname, callback) {
+ callback(null, []);
+ }
+ resolveCname(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveCname(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+ }
+ resolveMx(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveMx(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+ }
+ resolveNaptr(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveNaptr(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+ }
+ resolveNs(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveNs(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+ }
+ resolvePtr(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolvePtr(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+ }
+ resolveSrv(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveSrv(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+ }
+ resolveCaa(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveCaa(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+ }
+ resolveTxt(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveTxt(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+ }
+ resolveSoa(hostname, callback) {
+ if (typeof callback != "function")
+ throw new TypeError("callback must be a function");
+ dns.resolveSoa(hostname, callback).then((results) => {
+ callback(null, results);
+ }, (error) => {
+ callback(error);
+ });
+ }
+ reverse(ip, callback) {
+ callback(null, []);
+ }
+ setServers(servers) {
+ }
+};
+Object.setPrototypeOf(Resolver.prototype, InternalResolver.prototype);
+Object.setPrototypeOf(Resolver, InternalResolver);
+var {
+ resolve,
+ resolve4,
+ resolve6,
+ resolveAny,
+ resolveCname,
+ resolveCaa,
+ resolveMx,
+ resolveNaptr,
+ resolveNs,
+ resolvePtr,
+ resolveSoa,
+ resolveSrv,
+ reverse,
+ resolveTxt
+} = InternalResolver.prototype, promisifyLookup = (res) => {
+ res.sort((a, b) => a.family - b.family);
+ const [{ address, family }] = res;
+ return { address, family };
+}, mapLookupAll = (res) => {
+ const { address, family } = res;
+ return { address, family };
+}, promisifyLookupAll = (res) => {
+ return res.sort((a, b) => a.family - b.family), res.map(mapLookupAll);
+}, mapResolveX = (a) => a.address, promisifyResolveX = (res) => {
+ return res?.map(mapResolveX);
+}, promises = {
+ lookup(domain, options) {
+ if (options?.all)
+ return dns.lookup(domain, options).then(promisifyLookupAll);
+ return dns.lookup(domain, options).then(promisifyLookup);
+ },
+ lookupService(address, port) {
+ return Promise.resolve([]);
+ },
+ resolve(hostname, rrtype) {
+ if (typeof rrtype !== "string")
+ rrtype = null;
+ switch (rrtype?.toLowerCase()) {
+ case "a":
+ case "aaaa":
+ return dns.resolve(hostname, rrtype).then(promisifyLookup);
+ default:
+ return dns.resolve(hostname, rrtype);
+ }
+ },
+ resolve4(hostname, options) {
+ if (options?.ttl)
+ return dns.lookup(hostname, { family: 4 });
+ return dns.lookup(hostname, { family: 4 }).then(promisifyResolveX);
+ },
+ resolve6(hostname, options) {
+ if (options?.ttl)
+ return dns.lookup(hostname, { family: 6 });
+ return dns.lookup(hostname, { family: 6 }).then(promisifyResolveX);
+ },
+ resolveSrv(hostname) {
+ return dns.resolveSrv(hostname);
+ },
+ resolveTxt(hostname) {
+ return dns.resolveTxt(hostname);
+ },
+ resolveSoa(hostname) {
+ return dns.resolveSoa(hostname);
+ },
+ resolveNaptr(hostname) {
+ return dns.resolveNaptr(hostname);
+ },
+ resolveMx(hostname) {
+ return dns.resolveMx(hostname);
+ },
+ resolveCaa(hostname) {
+ return dns.resolveCaa(hostname);
+ },
+ resolveNs(hostname) {
+ return dns.resolveNs(hostname);
+ },
+ resolvePtr(hostname) {
+ return dns.resolvePtr(hostname);
+ },
+ resolveCname(hostname) {
+ return dns.resolveCname(hostname);
+ },
+ Resolver: class Resolver3 {
+ constructor(options) {
+ }
+ cancel() {
+ }
+ getServers() {
+ return [];
+ }
+ resolve(hostname, rrtype) {
+ if (typeof rrtype !== "string")
+ rrtype = null;
+ switch (rrtype?.toLowerCase()) {
+ case "a":
+ case "aaaa":
+ return dns.resolve(hostname, rrtype).then(promisifyLookup);
+ default:
+ return dns.resolve(hostname, rrtype);
+ }
+ }
+ resolve4(hostname, options) {
+ if (options?.ttl)
+ return dns.lookup(hostname, { family: 4 });
+ return dns.lookup(hostname, { family: 4 }).then(promisifyResolveX);
+ }
+ resolve6(hostname, options) {
+ if (options?.ttl)
+ return dns.lookup(hostname, { family: 6 });
+ return dns.lookup(hostname, { family: 6 }).then(promisifyResolveX);
+ }
+ resolveAny(hostname) {
+ return Promise.resolve([]);
+ }
+ resolveCname(hostname) {
+ return dns.resolveCname(hostname);
+ }
+ resolveMx(hostname) {
+ return dns.resolveMx(hostname);
+ }
+ resolveNaptr(hostname) {
+ return dns.resolveNaptr(hostname);
+ }
+ resolveNs(hostname) {
+ return dns.resolveNs(hostname);
+ }
+ resolvePtr(hostname) {
+ return dns.resolvePtr(hostname);
+ }
+ resolveSoa(hostname) {
+ return dns.resolveSoa(hostname);
+ }
+ resolveSrv(hostname) {
+ return dns.resolveSrv(hostname);
+ }
+ resolveCaa(hostname) {
+ return dns.resolveCaa(hostname);
+ }
+ resolveTxt(hostname) {
+ return dns.resolveTxt(hostname);
+ }
+ reverse(ip) {
+ return Promise.resolve([]);
+ }
+ setServers(servers) {
+ }
+ }
+};
+for (let key of ["resolveAny", "reverse"])
+ promises[key] = () => Promise.resolve(void 0);
+var exports = {
+ ADDRCONFIG: 0,
+ ALL: 1,
+ V4MAPPED: 2,
+ NODATA: "DNS_ENODATA",
+ FORMERR: "DNS_EFORMERR",
+ SERVFAIL: "DNS_ESERVFAIL",
+ NOTFOUND: "DNS_ENOTFOUND",
+ NOTIMP: "DNS_ENOTIMP",
+ REFUSED: "DNS_EREFUSED",
+ BADQUERY: "DNS_EBADQUERY",
+ BADNAME: "DNS_EBADNAME",
+ BADFAMILY: "DNS_EBADFAMILY",
+ BADRESP: "DNS_EBADRESP",
+ CONNREFUSED: "DNS_ECONNREFUSED",
+ TIMEOUT: "DNS_ETIMEOUT",
+ EOF: "DNS_EEOF",
+ FILE: "DNS_EFILE",
+ NOMEM: "DNS_ENOMEM",
+ DESTRUCTION: "DNS_EDESTRUCTION",
+ BADSTR: "DNS_EBADSTR",
+ BADFLAGS: "DNS_EBADFLAGS",
+ NONAME: "DNS_ENONAME",
+ BADHINTS: "DNS_EBADHINTS",
+ NOTINITIALIZED: "DNS_ENOTINITIALIZED",
+ LOADIPHLPAPI: "DNS_ELOADIPHLPAPI",
+ ADDRGETNETWORKPARAMS: "DNS_EADDRGETNETWORKPARAMS",
+ CANCELLED: "DNS_ECANCELLED",
+ lookup,
+ lookupService,
+ Resolver,
+ setServers,
+ setDefaultResultOrder,
+ resolve,
+ reverse,
+ resolve4,
+ resolve6,
+ resolveAny,
+ resolveCname,
+ resolveCaa,
+ resolveMx,
+ resolveNs,
+ resolvePtr,
+ resolveSoa,
+ resolveSrv,
+ resolveTxt,
+ resolveNaptr,
+ promises,
+ [Symbol.for("CommonJS")]: 0
+}, dns_default = exports, {
+ ADDRCONFIG,
+ ALL,
+ V4MAPPED,
+ NODATA,
+ FORMERR,
+ SERVFAIL,
+ NOTFOUND,
+ NOTIMP,
+ REFUSED,
+ BADQUERY,
+ BADNAME,
+ BADFAMILY,
+ BADRESP,
+ CONNREFUSED,
+ TIMEOUT,
+ EOF,
+ FILE,
+ NOMEM,
+ DESTRUCTION,
+ BADSTR,
+ BADFLAGS,
+ NONAME,
+ BADHINTS,
+ NOTINITIALIZED,
+ LOADIPHLPAPI,
+ ADDRGETNETWORKPARAMS,
+ CANCELLED
+} = exports;
+export {
+ setServers,
+ setDefaultResultOrder,
+ reverse,
+ resolveTxt,
+ resolveSrv,
+ resolveSoa,
+ resolvePtr,
+ resolveNs,
+ resolveNaptr,
+ resolveMx,
+ resolveCname,
+ resolveCaa,
+ resolveAny,
+ resolve6,
+ resolve4,
+ resolve,
+ promises,
+ lookupService,
+ lookup,
+ dns_default as default,
+ V4MAPPED,
+ TIMEOUT,
+ SERVFAIL,
+ Resolver,
+ REFUSED,
+ NOTINITIALIZED,
+ NOTIMP,
+ NOTFOUND,
+ NONAME,
+ NOMEM,
+ NODATA,
+ LOADIPHLPAPI,
+ FORMERR,
+ FILE,
+ EOF,
+ DESTRUCTION,
+ CONNREFUSED,
+ CANCELLED,
+ BADSTR,
+ BADRESP,
+ BADQUERY,
+ BADNAME,
+ BADHINTS,
+ BADFLAGS,
+ BADFAMILY,
+ ALL,
+ ADDRGETNETWORKPARAMS,
+ ADDRCONFIG
+};
generated by cgit v1.2.3 (git 2.46.0) at 2025-10-03 15:26:23 +0000