snapreq 0.0.4 → 0.0.8

package/build/retry.js

@@ -0,0 +1,95 @@
+// @ts-check
+import { SnapReqHttpError, SnapReqTimeoutError } from "./errors.js";
+const RETRYABLE_ERROR_CODES = new Set(["ECONNREFUSED", "ECONNRESET", "EHOSTUNREACH", "ENOENT", "ETIMEDOUT", "EPIPE"]);
+const DEFAULT_RETRYABLE_STATUSES = [502, 503, 504];
+/**
+ * @typedef {object} RetryOptions
+ * @property {number} [tries] - Maximum number of attempts. Defaults to 3.
+ * @property {number} [waitMs] - Delay between attempts in milliseconds. Defaults to 500.
+ * @property {number[]} [retryableStatuses] - HTTP status codes that should be retried. Defaults to 502/503/504.
+ * @property {(error: unknown, attempt: number) => boolean} [shouldRetry] - Override the retryable-error classifier.
+ */
+/**
+ * @typedef {object} NormalizedRetryOptions
+ * @property {number} tries - Maximum number of attempts.
+ * @property {number} waitMs - Delay between attempts in milliseconds.
+ * @property {number[]} retryableStatuses - HTTP status codes that should be retried.
+ * @property {(error: unknown, attempt: number) => boolean} shouldRetry - Retryable-error classifier.
+ */
+/**
+ * The default network-error classifier. Exposed so callers can compose extra
+ * rules on top of it (for example matching server-specific 500 messages).
+ * @param {unknown} error - Error thrown by a transport.
+ * @returns {boolean} - Whether the error is a transient network failure.
+ */
+export function defaultRetryableError(error) {
+    if (error instanceof SnapReqTimeoutError)
+        return true;
+    if (!error || typeof error !== "object")
+        return false;
+    if ("code" in error && typeof error.code === "string" && RETRYABLE_ERROR_CODES.has(error.code)) {
+        return true;
+    }
+    return error instanceof Error && error.message === "socket hang up";
+}
+/**
+ * Normalizes the `retry` option into a complete set of retry settings, or
+ * `null` when retries are disabled.
+ * @param {boolean | RetryOptions | undefined} retry - Retry configuration.
+ * @returns {NormalizedRetryOptions | null} - Normalized retry settings.
+ */
+export function normalizeRetryOptions(retry) {
+    if (!retry)
+        return null;
+    const options = retry === true ? {} : retry;
+    const retryableStatuses = options.retryableStatuses ?? DEFAULT_RETRYABLE_STATUSES;
+    const shouldRetry = options.shouldRetry ?? ((/** @type {unknown} */ error) => defaultRetryableError(error));
+    return {
+        tries: options.tries ?? 3,
+        waitMs: options.waitMs ?? 500,
+        retryableStatuses,
+        shouldRetry
+    };
+}
+/**
+ * @param {number} waitMs - Delay in milliseconds.
+ * @returns {Promise<void>} - Resolves after the delay.
+ */
+function wait(waitMs) {
+    return new Promise((resolve) => setTimeout(resolve, waitMs));
+}
+/**
+ * Runs a request attempt, retrying transient network errors and retryable HTTP
+ * statuses. Retries are only used for buffered requests — the caller must not
+ * apply this to streamed responses.
+ * @param {() => Promise<import("./response.js").default>} attempt - Performs one request attempt.
+ * @param {NormalizedRetryOptions} retry - Normalized retry settings.
+ * @returns {Promise<import("./response.js").default>} - The successful (or final) response.
+ */
+export async function runWithRetry(attempt, retry) {
+    for (let tryNumber = 1; tryNumber <= retry.tries; tryNumber += 1) {
+        /** @type {import("./response.js").default} */
+        let response;
+        try {
+            response = await attempt();
+        }
+        catch (error) {
+            if (tryNumber >= retry.tries || !retry.shouldRetry(error, tryNumber))
+                throw error;
+            await wait(retry.waitMs);
+            continue;
+        }
+        if (tryNumber < retry.tries && retry.retryableStatuses.includes(response.status)) {
+            await wait(retry.waitMs);
+            continue;
+        }
+        return response;
+    }
+    throw new SnapReqHttpError({
+        message: "Retry loop exited without a response.",
+        method: "",
+        url: "",
+        status: 0
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{types → build}/snap-req.d.ts

@@ -301,3 +301,4 @@ export type RequestTimeout = {
 };
 import { SnapReqHttpError } from "./errors.js";
 import SnapReqHeaders from "./headers.js";
+//# sourceMappingURL=snap-req.d.ts.map

package/build/snap-req.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snap-req.d.ts","sourceRoot":"","sources":["../src/snap-req.js"],"names":[],"mappings":"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"}

package/build/snap-req.js

@@ -0,0 +1,349 @@
+// @ts-check
+import { SnapReqHttpError, SnapReqTimeoutError, SnapReqUnsupportedFeatureError } from "./errors.js";
+import SnapReqHeaders from "./headers.js";
+import { buildUrl, normalizeBody } from "./request.js";
+import { normalizeRetryOptions, runWithRetry } from "./retry.js";
+import { selectTransport } from "./transports/select.js";
+/**
+ * @typedef {import("./request.js").CompressionEncoding} CompressionEncoding
+ */
+/**
+ * @typedef {object} NormalizedRequest
+ * @property {string} method - Upper-cased HTTP method.
+ * @property {string} url - Fully resolved request URL.
+ * @property {SnapReqHeaders} headers - Request headers.
+ * @property {import("./request.js").NormalizedBody} body - Normalized request body.
+ * @property {CompressionEncoding} bodyCompression - Request body compression.
+ * @property {AbortSignal} [signal] - Abort signal.
+ * @property {number} [timeoutMs] - Request timeout in milliseconds.
+ * @property {string} [credentials] - Fetch credentials mode ("omit" | "same-origin" | "include").
+ */
+/**
+ * @typedef {object} RequestOptions
+ * @property {string} [method] - HTTP method. Defaults to GET.
+ * @property {string} [path] - Request path (joined with the client `baseUrl`) or absolute URL.
+ * @property {string} [url] - Alias for `path`.
+ * @property {Record<string, string | number | boolean | null | undefined>} [query] - Query parameters.
+ * @property {Record<string, string | number> | SnapReqHeaders} [headers] - Per-request headers.
+ * @property {any} [body] - Request body: string, object (JSON), Uint8Array/ArrayBuffer, or a stream/async-iterable.
+ * @property {CompressionEncoding} [bodyCompression] - Compress the request body (Node transport only).
+ * @property {AbortSignal} [signal] - Abort signal for the request.
+ * @property {number} [timeoutMs] - Request timeout in milliseconds. Set to `0` to disable a client default.
+ * @property {string} [credentials] - Fetch credentials mode.
+ * @property {boolean | import("./retry.js").RetryOptions} [retry] - Retry transient failures.
+ * @property {boolean} [throwOnError] - Throw `SnapReqHttpError` on non-2xx responses.
+ */
+/**
+ * @typedef {object} RequestTimeout
+ * @property {AbortSignal | undefined} signal - Signal to use for the request.
+ * @property {() => void} clear - Clears timeout resources.
+ * @property {(response: import("./response.js").default, request: NormalizedRequest) => import("./response.js").default} response - Attaches timeout handling to a response.
+ * @property {(error: unknown, request: NormalizedRequest) => unknown} error - Maps a thrown error.
+ */
+/**
+ * A cross-platform HTTP client with one API across Node, web, Expo and React
+ * Native. The right transport is chosen at runtime; features a platform cannot
+ * provide raise `SnapReqUnsupportedFeatureError` rather than silently changing
+ * behaviour.
+ */
+export default class SnapReq {
+    /**
+     * @param {object} [config] - Client configuration.
+     * @param {string} [config.baseUrl] - Origin (and optional base path) prepended to relative paths.
+     * @param {string} [config.socketPath] - Unix domain socket path (Node transport only).
+     * @param {{ca?: string | Buffer, cert?: string | Buffer, key?: string | Buffer, rejectUnauthorized?: boolean}} [config.tls] - TLS material (Node transport only).
+     * @param {boolean} [config.keepAlive] - Reuse connections across requests (Node transport only). Defaults to true.
+     * @param {Record<string, string | number> | (() => Record<string, string | number>)} [config.headers] - Default headers (object or factory).
+     * @param {boolean | import("./retry.js").RetryOptions} [config.retry] - Default retry policy.
+     * @param {boolean} [config.throwOnError] - Throw `SnapReqHttpError` on non-2xx responses by default. Defaults to false.
+     * @param {number} [config.timeoutMs] - Default request timeout in milliseconds. Set per-request `timeoutMs: 0` to disable.
+     * @param {string} [config.credentials] - Default fetch credentials mode.
+     * @param {import("./transports/select.js").TransportName | import("./transports/select.js").Transport} [config.transport] - Transport preference or instance. Defaults to "auto".
+     */
+    constructor({ baseUrl, socketPath, tls, keepAlive = true, headers, retry, throwOnError = false, timeoutMs, credentials, transport = "auto" } = {}) {
+        this.baseUrl = baseUrl;
+        this.defaultHeaders = headers;
+        this.defaultRetry = retry;
+        this.throwOnError = throwOnError;
+        this.timeoutMs = timeoutMs;
+        this.credentials = credentials;
+        this._transportPreference = transport;
+        this._nodeConfig = { socketPath, tls, keepAlive };
+        /** @type {Promise<import("./transports/select.js").Transport> | null} */
+        this._transportPromise = null;
+        /** @type {import("./transports/select.js").Transport | null} */
+        this._transport = null;
+    }
+    /** @returns {Promise<import("./transports/select.js").Transport>} - The resolved transport. */
+    async _resolveTransport() {
+        this._transportPromise || (this._transportPromise = selectTransport(this._transportPreference, this._nodeConfig));
+        this._transport = await this._transportPromise;
+        return this._transport;
+    }
+    /** @returns {Promise<import("./capabilities.js").TransportCapabilities>} - The active transport's capabilities. */
+    async capabilities() {
+        return (await this._resolveTransport()).capabilities;
+    }
+    /** @returns {Promise<string>} - The active transport's name. */
+    async transportName() {
+        const transport = await this._resolveTransport();
+        return /** @type {any} */ (transport.constructor)?.transportName || "custom";
+    }
+    /**
+     * @param {RequestOptions} options - Request options.
+     * @returns {NormalizedRequest} - The normalized request.
+     */
+    _normalize(options) {
+        const headers = new SnapReqHeaders();
+        const defaults = typeof this.defaultHeaders === "function" ? this.defaultHeaders() : this.defaultHeaders;
+        if (defaults)
+            for (const [name, value] of new SnapReqHeaders(defaults).entries())
+                headers.set(name, value);
+        if (options.headers)
+            for (const [name, value] of new SnapReqHeaders(options.headers).entries())
+                headers.set(name, value);
+        const url = buildUrl(this.baseUrl, options.path ?? options.url ?? "", options.query);
+        const body = normalizeBody(options.body, headers);
+        return {
+            method: (options.method || "GET").toUpperCase(),
+            url,
+            headers,
+            body,
+            bodyCompression: options.bodyCompression || "identity",
+            signal: options.signal,
+            timeoutMs: options.timeoutMs ?? this.timeoutMs,
+            credentials: options.credentials ?? this.credentials
+        };
+    }
+    /**
+     * @param {RequestOptions} options - Request options.
+     * @returns {RequestTimeout} - Timeout handling for one request attempt.
+     */
+    _requestTimeout(options) {
+        const timeoutMs = options.timeoutMs ?? this.timeoutMs;
+        if (!timeoutMs || timeoutMs <= 0) {
+            return {
+                signal: options.signal,
+                clear: () => { },
+                response: (response) => response,
+                error: (error) => error
+            };
+        }
+        const timeoutController = new AbortController();
+        const composedSignal = this._composeSignal(options.signal, timeoutController.signal);
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            timeoutController.abort();
+        }, timeoutMs);
+        if (typeof timer.unref === "function")
+            timer.unref();
+        const clear = () => {
+            clearTimeout(timer);
+            composedSignal.clear();
+        };
+        const toError = (error, request) => {
+            if (timedOut) {
+                return new SnapReqTimeoutError({
+                    method: request.method,
+                    url: request.url,
+                    timeoutMs
+                });
+            }
+            return error;
+        };
+        return {
+            signal: composedSignal.signal,
+            clear,
+            response: (response, request) => {
+                if (response._bodyDone) {
+                    clear();
+                    return response;
+                }
+                response._onBodyDone = this._chainBodyDone(response._onBodyDone, clear);
+                response._mapBodyError = this._chainBodyError(response._mapBodyError, (error) => toError(error, request));
+                return response;
+            },
+            error: toError
+        };
+    }
+    /**
+     * @param {AbortSignal | undefined} callerSignal - Caller-supplied signal.
+     * @param {AbortSignal} timeoutSignal - Timeout signal.
+     * @returns {{signal: AbortSignal, clear: () => void}} - Signal that aborts when either source aborts.
+     */
+    _composeSignal(callerSignal, timeoutSignal) {
+        if (!callerSignal)
+            return { signal: timeoutSignal, clear: () => { } };
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        if (callerSignal.aborted || timeoutSignal.aborted) {
+            controller.abort();
+        }
+        else {
+            callerSignal.addEventListener("abort", abort, { once: true });
+            timeoutSignal.addEventListener("abort", abort, { once: true });
+        }
+        return {
+            signal: controller.signal,
+            clear: () => {
+                callerSignal.removeEventListener("abort", abort);
+                timeoutSignal.removeEventListener("abort", abort);
+            }
+        };
+    }
+    /**
+     * @param {(() => void) | undefined} existing - Existing body-done callback.
+     * @param {() => void} next - Callback to add.
+     * @returns {() => void} - Combined callback.
+     */
+    _chainBodyDone(existing, next) {
+        return () => {
+            if (existing)
+                existing();
+            next();
+        };
+    }
+    /**
+     * @param {((error: unknown) => unknown) | undefined} existing - Existing error mapper.
+     * @param {(error: unknown) => unknown} next - Mapper to add.
+     * @returns {(error: unknown) => unknown} - Combined mapper.
+     */
+    _chainBodyError(existing, next) {
+        return (error) => next(existing ? existing(error) : error);
+    }
+    /**
+     * Performs a request and buffers nothing eagerly — read the body via the
+     * returned response (`json()`, `text()`, `bytes()`). Retries transient
+     * failures when a retry policy is configured (never for streamed bodies).
+     * @param {RequestOptions} options - Request options.
+     * @returns {Promise<import("./response.js").default>} - The response.
+     */
+    async request(options) {
+        const transport = await this._resolveTransport();
+        const throwOnError = options.throwOnError ?? this.throwOnError;
+        const retry = normalizeRetryOptions(options.retry ?? this.defaultRetry);
+        const body = normalizeBody(options.body, new SnapReqHeaders(options.headers));
+        const canRetry = retry && body.kind !== "stream";
+        const attempt = async () => this._requestWithTimeout(options, (request) => transport.performRequest(request));
+        const response = canRetry ? await runWithRetry(attempt, /** @type {any} */ (retry)) : await attempt();
+        if (throwOnError && !response.ok)
+            throw await this._httpError(response, this._normalize(options));
+        return response;
+    }
+    /**
+     * Performs a request and returns the response with its body available as a
+     * stream (`response.stream()`). Requires a transport that supports response
+     * streaming; never retries.
+     * @param {RequestOptions} options - Request options.
+     * @returns {Promise<import("./response.js").default>} - The streaming response.
+     */
+    async requestStream(options) {
+        const transport = await this._resolveTransport();
+        if (!transport.capabilities.responseStreaming) {
+            throw new SnapReqUnsupportedFeatureError({
+                feature: "response streaming",
+                transport: /** @type {any} */ (transport.constructor)?.transportName || "custom"
+            });
+        }
+        const response = await this._requestWithTimeout(options, (request) => transport.performRequest(request));
+        if ((options.throwOnError ?? this.throwOnError) && !response.ok) {
+            throw await this._httpError(response, this._normalize(options));
+        }
+        return response;
+    }
+    /**
+     * @param {RequestOptions} options - Request options.
+     * @param {(request: NormalizedRequest) => Promise<import("./response.js").default>} performRequest - Transport request runner.
+     * @returns {Promise<import("./response.js").default>} - Response with timeout handling attached.
+     */
+    async _requestWithTimeout(options, performRequest) {
+        const timeout = this._requestTimeout(options);
+        const normalized = this._normalize({ ...options, signal: timeout.signal });
+        try {
+            const response = await performRequest(normalized);
+            return timeout.response(response, normalized);
+        }
+        catch (error) {
+            timeout.clear();
+            throw timeout.error(error, normalized);
+        }
+    }
+    /**
+     * @param {string} path - Request path or absolute URL.
+     * @param {RequestOptions} [options] - Request options.
+     * @returns {Promise<import("./response.js").default>} - The response.
+     */
+    get(path, options = {}) {
+        return this.request({ ...options, method: "GET", path });
+    }
+    /**
+     * @param {string} path - Request path or absolute URL.
+     * @param {any} [body] - Request body.
+     * @param {RequestOptions} [options] - Request options.
+     * @returns {Promise<import("./response.js").default>} - The response.
+     */
+    post(path, body, options = {}) {
+        return this.request({ ...options, method: "POST", path, body });
+    }
+    /**
+     * @param {string} path - Request path or absolute URL.
+     * @param {any} [body] - Request body.
+     * @param {RequestOptions} [options] - Request options.
+     * @returns {Promise<import("./response.js").default>} - The response.
+     */
+    put(path, body, options = {}) {
+        return this.request({ ...options, method: "PUT", path, body });
+    }
+    /**
+     * @param {string} path - Request path or absolute URL.
+     * @param {any} [body] - Request body.
+     * @param {RequestOptions} [options] - Request options.
+     * @returns {Promise<import("./response.js").default>} - The response.
+     */
+    patch(path, body, options = {}) {
+        return this.request({ ...options, method: "PATCH", path, body });
+    }
+    /**
+     * @param {string} path - Request path or absolute URL.
+     * @param {RequestOptions} [options] - Request options.
+     * @returns {Promise<import("./response.js").default>} - The response.
+     */
+    delete(path, options = {}) {
+        return this.request({ ...options, method: "DELETE", path });
+    }
+    /**
+     * @param {import("./response.js").default} response - The failed response.
+     * @param {NormalizedRequest} request - The request that produced it.
+     * @returns {Promise<SnapReqHttpError>} - An error describing the failure.
+     */
+    async _httpError(response, request) {
+        let responseText = "";
+        try {
+            responseText = await response.text();
+        }
+        catch (error) {
+            if (error instanceof SnapReqTimeoutError)
+                throw error;
+            // Body unavailable (already streamed or read error) — fall back to status text.
+        }
+        const detail = responseText || response.statusText || "";
+        return new SnapReqHttpError({
+            message: `HTTP ${response.status} ${request.method} ${request.url}${detail ? `: ${detail}` : ""}`,
+            method: request.method,
+            url: request.url,
+            status: response.status,
+            statusText: response.statusText,
+            responseText,
+            response
+        });
+    }
+    /**
+     * Releases transport resources (for example Node keep-alive sockets).
+     * @returns {void}
+     */
+    close() {
+        this._transport?.close?.();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snap-req.js","sourceRoot":"","sources":["../src/snap-req.js"],"names":[],"mappings":"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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-transport.d.ts","sourceRoot":"","sources":["../../src/transports/fetch-transport.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH;IACE,0CAA0C;IAC1C,4BADc,MAAM,CAGnB;IAED,sFAAsF;IACtF,sBADc,OAAO,CAGpB;IAED,8FAA8F;IAC9F,oBADc,OAAO,oBAAoB,EAAE,qBAAqB,CAM/D;IAED;;;OAGG;IACH,wBAHW,OAAO,gBAAgB,EAAE,iBAAiB,GACxC,OAAO,CAAC,eAAe,CAAC,CA6CpC;IAED;;;OAGG;IACH,2BAHW,QAAQ,GACN,cAAc,CAQ1B;IAED;;;;;;OAMG;IACH,0BAHW,QAAQ,GACN,aAAa,CAAC,UAAU,CAAC,CA2BrC;CACF;4BA1H2B,gBAAgB;2BADjB,eAAe"}

package/build/transports/fetch-transport.js

@@ -0,0 +1,116 @@
+// @ts-check
+import { buildCapabilities } from "../capabilities.js";
+import { SnapReqAbortError, SnapReqUnsupportedFeatureError } from "../errors.js";
+import SnapReqHeaders from "../headers.js";
+import SnapReqResponse from "../response.js";
+/**
+ * Transport backed by the `fetch` global. Works on web, Expo / React Native and
+ * Node 18+. It cannot open Unix sockets, present client certificates or
+ * compress request bodies — those raise `SnapReqUnsupportedFeatureError`.
+ * Response streaming uses `response.body` where available and otherwise buffers
+ * the body once, keeping the same stream interface everywhere.
+ */
+export default class FetchTransport {
+    /** @returns {string} - Transport name. */
+    static get transportName() {
+        return "fetch";
+    }
+    /** @returns {boolean} - Whether this transport can run in the current environment. */
+    static isAvailable() {
+        return typeof fetch === "function";
+    }
+    /** @returns {import("../capabilities.js").TransportCapabilities} - Supported capabilities. */
+    get capabilities() {
+        return buildCapabilities({
+            responseStreaming: true,
+            abort: true
+        });
+    }
+    /**
+     * @param {import("../snap-req.js").NormalizedRequest} request - Normalized request.
+     * @returns {Promise<SnapReqResponse>} - The response.
+     */
+    async performRequest(request) {
+        if (request.bodyCompression && request.bodyCompression !== "identity") {
+            throw new SnapReqUnsupportedFeatureError({ feature: "request body compression", transport: "fetch" });
+        }
+        /** @type {Record<string, any>} */
+        const init = {
+            method: request.method,
+            headers: request.headers.toObject()
+        };
+        if (request.signal)
+            init.signal = request.signal;
+        if (request.credentials)
+            init.credentials = request.credentials;
+        const body = request.body;
+        if (body.kind === "text") {
+            init.body = body.value;
+        }
+        else if (body.kind === "bytes") {
+            init.body = body.value;
+        }
+        else if (body.kind === "stream") {
+            throw new SnapReqUnsupportedFeatureError({ feature: "streamed request bodies", transport: "fetch" });
+        }
+        /** @type {Response} */
+        let fetchResponse;
+        try {
+            fetchResponse = await fetch(request.url, init);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError")
+                throw new SnapReqAbortError();
+            throw error;
+        }
+        return new SnapReqResponse({
+            url: request.url,
+            method: request.method,
+            status: fetchResponse.status,
+            statusText: fetchResponse.statusText,
+            headers: this._responseHeaders(fetchResponse),
+            stream: this._responseStream(fetchResponse)
+        });
+    }
+    /**
+     * @param {Response} response - The fetch response.
+     * @returns {SnapReqHeaders} - The response headers.
+     */
+    _responseHeaders(response) {
+        const headers = new SnapReqHeaders();
+        response.headers.forEach((value, name) => headers.set(name, value));
+        return headers;
+    }
+    /**
+     * Builds an async iterable of byte chunks over a fetch response. Uses the
+     * `ReadableStream` body for true streaming when present and otherwise buffers
+     * the whole body once so the stream interface stays identical everywhere.
+     * @param {Response} response - The fetch response.
+     * @returns {AsyncIterable<Uint8Array>} - The response body stream.
+     */
+    _responseStream(response) {
+        const body = response.body;
+        if (body && typeof body.getReader === "function") {
+            return (async function* () {
+                const reader = body.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        if (value)
+                            yield value instanceof Uint8Array ? value : new Uint8Array(value);
+                    }
+                }
+                finally {
+                    reader.releaseLock?.();
+                }
+            })();
+        }
+        return (async function* () {
+            const buffer = await response.arrayBuffer();
+            yield new Uint8Array(buffer);
+        })();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/transports/fetch.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./fetch-transport.js";
+//# sourceMappingURL=fetch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/transports/fetch.js"],"names":[],"mappings":""}

package/build/transports/fetch.js

@@ -0,0 +1,3 @@
+// @ts-check
+export { default } from "./fetch-transport.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmV0Y2guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJhbnNwb3J0cy9mZXRjaC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVosT0FBTyxFQUFDLE9BQU8sRUFBQyxNQUFNLHNCQUFzQixDQUFBIn0=

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"node-transport.d.ts","sourceRoot":"","sources":["../../src/transports/node-transport.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH;IACE,0CAA0C;IAC1C,4BADc,MAAM,CAGnB;IAED,sFAAsF;IACtF,sBADc,OAAO,CAGpB;IAED;;;;;OAKG;IACH,6CAJG;QAAwB,UAAU,GAA1B,MAAM;QACuG,GAAG,GAAhH;YAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;YAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;YAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;SAAC;QAClF,SAAS,GAA1B,OAAO;KACjB,EAWA;IATC,mBAA4B;IAC5B;aALe,MAAM,GAAG,MAAM;eAAS,MAAM,GAAG,MAAM;cAAQ,MAAM,GAAG,MAAM;6BAAuB,OAAO;MAK7F;IACd,mBAA0B;IAC1B,qEAAqE;IACrE,UADW;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,MAAM,EAAE,GAAG,CAAA;KAAC,GAAG,IAAI,CAC7C;IACpB,kBAAkB;IAClB,YADW,GAAG,CACQ;IACtB,kBAAkB;IAClB,aADW,GAAG,CACS;IAGzB,8FAA8F;IAC9F,oBADc,OAAO,oBAAoB,EAAE,qBAAqB,CAW/D;IAED,wGAAwG;IACxG,SADc,OAAO,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,MAAM,EAAE,GAAG,CAAA;KAAC,CAAC,CAcrE;IAED;;;OAGG;IACH,eAHW,OAAO,GACL,GAAG,CAoBf;IAED;;;;;OAKG;IACH,wBAHW,OAAO,gBAAgB,EAAE,iBAAiB,GACxC,OAAO,CAAC,eAAe,CAAC,CA2FpC;IAED;;;;;OAKG;IACH,6BALW,OAAO,gBAAgB,EAAE,iBAAiB,WAC1C,cAAc,oBACd;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,MAAM,EAAE,GAAG,CAAA;KAAC,GACtB;QAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,OAAO,aAAa,EAAE,QAAQ,GAAG,IAAI,CAAA;KAAC,CA8ClF;IAED;;;;OAIG;IACH,6BAJW,MAAM,QACN,GAAG,GACD,OAAO,aAAa,EAAE,SAAS,CAS3C;IAED;;;;OAIG;IACH,gCAJW,OAAO,WAAW,EAAE,eAAe,QACnC,GAAG,GACD,OAAO,aAAa,EAAE,QAAQ,CAkB1C;IAED;;;;OAIG;IACH,2BAJW,MAAM,QACN,GAAG,GACD,OAAO,aAAa,EAAE,SAAS,CAS3C;IAED;;;OAGG;IACH,2BAHW,OAAO,WAAW,EAAE,eAAe,GACjC,cAAc,CAY1B;IAED;;;OAGG;IACH,SAFa,IAAI,CAOhB;CACF;4BA7T2B,gBAAgB;2BADjB,eAAe"}