domain-alive 0.1.14 → 0.1.16

package/dist/index.js

@@ -4,13 +4,14 @@ var tldts = require('tldts');
 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$$0$4 = 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 require$$0$3 = require('url');
+var require$$1$1 = require('events');
+var require$$0$5 = require('tls');
+var require$$3 = require('http2');
+var require$$0$6 = require('stream');
+var require$$2 = require('assert');
 var asyncRetry = require('foxts/async-retry');
 var net = require('node:net');
 var retrie = require('foxts/retrie');
@@ -23,13 +24,14 @@ 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$$0__default$4 = /*#__PURE__*/_interopDefault(require$$0$4);
 var require$$1__default = /*#__PURE__*/_interopDefault(require$$1);
+var require$$0__default$3 = /*#__PURE__*/_interopDefault(require$$0$3);
+var require$$1__default$1 = /*#__PURE__*/_interopDefault(require$$1$1);
+var require$$0__default$5 = /*#__PURE__*/_interopDefault(require$$0$5);
+var require$$3__default = /*#__PURE__*/_interopDefault(require$$3);
+var require$$0__default$6 = /*#__PURE__*/_interopDefault(require$$0$6);
 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);
 
@@ -1208,11 +1210,11 @@ var hasRequiredDoh$1;
 function requireDoh$1 () {
 	if (hasRequiredDoh$1) return doh$1;
 	hasRequiredDoh$1 = 1;
-	const http = require$$0__default$3.default;
+	const http = require$$0__default$4.default;
 	const https = require$$1__default.default;
-	const { URL } = require$$2__default.default;
+	const { URL } = require$$0__default$3.default;
 	const Packet = requirePacket();
-	const EventEmitter = require$$4__default.default;
+	const EventEmitter = require$$1__default$1.default;
 	const { debuglog } = require$$0__default.default;
 	const debug = debuglog('dns2-server');
 	const decodeBase64URL = (str)=>{
@@ -1356,7 +1358,7 @@ var hasRequiredDns;
 function requireDns () {
 	if (hasRequiredDns) return dns;
 	hasRequiredDns = 1;
-	const EventEmitter = require$$4__default.default;
+	const EventEmitter = require$$1__default$1.default;
 	const DOHServer = requireDoh$1();
 	const TCPServer = requireTcp$1();
 	const UDPServer = requireUdp$1();
@@ -1477,7 +1479,7 @@ var hasRequiredTcp;
 function requireTcp () {
 	if (hasRequiredTcp) return tcp_1;
 	hasRequiredTcp = 1;
-	const tls = require$$0__default$4.default;
+	const tls = require$$0__default$5.default;
 	const tcp = require$$0__default$2.default;
 	const Packet = requirePacket();
 	const makeQuery = ({ name, type = 'A', cls = Packet.CLASS.IN, clientIp, recursive = true })=>{
@@ -1538,41 +1540,1531 @@ function requireTcp () {
 	return tcp_1;
 }
 
+var quickLru;
+var hasRequiredQuickLru;
+
+function requireQuickLru () {
+	if (hasRequiredQuickLru) return quickLru;
+	hasRequiredQuickLru = 1;
+	var _computedKey;
+	_computedKey = Symbol.iterator;
+	class QuickLRU {
+	    constructor(options = {}){
+	        if (!(options.maxSize && options.maxSize > 0)) {
+	            throw new TypeError('`maxSize` must be a number greater than 0');
+	        }
+	        this.maxSize = options.maxSize;
+	        this.onEviction = options.onEviction;
+	        this.cache = new Map();
+	        this.oldCache = new Map();
+	        this._size = 0;
+	    }
+	    _set(key, value) {
+	        this.cache.set(key, value);
+	        this._size++;
+	        if (this._size >= this.maxSize) {
+	            this._size = 0;
+	            if (typeof this.onEviction === 'function') {
+	                for (const [key, value] of this.oldCache.entries()){
+	                    this.onEviction(key, value);
+	                }
+	            }
+	            this.oldCache = this.cache;
+	            this.cache = new Map();
+	        }
+	    }
+	    get(key) {
+	        if (this.cache.has(key)) {
+	            return this.cache.get(key);
+	        }
+	        if (this.oldCache.has(key)) {
+	            const value = this.oldCache.get(key);
+	            this.oldCache.delete(key);
+	            this._set(key, value);
+	            return value;
+	        }
+	    }
+	    set(key, value) {
+	        if (this.cache.has(key)) {
+	            this.cache.set(key, value);
+	        } else {
+	            this._set(key, value);
+	        }
+	        return this;
+	    }
+	    has(key) {
+	        return this.cache.has(key) || this.oldCache.has(key);
+	    }
+	    peek(key) {
+	        if (this.cache.has(key)) {
+	            return this.cache.get(key);
+	        }
+	        if (this.oldCache.has(key)) {
+	            return this.oldCache.get(key);
+	        }
+	    }
+	    delete(key) {
+	        const deleted = this.cache.delete(key);
+	        if (deleted) {
+	            this._size--;
+	        }
+	        return this.oldCache.delete(key) || deleted;
+	    }
+	    clear() {
+	        this.cache.clear();
+	        this.oldCache.clear();
+	        this._size = 0;
+	    }
+	    *keys() {
+	        for (const [key] of this){
+	            yield key;
+	        }
+	    }
+	    *values() {
+	        for (const [, value] of this){
+	            yield value;
+	        }
+	    }
+	    *[_computedKey]() {
+	        for (const item of this.cache){
+	            yield item;
+	        }
+	        for (const item of this.oldCache){
+	            const [key] = item;
+	            if (!this.cache.has(key)) {
+	                yield item;
+	            }
+	        }
+	    }
+	    get size() {
+	        let oldCacheSize = 0;
+	        for (const key of this.oldCache.keys()){
+	            if (!this.cache.has(key)) {
+	                oldCacheSize++;
+	            }
+	        }
+	        return Math.min(this._size + oldCacheSize, this.maxSize);
+	    }
+	}
+	quickLru = QuickLRU;
+	return quickLru;
+}
+
+var delayAsyncDestroy;
+var hasRequiredDelayAsyncDestroy;
+
+function requireDelayAsyncDestroy () {
+	if (hasRequiredDelayAsyncDestroy) return delayAsyncDestroy;
+	hasRequiredDelayAsyncDestroy = 1;
+	delayAsyncDestroy = (stream)=>{
+	    if (stream.listenerCount('error') !== 0) {
+	        return stream;
+	    }
+	    stream.__destroy = stream._destroy;
+	    stream._destroy = (...args)=>{
+	        const callback = args.pop();
+	        stream.__destroy(...args, async (error)=>{
+	            await Promise.resolve();
+	            callback(error);
+	        });
+	    };
+	    const onError = (error)=>{
+	        // eslint-disable-next-line promise/prefer-await-to-then
+	        Promise.resolve().then(()=>{
+	            stream.emit('error', error);
+	        });
+	    };
+	    stream.once('error', onError);
+	    // eslint-disable-next-line promise/prefer-await-to-then
+	    Promise.resolve().then(()=>{
+	        stream.off('error', onError);
+	    });
+	    return stream;
+	};
+	return delayAsyncDestroy;
+}
+
+var agent;
+var hasRequiredAgent;
+
+function requireAgent () {
+	if (hasRequiredAgent) return agent;
+	hasRequiredAgent = 1;
+	// See https://github.com/facebook/jest/issues/2549
+	// eslint-disable-next-line node/prefer-global/url
+	const { URL } = require$$0__default$3.default;
+	const EventEmitter = require$$1__default$1.default;
+	const tls = require$$0__default$5.default;
+	const http2 = require$$3__default.default;
+	const QuickLRU = requireQuickLru();
+	const delayAsyncDestroy = requireDelayAsyncDestroy();
+	const kCurrentStreamCount = Symbol('currentStreamCount');
+	const kRequest = Symbol('request');
+	const kOriginSet = Symbol('cachedOriginSet');
+	const kGracefullyClosing = Symbol('gracefullyClosing');
+	const kLength = Symbol('length');
+	const nameKeys = [
+	    // Not an Agent option actually
+	    'createConnection',
+	    // `http2.connect()` options
+	    'maxDeflateDynamicTableSize',
+	    'maxSettings',
+	    'maxSessionMemory',
+	    'maxHeaderListPairs',
+	    'maxOutstandingPings',
+	    'maxReservedRemoteStreams',
+	    'maxSendHeaderBlockLength',
+	    'paddingStrategy',
+	    'peerMaxConcurrentStreams',
+	    'settings',
+	    // `tls.connect()` source options
+	    'family',
+	    'localAddress',
+	    'rejectUnauthorized',
+	    // `tls.connect()` secure context options
+	    'pskCallback',
+	    'minDHSize',
+	    // `tls.connect()` destination options
+	    // - `servername` is automatically validated, skip it
+	    // - `host` and `port` just describe the destination server,
+	    'path',
+	    'socket',
+	    // `tls.createSecureContext()` options
+	    'ca',
+	    'cert',
+	    'sigalgs',
+	    'ciphers',
+	    'clientCertEngine',
+	    'crl',
+	    'dhparam',
+	    'ecdhCurve',
+	    'honorCipherOrder',
+	    'key',
+	    'privateKeyEngine',
+	    'privateKeyIdentifier',
+	    'maxVersion',
+	    'minVersion',
+	    'pfx',
+	    'secureOptions',
+	    'secureProtocol',
+	    'sessionIdContext',
+	    'ticketKeys'
+	];
+	const getSortedIndex = (array, value, compare)=>{
+	    let low = 0;
+	    let high = array.length;
+	    while(low < high){
+	        const mid = low + high >>> 1;
+	        if (compare(array[mid], value)) {
+	            low = mid + 1;
+	        } else {
+	            high = mid;
+	        }
+	    }
+	    return low;
+	};
+	const compareSessions = (a, b)=>a.remoteSettings.maxConcurrentStreams > b.remoteSettings.maxConcurrentStreams;
+	// See https://tools.ietf.org/html/rfc8336
+	const closeCoveredSessions = (where, session)=>{
+	    // Clients SHOULD NOT emit new requests on any connection whose Origin
+	    // Set is a proper subset of another connection's Origin Set, and they
+	    // SHOULD close it once all outstanding requests are satisfied.
+	    for(let index = 0; index < where.length; index++){
+	        const coveredSession = where[index];
+	        if (// Unfortunately `.every()` returns true for an empty array
+	        coveredSession[kOriginSet].length > 0 && coveredSession[kOriginSet].length < session[kOriginSet].length && coveredSession[kOriginSet].every((origin)=>session[kOriginSet].includes(origin)) && coveredSession[kCurrentStreamCount] + session[kCurrentStreamCount] <= session.remoteSettings.maxConcurrentStreams) {
+	            // This allows pending requests to finish and prevents making new requests.
+	            gracefullyClose(coveredSession);
+	        }
+	    }
+	};
+	// This is basically inverted `closeCoveredSessions(...)`.
+	const closeSessionIfCovered = (where, coveredSession)=>{
+	    for(let index = 0; index < where.length; index++){
+	        const session = where[index];
+	        if (coveredSession[kOriginSet].length > 0 && coveredSession[kOriginSet].length < session[kOriginSet].length && coveredSession[kOriginSet].every((origin)=>session[kOriginSet].includes(origin)) && coveredSession[kCurrentStreamCount] + session[kCurrentStreamCount] <= session.remoteSettings.maxConcurrentStreams) {
+	            gracefullyClose(coveredSession);
+	            return true;
+	        }
+	    }
+	    return false;
+	};
+	const gracefullyClose = (session)=>{
+	    session[kGracefullyClosing] = true;
+	    if (session[kCurrentStreamCount] === 0) {
+	        session.close();
+	    }
+	};
+	class Agent extends EventEmitter {
+	    constructor({ timeout = 0, maxSessions = Number.POSITIVE_INFINITY, maxEmptySessions = 10, maxCachedTlsSessions = 100 } = {}){
+	        super();
+	        // SESSIONS[NORMALIZED_OPTIONS] = [];
+	        this.sessions = {};
+	        // The queue for creating new sessions. It looks like this:
+	        // QUEUE[NORMALIZED_OPTIONS][NORMALIZED_ORIGIN] = ENTRY_FUNCTION
+	        //
+	        // It's faster when there are many origins. If there's only one, then QUEUE[`${options}:${origin}`] is faster.
+	        // I guess object creation / deletion is causing the slowdown.
+	        //
+	        // The entry function has `listeners`, `completed` and `destroyed` properties.
+	        // `listeners` is an array of objects containing `resolve` and `reject` functions.
+	        // `completed` is a boolean. It's set to true after ENTRY_FUNCTION is executed.
+	        // `destroyed` is a boolean. If it's set to true, the session will be destroyed if hasn't connected yet.
+	        this.queue = {};
+	        // Each session will use this timeout value.
+	        this.timeout = timeout;
+	        // Max sessions in total
+	        this.maxSessions = maxSessions;
+	        // Max empty sessions in total
+	        this.maxEmptySessions = maxEmptySessions;
+	        this._emptySessionCount = 0;
+	        this._sessionCount = 0;
+	        // We don't support push streams by default.
+	        this.settings = {
+	            enablePush: false,
+	            initialWindowSize: 1024 * 1024 * 32 // 32MB, see https://github.com/nodejs/node/issues/38426
+	        };
+	        // Reusing TLS sessions increases performance.
+	        this.tlsSessionCache = new QuickLRU({
+	            maxSize: maxCachedTlsSessions
+	        });
+	    }
+	    get protocol() {
+	        return 'https:';
+	    }
+	    normalizeOptions(options) {
+	        let normalized = '';
+	        for(let index = 0; index < nameKeys.length; index++){
+	            const key = nameKeys[index];
+	            normalized += ':';
+	            if (options && options[key] !== undefined) {
+	                normalized += options[key];
+	            }
+	        }
+	        return normalized;
+	    }
+	    _processQueue() {
+	        if (this._sessionCount >= this.maxSessions) {
+	            this.closeEmptySessions(this.maxSessions - this._sessionCount + 1);
+	            return;
+	        }
+	        // eslint-disable-next-line guard-for-in
+	        for(const normalizedOptions in this.queue){
+	            // eslint-disable-next-line guard-for-in
+	            for(const normalizedOrigin in this.queue[normalizedOptions]){
+	                const item = this.queue[normalizedOptions][normalizedOrigin];
+	                // The entry function can be run only once.
+	                if (!item.completed) {
+	                    item.completed = true;
+	                    item();
+	                }
+	            }
+	        }
+	    }
+	    _isBetterSession(thisStreamCount, thatStreamCount) {
+	        return thisStreamCount > thatStreamCount;
+	    }
+	    _accept(session, listeners, normalizedOrigin, options) {
+	        let index = 0;
+	        while(index < listeners.length && session[kCurrentStreamCount] < session.remoteSettings.maxConcurrentStreams){
+	            // We assume `resolve(...)` calls `request(...)` *directly*,
+	            // otherwise the session will get overloaded.
+	            listeners[index].resolve(session);
+	            index++;
+	        }
+	        listeners.splice(0, index);
+	        if (listeners.length > 0) {
+	            this.getSession(normalizedOrigin, options, listeners);
+	            listeners.length = 0;
+	        }
+	    }
+	    getSession(origin, options, listeners) {
+	        return new Promise((resolve, reject)=>{
+	            if (Array.isArray(listeners) && listeners.length > 0) {
+	                listeners = [
+	                    ...listeners
+	                ];
+	                // Resolve the current promise ASAP, we're just moving the listeners.
+	                // They will be executed at a different time.
+	                resolve();
+	            } else {
+	                listeners = [
+	                    {
+	                        resolve,
+	                        reject
+	                    }
+	                ];
+	            }
+	            try {
+	                // Parse origin
+	                if (typeof origin === 'string') {
+	                    origin = new URL(origin);
+	                } else if (!(origin instanceof URL)) {
+	                    throw new TypeError('The `origin` argument needs to be a string or an URL object');
+	                }
+	                if (options) {
+	                    // Validate servername
+	                    const { servername } = options;
+	                    const { hostname } = origin;
+	                    if (servername && hostname !== servername) {
+	                        throw new Error(`Origin ${hostname} differs from servername ${servername}`);
+	                    }
+	                }
+	            } catch (error) {
+	                for(let index = 0; index < listeners.length; index++){
+	                    listeners[index].reject(error);
+	                }
+	                return;
+	            }
+	            const normalizedOptions = this.normalizeOptions(options);
+	            const normalizedOrigin = origin.origin;
+	            if (normalizedOptions in this.sessions) {
+	                const sessions = this.sessions[normalizedOptions];
+	                let maxConcurrentStreams = -1;
+	                let currentStreamsCount = -1;
+	                let optimalSession;
+	                // We could just do this.sessions[normalizedOptions].find(...) but that isn't optimal.
+	                // Additionally, we are looking for session which has biggest current pending streams count.
+	                //
+	                // |------------| |------------| |------------| |------------|
+	                // | Session: A | | Session: B | | Session: C | | Session: D |
+	                // | Pending: 5 |-| Pending: 8 |-| Pending: 9 |-| Pending: 4 |
+	                // | Max:    10 | | Max:    10 | | Max:     9 | | Max:     5 |
+	                // |------------| |------------| |------------| |------------|
+	                //                     ^
+	                //                     |
+	                //     pick this one  --
+	                //
+	                for(let index = 0; index < sessions.length; index++){
+	                    const session = sessions[index];
+	                    const sessionMaxConcurrentStreams = session.remoteSettings.maxConcurrentStreams;
+	                    if (sessionMaxConcurrentStreams < maxConcurrentStreams) {
+	                        break;
+	                    }
+	                    if (!session[kOriginSet].includes(normalizedOrigin)) {
+	                        continue;
+	                    }
+	                    const sessionCurrentStreamsCount = session[kCurrentStreamCount];
+	                    if (sessionCurrentStreamsCount >= sessionMaxConcurrentStreams || session[kGracefullyClosing] || session.destroyed) {
+	                        continue;
+	                    }
+	                    // We only need set this once.
+	                    if (!optimalSession) {
+	                        maxConcurrentStreams = sessionMaxConcurrentStreams;
+	                    }
+	                    // Either get the session which has biggest current stream count or the lowest.
+	                    if (this._isBetterSession(sessionCurrentStreamsCount, currentStreamsCount)) {
+	                        optimalSession = session;
+	                        currentStreamsCount = sessionCurrentStreamsCount;
+	                    }
+	                }
+	                if (optimalSession) {
+	                    this._accept(optimalSession, listeners, normalizedOrigin, options);
+	                    return;
+	                }
+	            }
+	            if (normalizedOptions in this.queue) {
+	                if (normalizedOrigin in this.queue[normalizedOptions]) {
+	                    // There's already an item in the queue, just attach ourselves to it.
+	                    this.queue[normalizedOptions][normalizedOrigin].listeners.push(...listeners);
+	                    return;
+	                }
+	            } else {
+	                this.queue[normalizedOptions] = {
+	                    [kLength]: 0
+	                };
+	            }
+	            // The entry must be removed from the queue IMMEDIATELY when:
+	            // 1. the session connects successfully,
+	            // 2. an error occurs.
+	            const removeFromQueue = ()=>{
+	                // Our entry can be replaced. We cannot remove the new one.
+	                if (normalizedOptions in this.queue && this.queue[normalizedOptions][normalizedOrigin] === entry) {
+	                    delete this.queue[normalizedOptions][normalizedOrigin];
+	                    if (--this.queue[normalizedOptions][kLength] === 0) {
+	                        delete this.queue[normalizedOptions];
+	                    }
+	                }
+	            };
+	            // The main logic is here
+	            const entry = async ()=>{
+	                this._sessionCount++;
+	                const name = `${normalizedOrigin}:${normalizedOptions}`;
+	                let receivedSettings = false;
+	                let socket;
+	                try {
+	                    const computedOptions = {
+	                        ...options
+	                    };
+	                    if (computedOptions.settings === undefined) {
+	                        computedOptions.settings = this.settings;
+	                    }
+	                    if (computedOptions.session === undefined) {
+	                        computedOptions.session = this.tlsSessionCache.get(name);
+	                    }
+	                    const createConnection = computedOptions.createConnection || this.createConnection;
+	                    // A hacky workaround to enable async `createConnection`
+	                    socket = await createConnection.call(this, origin, computedOptions);
+	                    computedOptions.createConnection = ()=>socket;
+	                    const session = http2.connect(origin, computedOptions);
+	                    session[kCurrentStreamCount] = 0;
+	                    session[kGracefullyClosing] = false;
+	                    // Node.js return https://false:443 instead of https://1.1.1.1:443
+	                    const getOriginSet = ()=>{
+	                        const { socket } = session;
+	                        let originSet;
+	                        if (socket.servername === false) {
+	                            socket.servername = socket.remoteAddress;
+	                            originSet = session.originSet;
+	                            socket.servername = false;
+	                        } else {
+	                            originSet = session.originSet;
+	                        }
+	                        return originSet;
+	                    };
+	                    const isFree = ()=>session[kCurrentStreamCount] < session.remoteSettings.maxConcurrentStreams;
+	                    session.socket.once('session', (tlsSession)=>{
+	                        this.tlsSessionCache.set(name, tlsSession);
+	                    });
+	                    session.once('error', (error)=>{
+	                        // Listeners are empty when the session successfully connected.
+	                        for(let index = 0; index < listeners.length; index++){
+	                            listeners[index].reject(error);
+	                        }
+	                        // The connection got broken, purge the cache.
+	                        this.tlsSessionCache.delete(name);
+	                    });
+	                    session.setTimeout(this.timeout, ()=>{
+	                        // Terminates all streams owned by this session.
+	                        session.destroy();
+	                    });
+	                    session.once('close', ()=>{
+	                        this._sessionCount--;
+	                        if (receivedSettings) {
+	                            // Assumes session `close` is emitted after request `close`
+	                            this._emptySessionCount--;
+	                            // This cannot be moved to the stream logic,
+	                            // because there may be a session that hadn't made a single request.
+	                            const where = this.sessions[normalizedOptions];
+	                            if (where.length === 1) {
+	                                delete this.sessions[normalizedOptions];
+	                            } else {
+	                                where.splice(where.indexOf(session), 1);
+	                            }
+	                        } else {
+	                            // Broken connection
+	                            removeFromQueue();
+	                            const error = new Error('Session closed without receiving a SETTINGS frame');
+	                            error.code = 'HTTP2WRAPPER_NOSETTINGS';
+	                            for(let index = 0; index < listeners.length; index++){
+	                                listeners[index].reject(error);
+	                            }
+	                        }
+	                        // There may be another session awaiting.
+	                        this._processQueue();
+	                    });
+	                    // Iterates over the queue and processes listeners.
+	                    const processListeners = ()=>{
+	                        const queue = this.queue[normalizedOptions];
+	                        if (!queue) {
+	                            return;
+	                        }
+	                        const originSet = session[kOriginSet];
+	                        for(let index = 0; index < originSet.length; index++){
+	                            const origin = originSet[index];
+	                            if (origin in queue) {
+	                                const { listeners, completed } = queue[origin];
+	                                let index = 0;
+	                                // Prevents session overloading.
+	                                while(index < listeners.length && isFree()){
+	                                    // We assume `resolve(...)` calls `request(...)` *directly*,
+	                                    // otherwise the session will get overloaded.
+	                                    listeners[index].resolve(session);
+	                                    index++;
+	                                }
+	                                queue[origin].listeners.splice(0, index);
+	                                if (queue[origin].listeners.length === 0 && !completed) {
+	                                    delete queue[origin];
+	                                    if (--queue[kLength] === 0) {
+	                                        delete this.queue[normalizedOptions];
+	                                        break;
+	                                    }
+	                                }
+	                                // We're no longer free, no point in continuing.
+	                                if (!isFree()) {
+	                                    break;
+	                                }
+	                            }
+	                        }
+	                    };
+	                    // The Origin Set cannot shrink. No need to check if it suddenly became covered by another one.
+	                    session.on('origin', ()=>{
+	                        session[kOriginSet] = getOriginSet() || [];
+	                        session[kGracefullyClosing] = false;
+	                        closeSessionIfCovered(this.sessions[normalizedOptions], session);
+	                        if (session[kGracefullyClosing] || !isFree()) {
+	                            return;
+	                        }
+	                        processListeners();
+	                        if (!isFree()) {
+	                            return;
+	                        }
+	                        // Close covered sessions (if possible).
+	                        closeCoveredSessions(this.sessions[normalizedOptions], session);
+	                    });
+	                    session.once('remoteSettings', ()=>{
+	                        // The Agent could have been destroyed already.
+	                        if (entry.destroyed) {
+	                            const error = new Error('Agent has been destroyed');
+	                            for(let index = 0; index < listeners.length; index++){
+	                                listeners[index].reject(error);
+	                            }
+	                            session.destroy();
+	                            return;
+	                        }
+	                        // See https://github.com/nodejs/node/issues/38426
+	                        if (session.setLocalWindowSize) {
+	                            session.setLocalWindowSize(1024 * 1024 * 4); // 4 MB
+	                        }
+	                        session[kOriginSet] = getOriginSet() || [];
+	                        if (session.socket.encrypted) {
+	                            const mainOrigin = session[kOriginSet][0];
+	                            if (mainOrigin !== normalizedOrigin) {
+	                                const error = new Error(`Requested origin ${normalizedOrigin} does not match server ${mainOrigin}`);
+	                                for(let index = 0; index < listeners.length; index++){
+	                                    listeners[index].reject(error);
+	                                }
+	                                session.destroy();
+	                                return;
+	                            }
+	                        }
+	                        removeFromQueue();
+	                        {
+	                            const where = this.sessions;
+	                            if (normalizedOptions in where) {
+	                                const sessions = where[normalizedOptions];
+	                                sessions.splice(getSortedIndex(sessions, session, compareSessions), 0, session);
+	                            } else {
+	                                where[normalizedOptions] = [
+	                                    session
+	                                ];
+	                            }
+	                        }
+	                        receivedSettings = true;
+	                        this._emptySessionCount++;
+	                        this.emit('session', session);
+	                        this._accept(session, listeners, normalizedOrigin, options);
+	                        if (session[kCurrentStreamCount] === 0 && this._emptySessionCount > this.maxEmptySessions) {
+	                            this.closeEmptySessions(this._emptySessionCount - this.maxEmptySessions);
+	                        }
+	                        // `session.remoteSettings.maxConcurrentStreams` might get increased
+	                        session.on('remoteSettings', ()=>{
+	                            if (!isFree()) {
+	                                return;
+	                            }
+	                            processListeners();
+	                            if (!isFree()) {
+	                                return;
+	                            }
+	                            // In case the Origin Set changes
+	                            closeCoveredSessions(this.sessions[normalizedOptions], session);
+	                        });
+	                    });
+	                    // Shim `session.request()` in order to catch all streams
+	                    session[kRequest] = session.request;
+	                    session.request = (headers, streamOptions)=>{
+	                        if (session[kGracefullyClosing]) {
+	                            throw new Error('The session is gracefully closing. No new streams are allowed.');
+	                        }
+	                        const stream = session[kRequest](headers, streamOptions);
+	                        // The process won't exit until the session is closed or all requests are gone.
+	                        session.ref();
+	                        if (session[kCurrentStreamCount]++ === 0) {
+	                            this._emptySessionCount--;
+	                        }
+	                        stream.once('close', ()=>{
+	                            if (--session[kCurrentStreamCount] === 0) {
+	                                this._emptySessionCount++;
+	                                session.unref();
+	                                if (this._emptySessionCount > this.maxEmptySessions || session[kGracefullyClosing]) {
+	                                    session.close();
+	                                    return;
+	                                }
+	                            }
+	                            if (session.destroyed || session.closed) {
+	                                return;
+	                            }
+	                            if (isFree() && !closeSessionIfCovered(this.sessions[normalizedOptions], session)) {
+	                                closeCoveredSessions(this.sessions[normalizedOptions], session);
+	                                processListeners();
+	                                if (session[kCurrentStreamCount] === 0) {
+	                                    this._processQueue();
+	                                }
+	                            }
+	                        });
+	                        return stream;
+	                    };
+	                } catch (error) {
+	                    removeFromQueue();
+	                    this._sessionCount--;
+	                    for(let index = 0; index < listeners.length; index++){
+	                        listeners[index].reject(error);
+	                    }
+	                }
+	            };
+	            entry.listeners = listeners;
+	            entry.completed = false;
+	            entry.destroyed = false;
+	            this.queue[normalizedOptions][normalizedOrigin] = entry;
+	            this.queue[normalizedOptions][kLength]++;
+	            this._processQueue();
+	        });
+	    }
+	    request(origin, options, headers, streamOptions) {
+	        return new Promise((resolve, reject)=>{
+	            this.getSession(origin, options, [
+	                {
+	                    reject,
+	                    resolve: (session)=>{
+	                        try {
+	                            const stream = session.request(headers, streamOptions);
+	                            // Do not throw before `request(...)` has been awaited
+	                            delayAsyncDestroy(stream);
+	                            resolve(stream);
+	                        } catch (error) {
+	                            reject(error);
+	                        }
+	                    }
+	                }
+	            ]);
+	        });
+	    }
+	    async createConnection(origin, options) {
+	        return Agent.connect(origin, options);
+	    }
+	    static connect(origin, options) {
+	        options.ALPNProtocols = [
+	            'h2'
+	        ];
+	        const port = origin.port || 443;
+	        const host = origin.hostname;
+	        if (typeof options.servername === 'undefined') {
+	            options.servername = host;
+	        }
+	        const socket = tls.connect(port, host, options);
+	        if (options.socket) {
+	            socket._peername = {
+	                family: undefined,
+	                address: undefined,
+	                port
+	            };
+	        }
+	        return socket;
+	    }
+	    closeEmptySessions(maxCount = Number.POSITIVE_INFINITY) {
+	        let closedCount = 0;
+	        const { sessions } = this;
+	        // eslint-disable-next-line guard-for-in
+	        for(const key in sessions){
+	            const thisSessions = sessions[key];
+	            for(let index = 0; index < thisSessions.length; index++){
+	                const session = thisSessions[index];
+	                if (session[kCurrentStreamCount] === 0) {
+	                    closedCount++;
+	                    session.close();
+	                    if (closedCount >= maxCount) {
+	                        return closedCount;
+	                    }
+	                }
+	            }
+	        }
+	        return closedCount;
+	    }
+	    destroy(reason) {
+	        const { sessions, queue } = this;
+	        // eslint-disable-next-line guard-for-in
+	        for(const key in sessions){
+	            const thisSessions = sessions[key];
+	            for(let index = 0; index < thisSessions.length; index++){
+	                thisSessions[index].destroy(reason);
+	            }
+	        }
+	        // eslint-disable-next-line guard-for-in
+	        for(const normalizedOptions in queue){
+	            const entries = queue[normalizedOptions];
+	            // eslint-disable-next-line guard-for-in
+	            for(const normalizedOrigin in entries){
+	                entries[normalizedOrigin].destroyed = true;
+	            }
+	        }
+	        // New requests should NOT attach to destroyed sessions
+	        this.queue = {};
+	        this.tlsSessionCache.clear();
+	    }
+	    get emptySessionCount() {
+	        return this._emptySessionCount;
+	    }
+	    get pendingSessionCount() {
+	        return this._sessionCount - this._emptySessionCount;
+	    }
+	    get sessionCount() {
+	        return this._sessionCount;
+	    }
+	}
+	Agent.kCurrentStreamCount = kCurrentStreamCount;
+	Agent.kGracefullyClosing = kGracefullyClosing;
+	agent = {
+	    Agent,
+	    globalAgent: new Agent()
+	};
+	return agent;
+}
+
+var incomingMessage;
+var hasRequiredIncomingMessage;
+
+function requireIncomingMessage () {
+	if (hasRequiredIncomingMessage) return incomingMessage;
+	hasRequiredIncomingMessage = 1;
+	const { Readable } = require$$0__default$6.default;
+	class IncomingMessage extends Readable {
+	    constructor(socket, highWaterMark){
+	        super({
+	            emitClose: false,
+	            autoDestroy: true,
+	            highWaterMark
+	        });
+	        this.statusCode = null;
+	        this.statusMessage = '';
+	        this.httpVersion = '2.0';
+	        this.httpVersionMajor = 2;
+	        this.httpVersionMinor = 0;
+	        this.headers = {};
+	        this.trailers = {};
+	        this.req = null;
+	        this.aborted = false;
+	        this.complete = false;
+	        this.upgrade = null;
+	        this.rawHeaders = [];
+	        this.rawTrailers = [];
+	        this.socket = socket;
+	        this._dumped = false;
+	    }
+	    get connection() {
+	        return this.socket;
+	    }
+	    set connection(value) {
+	        this.socket = value;
+	    }
+	    _destroy(error, callback) {
+	        if (!this.readableEnded) {
+	            this.aborted = true;
+	        }
+	        // See https://github.com/nodejs/node/issues/35303
+	        callback();
+	        this.req._request.destroy(error);
+	    }
+	    setTimeout(ms, callback) {
+	        this.req.setTimeout(ms, callback);
+	        return this;
+	    }
+	    _dump() {
+	        if (!this._dumped) {
+	            this._dumped = true;
+	            this.removeAllListeners('data');
+	            this.resume();
+	        }
+	    }
+	    _read() {
+	        if (this.req) {
+	            this.req._request.resume();
+	        }
+	    }
+	}
+	incomingMessage = IncomingMessage;
+	return incomingMessage;
+}
+
+var proxyEvents;
+var hasRequiredProxyEvents;
+
+function requireProxyEvents () {
+	if (hasRequiredProxyEvents) return proxyEvents;
+	hasRequiredProxyEvents = 1;
+	proxyEvents = (from, to, events)=>{
+	    for (const event of events){
+	        from.on(event, (...args)=>to.emit(event, ...args));
+	    }
+	};
+	return proxyEvents;
+}
+
+var errors$1 = {exports: {}};
+
+var hasRequiredErrors;
+
+function requireErrors () {
+	if (hasRequiredErrors) return errors$1.exports;
+	hasRequiredErrors = 1;
+	(function (module) {
+		/* istanbul ignore file: https://github.com/nodejs/node/blob/master/lib/internal/errors.js */ const makeError = (Base, key, getMessage)=>{
+		    module.exports[key] = class NodeError extends Base {
+		        constructor(...args){
+		            super(typeof getMessage === 'string' ? getMessage : getMessage(args));
+		            this.name = `${super.name} [${key}]`;
+		            this.code = key;
+		        }
+		    };
+		};
+		makeError(TypeError, 'ERR_INVALID_ARG_TYPE', (args)=>{
+		    const type = args[0].includes('.') ? 'property' : 'argument';
+		    let valid = args[1];
+		    const isManyTypes = Array.isArray(valid);
+		    if (isManyTypes) {
+		        valid = `${valid.slice(0, -1).join(', ')} or ${valid.slice(-1)}`;
+		    }
+		    return `The "${args[0]}" ${type} must be ${isManyTypes ? 'one of' : 'of'} type ${valid}. Received ${typeof args[2]}`;
+		});
+		makeError(TypeError, 'ERR_INVALID_PROTOCOL', (args)=>`Protocol "${args[0]}" not supported. Expected "${args[1]}"`);
+		makeError(Error, 'ERR_HTTP_HEADERS_SENT', (args)=>`Cannot ${args[0]} headers after they are sent to the client`);
+		makeError(TypeError, 'ERR_INVALID_HTTP_TOKEN', (args)=>`${args[0]} must be a valid HTTP token [${args[1]}]`);
+		makeError(TypeError, 'ERR_HTTP_INVALID_HEADER_VALUE', (args)=>`Invalid value "${args[0]} for header "${args[1]}"`);
+		makeError(TypeError, 'ERR_INVALID_CHAR', (args)=>`Invalid character in ${args[0]} [${args[1]}]`);
+		makeError(Error, 'ERR_HTTP2_NO_SOCKET_MANIPULATION', 'HTTP/2 sockets should not be directly manipulated (e.g. read and written)'); 
+	} (errors$1));
+	return errors$1.exports;
+}
+
+var isRequestPseudoHeader;
+var hasRequiredIsRequestPseudoHeader;
+
+function requireIsRequestPseudoHeader () {
+	if (hasRequiredIsRequestPseudoHeader) return isRequestPseudoHeader;
+	hasRequiredIsRequestPseudoHeader = 1;
+	isRequestPseudoHeader = (header)=>{
+	    switch(header){
+	        case ':method':
+	        case ':scheme':
+	        case ':authority':
+	        case ':path':
+	            return true;
+	        default:
+	            return false;
+	    }
+	};
+	return isRequestPseudoHeader;
+}
+
+var validateHeaderName;
+var hasRequiredValidateHeaderName;
+
+function requireValidateHeaderName () {
+	if (hasRequiredValidateHeaderName) return validateHeaderName;
+	hasRequiredValidateHeaderName = 1;
+	const { ERR_INVALID_HTTP_TOKEN } = requireErrors();
+	const isRequestPseudoHeader = requireIsRequestPseudoHeader();
+	const isValidHttpToken = /^[\^`\-\w!#$%&*+.|~]+$/;
+	validateHeaderName = (name)=>{
+	    if (typeof name !== 'string' || !isValidHttpToken.test(name) && !isRequestPseudoHeader(name)) {
+	        throw new ERR_INVALID_HTTP_TOKEN('Header name', name);
+	    }
+	};
+	return validateHeaderName;
+}
+
+var validateHeaderValue;
+var hasRequiredValidateHeaderValue;
+
+function requireValidateHeaderValue () {
+	if (hasRequiredValidateHeaderValue) return validateHeaderValue;
+	hasRequiredValidateHeaderValue = 1;
+	const { ERR_HTTP_INVALID_HEADER_VALUE, ERR_INVALID_CHAR } = requireErrors();
+	const isInvalidHeaderValue = /[^\t\u0020-\u007E\u0080-\u00FF]/;
+	validateHeaderValue = (name, value)=>{
+	    if (typeof value === 'undefined') {
+	        throw new ERR_HTTP_INVALID_HEADER_VALUE(value, name);
+	    }
+	    if (isInvalidHeaderValue.test(value)) {
+	        throw new ERR_INVALID_CHAR('header content', name);
+	    }
+	};
+	return validateHeaderValue;
+}
+
+var proxySocketHandler_1;
+var hasRequiredProxySocketHandler;
+
+function requireProxySocketHandler () {
+	if (hasRequiredProxySocketHandler) return proxySocketHandler_1;
+	hasRequiredProxySocketHandler = 1;
+	const { ERR_HTTP2_NO_SOCKET_MANIPULATION } = requireErrors();
+	/* istanbul ignore file */ /* https://github.com/nodejs/node/blob/6eec858f34a40ffa489c1ec54bb24da72a28c781/lib/internal/http2/compat.js#L195-L272 */ const proxySocketHandler = {
+	    has (stream, property) {
+	        // Replaced [kSocket] with .socket
+	        const reference = stream.session === undefined ? stream : stream.session.socket;
+	        return property in stream || property in reference;
+	    },
+	    get (stream, property) {
+	        switch(property){
+	            case 'on':
+	            case 'once':
+	            case 'end':
+	            case 'emit':
+	            case 'destroy':
+	                return stream[property].bind(stream);
+	            case 'writable':
+	            case 'destroyed':
+	                return stream[property];
+	            case 'readable':
+	                if (stream.destroyed) {
+	                    return false;
+	                }
+	                return stream.readable;
+	            case 'setTimeout':
+	                {
+	                    const { session } = stream;
+	                    if (session !== undefined) {
+	                        return session.setTimeout.bind(session);
+	                    }
+	                    return stream.setTimeout.bind(stream);
+	                }
+	            case 'write':
+	            case 'read':
+	            case 'pause':
+	            case 'resume':
+	                throw new ERR_HTTP2_NO_SOCKET_MANIPULATION();
+	            default:
+	                {
+	                    // Replaced [kSocket] with .socket
+	                    const reference = stream.session === undefined ? stream : stream.session.socket;
+	                    const value = reference[property];
+	                    return typeof value === 'function' ? value.bind(reference) : value;
+	                }
+	        }
+	    },
+	    getPrototypeOf (stream) {
+	        if (stream.session !== undefined) {
+	            // Replaced [kSocket] with .socket
+	            return Reflect.getPrototypeOf(stream.session.socket);
+	        }
+	        return Reflect.getPrototypeOf(stream);
+	    },
+	    set (stream, property, value) {
+	        switch(property){
+	            case 'writable':
+	            case 'readable':
+	            case 'destroyed':
+	            case 'on':
+	            case 'once':
+	            case 'end':
+	            case 'emit':
+	            case 'destroy':
+	                stream[property] = value;
+	                return true;
+	            case 'setTimeout':
+	                {
+	                    const { session } = stream;
+	                    if (session === undefined) {
+	                        stream.setTimeout = value;
+	                    } else {
+	                        session.setTimeout = value;
+	                    }
+	                    return true;
+	                }
+	            case 'write':
+	            case 'read':
+	            case 'pause':
+	            case 'resume':
+	                throw new ERR_HTTP2_NO_SOCKET_MANIPULATION();
+	            default:
+	                {
+	                    // Replaced [kSocket] with .socket
+	                    const reference = stream.session === undefined ? stream : stream.session.socket;
+	                    reference[property] = value;
+	                    return true;
+	                }
+	        }
+	    }
+	};
+	proxySocketHandler_1 = proxySocketHandler;
+	return proxySocketHandler_1;
+}
+
+var clientRequest;
+var hasRequiredClientRequest;
+
+function requireClientRequest () {
+	if (hasRequiredClientRequest) return clientRequest;
+	hasRequiredClientRequest = 1;
+	// See https://github.com/facebook/jest/issues/2549
+	// eslint-disable-next-line node/prefer-global/url
+	const { URL, urlToHttpOptions } = require$$0__default$3.default;
+	const http2 = require$$3__default.default;
+	const { Writable } = require$$0__default$6.default;
+	const { Agent, globalAgent } = requireAgent();
+	const IncomingMessage = requireIncomingMessage();
+	const proxyEvents = requireProxyEvents();
+	const { ERR_INVALID_ARG_TYPE, ERR_INVALID_PROTOCOL, ERR_HTTP_HEADERS_SENT } = requireErrors();
+	const validateHeaderName = requireValidateHeaderName();
+	const validateHeaderValue = requireValidateHeaderValue();
+	const proxySocketHandler = requireProxySocketHandler();
+	const { HTTP2_HEADER_STATUS, HTTP2_HEADER_METHOD, HTTP2_HEADER_PATH, HTTP2_HEADER_AUTHORITY, HTTP2_METHOD_CONNECT } = http2.constants;
+	const kHeaders = Symbol('headers');
+	const kOrigin = Symbol('origin');
+	const kSession = Symbol('session');
+	const kOptions = Symbol('options');
+	const kFlushedHeaders = Symbol('flushedHeaders');
+	const kJobs = Symbol('jobs');
+	const kPendingAgentPromise = Symbol('pendingAgentPromise');
+	class ClientRequest extends Writable {
+	    constructor(input, options, callback){
+	        super({
+	            autoDestroy: false,
+	            emitClose: false
+	        });
+	        if (typeof input === 'string') {
+	            input = urlToHttpOptions(new URL(input));
+	        } else if (input instanceof URL) {
+	            input = urlToHttpOptions(input);
+	        } else {
+	            input = {
+	                ...input
+	            };
+	        }
+	        if (typeof options === 'function' || options === undefined) {
+	            // (options, callback)
+	            callback = options;
+	            options = input;
+	        } else {
+	            // (input, options, callback)
+	            options = Object.assign(input, options);
+	        }
+	        if (options.h2session) {
+	            this[kSession] = options.h2session;
+	            if (this[kSession].destroyed) {
+	                throw new Error('The session has been closed already');
+	            }
+	            this.protocol = this[kSession].socket.encrypted ? 'https:' : 'http:';
+	        } else if (options.agent === false) {
+	            this.agent = new Agent({
+	                maxEmptySessions: 0
+	            });
+	        } else if (typeof options.agent === 'undefined' || options.agent === null) {
+	            this.agent = globalAgent;
+	        } else if (typeof options.agent.request === 'function') {
+	            this.agent = options.agent;
+	        } else {
+	            throw new ERR_INVALID_ARG_TYPE('options.agent', [
+	                'http2wrapper.Agent-like Object',
+	                'undefined',
+	                'false'
+	            ], options.agent);
+	        }
+	        if (this.agent) {
+	            this.protocol = this.agent.protocol;
+	        }
+	        if (options.protocol && options.protocol !== this.protocol) {
+	            throw new ERR_INVALID_PROTOCOL(options.protocol, this.protocol);
+	        }
+	        if (!options.port) {
+	            options.port = options.defaultPort || this.agent && this.agent.defaultPort || 443;
+	        }
+	        options.host = options.hostname || options.host || 'localhost';
+	        // Unused
+	        delete options.hostname;
+	        const { timeout } = options;
+	        options.timeout = undefined;
+	        this[kHeaders] = Object.create(null);
+	        this[kJobs] = [];
+	        this[kPendingAgentPromise] = undefined;
+	        this.socket = null;
+	        this.connection = null;
+	        this.method = options.method || 'GET';
+	        if (!(this.method === 'CONNECT' && (options.path === '/' || options.path === undefined))) {
+	            this.path = options.path;
+	        }
+	        this.res = null;
+	        this.aborted = false;
+	        this.reusedSocket = false;
+	        const { headers } = options;
+	        if (headers) {
+	            // eslint-disable-next-line guard-for-in
+	            for(const header in headers){
+	                this.setHeader(header, headers[header]);
+	            }
+	        }
+	        if (options.auth && !('authorization' in this[kHeaders])) {
+	            this[kHeaders].authorization = 'Basic ' + Buffer.from(options.auth).toString('base64');
+	        }
+	        options.session = options.tlsSession;
+	        options.path = options.socketPath;
+	        this[kOptions] = options;
+	        // Clients that generate HTTP/2 requests directly SHOULD use the :authority pseudo-header field instead of the Host header field.
+	        this[kOrigin] = new URL(`${this.protocol}//${options.servername || options.host}:${options.port}`);
+	        // A socket is being reused
+	        const reuseSocket = options._reuseSocket;
+	        if (reuseSocket) {
+	            options.createConnection = (...args)=>{
+	                if (reuseSocket.destroyed) {
+	                    return this.agent.createConnection(...args);
+	                }
+	                return reuseSocket;
+	            };
+	            // eslint-disable-next-line promise/prefer-await-to-then
+	            this.agent.getSession(this[kOrigin], this[kOptions]).catch(()=>{});
+	        }
+	        if (timeout) {
+	            this.setTimeout(timeout);
+	        }
+	        if (callback) {
+	            this.once('response', callback);
+	        }
+	        this[kFlushedHeaders] = false;
+	    }
+	    get method() {
+	        return this[kHeaders][HTTP2_HEADER_METHOD];
+	    }
+	    set method(value) {
+	        if (value) {
+	            this[kHeaders][HTTP2_HEADER_METHOD] = value.toUpperCase();
+	        }
+	    }
+	    get path() {
+	        const header = this.method === 'CONNECT' ? HTTP2_HEADER_AUTHORITY : HTTP2_HEADER_PATH;
+	        return this[kHeaders][header];
+	    }
+	    set path(value) {
+	        if (value) {
+	            const header = this.method === 'CONNECT' ? HTTP2_HEADER_AUTHORITY : HTTP2_HEADER_PATH;
+	            this[kHeaders][header] = value;
+	        }
+	    }
+	    get host() {
+	        return this[kOrigin].hostname;
+	    }
+	    set host(_value) {
+	    // Do nothing as this is read only.
+	    }
+	    get _mustNotHaveABody() {
+	        return this.method === 'GET' || this.method === 'HEAD' || this.method === 'DELETE';
+	    }
+	    _write(chunk, encoding, callback) {
+	        // https://github.com/nodejs/node/blob/654df09ae0c5e17d1b52a900a545f0664d8c7627/lib/internal/http2/util.js#L148-L156
+	        if (this._mustNotHaveABody) {
+	            callback(new Error('The GET, HEAD and DELETE methods must NOT have a body'));
+	            /* istanbul ignore next: Node.js 12 throws directly */ return;
+	        }
+	        this.flushHeaders();
+	        const callWrite = ()=>this._request.write(chunk, encoding, callback);
+	        if (this._request) {
+	            callWrite();
+	        } else {
+	            this[kJobs].push(callWrite);
+	        }
+	    }
+	    _final(callback) {
+	        this.flushHeaders();
+	        const callEnd = ()=>{
+	            // For GET, HEAD and DELETE and CONNECT
+	            if (this._mustNotHaveABody || this.method === 'CONNECT') {
+	                callback();
+	                return;
+	            }
+	            this._request.end(callback);
+	        };
+	        if (this._request) {
+	            callEnd();
+	        } else {
+	            this[kJobs].push(callEnd);
+	        }
+	    }
+	    abort() {
+	        if (this.res && this.res.complete) {
+	            return;
+	        }
+	        if (!this.aborted) {
+	            process.nextTick(()=>this.emit('abort'));
+	        }
+	        this.aborted = true;
+	        this.destroy();
+	    }
+	    async _destroy(error, callback) {
+	        if (this.res) {
+	            this.res._dump();
+	        }
+	        if (this._request) {
+	            this._request.destroy();
+	        } else {
+	            process.nextTick(()=>{
+	                this.emit('close');
+	            });
+	        }
+	        try {
+	            await this[kPendingAgentPromise];
+	        } catch (internalError) {
+	            if (this.aborted) {
+	                error = internalError;
+	            }
+	        }
+	        callback(error);
+	    }
+	    async flushHeaders() {
+	        if (this[kFlushedHeaders] || this.destroyed) {
+	            return;
+	        }
+	        this[kFlushedHeaders] = true;
+	        const isConnectMethod = this.method === HTTP2_METHOD_CONNECT;
+	        // The real magic is here
+	        const onStream = (stream)=>{
+	            this._request = stream;
+	            if (this.destroyed) {
+	                stream.destroy();
+	                return;
+	            }
+	            // Forwards `timeout`, `continue`, `close` and `error` events to this instance.
+	            if (!isConnectMethod) {
+	                // TODO: Should we proxy `close` here?
+	                proxyEvents(stream, this, [
+	                    'timeout',
+	                    'continue'
+	                ]);
+	            }
+	            stream.once('error', (error)=>{
+	                this.destroy(error);
+	            });
+	            stream.once('aborted', ()=>{
+	                const { res } = this;
+	                if (res) {
+	                    res.aborted = true;
+	                    res.emit('aborted');
+	                    res.destroy();
+	                } else {
+	                    this.destroy(new Error('The server aborted the HTTP/2 stream'));
+	                }
+	            });
+	            const onResponse = (headers, flags, rawHeaders)=>{
+	                // If we were to emit raw request stream, it would be as fast as the native approach.
+	                // Note that wrapping the raw stream in a Proxy instance won't improve the performance (already tested it).
+	                const response = new IncomingMessage(this.socket, stream.readableHighWaterMark);
+	                this.res = response;
+	                // Undocumented, but it is used by `cacheable-request`
+	                response.url = `${this[kOrigin].origin}${this.path}`;
+	                response.req = this;
+	                response.statusCode = headers[HTTP2_HEADER_STATUS];
+	                response.headers = headers;
+	                response.rawHeaders = rawHeaders;
+	                response.once('end', ()=>{
+	                    response.complete = true;
+	                    // Has no effect, just be consistent with the Node.js behavior
+	                    response.socket = null;
+	                    response.connection = null;
+	                });
+	                if (isConnectMethod) {
+	                    response.upgrade = true;
+	                    // The HTTP1 API says the socket is detached here,
+	                    // but we can't do that so we pass the original HTTP2 request.
+	                    if (this.emit('connect', response, stream, Buffer.alloc(0))) {
+	                        this.emit('close');
+	                    } else {
+	                        // No listeners attached, destroy the original request.
+	                        stream.destroy();
+	                    }
+	                } else {
+	                    // Forwards data
+	                    stream.on('data', (chunk)=>{
+	                        if (!response._dumped && !response.push(chunk)) {
+	                            stream.pause();
+	                        }
+	                    });
+	                    stream.once('end', ()=>{
+	                        if (!this.aborted) {
+	                            response.push(null);
+	                        }
+	                    });
+	                    if (!this.emit('response', response)) {
+	                        // No listeners attached, dump the response.
+	                        response._dump();
+	                    }
+	                }
+	            };
+	            // This event tells we are ready to listen for the data.
+	            stream.once('response', onResponse);
+	            // Emits `information` event
+	            stream.once('headers', (headers)=>this.emit('information', {
+	                    statusCode: headers[HTTP2_HEADER_STATUS]
+	                }));
+	            stream.once('trailers', (trailers, flags, rawTrailers)=>{
+	                const { res } = this;
+	                // https://github.com/nodejs/node/issues/41251
+	                if (res === null) {
+	                    onResponse(trailers, flags, rawTrailers);
+	                    return;
+	                }
+	                // Assigns trailers to the response object.
+	                res.trailers = trailers;
+	                res.rawTrailers = rawTrailers;
+	            });
+	            stream.once('close', ()=>{
+	                const { aborted, res } = this;
+	                if (res) {
+	                    if (aborted) {
+	                        res.aborted = true;
+	                        res.emit('aborted');
+	                        res.destroy();
+	                    }
+	                    const finish = ()=>{
+	                        res.emit('close');
+	                        this.destroy();
+	                        this.emit('close');
+	                    };
+	                    if (res.readable) {
+	                        res.once('end', finish);
+	                    } else {
+	                        finish();
+	                    }
+	                    return;
+	                }
+	                if (!this.destroyed) {
+	                    this.destroy(new Error('The HTTP/2 stream has been early terminated'));
+	                    this.emit('close');
+	                    return;
+	                }
+	                this.destroy();
+	                this.emit('close');
+	            });
+	            this.socket = new Proxy(stream, proxySocketHandler);
+	            for (const job of this[kJobs]){
+	                job();
+	            }
+	            this[kJobs].length = 0;
+	            this.emit('socket', this.socket);
+	        };
+	        if (!(HTTP2_HEADER_AUTHORITY in this[kHeaders]) && !isConnectMethod) {
+	            this[kHeaders][HTTP2_HEADER_AUTHORITY] = this[kOrigin].host;
+	        }
+	        // Makes a HTTP2 request
+	        if (this[kSession]) {
+	            try {
+	                onStream(this[kSession].request(this[kHeaders]));
+	            } catch (error) {
+	                this.destroy(error);
+	            }
+	        } else {
+	            this.reusedSocket = true;
+	            try {
+	                const promise = this.agent.request(this[kOrigin], this[kOptions], this[kHeaders]);
+	                this[kPendingAgentPromise] = promise;
+	                onStream(await promise);
+	                this[kPendingAgentPromise] = false;
+	            } catch (error) {
+	                this[kPendingAgentPromise] = false;
+	                this.destroy(error);
+	            }
+	        }
+	    }
+	    get connection() {
+	        return this.socket;
+	    }
+	    set connection(value) {
+	        this.socket = value;
+	    }
+	    getHeaderNames() {
+	        return Object.keys(this[kHeaders]);
+	    }
+	    hasHeader(name) {
+	        if (typeof name !== 'string') {
+	            throw new ERR_INVALID_ARG_TYPE('name', 'string', name);
+	        }
+	        return Boolean(this[kHeaders][name.toLowerCase()]);
+	    }
+	    getHeader(name) {
+	        if (typeof name !== 'string') {
+	            throw new ERR_INVALID_ARG_TYPE('name', 'string', name);
+	        }
+	        return this[kHeaders][name.toLowerCase()];
+	    }
+	    get headersSent() {
+	        return this[kFlushedHeaders];
+	    }
+	    removeHeader(name) {
+	        if (typeof name !== 'string') {
+	            throw new ERR_INVALID_ARG_TYPE('name', 'string', name);
+	        }
+	        if (this.headersSent) {
+	            throw new ERR_HTTP_HEADERS_SENT('remove');
+	        }
+	        delete this[kHeaders][name.toLowerCase()];
+	    }
+	    setHeader(name, value) {
+	        if (this.headersSent) {
+	            throw new ERR_HTTP_HEADERS_SENT('set');
+	        }
+	        validateHeaderName(name);
+	        validateHeaderValue(name, value);
+	        const lowercased = name.toLowerCase();
+	        if (lowercased === 'connection') {
+	            if (value.toLowerCase() === 'keep-alive') {
+	                return;
+	            }
+	            throw new Error(`Invalid 'connection' header: ${value}`);
+	        }
+	        if (lowercased === 'host' && this.method === 'CONNECT') {
+	            this[kHeaders][HTTP2_HEADER_AUTHORITY] = value;
+	        } else {
+	            this[kHeaders][lowercased] = value;
+	        }
+	    }
+	    setNoDelay() {
+	    // HTTP2 sockets cannot be malformed, do nothing.
+	    }
+	    setSocketKeepAlive() {
+	    // HTTP2 sockets cannot be malformed, do nothing.
+	    }
+	    setTimeout(ms, callback) {
+	        const applyTimeout = ()=>this._request.setTimeout(ms, callback);
+	        if (this._request) {
+	            applyTimeout();
+	        } else {
+	            this[kJobs].push(applyTimeout);
+	        }
+	        return this;
+	    }
+	    get maxHeadersCount() {
+	        if (!this.destroyed && this._request) {
+	            return this._request.session.localSettings.maxHeaderListSize;
+	        }
+	        return undefined;
+	    }
+	    set maxHeadersCount(_value) {
+	    // Updating HTTP2 settings would affect all requests, do nothing.
+	    }
+	}
+	clientRequest = ClientRequest;
+	return clientRequest;
+}
+
 var doh;
 var hasRequiredDoh;
 
 function requireDoh () {
 	if (hasRequiredDoh) return doh;
 	hasRequiredDoh = 1;
-	const http = require$$0__default$3.default;
+	const http = require$$0__default$4.default;
 	const https = require$$1__default.default;
-	const http2 = require$$2__default$1.default;
+	const HTTP2ClientRequest = requireClientRequest();
 	const Packet = requirePacket();
+	// https://github.com/szmarczak/http2-wrapper/blob/f1a1776d4b1aef1cd47d55b1a950986e86145a09/source/index.js#L24
+	// Copy the implementation allows us to pull in minimum code,
+	// instead of importing the entire module to reduce bundle size
+	function http2Get(url, options, callback) {
+	    const req = new HTTP2ClientRequest(url, options, callback);
+	    req.end();
+	    return req;
+	}
 	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;
-	    }
+	    'h2:': http2Get
 	};
 	const makeRequest = (url, query)=>new Promise((resolve, reject)=>{
 	        const index = url.indexOf('://');
@@ -1587,6 +3079,10 @@ function requireDoh () {
 	        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://)`);
+	        // after determining the protocol, convert h2 to https for get
+	        if (u.protocol === 'h2:') {
+	            u.protocol = 'https:';
+	        }
 	        const req = get(u.toString(), {
 	            headers: {
 	                accept: 'application/dns-message'
@@ -1644,7 +3140,7 @@ function requireUdp () {
 	hasRequiredUdp = 1;
 	const udp = require$$0__default$1.default;
 	const Packet = requirePacket();
-	const { equal } = require$$2__default$2.default;
+	const { equal } = require$$2__default.default;
 	const { debuglog } = require$$0__default.default;
 	const debug = debuglog('dns2');
 	udp_1 = ({ dns = '8.8.8.8', port = 53, socketType = 'udp4' } = {})=>{
@@ -1712,7 +3208,7 @@ function requireDns2 () {
 	if (hasRequiredDns2) return dns2;
 	hasRequiredDns2 = 1;
 	const { TCPServer, UDPServer, DOHServer, createTCPServer, createUDPServer, createDOHServer, createServer } = requireServer();
-	const EventEmitter = require$$4__default.default;
+	const EventEmitter = require$$1__default$1.default;
 	/**
 	 * [DNS description]
 	 * @docs https://tools.ietf.org/html/rfc1034
@@ -3112,7 +4608,7 @@ const sharedNullResponse = Object.freeze({
     const mutex = createAsyncMutex();
     const dnsClients = getDnsClients(dnsServers);
     return async function isRegisterableDomainAlive(domain) {
-        domain = require$$2.domainToASCII(domain);
+        domain = require$$0$3.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);
@@ -3218,7 +4714,7 @@ function createDomainAliveChecker(options = {}) {
     const mutex = createAsyncMutex();
     const dnsClients = getDnsClients(dnsServers);
     return async function isDomainAlive(domain) {
-        domain = require$$2.domainToASCII(domain);
+        domain = require$$0$3.domainToASCII(domain);
         const registerableDomainAliveResult = await isRegisterableDomainAlive(domain);
         if (registerableDomainAliveResult.registerableDomain === null) {
             return sharedNullishResult;