domain-alive 0.1.12 → 0.1.14

package/dist/index.js

@@ -1,20 +1,1808 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tldts = require('tldts');
-var dns2 = require('dns2');
+var require$$0$1 = require('dgram');
+var require$$0 = require('util');
+var require$$0$2 = require('net');
+var require$$0$3 = require('http');
+var require$$1 = require('https');
+var require$$2 = require('url');
+var require$$4 = require('events');
+var require$$0$4 = require('tls');
+var require$$2$1 = require('http2');
+var require$$2$2 = require('assert');
 var asyncRetry = require('foxts/async-retry');
 var net = require('node:net');
 var retrie = require('foxts/retrie');
 var extractErrorMessage = require('foxts/extract-error-message');
 var debug = require('debug');
 var shuffleArray = require('foxts/shuffle-array');
-var url = require('url');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var require$$0__default$1 = /*#__PURE__*/_interopDefault(require$$0$1);
+var require$$0__default = /*#__PURE__*/_interopDefault(require$$0);
+var require$$0__default$2 = /*#__PURE__*/_interopDefault(require$$0$2);
+var require$$0__default$3 = /*#__PURE__*/_interopDefault(require$$0$3);
+var require$$1__default = /*#__PURE__*/_interopDefault(require$$1);
+var require$$2__default = /*#__PURE__*/_interopDefault(require$$2);
+var require$$4__default = /*#__PURE__*/_interopDefault(require$$4);
+var require$$0__default$4 = /*#__PURE__*/_interopDefault(require$$0$4);
+var require$$2__default$1 = /*#__PURE__*/_interopDefault(require$$2$1);
+var require$$2__default$2 = /*#__PURE__*/_interopDefault(require$$2$2);
 var net__default = /*#__PURE__*/_interopDefault(net);
 var debug__default = /*#__PURE__*/_interopDefault(debug);
 
+var packet = {exports: {}};
+
+/**
+ * [Reader description]
+ * @param {[type]} buffer [description]
+ * @param {[type]} offset [description]
+ */
+
+var reader;
+var hasRequiredReader;
+
+function requireReader () {
+	if (hasRequiredReader) return reader;
+	hasRequiredReader = 1;
+	function BufferReader(buffer, offset) {
+	    this.buffer = buffer;
+	    this.offset = offset || 0;
+	    return this;
+	}
+	/**
+	 * [read description]
+	 * @param  {[type]} buffer [description]
+	 * @param  {[type]} offset [description]
+	 * @param  {[type]} length [description]
+	 * @return {[type]}        [description]
+	 */ BufferReader.read = function(buffer, offset, length) {
+	    let a = [];
+	    let c = Math.ceil(length / 8);
+	    let l = Math.floor(offset / 8);
+	    const m = offset % 8;
+	    function t(n) {
+	        const r = [
+	            0,
+	            0,
+	            0,
+	            0,
+	            0,
+	            0,
+	            0,
+	            0
+	        ];
+	        for(let i = 7; i >= 0; i--){
+	            r[7 - i] = n & Math.pow(2, i) ? 1 : 0;
+	        }
+	        a = a.concat(r);
+	    }
+	    function p(a) {
+	        let n = 0;
+	        const f = a.length - 1;
+	        for(let i = f; i >= 0; i--){
+	            if (a[f - i]) n += Math.pow(2, i);
+	        }
+	        return n;
+	    }
+	    while(c--)t(buffer.readUInt8(l++));
+	    return p(a.slice(m, m + length));
+	};
+	/**
+	 * [read description]
+	 * @param  {[type]} size [description]
+	 * @return {[type]}      [description]
+	 */ BufferReader.prototype.read = function(size) {
+	    const val = BufferReader.read(this.buffer, this.offset, size);
+	    this.offset += size;
+	    return val;
+	};
+	reader = BufferReader;
+	return reader;
+}
+
+/**
+ * [Writer description]
+ */
+
+var writer;
+var hasRequiredWriter;
+
+function requireWriter () {
+	if (hasRequiredWriter) return writer;
+	hasRequiredWriter = 1;
+	function BufferWriter() {
+	    this.buffer = [];
+	}
+	/**
+	 * [write description]
+	 * @param  {[type]} d    [description]
+	 * @param  {[type]} size [description]
+	 * @return {[type]}      [description]
+	 */ BufferWriter.prototype.write = function(d, size) {
+	    for(let i = 0; i < size; i++){
+	        this.buffer.push(d & Math.pow(2, size - i - 1) ? 1 : 0);
+	    }
+	};
+	/**
+	 * [writeBuffer description]
+	 * @param {[type]} b [description]
+	 */ BufferWriter.prototype.writeBuffer = function(b) {
+	    this.buffer = this.buffer.concat(b.buffer);
+	};
+	/**
+	 * [toBuffer description]
+	 * @return {[type]} [description]
+	 */ BufferWriter.prototype.toBuffer = function() {
+	    const arr = [];
+	    for(let i = 0; i < this.buffer.length; i += 8){
+	        const chunk = this.buffer.slice(i, i + 8);
+	        arr.push(parseInt(chunk.join(''), 2));
+	    }
+	    return Buffer.from(arr);
+	};
+	writer = BufferWriter;
+	return writer;
+}
+
+var hasRequiredPacket;
+
+function requirePacket () {
+	if (hasRequiredPacket) return packet.exports;
+	hasRequiredPacket = 1;
+	const { debuglog } = require$$0__default.default;
+	const BufferReader = requireReader();
+	const BufferWriter = requireWriter();
+	const debug = debuglog('dns2');
+	const toIPv6 = (buffer)=>buffer.map((part)=>part > 0 ? part.toString(16) : '0').join(':').replace(/\b(?:0+:){1,}/, ':');
+	const fromIPv6 = (address)=>{
+	    const digits = address.split(':');
+	    // CAVEAT edge case for :: and IPs starting
+	    // or ending by ::
+	    if (digits[0] === '') {
+	        digits.shift();
+	    }
+	    if (digits[digits.length - 1] === '') {
+	        digits.pop();
+	    }
+	    // node js 10 does not support Array.prototype.flatMap
+	    if (!Array.prototype.flatMap) {
+	        // eslint-disable-next-line no-extend-native
+	        Array.prototype.flatMap = function(f, ctx) {
+	            return this.reduce((r, x, i, a)=>r.concat(f.call(ctx, x, i, a)), []);
+	        };
+	    }
+	    // CAVEAT we have to take into account
+	    // the extra space used by the empty string
+	    const missingFields = 8 - digits.length + 1;
+	    return digits.flatMap((digit)=>{
+	        if (digit === '') {
+	            return Array(missingFields).fill('0');
+	        }
+	        return digit.padStart(4, '0');
+	    });
+	};
+	/**
+	 * [Packet description]
+	 * @param {[type]} data [description]
+	 * @docs https://tools.ietf.org/html/rfc1034
+	 * @docs https://tools.ietf.org/html/rfc1035
+	 *
+	 * <Buffer 29 64 01 00 00 01 00 00 00 00 00 00
+	 *       |-ID----------- HEADER ----------->|
+	 *
+	 *  03 77 77 77 01 7a 02 63 6e 00 00 01 00 01>
+	 *   <-W--W--W-----Z-----C--N>|<----------->|
+	 */ function Packet(data) {
+	    this.header = {};
+	    this.questions = [];
+	    this.answers = [];
+	    this.authorities = [];
+	    this.additionals = [];
+	    if (data instanceof Packet) {
+	        return data;
+	    } else if (data instanceof Packet.Header) {
+	        this.header = data;
+	    } else if (data instanceof Packet.Question) {
+	        this.questions.push(data);
+	    } else if (data instanceof Packet.Resource) {
+	        this.answers.push(data);
+	    } else if (typeof data === 'string') {
+	        this.questions.push(data);
+	    } else if (typeof data === 'object') {
+	        const type = ({}).toString.call(data).match(/\[object (\w+)\]/)[1];
+	        if (type === 'Array') {
+	            this.questions = data;
+	        }
+	        if (type === 'Object') {
+	            this.header = data;
+	        }
+	    }
+	    return this;
+	}
+	/**
+	 * [QUERY_TYPE description]
+	 * @type {Object}
+	 * @docs https://tools.ietf.org/html/rfc1035#section-3.2.2
+	 */ Packet.TYPE = {
+	    A: 0x01,
+	    NS: 0x02,
+	    MD: 0x03,
+	    MF: 0x04,
+	    CNAME: 0x05,
+	    SOA: 0x06,
+	    MB: 0x07,
+	    MG: 0x08,
+	    MR: 0x09,
+	    NULL: 0x0A,
+	    WKS: 0x0B,
+	    PTR: 0x0C,
+	    HINFO: 0x0D,
+	    MINFO: 0x0E,
+	    MX: 0x0F,
+	    TXT: 0x10,
+	    AAAA: 0x1C,
+	    SRV: 0x21,
+	    EDNS: 0x29,
+	    SPF: 0x63,
+	    AXFR: 0xFC,
+	    MAILB: 0xFD,
+	    MAILA: 0xFE,
+	    ANY: 0xFF,
+	    CAA: 0x101,
+	    DNSKEY: 0x30
+	};
+	/**
+	 * [QUERY_CLASS description]
+	 * @type {Object}
+	 * @docs https://tools.ietf.org/html/rfc1035#section-3.2.4
+	 */ Packet.CLASS = {
+	    IN: 0x01,
+	    CS: 0x02,
+	    CH: 0x03,
+	    HS: 0x04,
+	    ANY: 0xFF
+	};
+	/**
+	 * [EDNS_OPTION_CODE description]
+	 * @type {Object}
+	 * @docs https://tools.ietf.org/html/rfc6891#section-6.1.2
+	 */ Packet.EDNS_OPTION_CODE = {
+	    ECS: 0x08
+	};
+	/**
+	 * [uuid description]
+	 * @return {[type]} [description]
+	 */ Packet.uuid = function() {
+	    return Math.floor(Math.random() * 1e5);
+	};
+	/**
+	 * [parse description]
+	 * @param  {[type]} buffer [description]
+	 * @return {[type]}        [description]
+	 */ Packet.parse = function(buffer) {
+	    const packet = new Packet();
+	    const reader = new Packet.Reader(buffer);
+	    packet.header = Packet.Header.parse(reader);
+	    [
+	        [
+	            'questions',
+	            Packet.Question,
+	            packet.header.qdcount
+	        ],
+	        [
+	            'answers',
+	            Packet.Resource,
+	            packet.header.ancount
+	        ],
+	        [
+	            'authorities',
+	            Packet.Resource,
+	            packet.header.nscount
+	        ],
+	        [
+	            'additionals',
+	            Packet.Resource,
+	            packet.header.arcount
+	        ]
+	    ].forEach(function(def) {
+	        const section = def[0];
+	        const decoder = def[1];
+	        let count = def[2];
+	        while(count--){
+	            try {
+	                packet[section] = packet[section] || [];
+	                packet[section].push(decoder.parse(reader));
+	            } catch (e) {
+	                debug('node-dns > parse %s error:', section, e.message);
+	            }
+	        }
+	    });
+	    return packet;
+	};
+	/**
+	 * recursive
+	 */ Object.defineProperty(Packet.prototype, 'recursive', {
+	    enumerable: true,
+	    configurable: true,
+	    get () {
+	        return !!this.header.rd;
+	    },
+	    set (yn) {
+	        this.header.rd = +yn;
+	        return this.header.rd;
+	    }
+	});
+	/**
+	 * [toBuffer description]
+	 * @return {[type]} [description]
+	 */ Packet.prototype.toBuffer = function(writer) {
+	    writer = writer || new Packet.Writer();
+	    this.header.qdcount = this.questions.length;
+	    this.header.ancount = this.answers.length;
+	    this.header.nscount = this.authorities.length;
+	    this.header.arcount = this.additionals.length;
+	    if (!(this instanceof Packet.Header)) {
+	        this.header = new Packet.Header(this.header);
+	    }
+	    this.header.toBuffer(writer);
+	    [
+	        [
+	            'questions',
+	            Packet.Question
+	        ],
+	        [
+	            'answers',
+	            Packet.Resource
+	        ],
+	        [
+	            'authorities',
+	            Packet.Resource
+	        ],
+	        [
+	            'additionals',
+	            Packet.Resource
+	        ]
+	    ].forEach((function(def) {
+	        const section = def[0];
+	        const Encoder = def[1];
+	        (this[section] || []).map(function(resource) {
+	            return Encoder.encode(resource, writer);
+	        });
+	    }).bind(this));
+	    return writer.toBuffer();
+	};
+	/**
+	 * [Header description]
+	 * @param {[type]} options [description]
+	 * @docs https://tools.ietf.org/html/rfc1035#section-4.1.1
+	 */ Packet.Header = function(header) {
+	    this.id = 0;
+	    this.qr = 0;
+	    this.opcode = 0;
+	    this.aa = 0;
+	    this.tc = 0;
+	    this.rd = 0;
+	    this.ra = 0;
+	    this.z = 0;
+	    this.rcode = 0;
+	    this.qdcount = 0;
+	    this.nscount = 0;
+	    this.arcount = 0;
+	    for(const k in header){
+	        this[k] = header[k];
+	    }
+	    return this;
+	};
+	/**
+	 * [parse description]
+	 * @param  {[type]} buffer [description]
+	 * @return {[type]}        [description]
+	 * @docs https://tools.ietf.org/html/rfc1035#section-4.1.1
+	 */ Packet.Header.parse = function(reader) {
+	    const header = new Packet.Header();
+	    if (reader instanceof Buffer) {
+	        reader = new Packet.Reader(reader);
+	    }
+	    header.id = reader.read(16);
+	    header.qr = reader.read(1);
+	    header.opcode = reader.read(4);
+	    header.aa = reader.read(1);
+	    header.tc = reader.read(1);
+	    header.rd = reader.read(1);
+	    header.ra = reader.read(1);
+	    header.z = reader.read(3);
+	    header.rcode = reader.read(4);
+	    header.qdcount = reader.read(16);
+	    header.ancount = reader.read(16);
+	    header.nscount = reader.read(16);
+	    header.arcount = reader.read(16);
+	    return header;
+	};
+	/**
+	 * [toBuffer description]
+	 * @return {[type]} [description]
+	 */ Packet.Header.prototype.toBuffer = function(writer) {
+	    writer = writer || new Packet.Writer();
+	    writer.write(this.id, 16);
+	    writer.write(this.qr, 1);
+	    writer.write(this.opcode, 4);
+	    writer.write(this.aa, 1);
+	    writer.write(this.tc, 1);
+	    writer.write(this.rd, 1);
+	    writer.write(this.ra, 1);
+	    writer.write(this.z, 3);
+	    writer.write(this.rcode, 4);
+	    writer.write(this.qdcount, 16);
+	    writer.write(this.ancount, 16);
+	    writer.write(this.nscount, 16);
+	    writer.write(this.arcount, 16);
+	    return writer.toBuffer();
+	};
+	/**
+	 * Question section format
+	 * @docs https://tools.ietf.org/html/rfc1035#section-4.1.2
+	 */ Packet.Question = function(name, type, cls) {
+	    const defaults = {
+	        type: Packet.TYPE.ANY,
+	        class: Packet.CLASS.ANY
+	    };
+	    if (typeof name === 'object') {
+	        for(const k in name){
+	            this[k] = name[k] || defaults[k];
+	        }
+	    } else {
+	        this.name = name;
+	        this.type = type || defaults.type;
+	        this.class = cls || defaults.class;
+	    }
+	    return this;
+	};
+	/**
+	 * [toBuffer description]
+	 * @param  {[type]} writer [description]
+	 * @return {[type]}        [description]
+	 */ Packet.Question.prototype.toBuffer = function(writer) {
+	    return Packet.Question.encode(this, writer);
+	};
+	/**
+	 * [parse description]
+	 * @param  {[type]} reader [description]
+	 * @return {[type]}        [description]
+	 */ Packet.Question.parse = Packet.Question.decode = function(reader) {
+	    const question = new Packet.Question();
+	    if (reader instanceof Buffer) {
+	        reader = new Packet.Reader(reader);
+	    }
+	    question.name = Packet.Name.decode(reader);
+	    question.type = reader.read(16);
+	    question.class = reader.read(16);
+	    return question;
+	};
+	Packet.Question.encode = function(question, writer) {
+	    writer = writer || new Packet.Writer();
+	    Packet.Name.encode(question.name, writer);
+	    writer.write(question.type, 16);
+	    writer.write(question.class, 16);
+	    return writer.toBuffer();
+	};
+	/**
+	 * Resource record format
+	 * @docs https://tools.ietf.org/html/rfc1035#section-4.1.3
+	 */ Packet.Resource = function(name, type, cls, ttl) {
+	    const defaults = {
+	        name: '',
+	        ttl: 300,
+	        type: Packet.TYPE.ANY,
+	        class: Packet.CLASS.ANY
+	    };
+	    let input;
+	    if (typeof name === 'object') {
+	        input = name;
+	    } else {
+	        input = {
+	            name,
+	            type,
+	            class: cls,
+	            ttl
+	        };
+	    }
+	    Object.assign(this, defaults, input);
+	    return this;
+	};
+	/**
+	 * [toBuffer description]
+	 * @param  {[type]} writer [description]
+	 * @return {[type]}        [description]
+	 */ Packet.Resource.prototype.toBuffer = function(writer) {
+	    return Packet.Resource.encode(this, writer);
+	};
+	/**
+	 * [encode description]
+	 * @param  {[type]} resource [description]
+	 * @param  {[type]} writer   [description]
+	 * @return {[type]}          [description]
+	 */ Packet.Resource.encode = function(resource, writer) {
+	    writer = writer || new Packet.Writer();
+	    Packet.Name.encode(resource.name, writer);
+	    writer.write(resource.type, 16);
+	    writer.write(resource.class, 16);
+	    writer.write(resource.ttl, 32);
+	    const encoder = Object.keys(Packet.TYPE).filter(function(type) {
+	        return resource.type === Packet.TYPE[type];
+	    })[0];
+	    if (encoder in Packet.Resource && Packet.Resource[encoder].encode) {
+	        return Packet.Resource[encoder].encode(resource, writer);
+	    } else {
+	        debug('node-dns > unknown encoder %s(%j)', encoder, resource.type);
+	    }
+	};
+	/**
+	 * [parse description]
+	 * @param  {[type]} reader [description]
+	 * @return {[type]}        [description]
+	 */ Packet.Resource.parse = Packet.Resource.decode = function(reader) {
+	    if (reader instanceof Buffer) {
+	        reader = new Packet.Reader(reader);
+	    }
+	    let resource = new Packet.Resource();
+	    resource.name = Packet.Name.decode(reader);
+	    resource.type = reader.read(16);
+	    resource.class = reader.read(16);
+	    resource.ttl = reader.read(32);
+	    let length = reader.read(16);
+	    const parser = Object.keys(Packet.TYPE).filter(function(type) {
+	        return resource.type === Packet.TYPE[type];
+	    })[0];
+	    if (parser in Packet.Resource) {
+	        resource = Packet.Resource[parser].decode.call(resource, reader, length);
+	    } else {
+	        debug('node-dns > unknown parser type: %s(%j)', parser, resource.type);
+	        const arr = [];
+	        while(length--)arr.push(reader.read(8));
+	        resource.data = Buffer.from(arr);
+	    }
+	    return resource;
+	};
+	/**
+	 * [encode_name description]
+	 * @param  {[type]} domain [description]
+	 * @return {[type]}        [description]
+	 */ Packet.Name = {
+	    COPY: 0xc0,
+	    decode: function(reader) {
+	        if (reader instanceof Buffer) {
+	            reader = new Packet.Reader(reader);
+	        }
+	        const name = [];
+	        let o;
+	        let len = reader.read(8);
+	        while(len){
+	            if ((len & Packet.Name.COPY) === Packet.Name.COPY) {
+	                len -= Packet.Name.COPY;
+	                len = len << 8;
+	                const pos = len + reader.read(8);
+	                if (!o) o = reader.offset;
+	                reader.offset = pos * 8;
+	                len = reader.read(8);
+	                continue;
+	            } else {
+	                let part = '';
+	                while(len--)part += String.fromCharCode(reader.read(8));
+	                name.push(part);
+	                len = reader.read(8);
+	            }
+	        }
+	        if (o) reader.offset = o;
+	        return name.join('.');
+	    },
+	    encode: function(domain, writer) {
+	        writer = writer || new Packet.Writer();
+	        // TODO: domain name compress
+	        (domain || '').split('.').filter(function(part) {
+	            return !!part;
+	        }).forEach(function(part) {
+	            writer.write(part.length, 8);
+	            part.split('').map(function(c) {
+	                writer.write(c.charCodeAt(0), 8);
+	                return c.charCodeAt(0);
+	            });
+	        });
+	        writer.write(0, 8);
+	        return writer.toBuffer();
+	    }
+	};
+	/**
+	 * [A description]
+	 * @type {Object}
+	 * @docs https://tools.ietf.org/html/rfc1035#section-3.4.1
+	 */ Packet.Resource.A = function(address) {
+	    this.type = Packet.TYPE.A;
+	    this.class = Packet.CLASS.IN;
+	    this.address = address;
+	    return this;
+	};
+	Packet.Resource.A.encode = function(record, writer) {
+	    writer = writer || new Packet.Writer();
+	    const parts = record.address.split('.');
+	    writer.write(parts.length, 16);
+	    parts.forEach(function(part) {
+	        writer.write(parseInt(part, 10), 8);
+	    });
+	    return writer.toBuffer();
+	};
+	Packet.Resource.A.decode = function(reader, length) {
+	    const parts = [];
+	    while(length--)parts.push(reader.read(8));
+	    this.address = parts.join('.');
+	    return this;
+	};
+	/**
+	 * [MX description]
+	 * @param {[type]} exchange [description]
+	 * @param {[type]} priority [description]
+	 * @docs https://tools.ietf.org/html/rfc1035#section-3.3.9
+	 */ Packet.Resource.MX = function(exchange, priority) {
+	    this.type = Packet.TYPE.MX;
+	    this.class = Packet.CLASS.IN;
+	    this.exchange = exchange;
+	    this.priority = priority;
+	    return this;
+	};
+	/**
+	 * [encode description]
+	 * @param  {[type]} record [description]
+	 * @param  {[type]} writer [description]
+	 * @return {[type]}        [description]
+	 */ Packet.Resource.MX.encode = function(record, writer) {
+	    writer = writer || new Packet.Writer();
+	    const len = Packet.Name.encode(record.exchange).length;
+	    writer.write(len + 2, 16);
+	    writer.write(record.priority, 16);
+	    Packet.Name.encode(record.exchange, writer);
+	    return writer.toBuffer();
+	};
+	/**
+	 * [decode description]
+	 * @param  {[type]} reader [description]
+	 * @param  {[type]} length [description]
+	 * @return {[type]}        [description]
+	 */ Packet.Resource.MX.decode = function(reader, length) {
+	    this.priority = reader.read(16);
+	    this.exchange = Packet.Name.decode(reader);
+	    return this;
+	};
+	/**
+	 * [AAAA description]
+	 * @type {Object}
+	 * @docs https://en.wikipedia.org/wiki/IPv6
+	 */ Packet.Resource.AAAA = {
+	    decode: function(reader, length) {
+	        const parts = [];
+	        while(length){
+	            length -= 2;
+	            parts.push(reader.read(16));
+	        }
+	        this.address = toIPv6(parts);
+	        return this;
+	    },
+	    encode: function(record, writer) {
+	        writer = writer || new Packet.Writer();
+	        const parts = fromIPv6(record.address);
+	        writer.write(parts.length * 2, 16);
+	        parts.forEach(function(part) {
+	            writer.write(parseInt(part, 16), 16);
+	        });
+	        return writer.toBuffer();
+	    }
+	};
+	/**
+	 * [NS description]
+	 * @type {Object}
+	 * @docs https://tools.ietf.org/html/rfc1035#section-3.3.11
+	 */ Packet.Resource.NS = {
+	    decode: function(reader, length) {
+	        this.ns = Packet.Name.decode(reader);
+	        return this;
+	    },
+	    encode: function(record, writer) {
+	        writer = writer || new Packet.Writer();
+	        writer.write(Packet.Name.encode(record.ns).length, 16);
+	        Packet.Name.encode(record.ns, writer);
+	        return writer.toBuffer();
+	    }
+	};
+	/**
+	 * [CNAME description]
+	 * @type {Object}
+	 * @docs https://tools.ietf.org/html/rfc1035#section-3.3.1
+	 */ Packet.Resource.PTR = Packet.Resource.CNAME = {
+	    decode: function(reader, length) {
+	        this.domain = Packet.Name.decode(reader);
+	        return this;
+	    },
+	    encode: function(record, writer) {
+	        writer = writer || new Packet.Writer();
+	        writer.write(Packet.Name.encode(record.domain).length, 16);
+	        Packet.Name.encode(record.domain, writer);
+	        return writer.toBuffer();
+	    }
+	};
+	/**
+	 * [SPF description]
+	 * @type {[type]}
+	 * @docs https://tools.ietf.org/html/rfc1035#section-3.3.14
+	 */ Packet.Resource.SPF = Packet.Resource.TXT = {
+	    decode: function(reader, length) {
+	        const parts = [];
+	        let bytesRead = 0;
+	        let chunkLength = 0;
+	        while(bytesRead < length){
+	            chunkLength = reader.read(8); // text length
+	            bytesRead++;
+	            while(chunkLength--){
+	                parts.push(reader.read(8));
+	                bytesRead++;
+	            }
+	        }
+	        this.data = Buffer.from(parts).toString('utf8');
+	        return this;
+	    },
+	    encode: function(record, writer) {
+	        writer = writer || new Packet.Writer();
+	        // make sure that resource data is a an array of strings
+	        const characterStrings = Array.isArray(record.data) ? record.data : [
+	            record.data
+	        ];
+	        // convert array of strings to array of buffers
+	        const characterStringBuffers = characterStrings.map(function(characterString) {
+	            if (Buffer.isBuffer(characterString)) {
+	                return characterString;
+	            }
+	            if (typeof characterString === 'string') {
+	                return Buffer.from(characterString, 'utf8');
+	            }
+	            return false;
+	        }).filter(function(characterString) {
+	            // remove invalid values from the array
+	            return characterString;
+	        });
+	        // calculate byte length of resource strings
+	        const bufferLength = characterStringBuffers.reduce(function(sum, characterStringBuffer) {
+	            return sum + characterStringBuffer.length;
+	        }, 0);
+	        // write string length to output
+	        writer.write(bufferLength + characterStringBuffers.length, 16); // response length
+	        // write each string to output
+	        characterStringBuffers.forEach(function(buffer) {
+	            writer.write(buffer.length, 8); // text length
+	            buffer.forEach(function(c) {
+	                writer.write(c, 8);
+	            });
+	        });
+	        return writer.toBuffer();
+	    }
+	};
+	/**
+	 * [SOA description]
+	 * @type {Object}
+	 * @docs https://tools.ietf.org/html/rfc1035#section-3.3.13
+	 */ Packet.Resource.SOA = {
+	    decode: function(reader, length) {
+	        this.primary = Packet.Name.decode(reader);
+	        this.admin = Packet.Name.decode(reader);
+	        this.serial = reader.read(32);
+	        this.refresh = reader.read(32);
+	        this.retry = reader.read(32);
+	        this.expiration = reader.read(32);
+	        this.minimum = reader.read(32);
+	        return this;
+	    },
+	    encode: function(record, writer) {
+	        writer = writer || new Packet.Writer();
+	        let len = 0;
+	        len += Packet.Name.encode(record.primary).length;
+	        len += Packet.Name.encode(record.admin).length;
+	        len += 32 * 5 / 8;
+	        writer.write(len, 16);
+	        Packet.Name.encode(record.primary, writer);
+	        Packet.Name.encode(record.admin, writer);
+	        writer.write(record.serial, 32);
+	        writer.write(record.refresh, 32);
+	        writer.write(record.retry, 32);
+	        writer.write(record.expiration, 32);
+	        writer.write(record.minimum, 32);
+	        return writer.toBuffer();
+	    }
+	};
+	/**
+	 * [SRV description]
+	 * @type {Object}
+	 * @docs https://tools.ietf.org/html/rfc2782
+	 */ Packet.Resource.SRV = {
+	    decode: function(reader, length) {
+	        this.priority = reader.read(16);
+	        this.weight = reader.read(16);
+	        this.port = reader.read(16);
+	        this.target = Packet.Name.decode(reader);
+	        return this;
+	    },
+	    encode: function(record, writer) {
+	        writer = writer || new Packet.Writer();
+	        const { length } = Packet.Name.encode(record.target);
+	        writer.write(length + 6, 16);
+	        writer.write(record.priority, 16);
+	        writer.write(record.weight, 16);
+	        writer.write(record.port, 16);
+	        Packet.Name.encode(record.target, writer);
+	        return writer.toBuffer();
+	    }
+	};
+	Packet.Resource.EDNS = function(rdata) {
+	    return {
+	        type: Packet.TYPE.EDNS,
+	        class: 512,
+	        ttl: 0,
+	        rdata
+	    };
+	};
+	Packet.Resource.EDNS.decode = function(reader, length) {
+	    this.type = Packet.TYPE.EDNS;
+	    this.class = 512;
+	    this.ttl = 0;
+	    this.rdata = [];
+	    while(length){
+	        const optionCode = reader.read(16);
+	        const optionLength = reader.read(16); // In octet (https://tools.ietf.org/html/rfc6891#page-8)
+	        const decoder = Object.keys(Packet.EDNS_OPTION_CODE).filter(function(type) {
+	            return optionCode === Packet.EDNS_OPTION_CODE[type];
+	        })[0];
+	        if (decoder in Packet.Resource.EDNS && Packet.Resource.EDNS[decoder].decode) {
+	            const rdata = Packet.Resource.EDNS[decoder].decode(reader, optionLength);
+	            this.rdata.push(rdata);
+	        } else {
+	            reader.read(optionLength); // Ignore data that doesn't understand
+	            debug('node-dns > unknown EDNS rdata decoder %s(%j)', decoder, optionCode);
+	        }
+	        length = length - 4 - optionLength;
+	    }
+	    return this;
+	};
+	Packet.Resource.EDNS.encode = function(record, writer) {
+	    const rdataWriter = new Packet.Writer();
+	    for (const rdata of record.rdata){
+	        const encoder = Object.keys(Packet.EDNS_OPTION_CODE).filter(function(type) {
+	            return rdata.ednsCode === Packet.EDNS_OPTION_CODE[type];
+	        })[0];
+	        if (encoder in Packet.Resource.EDNS && Packet.Resource.EDNS[encoder].encode) {
+	            const w = new Packet.Writer();
+	            Packet.Resource.EDNS[encoder].encode(rdata, w);
+	            rdataWriter.write(rdata.ednsCode, 16);
+	            rdataWriter.write(w.buffer.length / 8, 16);
+	            rdataWriter.writeBuffer(w);
+	        } else {
+	            debug('node-dns > unknown EDNS rdata encoder %s(%j)', encoder, rdata.ednsCode);
+	        }
+	    }
+	    writer = writer || new Packet.Writer();
+	    writer.write(rdataWriter.buffer.length / 8, 16);
+	    writer.writeBuffer(rdataWriter);
+	    return writer.toBuffer();
+	};
+	Packet.Resource.EDNS.ECS = function(clientIp) {
+	    const [ip, prefixLength] = clientIp.split('/');
+	    const numPrefixLength = parseInt(prefixLength) || 32;
+	    return {
+	        ednsCode: Packet.EDNS_OPTION_CODE.ECS,
+	        family: 1,
+	        sourcePrefixLength: numPrefixLength,
+	        scopePrefixLength: 0,
+	        ip
+	    };
+	};
+	Packet.Resource.EDNS.ECS.decode = function(reader, length) {
+	    const rdata = {};
+	    rdata.ednsCode = Packet.EDNS_OPTION_CODE.ECS;
+	    rdata.family = reader.read(16);
+	    rdata.sourcePrefixLength = reader.read(8);
+	    rdata.scopePrefixLength = reader.read(8);
+	    length -= 4;
+	    if (rdata.family === 1) {
+	        const ipv4Octets = [];
+	        while(length--){
+	            const octet = reader.read(8);
+	            ipv4Octets.push(octet);
+	        }
+	        while(ipv4Octets.length < 4){
+	            ipv4Octets.push(0);
+	        }
+	        rdata.ip = ipv4Octets.join('.');
+	    }
+	    if (rdata.family === 2) {
+	        const ipv6Segments = [];
+	        for(; length; length -= 2){
+	            const segment = reader.read(16).toString(16);
+	            ipv6Segments.push(segment);
+	        }
+	        while(ipv6Segments.length < 8){
+	            ipv6Segments.push('0');
+	        }
+	        rdata.ip = ipv6Segments.join(':');
+	    }
+	    return rdata;
+	};
+	Packet.Resource.EDNS.ECS.encode = function(record, writer) {
+	    const ip = record.ip.split('.').map((s)=>parseInt(s));
+	    writer.write(record.family, 16);
+	    writer.write(record.sourcePrefixLength, 8);
+	    writer.write(record.scopePrefixLength, 8);
+	    writer.write(ip[0], 8);
+	    writer.write(ip[1], 8);
+	    writer.write(ip[2], 8);
+	    writer.write(ip[3], 8);
+	};
+	Packet.Resource.CAA = {
+	    encode: function(record, writer) {
+	        writer = writer || new Packet.Writer();
+	        const buffer = Buffer.from(record.tag + record.value, 'utf8');
+	        writer.write(2 + buffer.length, 16);
+	        writer.write(record.flags, 8);
+	        writer.write(record.tag.length, 8);
+	        buffer.forEach(function(c) {
+	            writer.write(c, 8);
+	        });
+	        return writer.toBuffer();
+	    }
+	};
+	/**
+	 * @type {{decode: (function(*, *): Packet.Resource.DNSKEY)}}
+	 * @link https://tools.ietf.org/html/rfc4034
+	 * @link https://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml#table-dns-sec-alg-numbers-1
+	 */ Packet.Resource.DNSKEY = {
+	    decode: function(reader, length) {
+	        const RData = [];
+	        while(RData.length < length){
+	            RData.push(reader.read(8));
+	        }
+	        this.flags = RData[0] << 8 | RData[1];
+	        this.protocol = RData[2];
+	        this.algorithm = RData[3];
+	        // for key tag
+	        let ac = 0;
+	        for(let i = 0; i < length; ++i){
+	            ac += i & 1 ? RData[i] : RData[i] << 8;
+	        }
+	        ac += ac >> 16 & 0xFFFF;
+	        this.keyTag = ac & 0XFFFF;
+	        //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 = 16
+	        // convert binary flags
+	        let binFlags = this.flags.toString(2);
+	        // add left padding until 16 chars
+	        while(binFlags.length < 16){
+	            binFlags = '0' + binFlags;
+	        }
+	        this.zoneKey = binFlags[7] === '1';
+	        this.zoneSep = binFlags[15] === '1';
+	        this.key = Buffer.from(RData.slice(4)).toString('base64');
+	        return this;
+	    },
+	    encode: function(record, writer) {
+	        writer = writer || new Packet.Writer();
+	        const buffer = Buffer.from(record.key, 'base64');
+	        writer.write(4 + buffer.length, 16);
+	        writer.write(record.flags, 16);
+	        writer.write(record.protocol, 8);
+	        writer.write(record.algorithm, 8);
+	        buffer.forEach(function(c) {
+	            writer.write(c, 8);
+	        });
+	        return writer.toBuffer();
+	    }
+	};
+	/**
+	 * RRSIG just support decode
+	 * test with dns.resolveRRSIG('example.com')
+	 *
+	 * @type {{decode: (function(*, *): Packet.Resource.RRSIG)}}
+	 */ Packet.Resource.RRSIG = {
+	    decode: function(reader, length) {
+	        function dateForSig(date) {
+	            // javascript date is from millisecond
+	            date = new Date(date * 1000);
+	            const definitions = {
+	                month: date.getUTCMonth() + 1,
+	                date: date.getUTCDate(),
+	                hour: date.getUTCHours(),
+	                minutes: date.getUTCMinutes(),
+	                seconds: date.getUTCSeconds()
+	            };
+	            let i;
+	            for(i in definitions){
+	                // if less than 10 > single
+	                if (definitions[i] < 10) {
+	                    definitions[i] = '0' + '' + definitions[i];
+	                }
+	            }
+	            return date.getFullYear() + '' + definitions.month + '' + definitions.date + '' + definitions.hour + '' + definitions.minutes + '' + definitions.seconds;
+	        }
+	        // calculate max-offset uint8
+	        const maxOffset = reader.offset + length * 8;
+	        /*
+	     * Stuff sign contains 18 octets
+	     */ this.sigType = reader.read(16); // 2
+	        this.algorithm = reader.read(8); // 1
+	        this.labels = reader.read(8); // 1
+	        this.originalTtl = reader.read(32); // 4
+	        this.expiration = dateForSig(reader.read(32)); // 4
+	        this.inception = dateForSig(reader.read(32)); // 4
+	        this.keyTag = reader.read(16); // 2
+	        this.signer = Packet.Name.decode(reader);
+	        const maxLength = (maxOffset - reader.offset) / 8;
+	        const signature = [];
+	        while(signature.length < maxLength){
+	            signature.push(reader.read(8));
+	        }
+	        this.signature = Buffer.from(signature).toString('base64');
+	        return this;
+	    }
+	};
+	Packet.Reader = BufferReader;
+	Packet.Writer = BufferWriter;
+	Packet.createResponseFromRequest = function(request) {
+	    const response = new Packet(request);
+	    response.header.qr = 1;
+	    response.additionals = [];
+	    return response;
+	};
+	Packet.createResourceFromQuestion = function(base, record) {
+	    const resource = new Packet.Resource(base);
+	    Object.assign(resource, record);
+	    return resource;
+	};
+	Packet.readStream = (socket)=>{
+	    let chunks = [];
+	    let chunklen = 0;
+	    let received = false;
+	    let expected = false;
+	    return new Promise((resolve, reject)=>{
+	        const processMessage = ()=>{
+	            if (received) return;
+	            received = true;
+	            const buffer = Buffer.concat(chunks, chunklen);
+	            resolve(buffer.slice(2));
+	        };
+	        socket.on('end', processMessage);
+	        socket.on('error', reject);
+	        socket.on('readable', ()=>{
+	            let chunk;
+	            while((chunk = socket.read()) !== null){
+	                chunks.push(chunk);
+	                chunklen += chunk.length;
+	            }
+	            if (!expected && chunklen >= 2) {
+	                if (chunks.length > 1) {
+	                    chunks = [
+	                        Buffer.concat(chunks, chunklen)
+	                    ];
+	                }
+	                expected = chunks[0].readUInt16BE(0);
+	            }
+	            if (chunklen >= 2 + expected) {
+	                processMessage();
+	            }
+	        });
+	    });
+	};
+	/**
+	 * DoH
+	 * @docs https://tools.ietf.org/html/rfc8484
+	 */ Packet.prototype.toBase64URL = function() {
+	    const buffer = this.toBuffer();
+	    const base64 = buffer.toString('base64');
+	    return base64.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+	};
+	packet.exports = Packet;
+	packet.exports.toIPv6 = toIPv6;
+	packet.exports.fromIPv6 = fromIPv6;
+	return packet.exports;
+}
+
+var udp_1$1;
+var hasRequiredUdp$1;
+
+function requireUdp$1 () {
+	if (hasRequiredUdp$1) return udp_1$1;
+	hasRequiredUdp$1 = 1;
+	const udp = require$$0__default$1.default;
+	const Packet = requirePacket();
+	/**
+	 * [Server description]
+	 * @docs https://tools.ietf.org/html/rfc1034
+	 * @docs https://tools.ietf.org/html/rfc1035
+	 */ class Server extends udp.Socket {
+	    constructor(options){
+	        let type = 'udp4';
+	        if (typeof options === 'object') {
+	            type = options.type ?? type;
+	        }
+	        super(type);
+	        if (typeof options === 'function') {
+	            this.on('request', options);
+	        }
+	        this.on('message', this.handle.bind(this));
+	    }
+	    handle(data, rinfo) {
+	        try {
+	            const message = Packet.parse(data);
+	            this.emit('request', message, this.response.bind(this, rinfo), rinfo);
+	        } catch (e) {
+	            this.emit('requestError', e);
+	        }
+	    }
+	    response(rinfo, message) {
+	        if (message instanceof Packet) {
+	            message = message.toBuffer();
+	        }
+	        return new Promise((resolve, reject)=>{
+	            this.send(message, rinfo.port, rinfo.address, (err)=>{
+	                if (err) return reject(err);
+	                resolve(message);
+	            });
+	        });
+	    }
+	    listen(port, address) {
+	        return new Promise((resolve)=>this.bind(port, address, resolve));
+	    }
+	}
+	udp_1$1 = Server;
+	return udp_1$1;
+}
+
+var tcp_1$1;
+var hasRequiredTcp$1;
+
+function requireTcp$1 () {
+	if (hasRequiredTcp$1) return tcp_1$1;
+	hasRequiredTcp$1 = 1;
+	const tcp = require$$0__default$2.default;
+	const Packet = requirePacket();
+	class Server extends tcp.Server {
+	    constructor(options){
+	        super();
+	        if (typeof options === 'function') {
+	            this.on('request', options);
+	        }
+	        this.on('connection', this.handle.bind(this));
+	    }
+	    async handle(client) {
+	        try {
+	            const data = await Packet.readStream(client);
+	            const message = Packet.parse(data);
+	            this.emit('request', message, this.response.bind(this, client), client);
+	        } catch (e) {
+	            this.emit('requestError', e);
+	            client.destroy();
+	        }
+	    }
+	    response(client, message) {
+	        if (message instanceof Packet) {
+	            message = message.toBuffer();
+	        }
+	        const len = Buffer.alloc(2);
+	        len.writeUInt16BE(message.length);
+	        client.end(Buffer.concat([
+	            len,
+	            message
+	        ]));
+	    }
+	}
+	tcp_1$1 = Server;
+	return tcp_1$1;
+}
+
+var doh$1;
+var hasRequiredDoh$1;
+
+function requireDoh$1 () {
+	if (hasRequiredDoh$1) return doh$1;
+	hasRequiredDoh$1 = 1;
+	const http = require$$0__default$3.default;
+	const https = require$$1__default.default;
+	const { URL } = require$$2__default.default;
+	const Packet = requirePacket();
+	const EventEmitter = require$$4__default.default;
+	const { debuglog } = require$$0__default.default;
+	const debug = debuglog('dns2-server');
+	const decodeBase64URL = (str)=>{
+	    let queryData = str.replace(/-/g, '+').replace(/_/g, '/');
+	    const pad = queryData.length % 4;
+	    if (pad === 1) return;
+	    if (pad) {
+	        queryData += new Array(5 - pad).join('=');
+	    }
+	    return queryData;
+	};
+	const readStream = (stream)=>new Promise((resolve, reject)=>{
+	        let buffer = '';
+	        stream.on('error', reject).on('data', (chunk)=>{
+	            buffer += chunk;
+	        }).on('end', ()=>resolve(buffer));
+	    });
+	class Server extends EventEmitter {
+	    constructor(options){
+	        super();
+	        const { ssl } = Object.assign(this, {
+	            cors: true
+	        }, options);
+	        this.server = (ssl ? https.createServer(options) : http.createServer()).on('request', this.handleRequest.bind(this)).on('listening', ()=>this.emit('listening', this.address())).on('error', (error)=>this.emit('error', error)).on('close', ()=>{
+	            this.server.removeAllListeners();
+	            this.emit('close');
+	        });
+	        return this;
+	    }
+	    async handleRequest(client, res) {
+	        try {
+	            const { method, url, headers } = client;
+	            const { pathname, searchParams: query } = new URL(url, 'http://unused/');
+	            const { cors } = this;
+	            if (cors === true) {
+	                res.setHeader('Access-Control-Allow-Origin', '*');
+	            } else if (typeof cors === 'string') {
+	                res.setHeader('Access-Control-Allow-Origin', cors);
+	                res.setHeader('Vary', 'Origin');
+	            } else if (typeof cors === 'function') {
+	                const isAllowed = cors(headers.origin);
+	                res.setHeader('Access-Control-Allow-Origin', isAllowed ? headers.origin : 'false');
+	                res.setHeader('Vary', 'Origin');
+	            }
+	            // debug
+	            debug('request', method, url);
+	            // We are only handling get and post as reqired by rfc
+	            if (method !== 'GET' && method !== 'POST') {
+	                res.writeHead(405, {
+	                    'Content-Type': 'text/plain'
+	                });
+	                res.write('405 Method not allowed\n');
+	                res.end();
+	                return;
+	            }
+	            // Check so the uri is correct
+	            if (pathname !== '/dns-query') {
+	                res.writeHead(404, {
+	                    'Content-Type': 'text/plain'
+	                });
+	                res.write('404 Not Found\n');
+	                res.end();
+	                return;
+	            }
+	            // Make sure the requestee is requesting the correct content type
+	            const contentType = headers.accept;
+	            if (contentType !== 'application/dns-message') {
+	                res.writeHead(400, {
+	                    'Content-Type': 'text/plain'
+	                });
+	                res.write('400 Bad Request: Illegal content type\n');
+	                res.end();
+	                return;
+	            }
+	            let queryData;
+	            if (method === 'GET') {
+	                // Parse query string for the request data
+	                const dns = query.get('dns');
+	                if (!dns) {
+	                    res.writeHead(400, {
+	                        'Content-Type': 'text/plain'
+	                    });
+	                    res.write('400 Bad Request: No query defined\n');
+	                    res.end();
+	                    return;
+	                }
+	                // Decode from Base64Url Encoding
+	                const base64 = decodeBase64URL(dns);
+	                if (!base64) {
+	                    res.writeHead(400, {
+	                        'Content-Type': 'text/plain'
+	                    });
+	                    res.write('400 Bad Request: Invalid query data\n');
+	                    res.end();
+	                    return;
+	                }
+	                // Decode Base64 to buffer
+	                queryData = Buffer.from(base64, 'base64');
+	            } else if (method === 'POST') {
+	                queryData = await readStream(client);
+	            }
+	            // Parse DNS query and Raise event.
+	            const message = Packet.parse(queryData);
+	            this.emit('request', message, this.response.bind(this, res), client);
+	        } catch (e) {
+	            this.emit('requestError', e);
+	            res.destroy();
+	        }
+	    }
+	    /**
+	   * Send of the response to the client
+	   * @param {*} res
+	   * @param {*} message
+	   */ response(res, message) {
+	        debug('response');
+	        res.setHeader('Content-Type', 'application/dns-message');
+	        res.writeHead(200);
+	        res.end(message.toBuffer());
+	    }
+	    /**
+	   * listen
+	   * @param {*} port
+	   * @returns
+	   */ listen(port, address) {
+	        return this.server.listen(port || this.port, address);
+	    }
+	    address() {
+	        return this.server.address();
+	    }
+	    close() {
+	        return this.server.close();
+	    }
+	}
+	doh$1 = Server;
+	return doh$1;
+}
+
+var dns;
+var hasRequiredDns;
+
+function requireDns () {
+	if (hasRequiredDns) return dns;
+	hasRequiredDns = 1;
+	const EventEmitter = require$$4__default.default;
+	const DOHServer = requireDoh$1();
+	const TCPServer = requireTcp$1();
+	const UDPServer = requireUdp$1();
+	class DNSServer extends EventEmitter {
+	    constructor(options = {}){
+	        super();
+	        this.servers = {};
+	        if (options.doh) {
+	            this.servers.doh = new DOHServer(options.doh).on('error', (error)=>this.emit('error', error, 'doh'));
+	        }
+	        if (options.tcp) {
+	            this.servers.tcp = new TCPServer().on('error', (error)=>this.emit('error', error, 'tcp'));
+	        }
+	        if (options.udp) {
+	            this.servers.udp = new UDPServer(typeof options.udp === 'object' ? options.udp : undefined).on('error', (error)=>this.emit('error', error, 'udp'));
+	        }
+	        const servers = Object.values(this.servers);
+	        this.closed = Promise.all(servers.map((server)=>new Promise((resolve)=>server.once('close', resolve)))).then(()=>{
+	            this.emit('close');
+	        });
+	        this.listening = Promise.all(servers.map((server)=>new Promise((resolve)=>server.once('listening', resolve)))).then(()=>{
+	            const addresses = this.addresses();
+	            this.emit('listening', addresses);
+	            return addresses;
+	        });
+	        const emitRequest = (request, send, client)=>this.emit('request', request, send, client);
+	        const emitRequestError = (error)=>this.emit('requestError', error);
+	        for (const server of servers){
+	            server.on('request', emitRequest);
+	            server.on('requestError', emitRequestError);
+	        }
+	        if (options.handle) {
+	            this.on('request', options.handle.bind(options));
+	        }
+	    }
+	    addresses() {
+	        const addresses = {};
+	        const { udp, tcp, doh } = this.servers;
+	        if (udp) {
+	            addresses.udp = udp.address();
+	        }
+	        if (tcp) {
+	            addresses.tcp = tcp.address();
+	        }
+	        if (doh) {
+	            addresses.doh = doh.address();
+	        }
+	        return addresses;
+	    }
+	    listen(options = {}) {
+	        for (const serverType of Object.keys(this.servers)){
+	            const server = this.servers[serverType];
+	            const serverOptions = options[serverType]; // Port or { port, address }
+	            if (serverOptions && serverOptions.port) {
+	                server.listen(serverOptions.port, serverOptions.address);
+	            } else {
+	                server.listen(serverOptions);
+	            }
+	        }
+	        return this.listening;
+	    }
+	    close() {
+	        const { doh, udp, tcp } = this.servers;
+	        if (udp) {
+	            udp.close();
+	        }
+	        if (tcp) {
+	            tcp.close();
+	        }
+	        if (doh) {
+	            doh.close();
+	        }
+	        return this.closed;
+	    }
+	}
+	dns = DNSServer;
+	return dns;
+}
+
+var server;
+var hasRequiredServer;
+
+function requireServer () {
+	if (hasRequiredServer) return server;
+	hasRequiredServer = 1;
+	const UDPServer = requireUdp$1();
+	const TCPServer = requireTcp$1();
+	const DOHServer = requireDoh$1();
+	const DNSServer = requireDns();
+	const createUDPServer = (options)=>{
+	    return new UDPServer(options);
+	};
+	const createTCPServer = (options)=>{
+	    return new TCPServer(options);
+	};
+	const createDOHServer = (options)=>{
+	    return new DOHServer(options);
+	};
+	const createServer = (options)=>{
+	    return new DNSServer(options);
+	};
+	server = {
+	    UDPServer,
+	    TCPServer,
+	    DOHServer,
+	    DNSServer,
+	    createTCPServer,
+	    createUDPServer,
+	    createDOHServer,
+	    createServer
+	};
+	return server;
+}
+
+var tcp_1;
+var hasRequiredTcp;
+
+function requireTcp () {
+	if (hasRequiredTcp) return tcp_1;
+	hasRequiredTcp = 1;
+	const tls = require$$0__default$4.default;
+	const tcp = require$$0__default$2.default;
+	const Packet = requirePacket();
+	const makeQuery = ({ name, type = 'A', cls = Packet.CLASS.IN, clientIp, recursive = true })=>{
+	    const packet = new Packet();
+	    packet.header.rd = recursive ? 1 : 0;
+	    if (clientIp) {
+	        packet.additionals.push(Packet.Resource.EDNS([
+	            Packet.Resource.EDNS.ECS(clientIp)
+	        ]));
+	    }
+	    packet.questions.push({
+	        name,
+	        class: cls,
+	        type: Packet.TYPE[type]
+	    });
+	    return packet.toBuffer();
+	};
+	const sendQuery = (client, message)=>{
+	    const len = Buffer.alloc(2);
+	    len.writeUInt16BE(message.length);
+	    client.write(Buffer.concat([
+	        len,
+	        message
+	    ]));
+	};
+	const protocols = {
+	    'tcp:': (host, port)=>tcp.connect({
+	            host,
+	            port
+	        }),
+	    'tls:': (host, port)=>tls.connect({
+	            host,
+	            port,
+	            servername: host
+	        })
+	};
+	const TCPClient = ({ dns, protocol = 'tcp:', port = protocol === 'tls:' ? 853 : 53 } = {})=>{
+	    if (!protocols[protocol]) {
+	        throw new Error('Protocol must be tcp: or tls:');
+	    }
+	    return async (name, type, cls, options = {})=>{
+	        const message = makeQuery({
+	            name,
+	            type,
+	            cls,
+	            ...options
+	        });
+	        const [host] = dns.split(':');
+	        const client = protocols[protocol](host, port);
+	        sendQuery(client, message);
+	        const data = await Packet.readStream(client);
+	        client.end();
+	        if (!data.length) throw new Error('Empty response');
+	        return Packet.parse(data);
+	    };
+	};
+	tcp_1 = TCPClient;
+	return tcp_1;
+}
+
+var doh;
+var hasRequiredDoh;
+
+function requireDoh () {
+	if (hasRequiredDoh) return doh;
+	hasRequiredDoh = 1;
+	const http = require$$0__default$3.default;
+	const https = require$$1__default.default;
+	const http2 = require$$2__default$1.default;
+	const Packet = requirePacket();
+	const protocols = {
+	    'http:': http.get,
+	    'https:': https.get,
+	    'h2:': (url, options, done)=>{
+	        const urlObj = new URL(url);
+	        const client = http2.connect(url.replace('h2:', 'https:'));
+	        const req = client.request({
+	            ':path': `${urlObj.pathname}${urlObj.search}`,
+	            ':method': 'GET',
+	            ...options.headers
+	        });
+	        req.on('response', (headers)=>{
+	            client.close();
+	            done({
+	                headers,
+	                statusCode: headers[':status'],
+	                on: req.on.bind(req)
+	            });
+	        });
+	        req.on('error', (_err)=>{
+	            client.close();
+	        });
+	        req.end();
+	        return req;
+	    }
+	};
+	const makeRequest = (url, query)=>new Promise((resolve, reject)=>{
+	        const index = url.indexOf('://');
+	        if (index === -1) url = `https://${url}`;
+	        const u = new URL(url);
+	        // The DNS query is included in a single variable named “dns” in the
+	        // query component of the request URI.  The value of the “dns” variable
+	        // is the content of the DNS request message, encoded with base64url
+	        // [RFC4648](https://datatracker.ietf.org/doc/html/rfc8484#section-4.1).
+	        const searchParams = u.searchParams;
+	        searchParams.set('dns', query);
+	        u.search = searchParams.toString();
+	        const get = protocols[u.protocol];
+	        if (!get) throw new Error(`Unsupported protocol: ${u.protocol}, must be specified (http://, https:// or h2://)`);
+	        const req = get(u.toString(), {
+	            headers: {
+	                accept: 'application/dns-message'
+	            }
+	        }, resolve);
+	        if (req) req.on('error', reject);
+	    });
+	const readStream = (res)=>new Promise((resolve, reject)=>{
+	        const chunks = [];
+	        res.on('error', reject).on('data', (chunk)=>chunks.push(chunk)).on('end', ()=>{
+	            const data = Buffer.concat(chunks);
+	            if (res.statusCode !== 200) {
+	                reject(new Error(`HTTP ${res.statusCode}: ${data.toString()}`));
+	            }
+	            resolve(data);
+	        });
+	    });
+	const buildQuery = ({ name, type = 'A', cls = Packet.CLASS.IN, clientIp, recursive = true })=>{
+	    const packet = new Packet();
+	    packet.header.rd = recursive ? 1 : 0;
+	    if (clientIp) {
+	        packet.additionals.push(Packet.Resource.EDNS([
+	            Packet.Resource.EDNS.ECS(clientIp)
+	        ]));
+	    }
+	    packet.questions.push({
+	        name,
+	        class: cls,
+	        type: Packet.TYPE[type]
+	    });
+	    return packet.toBase64URL();
+	};
+	const DOHClient = ({ dns })=>{
+	    return async (name, type, cls, options = {})=>{
+	        const query = buildQuery({
+	            name,
+	            type,
+	            cls,
+	            ...options
+	        });
+	        const response = await makeRequest(dns, query);
+	        const data = await readStream(response);
+	        return Packet.parse(data);
+	    };
+	};
+	doh = DOHClient;
+	return doh;
+}
+
+var udp_1;
+var hasRequiredUdp;
+
+function requireUdp () {
+	if (hasRequiredUdp) return udp_1;
+	hasRequiredUdp = 1;
+	const udp = require$$0__default$1.default;
+	const Packet = requirePacket();
+	const { equal } = require$$2__default$2.default;
+	const { debuglog } = require$$0__default.default;
+	const debug = debuglog('dns2');
+	udp_1 = ({ dns = '8.8.8.8', port = 53, socketType = 'udp4' } = {})=>{
+	    return (name, type = 'A', cls = Packet.CLASS.IN, options = {})=>{
+	        const { clientIp, recursive = true } = options;
+	        const query = new Packet();
+	        query.header.id = Math.random() * 1e4 | 0;
+	        // see https://github.com/song940/node-dns/issues/29
+	        if (recursive) {
+	            query.header.rd = 1;
+	        }
+	        if (clientIp) {
+	            query.additionals.push(Packet.Resource.EDNS([
+	                Packet.Resource.EDNS.ECS(clientIp)
+	            ]));
+	        }
+	        query.questions.push({
+	            name,
+	            class: cls,
+	            type: Packet.TYPE[type]
+	        });
+	        const client = new udp.Socket(socketType);
+	        return new Promise((resolve, reject)=>{
+	            client.once('message', function onMessage(message) {
+	                client.close();
+	                const response = Packet.parse(message);
+	                equal(response.header.id, query.header.id);
+	                resolve(response);
+	            });
+	            debug('send', dns, query.toBuffer());
+	            client.send(query.toBuffer(), port, dns, (err)=>err && reject(err));
+	        });
+	    };
+	};
+	return udp_1;
+}
+
+var google;
+var hasRequiredGoogle;
+
+function requireGoogle () {
+	if (hasRequiredGoogle) return google;
+	hasRequiredGoogle = 1;
+	const https = require$$1__default.default;
+	const get = (url)=>new Promise((resolve)=>https.get(url, resolve));
+	const readStream = (stream)=>{
+	    const buffer = [];
+	    return new Promise((resolve, reject)=>{
+	        stream.on('error', reject).on('data', (chunk)=>{
+	            buffer.push(chunk);
+	        }).on('end', ()=>resolve(Buffer.concat(buffer)));
+	    });
+	};
+	const GoogleClient = ()=>(name, type = 'ANY')=>{
+	        return Promise.resolve().then(()=>get(`https://dns.google.com/resolve?name=${name}&type=${type}`)).then(readStream).then(JSON.parse);
+	    };
+	google = GoogleClient;
+	return google;
+}
+
+var dns2;
+var hasRequiredDns2;
+
+function requireDns2 () {
+	if (hasRequiredDns2) return dns2;
+	hasRequiredDns2 = 1;
+	const { TCPServer, UDPServer, DOHServer, createTCPServer, createUDPServer, createDOHServer, createServer } = requireServer();
+	const EventEmitter = require$$4__default.default;
+	/**
+	 * [DNS description]
+	 * @docs https://tools.ietf.org/html/rfc1034
+	 * @docs https://tools.ietf.org/html/rfc1035
+	 */ class DNS extends EventEmitter {
+	    constructor(options){
+	        super();
+	        Object.assign(this, {
+	            port: 53,
+	            retries: 3,
+	            timeout: 3,
+	            recursive: true,
+	            resolverProtocol: 'UDP',
+	            nameServers: [
+	                '8.8.8.8',
+	                '114.114.114.114'
+	            ],
+	            rootServers: [
+	                'a',
+	                'b',
+	                'c',
+	                'd',
+	                'e',
+	                'f',
+	                'g',
+	                'h',
+	                'i',
+	                'j',
+	                'k',
+	                'l',
+	                'm'
+	            ].map((x)=>`${x}.root-servers.net`)
+	        }, options);
+	    }
+	    /**
+	   * resolve
+	   * @param {*} domain
+	   * @param {*} type
+	   * @param {*} cls
+	   */ resolve(domain, type = 'ANY', cls = DNS.Packet.CLASS.IN, options = {}) {
+	        const { port, nameServers, resolverProtocol = 'UDP' } = this;
+	        const createResolver = DNS[resolverProtocol + 'Client'];
+	        return Promise.race(nameServers.map((address)=>{
+	            const resolve = createResolver({
+	                dns: address,
+	                port
+	            });
+	            return resolve(domain, type, cls, options);
+	        }));
+	    }
+	    resolveA(domain, clientIp) {
+	        return this.resolve(domain, 'A', undefined, clientIp);
+	    }
+	    resolveAAAA(domain) {
+	        return this.resolve(domain, 'AAAA');
+	    }
+	    resolveMX(domain) {
+	        return this.resolve(domain, 'MX');
+	    }
+	    resolveCNAME(domain) {
+	        return this.resolve(domain, 'CNAME');
+	    }
+	    resolvePTR(domain) {
+	        return this.resolve(domain, 'PTR');
+	    }
+	    resolveDNSKEY(domain) {
+	        return this.resolve(domain, 'DNSKEY');
+	    }
+	    resolveRRSIG(domain) {
+	        return this.resolve(domain, 'RRSIG');
+	    }
+	}
+	DNS.TCPServer = TCPServer;
+	DNS.UDPServer = UDPServer;
+	DNS.DOHServer = DOHServer;
+	DNS.createUDPServer = createUDPServer;
+	DNS.createTCPServer = createTCPServer;
+	DNS.createDOHServer = createDOHServer;
+	DNS.createServer = createServer;
+	DNS.TCPClient = requireTcp();
+	DNS.DOHClient = requireDoh();
+	DNS.UDPClient = requireUdp();
+	DNS.GoogleClient = requireGoogle();
+	DNS.Packet = requirePacket();
+	dns2 = DNS;
+	return dns2;
+}
+
+var dns2Exports = requireDns2();
+
 const defaultDnsServers = [
     'https://1.1.1.1',
     'https://1.0.0.1',
@@ -29,26 +1817,28 @@ function getDnsClients(servers) {
         const port = _port ? Number.parseInt(_port, 10) : 0;
         let client;
         switch(protocol){
+            // case 'http':
             case 'https':
+            case 'h2':
                 {
                     const u = new URL(dns);
                     if (!server.includes('/')) {
                         u.pathname = '/dns-query';
                     }
-                    client = dns2.DOHClient({
+                    client = dns2Exports.DOHClient({
                         dns: u.href
                     });
                     break;
                 }
             case 'tls':
-                client = dns2.TCPClient({
+                client = dns2Exports.TCPClient({
                     dns: server,
                     protocol: 'tls:',
                     port: port || 853
                 });
                 break;
             case 'tcp':
-                client = dns2.TCPClient({
+                client = dns2Exports.TCPClient({
                     dns: server,
                     protocol: 'tcp:',
                     port: port || 53
@@ -56,7 +1846,7 @@ function getDnsClients(servers) {
                 break;
             case '':
             case 'udp':
-                client = dns2.UDPClient({
+                client = dns2Exports.UDPClient({
                     dns: server,
                     port: port || 53
                 });
@@ -1322,7 +3112,7 @@ const sharedNullResponse = Object.freeze({
     const mutex = createAsyncMutex();
     const dnsClients = getDnsClients(dnsServers);
     return async function isRegisterableDomainAlive(domain) {
-        domain = url.domainToASCII(domain);
+        domain = require$$2.domainToASCII(domain);
         return mutex(domain, ()=>cacheApply(registerableDomainResultCache, domain, async ()=>{
                 // Step 0: we normalize the domain and find the registerable part
                 const registerableDomain = tldts.getDomain(domain, getRegisterableDomainTldtsOption);
@@ -1428,7 +3218,7 @@ function createDomainAliveChecker(options = {}) {
     const mutex = createAsyncMutex();
     const dnsClients = getDnsClients(dnsServers);
     return async function isDomainAlive(domain) {
-        domain = url.domainToASCII(domain);
+        domain = require$$2.domainToASCII(domain);
         const registerableDomainAliveResult = await isRegisterableDomainAlive(domain);
         if (registerableDomainAliveResult.registerableDomain === null) {
             return sharedNullishResult;