snapreq 0.0.4 → 0.0.8

package/build/transports/node-transport.js

@@ -0,0 +1,287 @@
+// @ts-check
+import { buildCapabilities } from "../capabilities.js";
+import { SnapReqAbortError, SnapReqUnsupportedFeatureError } from "../errors.js";
+import SnapReqHeaders from "../headers.js";
+import SnapReqResponse from "../response.js";
+/**
+ * Full-featured transport backed by Node's `http`/`https` modules. Supports
+ * Unix sockets, client TLS, keep-alive, request-body compression, response
+ * decompression and streaming. The `node:*` modules are loaded with a dynamic
+ * `import()` so this file never has to be bundled by web/Expo bundlers — the
+ * transport selector only imports it when running on Node.
+ */
+export default class NodeTransport {
+    /** @returns {string} - Transport name. */
+    static get transportName() {
+        return "node";
+    }
+    /** @returns {boolean} - Whether this transport can run in the current environment. */
+    static isAvailable() {
+        return typeof process !== "undefined" && Boolean(process.versions?.node);
+    }
+    /**
+     * @param {object} [config] - Transport configuration.
+     * @param {string} [config.socketPath] - Unix domain socket path.
+     * @param {{ca?: string | Buffer, cert?: string | Buffer, key?: string | Buffer, rejectUnauthorized?: boolean}} [config.tls] - TLS material for HTTPS connections.
+     * @param {boolean} [config.keepAlive] - Reuse connections across requests. Defaults to true.
+     */
+    constructor({ socketPath, tls, keepAlive = true } = {}) {
+        this.socketPath = socketPath;
+        this.tls = tls;
+        this.keepAlive = keepAlive;
+        /** @type {{http: any, https: any, zlib: any, stream: any} | null} */
+        this._modules = null;
+        /** @type {any} */
+        this._httpAgent = null;
+        /** @type {any} */
+        this._httpsAgent = null;
+    }
+    /** @returns {import("../capabilities.js").TransportCapabilities} - Supported capabilities. */
+    get capabilities() {
+        return buildCapabilities({
+            unixSocket: true,
+            tlsClientCert: true,
+            requestCompression: true,
+            responseStreaming: true,
+            requestStreaming: true,
+            keepAlive: true,
+            abort: true
+        });
+    }
+    /** @returns {Promise<{http: any, https: any, zlib: any, stream: any}>} - Lazily-loaded Node modules. */
+    async _load() {
+        if (!this._modules) {
+            const [http, https, zlib, stream] = await Promise.all([
+                import("node:http"),
+                import("node:https"),
+                import("node:zlib"),
+                import("node:stream")
+            ]);
+            this._modules = { http, https, zlib, stream };
+        }
+        return this._modules;
+    }
+    /**
+     * @param {boolean} useTls - Whether the request uses TLS.
+     * @returns {any} - The keep-alive agent for the protocol.
+     */
+    _agent(useTls) {
+        const { http, https } = /** @type {{http: any, https: any}} */ (this._modules);
+        if (useTls) {
+            this._httpsAgent || (this._httpsAgent = new https.Agent({
+                keepAlive: this.keepAlive,
+                ...(this.tls?.ca !== undefined ? { ca: this.tls.ca } : {}),
+                ...(this.tls?.cert !== undefined ? { cert: this.tls.cert } : {}),
+                ...(this.tls?.key !== undefined ? { key: this.tls.key } : {}),
+                ...(this.tls?.rejectUnauthorized !== undefined ? { rejectUnauthorized: this.tls.rejectUnauthorized } : {})
+            }));
+            return this._httpsAgent;
+        }
+        this._httpAgent || (this._httpAgent = new http.Agent({ keepAlive: this.keepAlive }));
+        return this._httpAgent;
+    }
+    /**
+     * Performs a single request and resolves once the response headers arrive,
+     * exposing the (decoded) body as a stream so callers can buffer or stream it.
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @returns {Promise<SnapReqResponse>} - The response.
+     */
+    async performRequest(request) {
+        const modules = await this._load();
+        const { zlib, stream } = modules;
+        const parsedUrl = new URL(request.url);
+        const useTls = Boolean(this.tls) || parsedUrl.protocol === "https:";
+        const httpModule = useTls ? modules.https : modules.http;
+        const headers = new SnapReqHeaders(request.headers);
+        const requestBody = this._prepareRequestBody(request, headers, { zlib, stream });
+        /** @type {Record<string, any>} */
+        const requestOptions = {
+            method: request.method,
+            path: `${parsedUrl.pathname}${parsedUrl.search}`,
+            headers: headers.toObject(),
+            agent: this._agent(useTls)
+        };
+        if (this.socketPath) {
+            requestOptions.socketPath = this.socketPath;
+        }
+        else {
+            requestOptions.hostname = parsedUrl.hostname;
+            requestOptions.port = parsedUrl.port || (useTls ? 443 : 80);
+        }
+        return await new Promise((resolve, reject) => {
+            if (request.signal?.aborted) {
+                reject(new SnapReqAbortError());
+                return;
+            }
+            let settled = false;
+            const abort = () => req.destroy(new SnapReqAbortError());
+            const removeAbortListener = () => request.signal?.removeEventListener("abort", abort);
+            const req = httpModule.request(requestOptions, (res) => {
+                /** @type {import("node:stream").Readable} */
+                let responseStream;
+                try {
+                    responseStream = this._decodeResponseStream(res, zlib);
+                }
+                catch (error) {
+                    if (!settled) {
+                        settled = true;
+                        removeAbortListener();
+                        reject(error);
+                    }
+                    return;
+                }
+                // Re-point the abort listener at the response stream so aborting after
+                // headers arrive tears down the body stream rather than the request.
+                removeAbortListener();
+                const abortStream = () => responseStream.destroy(new SnapReqAbortError());
+                request.signal?.addEventListener("abort", abortStream, { once: true });
+                responseStream.on("close", () => request.signal?.removeEventListener("abort", abortStream));
+                settled = true;
+                resolve(new SnapReqResponse({
+                    url: request.url,
+                    method: request.method,
+                    status: res.statusCode,
+                    statusText: res.statusMessage || "",
+                    headers: this._responseHeaders(res),
+                    stream: responseStream,
+                    nodeStream: responseStream
+                }));
+            });
+            request.signal?.addEventListener("abort", abort, { once: true });
+            req.on("error", (/** @type {unknown} */ error) => {
+                removeAbortListener();
+                if (!settled) {
+                    settled = true;
+                    reject(error);
+                }
+            });
+            if (requestBody.stream) {
+                requestBody.stream.pipe(req);
+            }
+            else {
+                if (requestBody.buffer)
+                    req.write(requestBody.buffer);
+                req.end();
+            }
+        });
+    }
+    /**
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @param {SnapReqHeaders} headers - Headers, mutated with Content-Length / Content-Encoding.
+     * @param {{zlib: any, stream: any}} modules - Node modules.
+     * @returns {{buffer: Buffer | null, stream: import("node:stream").Readable | null}} - Prepared body.
+     */
+    _prepareRequestBody(request, headers, { zlib, stream }) {
+        const compression = request.bodyCompression || "identity";
+        const body = request.body;
+        if (body.kind === "none")
+            return { buffer: null, stream: null };
+        /** @type {Buffer | null} */
+        let buffer = null;
+        /** @type {import("node:stream").Readable | null} */
+        let bodyStream = null;
+        if (body.kind === "stream") {
+            const value = /** @type {any} */ (body.value);
+            bodyStream = typeof value.pipe === "function" ? value : stream.Readable.from(value);
+        }
+        else if (body.kind === "bytes") {
+            buffer = Buffer.from(/** @type {Uint8Array} */ (body.value));
+        }
+        else {
+            buffer = Buffer.from(/** @type {string} */ (body.value));
+        }
+        if (compression === "identity") {
+            if (buffer)
+                headers.set("Content-Length", String(buffer.length));
+            return { buffer, stream: bodyStream };
+        }
+        if (headers.has("content-encoding")) {
+            throw new SnapReqUnsupportedFeatureError({
+                feature: "bodyCompression",
+                transport: "node",
+                detail: "cannot combine bodyCompression with an explicit Content-Encoding header"
+            });
+        }
+        headers.set("Content-Encoding", compression);
+        const compressor = this._requestCompressor(compression, zlib);
+        const source = bodyStream || stream.Readable.from(/** @type {Buffer} */ (buffer));
+        source.on("error", (/** @type {Error} */ error) => compressor.destroy(error));
+        source.pipe(compressor);
+        return { buffer: null, stream: compressor };
+    }
+    /**
+     * @param {string} encoding - Compression encoding.
+     * @param {any} zlib - The zlib module.
+     * @returns {import("node:stream").Transform} - A compressor transform.
+     */
+    _requestCompressor(encoding, zlib) {
+        if (encoding === "gzip")
+            return zlib.createGzip();
+        if (encoding === "deflate")
+            return zlib.createDeflate();
+        if (encoding === "br")
+            return zlib.createBrotliCompress();
+        if (encoding === "zstd" && typeof zlib.createZstdCompress === "function")
+            return zlib.createZstdCompress();
+        throw new SnapReqUnsupportedFeatureError({ feature: `bodyCompression "${encoding}"`, transport: "node" });
+    }
+    /**
+     * @param {import("node:http").IncomingMessage} response - The raw response.
+     * @param {any} zlib - The zlib module.
+     * @returns {import("node:stream").Readable} - The decoded response body stream.
+     */
+    _decodeResponseStream(response, zlib) {
+        const header = response.headers["content-encoding"];
+        const headerValue = Array.isArray(header) ? header.join(",") : header;
+        const encodings = (headerValue || "")
+            .split(",")
+            .map((encoding) => encoding.trim().toLowerCase())
+            .filter((encoding) => encoding && encoding !== "identity");
+        /** @type {import("node:stream").Readable} */
+        let decoded = response;
+        for (let index = encodings.length - 1; index >= 0; index -= 1) {
+            decoded = decoded.pipe(this._responseDecoder(encodings[index], zlib));
+        }
+        return decoded;
+    }
+    /**
+     * @param {string} encoding - Content encoding.
+     * @param {any} zlib - The zlib module.
+     * @returns {import("node:stream").Transform} - A decompressor transform.
+     */
+    _responseDecoder(encoding, zlib) {
+        if (encoding === "gzip" || encoding === "x-gzip")
+            return zlib.createGunzip();
+        if (encoding === "deflate")
+            return zlib.createInflate();
+        if (encoding === "br")
+            return zlib.createBrotliDecompress();
+        if (encoding === "zstd" && typeof zlib.createZstdDecompress === "function")
+            return zlib.createZstdDecompress();
+        throw new SnapReqUnsupportedFeatureError({ feature: `response content-encoding "${encoding}"`, transport: "node" });
+    }
+    /**
+     * @param {import("node:http").IncomingMessage} response - The raw response.
+     * @returns {SnapReqHeaders} - The response headers.
+     */
+    _responseHeaders(response) {
+        const headers = new SnapReqHeaders();
+        for (const [name, value] of Object.entries(response.headers)) {
+            if (value === undefined)
+                continue;
+            headers.set(name, Array.isArray(value) ? value.join(", ") : value);
+        }
+        return headers;
+    }
+    /**
+     * Destroys the keep-alive agents, closing all persistent connections.
+     * @returns {void}
+     */
+    close() {
+        this._httpAgent?.destroy();
+        this._httpsAgent?.destroy();
+        this._httpAgent = null;
+        this._httpsAgent = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-transport.js","sourceRoot":"","sources":["../../src/transports/node-transport.js"],"names":[],"mappings":"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"}

package/build/transports/proxy-bounce-transport.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Transport that bounces every request through a same-origin proxy endpoint.
+ * Used when the real target is a different origin and CORS would block direct
+ * browser `fetch` calls. The proxy backend makes the outbound request
+ * server-side where CORS does not apply.
+ */
+export default class ProxyBounceTransport {
+    /** @returns {string} - Transport name. */
+    static get transportName(): string;
+    /**
+     * @param {object} config - Transport configuration.
+     * @param {string} config.proxyUrl - Absolute URL of the proxy endpoint.
+     */
+    constructor({ proxyUrl }: {
+        proxyUrl: string;
+    });
+    proxyUrl: string;
+    /** @returns {import("../capabilities.js").TransportCapabilities} - Supported capabilities. */
+    get capabilities(): import("../capabilities.js").TransportCapabilities;
+    /**
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @returns {Promise<SnapReqResponse>} - The response.
+     */
+    performRequest(request: import("../snap-req.js").NormalizedRequest): Promise<SnapReqResponse>;
+}
+import SnapReqResponse from "../response.js";
+//# sourceMappingURL=proxy-bounce-transport.d.ts.map

package/build/transports/proxy-bounce-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy-bounce-transport.d.ts","sourceRoot":"","sources":["../../src/transports/proxy-bounce-transport.js"],"names":[],"mappings":"AA4CA;;;;;GAKG;AACH;IASE,0CAA0C;IAC1C,4BADc,MAAM,CAGnB;IAXD;;;OAGG;IACH,0BAFG;QAAuB,QAAQ,EAAvB,MAAM;KAChB,EAGA;IADC,iBAAwB;IAQ1B,8FAA8F;IAC9F,oBADc,OAAO,oBAAoB,EAAE,qBAAqB,CAG/D;IAED;;;OAGG;IACH,wBAHW,OAAO,gBAAgB,EAAE,iBAAiB,GACxC,OAAO,CAAC,eAAe,CAAC,CA2EpC;CACF;4BA9I2B,gBAAgB"}

package/build/transports/proxy-bounce-transport.js

@@ -0,0 +1,127 @@
+// @ts-check
+import { buildCapabilities } from "../capabilities.js";
+import { SnapReqUnsupportedFeatureError } from "../errors.js";
+import SnapReqHeaders from "../headers.js";
+import SnapReqResponse from "../response.js";
+/**
+ * @param {Uint8Array} bytes - Bytes to encode.
+ * @returns {string} - Base64 string.
+ */
+function base64Encode(bytes) {
+    const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+    return btoa(binary);
+}
+/**
+ * @param {string} base64 - Base64-encoded string.
+ * @returns {Uint8Array} - Decoded bytes.
+ */
+function base64Decode(base64) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * @param {Uint8Array} bytes - Buffered response bytes.
+ * @returns {AsyncIterable<Uint8Array>} - One-shot stream over the buffered bytes.
+ */
+function bufferedByteStream(bytes) {
+    return (async function* () {
+        if (bytes.byteLength > 0) {
+            yield bytes;
+        }
+    })();
+}
+/**
+ * Transport that bounces every request through a same-origin proxy endpoint.
+ * Used when the real target is a different origin and CORS would block direct
+ * browser `fetch` calls. The proxy backend makes the outbound request
+ * server-side where CORS does not apply.
+ */
+export default class ProxyBounceTransport {
+    /**
+     * @param {object} config - Transport configuration.
+     * @param {string} config.proxyUrl - Absolute URL of the proxy endpoint.
+     */
+    constructor({ proxyUrl }) {
+        this.proxyUrl = proxyUrl;
+    }
+    /** @returns {string} - Transport name. */
+    static get transportName() {
+        return "proxy-bounce";
+    }
+    /** @returns {import("../capabilities.js").TransportCapabilities} - Supported capabilities. */
+    get capabilities() {
+        return buildCapabilities({ abort: true });
+    }
+    /**
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @returns {Promise<SnapReqResponse>} - The response.
+     */
+    async performRequest(request) {
+        const requestBody = request.body;
+        /** @type {string | null} */
+        let serializedBody = null;
+        /** @type {string | undefined} */
+        let bodyEncoding;
+        if (requestBody.kind === "text") {
+            serializedBody = /** @type {string} */ (requestBody.value);
+        }
+        else if (requestBody.kind === "bytes") {
+            serializedBody = base64Encode(/** @type {Uint8Array} */ (requestBody.value));
+            bodyEncoding = "base64";
+        }
+        else if (requestBody.kind === "stream") {
+            throw new SnapReqUnsupportedFeatureError({ feature: "streamed request bodies", transport: "proxy-bounce" });
+        }
+        /** @type {Record<string, any>} */
+        const proxyPayload = {
+            body: serializedBody,
+            headers: request.headers.toObject(),
+            method: request.method,
+            url: request.url
+        };
+        if (bodyEncoding) {
+            proxyPayload.bodyEncoding = bodyEncoding;
+        }
+        /** @type {Response} */
+        let proxyResponse;
+        try {
+            proxyResponse = await fetch(this.proxyUrl, {
+                body: JSON.stringify(proxyPayload),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+                signal: request.signal || undefined
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                throw error;
+            }
+            throw error;
+        }
+        const payload = await proxyResponse.json();
+        const responseHeaders = new SnapReqHeaders();
+        if (payload.headers) {
+            for (const [name, value] of Object.entries(payload.headers)) {
+                responseHeaders.set(name, String(value));
+            }
+        }
+        /** @type {Uint8Array} */
+        let bodyBytes = new Uint8Array(0);
+        if (payload.body) {
+            bodyBytes = base64Decode(payload.body);
+        }
+        return new SnapReqResponse({
+            headers: responseHeaders,
+            method: request.method,
+            status: payload.status,
+            statusText: payload.statusText || "",
+            stream: bufferedByteStream(bodyBytes),
+            url: request.url
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{types → build}/transports/select.d.ts

@@ -7,6 +7,12 @@
  * @property {(request: import("../snap-req.js").NormalizedRequest) => Promise<import("../response.js").default>} performRequest - Perform a request.
  * @property {() => void} [close] - Optional resource cleanup.
  */
+/**
+ * @typedef {new (config: object) => Transport} NodeTransportConstructor
+ */
+/**
+ * @typedef {{default: NodeTransportConstructor}} NodeTransportModule
+ */
 /**
  * Detects the JavaScript runtime so `auto` can pick the right transport.
  * @returns {"node" | "react-native" | "browser" | "unknown"} - Detected runtime.
@@ -36,3 +42,8 @@ export type Transport = {
      */
     close?: () => void;
 };
+export type NodeTransportConstructor = new (config: object) => Transport;
+export type NodeTransportModule = {
+    default: NodeTransportConstructor;
+};
+//# sourceMappingURL=select.d.ts.map

package/build/transports/select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/transports/select.js"],"names":[],"mappings":"AAQA;;GAEG;AAEH;;;;;GAKG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;GAGG;AACH,iCAFa,MAAM,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,CAU3D;AAeD;;;;;;;GAOG;AACH,4CAJW,aAAa,GAAG,SAAS,GAAG,SAAS,cACrC,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAyB9B;4BA5EY,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK;;;;;kBAKhC,OAAO,oBAAoB,EAAE,qBAAqB;;;;oBAClD,CAAC,OAAO,EAAE,OAAO,gBAAgB,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,gBAAgB,EAAE,OAAO,CAAC;;;;YAClG,MAAM,IAAI;;uCAIX,KAAK,MAAM,EAAE,MAAM,KAAK,SAAS;kCAIjC;IAAC,OAAO,EAAE,wBAAwB,CAAA;CAAC"}

package/build/transports/select.js

@@ -0,0 +1,77 @@
+// @ts-check
+import { SnapReqError } from "../errors.js";
+import FetchTransport from "./fetch-transport.js";
+import XhrTransport from "./xhr-transport.js";
+const NODE_TRANSPORT_MODULE_PATH = "snapreq/transports/node-transport";
+/**
+ * @typedef {"auto" | "node" | "fetch" | "xhr"} TransportName
+ */
+/**
+ * @typedef {object} Transport
+ * @property {import("../capabilities.js").TransportCapabilities} capabilities - Supported capabilities.
+ * @property {(request: import("../snap-req.js").NormalizedRequest) => Promise<import("../response.js").default>} performRequest - Perform a request.
+ * @property {() => void} [close] - Optional resource cleanup.
+ */
+/**
+ * @typedef {new (config: object) => Transport} NodeTransportConstructor
+ */
+/**
+ * @typedef {{default: NodeTransportConstructor}} NodeTransportModule
+ */
+/**
+ * Detects the JavaScript runtime so `auto` can pick the right transport.
+ * @returns {"node" | "react-native" | "browser" | "unknown"} - Detected runtime.
+ */
+export function detectRuntime() {
+    const navigatorRef = /** @type {any} */ (globalThis).navigator;
+    if (navigatorRef && navigatorRef.product === "ReactNative")
+        return "react-native";
+    if (typeof process !== "undefined" && Boolean(process.versions?.node))
+        return "node";
+    if (typeof window !== "undefined" && typeof document !== "undefined")
+        return "browser";
+    return "unknown";
+}
+/**
+ * @param {object} config - Node transport configuration.
+ * @returns {Promise<Transport>} - A Node transport instance.
+ */
+async function createNodeTransport(config) {
+    const dynamicImport = /** @type {(specifier: string) => Promise<NodeTransportModule>} */ (new Function("specifier", "return import(specifier)"));
+    const { default: NodeTransport } = await dynamicImport(NODE_TRANSPORT_MODULE_PATH);
+    return new NodeTransport(config);
+}
+/**
+ * Resolves a transport for the requested preference. Returns the preference
+ * untouched when it is already a transport instance. The Node transport is
+ * imported dynamically so web/Expo bundlers never pull in `node:*` modules.
+ * @param {TransportName | Transport | undefined} preference - Requested transport.
+ * @param {object} nodeConfig - Configuration forwarded to the Node transport.
+ * @returns {Promise<Transport>} - The resolved transport.
+ */
+export async function selectTransport(preference, nodeConfig) {
+    if (preference && typeof preference === "object" && typeof ( /** @type {any} */(preference).performRequest) === "function") {
+        return /** @type {Transport} */ (preference);
+    }
+    const choice = /** @type {TransportName} */ (preference || "auto");
+    if (choice === "node")
+        return await createNodeTransport(nodeConfig);
+    if (choice === "fetch")
+        return new FetchTransport();
+    if (choice === "xhr")
+        return new XhrTransport();
+    if (choice !== "auto") {
+        throw new SnapReqError(`Unknown transport "${choice}". Use "auto", "node", "fetch", "xhr" or a transport instance.`);
+    }
+    const runtime = detectRuntime();
+    if (runtime === "node")
+        return await createNodeTransport(nodeConfig);
+    if (FetchTransport.isAvailable())
+        return new FetchTransport();
+    if (XhrTransport.isAvailable())
+        return new XhrTransport();
+    if (typeof process !== "undefined" && Boolean(process.versions?.node))
+        return await createNodeTransport(nodeConfig);
+    throw new SnapReqError("No suitable transport found: this platform has no fetch, XMLHttpRequest or Node http support.");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{types → build}/transports/xhr-transport.d.ts

@@ -23,3 +23,4 @@ export default class XhrTransport {
 }
 import SnapReqResponse from "../response.js";
 import SnapReqHeaders from "../headers.js";
+//# sourceMappingURL=xhr-transport.d.ts.map

package/build/transports/xhr-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xhr-transport.d.ts","sourceRoot":"","sources":["../../src/transports/xhr-transport.js"],"names":[],"mappings":"AAOA;;;;GAIG;AACH;IACE,0CAA0C;IAC1C,4BADc,MAAM,CAGnB;IAED,sFAAsF;IACtF,sBADc,OAAO,CAGpB;IAED,8FAA8F;IAC9F,oBADc,OAAO,oBAAoB,EAAE,qBAAqB,CAG/D;IAED;;;OAGG;IACH,wBAHW,OAAO,gBAAgB,EAAE,iBAAiB,GACxC,OAAO,CAAC,eAAe,CAAC,CA8DpC;IAED;;;OAGG;IACH,0BAHW,MAAM,GACJ,cAAc,CAc1B;CACF;4BA1G2B,gBAAgB;2BADjB,eAAe"}