fetch-h 3.0.2

package/dist/lib/fetch-http2.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetch = void 0;
+const http2_1 = require("http2");
+const callguard_1 = require("callguard");
+const abort_1 = require("./abort");
+const core_1 = require("./core");
+const fetch_common_1 = require("./fetch-common");
+const headers_1 = require("./headers");
+const response_1 = require("./response");
+const utils_1 = require("./utils");
+const utils_http2_1 = require("./utils-http2");
+const { 
+// Responses
+HTTP2_HEADER_STATUS, HTTP2_HEADER_LOCATION, HTTP2_HEADER_SET_COOKIE, 
+// Error codes
+NGHTTP2_NO_ERROR, } = http2_1.constants;
+// This is from nghttp2.h, but undocumented in Node.js
+const NGHTTP2_ERR_START_STREAM_NOT_ALLOWED = -516;
+async function fetchImpl(session, input, init = {}, extra) {
+    const { cleanup, contentDecoders, endStream, headersToSend, integrity, method, onTrailers, origin, redirect, redirected, request, signal, signalPromise, timeoutAt, timeoutInfo, url, } = await (0, fetch_common_1.setupFetch)(session, input, init, extra);
+    const { raceConditionedGoaway } = extra;
+    const streamPromise = session.get();
+    async function doFetch() {
+        const { session: ph2session, cleanup: socketCleanup } = streamPromise;
+        const h2session = await ph2session;
+        const tryRetryOnGoaway = (resolve) => {
+            // This could be due to a race-condition in GOAWAY.
+            // As of current Node.js, the 'goaway' event is emitted on the
+            // session before this event (at least frameError, probably
+            // 'error' too) is emitted, so we will know if we got it.
+            if (!raceConditionedGoaway.has(origin) &&
+                (0, utils_http2_1.hasGotGoaway)(h2session)) {
+                // Don't retry again due to potential GOAWAY
+                raceConditionedGoaway.add(origin);
+                // Since we've got the 'goaway' event, the
+                // context has already released the session,
+                // so a retry will create a new session.
+                resolve(fetchImpl(session, request, { signal, onTrailers }, {
+                    raceConditionedGoaway,
+                    redirected,
+                    timeoutAt,
+                }));
+                return true;
+            }
+            return false;
+        };
+        let stream;
+        let shouldCleanupSocket = true;
+        try {
+            stream = h2session.request(headersToSend, { endStream });
+        }
+        catch (err) {
+            if (err.code === "ERR_HTTP2_GOAWAY_SESSION") {
+                // Retry with new session
+                throw new core_1.RetryError(err.code);
+            }
+            throw err;
+        }
+        const response = new Promise((resolve, reject) => {
+            const guard = (0, callguard_1.syncGuard)(reject, { catchAsync: true });
+            stream.on("aborted", guard((..._whatever) => {
+                reject((0, fetch_common_1.makeAbortedError)());
+            }));
+            stream.on("error", guard((err) => {
+                if (err &&
+                    err.code === "ERR_HTTP2_STREAM_ERROR" &&
+                    err.message &&
+                    err.message.includes("NGHTTP2_REFUSED_STREAM")) {
+                    if (tryRetryOnGoaway(resolve))
+                        return;
+                }
+                reject(err);
+            }));
+            stream.on("frameError", guard((_type, code, _streamId) => {
+                if (code === NGHTTP2_ERR_START_STREAM_NOT_ALLOWED &&
+                    endStream) {
+                    if (tryRetryOnGoaway(resolve))
+                        return;
+                }
+                reject(new Error("Request failed"));
+            }));
+            stream.on("close", guard(() => {
+                if (shouldCleanupSocket)
+                    socketCleanup();
+                // We'll get an 'error' event if there actually is an
+                // error, but not if we got NGHTTP2_NO_ERROR.
+                // In case of an error, the 'error' event will be awaited
+                // instead, to get (and propagate) the error object.
+                if (stream.rstCode === NGHTTP2_NO_ERROR)
+                    reject(new core_1.AbortError("Stream prematurely closed"));
+            }));
+            stream.on("timeout", guard((..._whatever) => {
+                reject((0, fetch_common_1.makeTimeoutError)());
+            }));
+            stream.on("trailers", guard((_headers, _flags) => {
+                if (!onTrailers)
+                    return;
+                try {
+                    const headers = new headers_1.GuardedHeaders("response");
+                    Object.keys(_headers).forEach(key => {
+                        if (Array.isArray(_headers[key]))
+                            _headers[key]
+                                .forEach(value => headers.append(key, value));
+                        else
+                            headers.set(key, "" + _headers[key]);
+                    });
+                    onTrailers(headers);
+                }
+                catch (err) {
+                    // TODO: Implement #8
+                    // tslint:disable-next-line
+                    console.warn("Trailer handling failed", err);
+                }
+            }));
+            // ClientHttp2Stream events
+            stream.on("continue", guard((..._whatever) => {
+                reject((0, fetch_common_1.make100Error)());
+            }));
+            stream.on("response", guard((headers) => {
+                const { signal: bodySignal = void 0, abort: bodyAbort = void 0, } = signal ? new abort_1.AbortController() : {};
+                if (signal) {
+                    const abortHandler = () => {
+                        bodyAbort();
+                        stream.destroy();
+                    };
+                    if (signal.aborted) {
+                        // No reason to continue, the request is aborted
+                        abortHandler();
+                        return;
+                    }
+                    signal.once("abort", abortHandler);
+                    stream.once("close", () => {
+                        signal.removeListener("abort", abortHandler);
+                    });
+                }
+                const status = "" + headers[HTTP2_HEADER_STATUS];
+                const location = (0, utils_1.parseLocation)(headers[HTTP2_HEADER_LOCATION], url);
+                const isRedirected = utils_1.isRedirectStatus[status];
+                if (headers[HTTP2_HEADER_SET_COOKIE]) {
+                    const setCookies = (0, utils_1.arrayify)(headers[HTTP2_HEADER_SET_COOKIE]);
+                    session.cookieJar.setCookies(setCookies, url);
+                }
+                if (!input.allowForbiddenHeaders) {
+                    delete headers["set-cookie"];
+                    delete headers["set-cookie2"];
+                }
+                if (isRedirected && !location)
+                    return reject((0, fetch_common_1.makeIllegalRedirectError)());
+                if (!isRedirected || redirect === "manual")
+                    return resolve(new response_1.StreamResponse(contentDecoders, url, stream, headers, redirect === "manual"
+                        ? false
+                        : extra.redirected.length > 0, {}, bodySignal, 2, input.allowForbiddenHeaders, integrity));
+                const { url: locationUrl, isRelative } = location;
+                if (redirect === "error")
+                    return reject((0, fetch_common_1.makeRedirectionError)(locationUrl));
+                // redirect is 'follow'
+                // We don't support re-sending a non-GET/HEAD request (as
+                // we don't want to [can't, if its' streamed] re-send the
+                // body). The concept is fundementally broken anyway...
+                if (!endStream)
+                    return reject((0, fetch_common_1.makeRedirectionMethodError)(locationUrl, method));
+                if (!location)
+                    return reject((0, fetch_common_1.makeIllegalRedirectError)());
+                if (isRelative) {
+                    shouldCleanupSocket = false;
+                    stream.destroy();
+                    resolve(fetchImpl(session, request.clone(locationUrl), init, {
+                        raceConditionedGoaway,
+                        redirected: redirected.concat(url),
+                        timeoutAt,
+                    }));
+                }
+                else {
+                    resolve(session.newFetch(request.clone(locationUrl), init, {
+                        timeoutAt,
+                        redirected: redirected.concat(url),
+                    }));
+                }
+            }));
+        });
+        if (!endStream)
+            await request.readable()
+                .then(readable => {
+                (0, utils_1.pipeline)(readable, stream)
+                    .catch(_err => {
+                    // TODO: Implement error handling
+                });
+            });
+        return response;
+    }
+    return (0, fetch_common_1.handleSignalAndTimeout)(signalPromise, timeoutInfo, cleanup, doFetch, streamPromise.cleanup);
+}
+function fetch(session, input, init, extra) {
+    var _a;
+    const http2Extra = {
+        timeoutAt: extra === null || extra === void 0 ? void 0 : extra.timeoutAt,
+        redirected: (_a = extra === null || extra === void 0 ? void 0 : extra.redirected) !== null && _a !== void 0 ? _a : [],
+        raceConditionedGoaway: new Set(),
+    };
+    return fetchImpl(session, input, init, http2Extra);
+}
+exports.fetch = fetch;
+//# sourceMappingURL=fetch-http2.js.map

package/dist/lib/generated/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "3.0.2";

package/dist/lib/generated/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+exports.version = "3.0.2";
+//# sourceMappingURL=version.js.map

package/dist/lib/headers.d.ts

@@ -0,0 +1,24 @@
+export declare type GuardTypes = "immutable" | "request" | "request-no-cors" | "response" | "none";
+export interface RawHeaders {
+    [key: string]: string | Array<string> | undefined;
+}
+export declare class Headers {
+    protected _guard: GuardTypes;
+    private _data;
+    constructor(init?: RawHeaders | Headers);
+    get [Symbol.toStringTag](): string;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    entries(): IterableIterator<[string, string]>;
+    get(name: string): string | null;
+    has(name: string): boolean;
+    keys(): IterableIterator<string>;
+    set(name: string, value: string): void;
+    values(): IterableIterator<string>;
+    toJSON(): {};
+}
+export declare class GuardedHeaders extends Headers {
+    constructor(guard: GuardTypes, init?: RawHeaders | Headers);
+}
+export declare function ensureHeaders(headers: RawHeaders | Headers | undefined): Headers;

package/dist/lib/headers.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureHeaders = exports.GuardedHeaders = exports.Headers = void 0;
+const utils_1 = require("./utils");
+const forbiddenHeaders = [
+    "accept-charset",
+    "accept-encoding",
+    "access-control-request-headers",
+    "access-control-request-method",
+    "connection",
+    "content-length",
+    "cookie",
+    "cookie2",
+    "date",
+    "dnt",
+    "expect",
+    "host",
+    "keep-alive",
+    "origin",
+    "referer",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+    "via",
+];
+function isForbiddenHeader(name) {
+    if (name.startsWith("proxy-") || name.startsWith("sec-"))
+        // Safe headers
+        return false;
+    return forbiddenHeaders.includes(name);
+}
+function isForbiddenResponseHeader(name) {
+    return ["set-cookie", "set-cookie2"].includes(name);
+}
+function isSimpleHeader(name, value) {
+    const simpleHeaders = [
+        "accept",
+        "accept-language",
+        "content-language",
+        "dpr",
+        "downlink",
+        "save-data",
+        "viewport-width",
+        "width",
+    ];
+    if (simpleHeaders.includes(name))
+        return true;
+    if (name !== "content-type")
+        return false;
+    if (value == null)
+        return false;
+    const mimeType = value.replace(/;.*/, "").toLowerCase();
+    return [
+        "application/x-www-form-urlencoded",
+        "multipart/form-data",
+        "text/plain",
+    ].includes(mimeType);
+}
+function filterName(name) {
+    if (/[^A-Za-z0-9\-#$%&'*+.\^_`|~]/.test(name))
+        throw new TypeError("Invalid character in header field name: " + name);
+    return name.toLowerCase();
+}
+function _ensureGuard(guard, name, value) {
+    if (guard === "immutable")
+        throw new TypeError("Header guard error: Cannot change immutable header");
+    if (!name)
+        return;
+    if (guard === "request" && isForbiddenHeader(name))
+        throw new TypeError("Header guard error: " +
+            "Cannot set forbidden header for requests" +
+            ` (${name})`);
+    if (guard === "request-no-cors" && !isSimpleHeader(name, value))
+        throw new TypeError("Header guard error: " +
+            "Cannot set non-simple header for no-cors requests" +
+            ` (${name})`);
+    if (guard === "response" && isForbiddenResponseHeader(name))
+        throw new TypeError("Header guard error: " +
+            "Cannot set forbidden response header for response" +
+            ` (${name})`);
+}
+let _guard = null;
+class Headers {
+    constructor(init) {
+        this._guard = _guard || "none";
+        _guard = null;
+        this._data = new Map();
+        const set = (name, values) => {
+            if (values.length === 1)
+                this.set(name, values[0]);
+            else
+                for (const value of values)
+                    this.append(name, value);
+        };
+        if (!init)
+            return;
+        else if (init instanceof Headers) {
+            for (const [name, values] of init._data.entries())
+                set(name, values);
+        }
+        else {
+            for (const _name of Object.keys(init)) {
+                const name = filterName(_name);
+                const value = (0, utils_1.arrayify)(init[_name])
+                    .map(val => `${val}`);
+                set(name, [...value]);
+            }
+        }
+    }
+    get [Symbol.toStringTag]() {
+        return "Map"; // This causes unit test libraries to treat this as a Map
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    append(name, value) {
+        const _name = filterName(name);
+        _ensureGuard(this._guard, _name, value);
+        if (!this._data.has(_name))
+            this._data.set(_name, [value]);
+        else
+            this._data.get(_name).push(value);
+    }
+    delete(name) {
+        const _name = filterName(name);
+        _ensureGuard(this._guard);
+        this._data.delete(_name);
+    }
+    *entries() {
+        for (const [name, value] of this._data.entries())
+            yield [name, value.join(",")];
+    }
+    get(name) {
+        const _name = filterName(name);
+        return this._data.has(_name)
+            ? this._data.get(_name).join(",")
+            : null;
+    }
+    has(name) {
+        return this._data.has(filterName(name));
+    }
+    keys() {
+        return this._data.keys();
+    }
+    set(name, value) {
+        const _name = filterName(name);
+        _ensureGuard(this._guard, _name, value);
+        this._data.set(_name, [value]);
+    }
+    *values() {
+        for (const value of this._data.values())
+            yield value.join(",");
+    }
+    // This is non-standard, but useful
+    toJSON() {
+        return [...this.entries()]
+            .reduce((prev, [key, val]) => Object.assign(prev, { [key]: val }), {});
+    }
+}
+exports.Headers = Headers;
+class GuardedHeaders extends Headers {
+    constructor(guard, init) {
+        super((_guard = guard, init));
+        _guard = null;
+    }
+}
+exports.GuardedHeaders = GuardedHeaders;
+function ensureHeaders(headers) {
+    return headers instanceof Headers ? headers : new Headers(headers);
+}
+exports.ensureHeaders = ensureHeaders;
+//# sourceMappingURL=headers.js.map

package/dist/lib/origin-cache.d.ts

@@ -0,0 +1,20 @@
+import { AltNameMatch } from "./san";
+export declare type Protocol = 'https1' | 'https2' | 'http1' | 'http2';
+declare type AnySessionMap = {
+    [key in Protocol]: unknown;
+};
+export interface OriginCacheEntry<P, Session> {
+    protocol: P;
+    session: Session;
+    firstOrigin: string;
+}
+export default class OriginCache<SessionMap extends AnySessionMap> {
+    private sessionMap;
+    private staticMap;
+    get<P extends Protocol>(protocol: P, origin: string): OriginCacheEntry<typeof protocol, SessionMap[P]> | undefined;
+    set(origin: string, protocol: Protocol, session: SessionMap[typeof protocol], altNameMatch?: AltNameMatch, cleanup?: () => void): void;
+    delete(session: SessionMap[keyof SessionMap]): boolean;
+    disconnectAll(): void;
+    disconnect(origin: string): void;
+}
+export {};

package/dist/lib/origin-cache.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function makeKey(protocol, origin) {
+    return protocol + ":" + origin;
+}
+class OriginCache {
+    constructor() {
+        this.sessionMap = new Map();
+        this.staticMap = new Map();
+    }
+    get(protocol, origin) {
+        const key = makeKey(protocol, origin);
+        const stateByStatic = this.staticMap.get(key);
+        if (stateByStatic)
+            return {
+                protocol: stateByStatic.protocol,
+                session: stateByStatic.session,
+                firstOrigin: stateByStatic.firstOrigin,
+            };
+        const stateByDynamic = [...this.sessionMap.values()].find(state => state.protocol === protocol &&
+            state.match &&
+            state.match.dynamic &&
+            state.match.dynamic(origin));
+        if (stateByDynamic) {
+            // An origin matching a dynamic (wildcard) alt-name was found.
+            // Cache this to find it statically in the future.
+            stateByDynamic.resolved.push(origin);
+            this.staticMap.set(key, stateByDynamic);
+            return {
+                protocol: stateByDynamic.protocol,
+                session: stateByDynamic.session,
+                firstOrigin: stateByDynamic.firstOrigin,
+            };
+        }
+    }
+    set(origin, protocol, session, altNameMatch, cleanup) {
+        const state = {
+            protocol,
+            firstOrigin: origin,
+            session,
+            match: altNameMatch,
+            resolved: [],
+            cleanup,
+        };
+        this.sessionMap.set(session, state);
+        if (altNameMatch)
+            altNameMatch.names.forEach(origin => {
+                this.staticMap.set(makeKey(protocol, origin), state);
+            });
+        this.staticMap.set(makeKey(protocol, origin), state);
+    }
+    // Returns true if a session was deleted, false otherwise
+    delete(session) {
+        var _a, _b;
+        const state = this.sessionMap.get(session);
+        if (!state)
+            return false;
+        [
+            state.firstOrigin,
+            ...state.resolved,
+            ...((_b = (_a = state.match) === null || _a === void 0 ? void 0 : _a.names) !== null && _b !== void 0 ? _b : []),
+        ]
+            .forEach(origin => {
+            this.staticMap.delete(makeKey(state.protocol, origin));
+        });
+        this.sessionMap.delete(session);
+        return true;
+    }
+    disconnectAll() {
+        [...this.sessionMap].forEach(([_, session]) => {
+            var _a;
+            (_a = session.cleanup) === null || _a === void 0 ? void 0 : _a.call(session);
+        });
+        this.sessionMap.clear();
+        this.staticMap.clear();
+    }
+    disconnect(origin) {
+        [
+            this.get('https1', origin),
+            this.get('https2', origin),
+            this.get('http1', origin),
+            this.get('http2', origin),
+        ]
+            .filter((t) => !!t)
+            .forEach(({ session }) => {
+            var _a, _b;
+            (_b = (_a = this.sessionMap.get(session)) === null || _a === void 0 ? void 0 : _a.cleanup) === null || _b === void 0 ? void 0 : _b.call(_a);
+            this.delete(session);
+        });
+    }
+}
+exports.default = OriginCache;
+//# sourceMappingURL=origin-cache.js.map

package/dist/lib/request.d.ts

@@ -0,0 +1,20 @@
+import { CacheTypes, CredentialsTypes, Method, ModeTypes, RedirectTypes, ReferrerPolicyTypes, ReferrerTypes, RequestInitWithoutBody, RequestInitWithUrl } from "./core";
+import { Body } from "./body";
+import { Headers } from "./headers";
+export declare class Request extends Body implements RequestInitWithoutBody {
+    readonly method: Method;
+    readonly url: string;
+    readonly headers: Headers;
+    readonly referrer: ReferrerTypes;
+    readonly referrerPolicy: ReferrerPolicyTypes;
+    readonly mode: ModeTypes;
+    readonly credentials: CredentialsTypes;
+    readonly redirect: RedirectTypes;
+    readonly integrity: string;
+    readonly cache: CacheTypes;
+    readonly allowForbiddenHeaders: boolean;
+    private _url;
+    private _init;
+    constructor(input: string | Request, init?: Partial<RequestInitWithUrl>);
+    clone(newUrl?: string): Request;
+}

package/dist/lib/request.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Request = void 0;
+const body_1 = require("./body");
+const headers_1 = require("./headers");
+const defaultInit = {
+    allowForbiddenHeaders: false,
+    cache: "default",
+    credentials: "omit",
+    method: "GET",
+    mode: "same-origin",
+    redirect: "manual",
+    referrer: "client",
+};
+class Request extends body_1.Body {
+    constructor(input, init) {
+        super();
+        const { url: overwriteUrl } = init || {};
+        // TODO: Consider throwing a TypeError if the URL has credentials
+        this._url =
+            input instanceof Request
+                ? (overwriteUrl || input._url)
+                : (overwriteUrl || input);
+        if (input instanceof Request) {
+            if (input.hasBody())
+                // Move body to this request
+                this.setBody(input);
+            const newInit = Object.assign({}, input, init);
+            init = newInit;
+            // TODO: Follow MDN:
+            //       If this object exists on another origin to the
+            //       constructor call, the Request.referrer is stripped out.
+            //       If this object has a Request.mode of navigate, the mode
+            //       value is converted to same-origin.
+        }
+        this._init = Object.assign({}, defaultInit, init);
+        const allowForbiddenHeaders = this._init.allowForbiddenHeaders;
+        const headers = new headers_1.GuardedHeaders(allowForbiddenHeaders
+            ? "none"
+            : this._init.mode === "no-cors"
+                ? "request-no-cors"
+                : "request", this._init.headers);
+        if (this._init.body && this._init.json)
+            throw new Error("Cannot specify both 'body' and 'json'");
+        if (!this.hasBody() && this._init.body) {
+            if (headers.has("content-type"))
+                this.setBody(this._init.body, headers.get("content-type"));
+            else
+                this.setBody(this._init.body);
+        }
+        else if (!this.hasBody() && this._init.json) {
+            this.setBody(new body_1.JsonBody(this._init.json));
+        }
+        Object.defineProperties(this, {
+            allowForbiddenHeaders: {
+                enumerable: true,
+                value: allowForbiddenHeaders,
+            },
+            cache: {
+                enumerable: true,
+                value: this._init.cache,
+            },
+            credentials: {
+                enumerable: true,
+                value: this._init.credentials,
+            },
+            headers: {
+                enumerable: true,
+                value: headers,
+            },
+            integrity: {
+                enumerable: true,
+                value: this._init.integrity,
+            },
+            method: {
+                enumerable: true,
+                value: this._init.method,
+            },
+            mode: {
+                enumerable: true,
+                value: this._init.mode,
+            },
+            redirect: {
+                enumerable: true,
+                value: this._init.redirect,
+            },
+            referrer: {
+                enumerable: true,
+                value: this._init.referrer,
+            },
+            referrerPolicy: {
+                enumerable: true,
+                value: this._init.referrerPolicy,
+            },
+            url: {
+                enumerable: true,
+                value: this._url,
+            },
+        });
+    }
+    clone(newUrl) {
+        return new Request(this, { url: newUrl });
+    }
+}
+exports.Request = Request;
+//# sourceMappingURL=request.js.map

package/dist/lib/response.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { BodyTypes, Decoder, HttpVersion, ResponseInit, ResponseTypes } from "./core";
+import { AbortSignal } from "./abort";
+import { Headers } from "./headers";
+import { Body } from "./body";
+import { IncomingHttpHeaders } from "./types";
+interface Extra {
+    httpVersion: HttpVersion;
+    redirected: boolean;
+    integrity: string;
+    signal: AbortSignal;
+    type: ResponseTypes;
+    url: string;
+}
+export declare class Response extends Body {
+    readonly headers: Headers;
+    readonly ok: boolean;
+    readonly redirected: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly type: ResponseTypes;
+    readonly url: string;
+    readonly useFinalURL: boolean;
+    readonly httpVersion: HttpVersion;
+    constructor(body?: BodyTypes | Body | null, init?: Partial<ResponseInit>, extra?: Partial<Extra>);
+    static error(): Response;
+    static redirect(url: string, status?: number): Response;
+    clone(): Response;
+}
+export declare class StreamResponse extends Response {
+    constructor(contentDecoders: ReadonlyArray<Decoder>, url: string, stream: NodeJS.ReadableStream, headers: IncomingHttpHeaders, redirected: boolean, init: Partial<ResponseInit>, signal: AbortSignal | undefined, httpVersion: HttpVersion, allowForbiddenHeaders: boolean, integrity?: string);
+}
+export {};