fetch-h 3.0.2

package/dist/lib/context-http2.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.H2Context = void 0;
+const http2_1 = require("http2");
+const url_1 = require("url");
+const callguard_1 = require("callguard");
+const core_1 = require("./core");
+const request_1 = require("./request");
+const response_1 = require("./response");
+const utils_1 = require("./utils");
+const utils_http2_1 = require("./utils-http2");
+const { HTTP2_HEADER_PATH, } = http2_1.constants;
+class H2Context {
+    constructor(getDecoders, getSessionOptions) {
+        // TODO: Remove in favor of protocol-agnostic origin cache
+        this._h2sessions = new Map();
+        this._h2staleSessions = new Map();
+        this._getDecoders = getDecoders;
+        this._getSessionOptions = getSessionOptions;
+        /* istanbul ignore next */
+        if (process.env.DEBUG_FETCH_H2) {
+            const debug = (line, ...args) => {
+                // tslint:disable-next-line
+                console.error(line, ...args);
+            };
+            const printSession = (origin, session) => {
+                debug("  First origin:", origin);
+                debug("   Ref-counter:", session.__fetch_h2_refcount);
+                debug("   Destroyed:", session.destroyed);
+                debug("   Destroyed mark:", session.__fetch_h2_destroyed);
+            };
+            process.on("SIGUSR2", () => {
+                debug("[Debug fetch-h2]: H2 sessions");
+                debug(" Active sessions");
+                [...this._h2sessions.entries()]
+                    .forEach(([origin, { session }]) => {
+                    printSession(origin, session);
+                });
+                debug(" Stale sessions");
+                [...this._h2staleSessions.entries()]
+                    .forEach(([origin, set]) => {
+                    [...set]
+                        .forEach((session) => {
+                        printSession(origin, session);
+                    });
+                });
+            });
+        }
+    }
+    createHttp2(origin, onGotGoaway, extraOptions) {
+        const sessionItem = this.connectHttp2(origin, extraOptions);
+        const { promise } = sessionItem;
+        // Handle session closure (delete from store)
+        promise
+            .then(session => {
+            session.once("close", () => this.disconnect(origin, session));
+            session.once("goaway", (_errorCode, _lastStreamID, _opaqueData) => {
+                (0, utils_http2_1.setGotGoaway)(session);
+                onGotGoaway();
+                this.releaseSession(origin);
+            });
+        })
+            .catch(() => {
+            if (sessionItem.session)
+                this.disconnect(origin, sessionItem.session);
+        });
+        this._h2sessions.set(origin, sessionItem);
+        const { promise: session, ref, unref } = sessionItem;
+        return {
+            ref,
+            unref,
+            session,
+        };
+    }
+    disconnectSession(session) {
+        return new Promise(resolve => {
+            if (session.destroyed)
+                return resolve();
+            session.once("close", () => resolve());
+            session.destroy();
+        });
+    }
+    releaseSession(origin) {
+        const sessionItem = this.deleteActiveSession(origin);
+        if (!sessionItem)
+            return;
+        if (!this._h2staleSessions.has(origin))
+            this._h2staleSessions.set(origin, new Set());
+        this._h2staleSessions.get(origin)
+            .add(sessionItem.session);
+    }
+    deleteActiveSession(origin) {
+        const sessionItem = this._h2sessions.get(origin);
+        if (!sessionItem)
+            return;
+        this._h2sessions.delete(origin);
+        sessionItem.session.unref();
+        // Never re-ref, this session is over
+        (0, utils_http2_1.setDestroyed)(sessionItem.session);
+        return sessionItem;
+    }
+    async disconnectStaleSessions(origin) {
+        const promises = [];
+        const sessionSet = this._h2staleSessions.get(origin);
+        if (!sessionSet)
+            return;
+        this._h2staleSessions.delete(origin);
+        for (const session of sessionSet)
+            promises.push(this.disconnectSession(session));
+        return Promise.all(promises).then(() => { });
+    }
+    disconnectAll() {
+        const promises = [];
+        for (const eventualH2session of this._h2sessions.values()) {
+            promises.push(this.handleDisconnect(eventualH2session));
+        }
+        this._h2sessions.clear();
+        for (const origin of this._h2staleSessions.keys()) {
+            promises.push(this.disconnectStaleSessions(origin));
+        }
+        return Promise.all(promises).then(() => { });
+    }
+    disconnect(url, session) {
+        const { origin } = new url_1.URL(url);
+        const promises = [];
+        const sessionItem = this.deleteActiveSession(origin);
+        if (sessionItem && (!session || sessionItem.session === session))
+            promises.push(this.handleDisconnect(sessionItem));
+        if (!session) {
+            promises.push(this.disconnectStaleSessions(origin));
+        }
+        else if (this._h2staleSessions.has(origin)) {
+            const sessionSet = this._h2staleSessions.get(origin);
+            if (sessionSet.has(session)) {
+                sessionSet.delete(session);
+                promises.push(this.disconnectSession(session));
+            }
+        }
+        return Promise.all(promises).then(() => { });
+    }
+    handleDisconnect(sessionItem) {
+        const { promise, session } = sessionItem;
+        if (session)
+            session.destroy();
+        return promise
+            .then(_h2session => { })
+            .catch(err => {
+            const debugMode = false;
+            if (debugMode)
+                // tslint:disable-next-line
+                console.warn("Disconnect error", err);
+        });
+    }
+    handlePush(origin, pushedStream, requestHeaders, ref, unref) {
+        if (!this._pushHandler)
+            return; // Drop push. TODO: Signal through error log: #8
+        const path = requestHeaders[HTTP2_HEADER_PATH];
+        // Remove pseudo-headers
+        Object.keys(requestHeaders)
+            .filter(name => name.charAt(0) === ":")
+            .forEach(name => { delete requestHeaders[name]; });
+        const pushedRequest = new request_1.Request(path, { headers: requestHeaders, allowForbiddenHeaders: true });
+        ref();
+        const futureResponse = new Promise((resolve, reject) => {
+            const guard = (0, callguard_1.syncGuard)(reject, { catchAsync: true });
+            pushedStream.once("close", unref);
+            pushedStream.once("aborted", () => reject(new core_1.AbortError("Response aborted")));
+            pushedStream.once("frameError", () => reject(new Error("Push request failed")));
+            pushedStream.once("error", reject);
+            pushedStream.once("push", guard((responseHeaders) => {
+                const response = new response_1.StreamResponse(this._getDecoders(origin), path, pushedStream, responseHeaders, false, {}, void 0, 2, false);
+                resolve(response);
+            }));
+        });
+        futureResponse
+            .catch(_err => { }); // TODO: #8
+        const getResponse = () => futureResponse;
+        return this._pushHandler(origin, pushedRequest, getResponse);
+    }
+    connectHttp2(origin, extraOptions = {}) {
+        const makeConnectionTimeout = () => new core_1.TimeoutError(`Connection timeout to ${origin}`);
+        const makeError = (event) => event
+            ? new Error(`Unknown connection error (${event}): ${origin}`)
+            : new Error(`Connection closed`);
+        let session = void 0;
+        // TODO: #8
+        // tslint:disable-next-line
+        const aGuard = (0, callguard_1.asyncGuard)(console.error.bind(console));
+        const sessionRefs = {};
+        const makeRefs = (session) => {
+            const monkeySession = session;
+            monkeySession.__fetch_h2_refcount = 1; // Begins ref'd
+            sessionRefs.ref = () => {
+                if ((0, utils_http2_1.isDestroyed)(session))
+                    return;
+                if (monkeySession.__fetch_h2_refcount === 0)
+                    // Go from unref'd to ref'd
+                    session.ref();
+                ++monkeySession.__fetch_h2_refcount;
+            };
+            sessionRefs.unref = () => {
+                if ((0, utils_http2_1.isDestroyed)(session))
+                    return;
+                --monkeySession.__fetch_h2_refcount;
+                if (monkeySession.__fetch_h2_refcount === 0)
+                    // Go from ref'd to unref'd
+                    session.unref();
+            };
+        };
+        const options = {
+            ...this._getSessionOptions(origin),
+            ...extraOptions,
+        };
+        const promise = new Promise((resolve, reject) => {
+            session =
+                (0, http2_1.connect)(origin, options, () => resolve(session));
+            makeRefs(session);
+            session.on("stream", aGuard((stream, headers) => this.handlePush(origin, stream, headers, () => sessionRefs.ref(), () => sessionRefs.unref())));
+            session.once("close", () => reject((0, utils_1.makeOkError)(makeError())));
+            session.once("timeout", () => reject(makeConnectionTimeout()));
+            session.once("error", reject);
+        });
+        return {
+            firstOrigin: origin,
+            promise,
+            ref: () => sessionRefs.ref(),
+            session,
+            unref: () => sessionRefs.unref(),
+        };
+    }
+}
+exports.H2Context = H2Context;
+//# sourceMappingURL=context-http2.js.map

package/dist/lib/context-https.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { SecureClientSessionOptions } from "http2";
+import { TLSSocket } from "tls";
+import { HttpProtocols } from "./core";
+import { AltNameMatch } from "./san";
+export interface HttpsSocketResult {
+    socket: TLSSocket;
+    protocol: "http1" | "http2";
+    altNameMatch: AltNameMatch;
+}
+export declare function connectTLS(host: string, port: string, protocols: ReadonlyArray<HttpProtocols>, connOpts: SecureClientSessionOptions): Promise<HttpsSocketResult>;

package/dist/lib/context-https.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectTLS = void 0;
+const tls_1 = require("tls");
+const san_1 = require("./san");
+const needsSocketHack = ["12", "13"]
+    .includes(process.versions.node.split('.')[0]);
+const alpnProtocols = {
+    http1: Buffer.from("\x08http/1.1"),
+    http2: Buffer.from("\x02h2"),
+};
+const defaultMethod = ["http2", "http1"];
+function connectTLS(host, port, protocols, connOpts) {
+    const usedProtocol = new Set();
+    const _protocols = protocols.filter(protocol => {
+        if (protocol !== "http1" && protocol !== "http2")
+            return false;
+        if (usedProtocol.has(protocol))
+            return false;
+        usedProtocol.add(protocol);
+        return true;
+    });
+    const orderedProtocols = Buffer.concat((_protocols.length !== 0 ? _protocols : defaultMethod)
+        .map(protocol => alpnProtocols[protocol]));
+    const opts = {
+        ...connOpts,
+        ALPNProtocols: orderedProtocols,
+        servername: host,
+    };
+    return new Promise((resolve, reject) => {
+        const socket = (0, tls_1.connect)(parseInt(port, 10), host, opts, () => {
+            const { authorized, authorizationError, alpnProtocol = "" } = socket;
+            const cert = socket.getPeerCertificate();
+            const altNameMatch = (0, san_1.parseOrigin)(cert);
+            if (!authorized && opts.rejectUnauthorized !== false)
+                return reject(authorizationError);
+            if (!alpnProtocol ||
+                !["h2", "http/1.1", "http/1.0"].includes(alpnProtocol)) {
+                // Maybe the server doesn't understand ALPN, enforce
+                // user-provided protocol, or fallback to HTTP/1
+                if (_protocols.length === 1)
+                    return resolve({
+                        altNameMatch,
+                        protocol: _protocols[0],
+                        socket,
+                    });
+                else
+                    return resolve({
+                        altNameMatch,
+                        protocol: "http1",
+                        socket,
+                    });
+            }
+            const protocol = alpnProtocol === "h2" ? "http2" : "http1";
+            resolve({ socket, protocol, altNameMatch });
+        });
+        if (needsSocketHack)
+            socket.once('secureConnect', () => {
+                socket.secureConnecting = false;
+            });
+        socket.once("error", reject);
+    });
+}
+exports.connectTLS = connectTLS;
+//# sourceMappingURL=context-https.js.map

package/dist/lib/context.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import { SecureClientSessionOptions } from "http2";
+import { PushHandler } from "./context-http2";
+import { CookieJar } from "./cookie-jar";
+import { Decoder, FetchInit, Http1Options, HttpProtocols, PerOrigin } from "./core";
+import { Request } from "./request";
+import { Response } from "./response";
+export interface ContextOptions {
+    userAgent: string | PerOrigin<string>;
+    overwriteUserAgent: boolean | PerOrigin<boolean>;
+    accept: string | PerOrigin<string>;
+    cookieJar: CookieJar;
+    decoders: ReadonlyArray<Decoder> | PerOrigin<ReadonlyArray<Decoder>>;
+    session: SecureClientSessionOptions | PerOrigin<SecureClientSessionOptions>;
+    httpProtocol: HttpProtocols | PerOrigin<HttpProtocols>;
+    httpsProtocols: ReadonlyArray<HttpProtocols> | PerOrigin<ReadonlyArray<HttpProtocols>>;
+    http1: Partial<Http1Options> | PerOrigin<Partial<Http1Options>>;
+}
+export declare class Context {
+    private h1Context;
+    private h2Context;
+    private _userAgent;
+    private _overwriteUserAgent;
+    private _accept;
+    private _cookieJar;
+    private _decoders;
+    private _sessionOptions;
+    private _httpProtocol;
+    private _httpsProtocols;
+    private _http1Options;
+    private _httpsFunnel;
+    private _http1Funnel;
+    private _http2Funnel;
+    private _originCache;
+    constructor(opts?: Partial<ContextOptions>);
+    setup(opts?: Partial<ContextOptions>): void;
+    userAgent(origin: string): string;
+    decoders(origin: string): readonly Decoder[];
+    sessionOptions(origin: string): SecureClientSessionOptions;
+    onPush(pushHandler?: PushHandler): void;
+    fetch(input: string | Request, init?: Partial<FetchInit>): Promise<Response>;
+    disconnect(url: string): Promise<void>;
+    disconnectAll(): Promise<void>;
+    private retryFetch;
+    private retryableFetch;
+    private connectSequenciallyTLS;
+    private getHttp1;
+    private parseInput;
+}

package/dist/lib/context.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const url_1 = require("url");
+const already_1 = require("already");
+const context_http1_1 = require("./context-http1");
+const context_http2_1 = require("./context-http2");
+const context_https_1 = require("./context-https");
+const cookie_jar_1 = require("./cookie-jar");
+const core_1 = require("./core");
+const fetch_http1_1 = require("./fetch-http1");
+const fetch_http2_1 = require("./fetch-http2");
+const version_1 = require("./generated/version");
+const request_1 = require("./request");
+const utils_1 = require("./utils");
+const origin_cache_1 = require("./origin-cache");
+function makeDefaultUserAgent() {
+    const name = `fetch-h2/${version_1.version} (+https://github.com/grantila/fetch-h2)`;
+    const node = `nodejs/${process.versions.node}`;
+    const nghttp2 = `nghttp2/${process.versions.nghttp2}`;
+    const uv = `uv/${process.versions.uv}`;
+    return `${name} ${node} ${nghttp2} ${uv}`;
+}
+const defaultUserAgent = makeDefaultUserAgent();
+const defaultAccept = "application/json,text/*;q=0.9,*/*;q=0.8";
+class Context {
+    constructor(opts) {
+        this._httpsFunnel = (0, already_1.funnel)();
+        this._http1Funnel = (0, already_1.funnel)();
+        this._http2Funnel = (0, already_1.funnel)();
+        this._originCache = new origin_cache_1.default();
+        this._userAgent = "";
+        this._overwriteUserAgent = false;
+        this._accept = "";
+        this._cookieJar = void 0;
+        this._decoders = [];
+        this._sessionOptions = {};
+        this._httpProtocol = "http1";
+        this._httpsProtocols = ["http2", "http1"];
+        this._http1Options = {};
+        this.setup(opts);
+        this.h1Context = new context_http1_1.H1Context(this._http1Options);
+        this.h2Context = new context_http2_1.H2Context(this.decoders.bind(this), this.sessionOptions.bind(this));
+    }
+    setup(opts) {
+        opts = opts || {};
+        this._cookieJar = "cookieJar" in opts
+            ? (opts.cookieJar || new cookie_jar_1.CookieJar())
+            : new cookie_jar_1.CookieJar();
+        this._userAgent = (0, core_1.parsePerOrigin)(opts.userAgent, "");
+        this._overwriteUserAgent =
+            (0, core_1.parsePerOrigin)(opts.overwriteUserAgent, false);
+        this._accept = (0, core_1.parsePerOrigin)(opts.accept, defaultAccept);
+        this._decoders = (0, core_1.parsePerOrigin)(opts.decoders, []);
+        this._sessionOptions = (0, core_1.parsePerOrigin)(opts.session, {});
+        this._httpProtocol = (0, core_1.parsePerOrigin)(opts.httpProtocol, "http1");
+        this._httpsProtocols = (0, core_1.parsePerOrigin)(opts.httpsProtocols, ["http2", "http1"]);
+        Object.assign(this._http1Options, opts.http1 || {});
+    }
+    userAgent(origin) {
+        const combine = (userAgent, overwriteUserAgent) => {
+            const defaultUA = overwriteUserAgent ? "" : defaultUserAgent;
+            return userAgent
+                ? defaultUA
+                    ? userAgent + " " + defaultUA
+                    : userAgent
+                : defaultUA;
+        };
+        return combine((0, core_1.getByOrigin)(this._userAgent, origin), (0, core_1.getByOrigin)(this._overwriteUserAgent, origin));
+    }
+    decoders(origin) {
+        return (0, core_1.getByOrigin)(this._decoders, origin);
+    }
+    sessionOptions(origin) {
+        return (0, core_1.getByOrigin)(this._sessionOptions, origin);
+    }
+    onPush(pushHandler) {
+        this.h2Context._pushHandler = pushHandler;
+    }
+    async fetch(input, init) {
+        return this.retryFetch(input, init);
+    }
+    async disconnect(url) {
+        const { origin } = this.parseInput(url);
+        this._originCache.disconnect(origin);
+        await Promise.all([
+            this.h1Context.disconnect(url),
+            this.h2Context.disconnect(url),
+        ]);
+    }
+    async disconnectAll() {
+        this._originCache.disconnectAll();
+        await Promise.all([
+            this.h1Context.disconnectAll(),
+            this.h2Context.disconnectAll(),
+        ]);
+    }
+    async retryFetch(input, init, extra, count = 0) {
+        ++count;
+        return this.retryableFetch(input, init, extra)
+            .catch((0, already_1.specific)(core_1.RetryError, err => {
+            // TODO: Implement a more robust retry logic
+            if (count > 10)
+                throw err;
+            return this.retryFetch(input, init, extra, count);
+        }));
+    }
+    async retryableFetch(input, init, extra) {
+        const { hostname, origin, port, protocol, url } = this.parseInput(input);
+        // Rewrite url to get rid of "http1://" and "http2://"
+        const request = input instanceof request_1.Request
+            ? input.url !== url
+                ? input.clone(url)
+                : input
+            : new request_1.Request(input, { ...(init || {}), url });
+        const { rejectUnauthorized } = this.sessionOptions(origin);
+        const makeSimpleSession = (protocol) => ({
+            accept: () => (0, core_1.getByOrigin)(this._accept, origin),
+            contentDecoders: () => (0, core_1.getByOrigin)(this._decoders, origin),
+            cookieJar: this._cookieJar,
+            protocol,
+            userAgent: () => this.userAgent(origin),
+            newFetch: this.retryFetch.bind(this),
+        });
+        const doFetchHttp1 = (socket, cleanup) => {
+            const sessionGetterHttp1 = {
+                get: (url) => ({
+                    cleanup,
+                    req: this.getHttp1(url, socket, request, rejectUnauthorized),
+                }),
+                ...makeSimpleSession("http1"),
+            };
+            return (0, fetch_http1_1.fetch)(sessionGetterHttp1, request, init, extra);
+        };
+        const doFetchHttp2 = async (cacheableSession) => {
+            const { session, unref } = cacheableSession;
+            const cleanup = (0, already_1.once)(unref);
+            try {
+                const sessionGetterHttp2 = {
+                    get: () => ({ session, cleanup }),
+                    ...makeSimpleSession("http2"),
+                };
+                return await (0, fetch_http2_1.fetch)(sessionGetterHttp2, request, init, extra);
+            }
+            catch (err) {
+                cleanup();
+                throw err;
+            }
+        };
+        const tryWaitForHttp1 = async (session) => {
+            const { socket: freeHttp1Socket, cleanup, shouldCreateNew } = this.h1Context.getFreeSocketForSession(session);
+            if (freeHttp1Socket)
+                return doFetchHttp1(freeHttp1Socket, cleanup);
+            if (!shouldCreateNew) {
+                // We've maxed out HTTP/1 connections, wait for one to be
+                // freed.
+                const { socket, cleanup } = await this.h1Context.waitForSocketBySession(session);
+                return doFetchHttp1(socket, cleanup);
+            }
+        };
+        if (protocol === "http1") {
+            return this._http1Funnel(async (shouldRetry, retry, shortcut) => {
+                var _a;
+                if (shouldRetry())
+                    return retry();
+                // Plain text HTTP/1(.1)
+                const cacheItem = this._originCache.get("http1", origin);
+                const session = (_a = cacheItem === null || cacheItem === void 0 ? void 0 : cacheItem.session) !== null && _a !== void 0 ? _a : this.h1Context.getSessionForOrigin(origin);
+                const resp = await tryWaitForHttp1(session);
+                if (resp)
+                    return resp;
+                const socket = await this.h1Context.makeNewConnection(url);
+                this._originCache.set(origin, "http1", session);
+                shortcut();
+                const cleanup = this.h1Context.addUsedSocket(session, socket);
+                return doFetchHttp1(socket, cleanup);
+            });
+        }
+        else if (protocol === "http2") {
+            return this._http2Funnel(async (_, __, shortcut) => {
+                // Plain text HTTP/2
+                const cacheItem = this._originCache.get("http2", origin);
+                if (cacheItem) {
+                    cacheItem.session.ref();
+                    shortcut();
+                    return doFetchHttp2(cacheItem.session);
+                }
+                // Convert socket into http2 session, this will ref (*)
+                const cacheableSession = this.h2Context.createHttp2(origin, () => { this._originCache.delete(cacheableSession); });
+                this._originCache.set(origin, "http2", cacheableSession);
+                shortcut();
+                // Session now lingering, it will be re-used by the next get()
+                return doFetchHttp2(cacheableSession);
+            });
+        }
+        else // protocol === "https"
+         {
+            return this._httpsFunnel((shouldRetry, retry, shortcut) => shouldRetry()
+                ? retry()
+                : this.connectSequenciallyTLS(shortcut, hostname, port, origin, tryWaitForHttp1, doFetchHttp1, doFetchHttp2));
+        }
+    }
+    async connectSequenciallyTLS(shortcut, hostname, port, origin, tryWaitForHttp1, doFetchHttp1, doFetchHttp2) {
+        var _a, _b;
+        const cacheItem = (_a = this._originCache.get("https2", origin)) !== null && _a !== void 0 ? _a : this._originCache.get("https1", origin);
+        if (cacheItem) {
+            if (cacheItem.protocol === "https1") {
+                shortcut();
+                const resp = await tryWaitForHttp1(cacheItem.session);
+                if (resp)
+                    return resp;
+            }
+            else if (cacheItem.protocol === "https2") {
+                cacheItem.session.ref();
+                shortcut();
+                return doFetchHttp2(cacheItem.session);
+            }
+        }
+        // Use ALPN to figure out protocol lazily
+        const { protocol, socket, altNameMatch } = await (0, context_https_1.connectTLS)(hostname, port, (0, core_1.getByOrigin)(this._httpsProtocols, origin), (0, core_1.getByOrigin)(this._sessionOptions, origin));
+        const disconnect = (0, already_1.once)(() => {
+            if (!socket.destroyed) {
+                socket.destroy();
+                socket.unref();
+            }
+        });
+        if (protocol === "http2") {
+            // Convert socket into http2 session, this will ref (*)
+            // const { cleanup, session, didCreate } =
+            const cacheableSession = this.h2Context.createHttp2(origin, () => { this._originCache.delete(cacheableSession); }, {
+                createConnection: () => socket,
+            });
+            this._originCache.set(origin, "https2", cacheableSession, altNameMatch, disconnect);
+            shortcut();
+            // Session now lingering, it will be re-used by the next get()
+            return doFetchHttp2(cacheableSession);
+        }
+        else // protocol === "http1"
+         {
+            const session = (_b = cacheItem === null || cacheItem === void 0 ? void 0 : cacheItem.session) !== null && _b !== void 0 ? _b : this.h1Context.getSessionForOrigin(origin);
+            // TODO: Update the alt-name list in the origin cache (if the new
+            //       TLS socket contains more/other alt-names).
+            if (!cacheItem)
+                this._originCache.set(origin, "https1", session, altNameMatch, disconnect);
+            const cleanup = this.h1Context.addUsedSocket(session, socket);
+            shortcut();
+            return doFetchHttp1(socket, cleanup);
+        }
+    }
+    getHttp1(url, socket, request, rejectUnauthorized) {
+        return this.h1Context.connect(new url_1.URL(url), {
+            createConnection: () => socket,
+            rejectUnauthorized,
+        }, request);
+    }
+    parseInput(input) {
+        const { hostname, origin, port, protocol, url } = (0, utils_1.parseInput)(typeof input !== "string" ? input.url : input);
+        const defaultHttp = this._httpProtocol;
+        if ((protocol === "http" && defaultHttp === "http1")
+            || protocol === "http1")
+            return {
+                hostname,
+                origin,
+                port,
+                protocol: "http1",
+                url,
+            };
+        else if ((protocol === "http" && defaultHttp === "http2")
+            || protocol === "http2")
+            return {
+                hostname,
+                origin,
+                port,
+                protocol: "http2",
+                url,
+            };
+        else if (protocol === "https")
+            return {
+                hostname,
+                origin,
+                port,
+                protocol: "https",
+                url,
+            };
+        else
+            throw new core_1.FetchError(`Invalid protocol "${protocol}"`);
+    }
+}
+exports.Context = Context;
+//# sourceMappingURL=context.js.map

package/dist/lib/cookie-jar.d.ts

@@ -0,0 +1,9 @@
+import { Cookie, CookieJar as ToughCookieJar } from "tough-cookie";
+export declare class CookieJar {
+    private _jar;
+    constructor(jar?: ToughCookieJar);
+    reset(jar?: ToughCookieJar): void;
+    setCookie(cookie: string | Cookie, url: string): Promise<Cookie>;
+    setCookies(cookies: ReadonlyArray<string | Cookie>, url: string): Promise<ReadonlyArray<Cookie>>;
+    getCookies(url: string): Promise<ReadonlyArray<Cookie>>;
+}