@statewalker/webrun-http-browser 0.7.0 → 0.7.1

package/dist/index.js

@@ -178,8 +178,8 @@ const TYPE_CLOSE = 6;
 const DEFAULT_MAX_STREAMS = 256;
 const DEFAULT_MTU = 65536;
 const DEFAULT_MAX_STREAM_BUFFER = 8388608;
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
+const textEncoder = /* @__PURE__ */ new TextEncoder();
+const textDecoder = /* @__PURE__ */ new TextDecoder();
 function emulateMux(channel, opts = {}) {
 	const maxStreams = opts.maxStreams ?? DEFAULT_MAX_STREAMS;
 	const mtu = opts.mtu ?? DEFAULT_MTU;
@@ -716,7 +716,7 @@ async function* newAsyncGenerator(init, skipValues = false) {
 		drainQueue();
 	}
 }
-const utf8 = new TextEncoder();
+const utf8 = /* @__PURE__ */ new TextEncoder();
 /**
 * Coerce common byte-like inputs into a `Uint8Array`. Strings encode as UTF-8.
 * Blobs return a `Promise<Uint8Array>`; every other input returns synchronously.
@@ -1483,8 +1483,8 @@ var HttpParseError = class extends Error {
 const NEWLINE = 10;
 /** Mirrors the HTTP/1.1 codec's default `maxHeaderBytes`. */
 const MAX_ENVELOPE_BYTES = 65536;
-const encoder$1 = new TextEncoder();
-const decoder = new TextDecoder();
+const encoder$1 = /* @__PURE__ */ new TextEncoder();
+const decoder = /* @__PURE__ */ new TextDecoder();
 /**
 * Encode an HTTP envelope plus optional body as one continuous byte stream:
 *
@@ -1738,15 +1738,15 @@ function resolveFraming(headers, version) {
 	};
 	return { kind: "none" };
 }
-const CRLF = new Uint8Array([13, 10]);
-const LAST_CHUNK = new Uint8Array([
+const CRLF = /* @__PURE__ */ new Uint8Array([13, 10]);
+const LAST_CHUNK = /* @__PURE__ */ new Uint8Array([
 	48,
 	13,
 	10,
 	13,
 	10
 ]);
-const encoder = new TextEncoder();
+const encoder = /* @__PURE__ */ new TextEncoder();
 /**
 * Chunk sizes are written in HEXADECIMAL — a 21-byte chunk is `15`. Writing
 * them in decimal is the defect note 15 found in @libp2p/http, and it is the
@@ -2051,7 +2051,7 @@ function newHttpCodec(options = {}) {
 		decodeResponse: (input, o) => decodeResponse(input, opts, o.method)
 	};
 }
-const httpCodec = newHttpCodec();
+const httpCodec = /* @__PURE__ */ newHttpCodec();
 /**
 * Dispatches on byte 0. The formats are self-identifying — a JSON envelope
 * always begins `{`, which is not a token character and so can never begin an
@@ -2101,10 +2101,29 @@ function newSniffingCodec(options) {
 * Writes HTTP/1.1; accepts HTTP/1.1 or the legacy JSON envelope. Used whenever
 * no `codec` option is supplied.
 */
-const defaultCodec = newSniffingCodec({
+const defaultCodec = /* @__PURE__ */ newSniffingCodec({
 	write: httpCodec,
 	accept: [httpCodec, jsonEnvelopeCodec]
 });
+/**
+* Makes `target` disposable with `await using`: installs `dispose` as its
+* `[Symbol.asyncDispose]`, where the runtime defines the symbol. Hand-written
+* iterators lose what a native generator gets from `AsyncIteratorPrototype`;
+* this gives it back. A no-op where the symbol is missing. Kept off the
+* declared types, which would require consumers to compile with the
+* `esnext.disposable` lib.
+*/
+function asyncDisposable$2(target, dispose) {
+	const asyncDispose = Symbol.asyncDispose;
+	if (asyncDispose && !(asyncDispose in target)) Object.defineProperty(target, asyncDispose, {
+		value: async () => {
+			await dispose();
+		},
+		configurable: true,
+		writable: true
+	});
+	return target;
+}
 /** Carries the serialized JS error between two webrun peers. */
 const PEER_ERROR_HEADER = "x-webrun-error";
 /** Hard cap on the peer-error header (M3): see `encodeErrorResponse`. */
@@ -2182,41 +2201,105 @@ async function throwIfPeerError(result, output) {
 */
 async function httpFetch(call, env, body, options = {}) {
 	const codec = options.codec ?? defaultCodec;
+	const { signal } = options;
+	if (signal?.aborted) throw abortReason$1(signal);
 	const output = call(codec.encodeRequest(env, body));
-	const decoded = await codec.decodeResponse(output, { method: env.method });
-	const release = async () => {
-		try {
-			await output.return?.(void 0);
-		} catch {}
+	let released;
+	const release = () => {
+		released ??= (async () => {
+			try {
+				await output.return?.(void 0);
+			} catch {}
+		})();
+		return released;
+	};
+	let finished = false;
+	const finish = () => {
+		if (finished || released) return;
+		finished = true;
+		if (signal?.aborted) {
+			release();
+			return;
+		}
+		const onAbort = () => void release();
+		signal?.addEventListener("abort", onAbort, { once: true });
+		drain(output).finally(() => signal?.removeEventListener("abort", onAbort));
 	};
+	let decoded;
+	try {
+		decoded = await untilAborted(codec.decodeResponse(output, { method: env.method }), signal);
+	} catch (error) {
+		if (signal?.aborted) release();
+		else await release();
+		throw error;
+	}
 	const result = {
 		envelope: decoded.envelope,
-		body: releasingOnExit(decoded.body, release),
-		release
+		body: releasingOnExit(decoded.body, finish, release),
+		release,
+		finish
 	};
 	await throwIfPeerError(result, output);
 	return result;
 }
+/** `promise`, rejected with the signal's reason if it aborts first. */
+function untilAborted(promise, signal) {
+	if (!signal) return promise;
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(abortReason$1(signal));
+		if (signal.aborted) return onAbort();
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+/** The signal's reason as an `Error` (`AbortError` when it gave none). */
+function abortReason$1(signal) {
+	const reason = signal.reason;
+	if (reason instanceof Error) return reason;
+	const err = new Error(reason === void 0 ? "Aborted" : String(reason));
+	err.name = "AbortError";
+	return err;
+}
 /**
-* `body`, but leaving it before its end releases the call.
+* `body`, ending the call however it is left: read to its end, or left early.
 *
 * The body the codec hands back is a generator of its own over a `ByteReader`,
-* and `.return()` on it never reaches the call's `output` (see
-* `throwIfPeerError` for why the codec must not do that itself). So a caller
-* that stopped reading — an aborted `fetch`, a cancelled response stream —
-* left the peer's producer parked forever, holding its handler open. Safe here
-* for the same reason it is safe in `throwIfPeerError`: `output` is this
-* call's own response-only generator, and the request was fully sent.
-*/
-async function* releasingOnExit(body, release) {
+* and its ending never reaches the call's `output` (see `throwIfPeerError` for
+* why the codec must not do that itself). A caller that stopped reading — an
+* aborted `fetch`, a cancelled response stream — left the peer's producer
+* parked forever; and one that read the body to its end left the call itself
+* open, which on a multiplexed transport is one port per exchange until the
+* multiplexer refuses to open more (`maxPorts`).
+*
+* Left early, the call is abandoned (`.return()`): the peer's producer is
+* released. Read to its end, the call is not cut short but read to ITS end, in
+* the background: the peer ends it once its side of the exchange is over,
+* which may be later than the response — a handler that answered before it
+* read the request body is still receiving it (`HttpDataHandlerResult.settled`),
+* and abandoning the call would abort that upload.
+*/
+async function* releasingOnExit(body, finish, release) {
 	let completed = false;
 	try {
 		yield* body;
 		completed = true;
 	} finally {
-		if (!completed) await release();
+		if (completed) finish();
+		else await release();
 	}
 }
+/** Reads `output` to its end, discarding what is left, ignoring a failure. */
+async function drain(output) {
+	try {
+		for (let r = await output.next(); !r.done; r = await output.next());
+	} catch {}
+}
 /**
 * Wrap an HTTP handler as a `Duplex` so it can be registered with any
 * `webrun-streams-*` adapter's `serve`.
@@ -2244,6 +2327,7 @@ function httpServe(handler, options = {}) {
 		try {
 			yield* replyCodec.encodeResponse(result.envelope, result.body, { method: decoded.envelope.method });
 			completed = true;
+			await result.settled?.();
 		} finally {
 			if (!completed) try {
 				await result.release?.();
@@ -2500,14 +2584,18 @@ async function fetchOverDuplex(call, request, options = {}) {
 		const buffered = new Uint8Array(await request.arrayBuffer());
 		if (buffered.byteLength > 0) body = [buffered];
 	}
-	const { envelope, body: respBody, release } = await httpFetch(call, env, body, options);
+	const { envelope, body: respBody, release, finish } = await httpFetch(call, env, body, {
+		...options,
+		signal: request.signal ?? void 0
+	});
 	const responseInit = {
 		status: envelope.status,
 		statusText: envelope.statusText,
 		headers: forwardableHeaders(envelope.headers)
 	};
 	if (request.method === "HEAD" || request.method === "OPTIONS" || NULL_BODY_STATUSES.has(envelope.status)) {
-		await release?.();
+		if (finish) finish();
+		else await release?.();
 		return new Response(null, responseInit);
 	}
 	return new Response(asyncIterableToReadable(withAbort(respBody, request.signal)), responseInit);
@@ -2522,13 +2610,21 @@ function serveFetchOverDuplex(handler, options = {}) {
 			method: env.method,
 			headers: forwardableHeaders(env.headers)
 		};
+		let upload;
 		if (env.method !== "GET" && env.method !== "HEAD") {
 			if (supportsRequestStreams()) {
-				reqInit.body = asyncIterableToReadable(body);
+				upload = trackingEnd(body);
+				reqInit.body = asyncIterableToReadable(upload.source);
 				reqInit.duplex = "half";
 			} else reqInit.body = await collectBytes$1(body);
 		}
-		const response = await handler(new Request(env.url, reqInit));
+		const request = new Request(env.url, reqInit);
+		const response = await handler(request);
+		const settled = async () => {
+			if (!upload) return;
+			if (!request.bodyUsed && !request.body?.locked) request.body?.cancel().catch(() => {});
+			await upload.settle(options.requestIdleMs ?? 3e4);
+		};
 		const respEnv = {
 			status: response.status,
 			statusText: response.statusText,
@@ -2538,16 +2634,101 @@ function serveFetchOverDuplex(handler, options = {}) {
 			await response.body?.cancel();
 			return {
 				envelope: respEnv,
-				body: void 0
+				body: void 0,
+				settled
 			};
 		}
 		return {
 			envelope: respEnv,
 			body: response.body ? readableToAsyncIterable(response.body) : void 0,
-			release: () => response.body?.cancel()
+			release: () => response.body?.cancel(),
+			settled
 		};
 	}, options);
 }
+/**
+* `source`, and `settle(idleMs)`: resolves once it is done — read to its end,
+* failed, or abandoned (`return()` included before the first `next()`, which a
+* generator's `finally` would not see) — or once nobody has asked it for a
+* chunk for `idleMs`, in which case it is abandoned: later reads fail.
+*
+* Idle counts only while no `next()` is pending: a reader waiting for a slow
+* sender is still reading.
+*/
+function trackingEnd(source) {
+	let end = () => {};
+	let isEnded = false;
+	const ended = new Promise((resolve) => {
+		end = () => {
+			isEnded = true;
+			resolve();
+		};
+	});
+	let abandoned;
+	let pending = 0;
+	let idleSince = Date.now();
+	const it = source[Symbol.asyncIterator]();
+	const abandon = (reason) => {
+		abandoned ??= reason;
+		end();
+		Promise.resolve(it.return?.(void 0)).catch(() => {});
+	};
+	const tracked = {
+		[Symbol.asyncIterator]() {
+			return tracked;
+		},
+		async next() {
+			if (abandoned) throw abandoned;
+			pending++;
+			try {
+				const r = await it.next();
+				if (r.done) end();
+				return r;
+			} catch (error) {
+				end();
+				throw error;
+			} finally {
+				if (--pending === 0) idleSince = Date.now();
+			}
+		},
+		async return(value) {
+			end();
+			try {
+				await it.return?.(value);
+			} catch {}
+			return {
+				done: true,
+				value: void 0
+			};
+		}
+	};
+	asyncDisposable$2(tracked, () => tracked.return?.() ?? Promise.resolve());
+	const settle = (idleMs) => {
+		if (isEnded || !Number.isFinite(idleMs)) return ended;
+		return new Promise((resolve) => {
+			let timer;
+			const check = () => {
+				if (isEnded) return resolve();
+				const idle = pending === 0 ? Date.now() - idleSince : 0;
+				if (idle >= idleMs) {
+					abandon(/* @__PURE__ */ new Error(`webrun-http-streams: the request body was left unread for ${idleMs} ms after the response; abandoned`));
+					return resolve();
+				}
+				timer = setTimeout(check, Math.max(1, Math.min(idleMs - idle, 1e3)));
+				timer.unref?.();
+			};
+			ended.then(() => {
+				clearTimeout(timer);
+				resolve();
+			});
+			check();
+		});
+	};
+	return {
+		source: tracked,
+		settle
+	};
+}
 async function* withAbort(iter, signal) {
 	if (!signal) {
 		yield* iter;
@@ -2558,13 +2739,6 @@ async function* withAbort(iter, signal) {
 		yield chunk;
 	}
 }
-function abortReason$1(signal) {
-	const reason = signal.reason;
-	if (reason instanceof Error) return reason;
-	const err = new Error(reason === void 0 ? "Aborted" : String(reason));
-	err.name = "AbortError";
-	return err;
-}
 /**
 * Host a `SiteHandler` over a `Connect/Serve` pair. The `start(serve, params)`
 * call hands the handler to any `webrun-streams-*` adapter's `serve`.
@@ -2881,6 +3055,69 @@ async function* throughAbort(input, signal) {
 	}
 }
 /**
+* Makes `target` disposable with `await using`: installs `dispose` as its
+* `[Symbol.asyncDispose]`, where the runtime defines the symbol. Hand-written
+* iterators lose what a native generator gets from `AsyncIteratorPrototype`;
+* this gives it back. A no-op where the symbol is missing. Kept off the
+* declared types, which would require consumers to compile with the
+* `esnext.disposable` lib.
+*/
+function asyncDisposable$1(target, dispose) {
+	const asyncDispose = Symbol.asyncDispose;
+	if (asyncDispose && !(asyncDispose in target)) Object.defineProperty(target, asyncDispose, {
+		value: async () => {
+			await dispose();
+		},
+		configurable: true,
+		writable: true
+	});
+	return target;
+}
+/**
+* `gen`, except that `return()` and `throw()` take effect at once.
+*
+* On an async generator both are queued behind a `next()` that is still
+* pending: a consumer that gives up on a stream while it waits for the peer's
+* next chunk — an aborted fetch whose response head has not come, say — cannot
+* end it until that chunk arrives, which for a peer that never answers is
+* never. The stream's `finally` (which closes its port and tells the peer)
+* then never runs, and on a multiplexer the port is kept for good.
+*
+* So `abandon` runs first, synchronously: it must make the pending `next()`
+* settle (abort the stream), which then resolves done, after which the
+* generator's own `return()` / `throw()` proceeds as usual. On a generator
+* suspended at a `yield` it is the same ending, a step earlier. `abandon` runs once, whichever comes first.
+*/
+function returningAtOnce(gen, abandon) {
+	let abandoned = false;
+	const giveUp = (reason) => {
+		if (abandoned) return;
+		abandoned = true;
+		abandon(reason);
+	};
+	const wrapped = {
+		next: (...args) => gen.next(...args).catch((error) => {
+			if (abandoned) return {
+				done: true,
+				value: void 0
+			};
+			throw error;
+		}),
+		return(value) {
+			giveUp();
+			return gen.return(value);
+		},
+		throw(error) {
+			giveUp(error);
+			return gen.throw(error);
+		},
+		[Symbol.asyncIterator]() {
+			return wrapped;
+		}
+	};
+	return asyncDisposable$1(wrapped, () => wrapped.return(void 0));
+}
+/**
 * The `type` of the out-of-band notice a side posts when it abandons a stream.
 *
 * Layer 1's `close` is not observable to layer 2 — a closed virtual port drops
@@ -2976,7 +3213,7 @@ function runCallerSide(port, input, options) {
 	const inbound = receiveChunks(port, CHANNEL_OUT, controller, clock.touch);
 	const pump = sendChunks(port, CHANNEL_IN, input, options, controller.signal, clock.touch);
 	pump.catch(() => {});
-	return (async function* () {
+	return returningAtOnce((async function* () {
 		try {
 			yield* inbound.stream;
 		} finally {
@@ -2990,7 +3227,9 @@ function runCallerSide(port, input, options) {
 				await port.close?.();
 			} catch {}
 		}
-	})();
+	})(), () => {
+		if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("webrun-rpc: the caller abandoned the stream"));
+	});
 }
 /**
 * Listens for the peer's abort notice, and can post our own. The notice is a
@@ -3386,9 +3625,22 @@ const connect = async ({ mux: factory, timeout }) => {
 		maxMessageSize: mux.maxMessageSize,
 		timeout
 	};
-	const call = (input) => (async function* () {
-		yield* duplexOverPort(await mux.openPort(STREAM_META), streamOptions)(input);
-	})();
+	const call = (input) => {
+		let stream;
+		let abandoned = false;
+		return returningAtOnce((async function* () {
+			const port = await mux.openPort(STREAM_META);
+			if (abandoned) {
+				await port.close?.();
+				return;
+			}
+			stream = duplexOverPort(port, streamOptions)(input);
+			yield* stream;
+		})(), () => {
+			abandoned = true;
+			stream?.return(void 0).catch(() => {});
+		});
+	};
 	return {
 		call,
 		async close() {
@@ -3479,6 +3731,27 @@ const structuredCodec = {
 	}
 };
 //#endregion
+//#region src/link/async-dispose.ts
+/**
+* Makes `target` disposable with `await using`: installs `dispose` as its
+* `[Symbol.asyncDispose]`, where the runtime defines the symbol. Hand-written
+* iterators lose what a native generator gets from `AsyncIteratorPrototype`;
+* this gives it back. A no-op where the symbol is missing. Kept off the
+* declared types, which would require consumers to compile with the
+* `esnext.disposable` lib.
+*/
+function asyncDisposable(target, dispose) {
+	const asyncDispose = Symbol.asyncDispose;
+	if (asyncDispose && !(asyncDispose in target)) Object.defineProperty(target, asyncDispose, {
+		value: async () => {
+			await dispose();
+		},
+		configurable: true,
+		writable: true
+	});
+	return target;
+}
+//#endregion
 //#region src/link/http-link.ts
 /**
 * The version of the HTTP-over-`MessagePort` protocol this package speaks,
@@ -3508,11 +3781,12 @@ var LinkLostError = class extends Error {
 */
 const LINK_CLOSE = "webrun-http:link-close";
 /** Opens the calling end of a link on `port` (one port per link). */
-async function connectHttpLink(port, { streamTimeout } = {}) {
+async function connectHttpLink(port, { streamTimeout, maxPorts } = {}) {
 	const { call, close } = await connect({
 		mux: overPipe(port, {
 			codec: structuredCodec,
-			side: "initiator"
+			side: "initiator",
+			maxPorts
 		}),
 		timeout: streamTimeout
 	});
@@ -3528,14 +3802,15 @@ async function connectHttpLink(port, { streamTimeout } = {}) {
 * that abandons the requests still running (their handlers see the
 * cancellation) and releases the port.
 */
-async function serveHttpLink(port, handler, { streamTimeout } = {}) {
+async function serveHttpLink(port, handler, { streamTimeout, maxPorts, requestIdleMs } = {}) {
 	const teardown = await serve({
 		mux: overPipe(port, {
 			codec: structuredCodec,
-			side: "responder"
+			side: "responder",
+			maxPorts
 		}),
 		timeout: streamTimeout
-	}, serveFetchOverDuplex(async (request) => await handler(request)));
+	}, serveFetchOverDuplex(async (request) => await handler(request), { requestIdleMs }));
 	const onClose = (event) => {
 		if (event.data?.type === LINK_CLOSE) close();
 	};
@@ -3560,7 +3835,7 @@ function trackedLink(send, release) {
 		inflight--;
 		if (inflight === 0) for (const resolve of idleWaiters.splice(0)) resolve();
 	};
-	return {
+	const link = {
 		get inflight() {
 			return inflight;
 		},
@@ -3613,6 +3888,7 @@ function trackedLink(send, release) {
 			} catch {}
 		}
 	};
+	return asyncDisposable(link, () => link.close());
 }
 /**
 * A response body that reports its end (done, cancelled or failed) and fails

package/dist/link/async-dispose.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Makes `target` disposable with `await using`: installs `dispose` as its
+ * `[Symbol.asyncDispose]`, where the runtime defines the symbol. Hand-written
+ * iterators lose what a native generator gets from `AsyncIteratorPrototype`;
+ * this gives it back. A no-op where the symbol is missing. Kept off the
+ * declared types, which would require consumers to compile with the
+ * `esnext.disposable` lib.
+ */
+export declare function asyncDisposable<T extends object>(target: T, dispose: () => Promise<unknown>): T;
+//# sourceMappingURL=async-dispose.d.ts.map

package/dist/link/async-dispose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-dispose.d.ts","sourceRoot":"","sources":["../../src/link/async-dispose.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAa/F"}

package/dist/link/http-link.d.ts

@@ -15,6 +15,20 @@ export interface HttpLinkOptions {
      * none: a slow consumer is throttled, never failed.
      */
     streamTimeout?: number;
+    /**
+     * Ceiling on the requests in flight on the link at once: webrun-rpc's
+     * `maxPorts`, one multiplexed port per request (default 1024). A request
+     * past it fails on the calling end; one the answering end has no room for is
+     * refused. Every exchange gives its port back when it ends, however it ends.
+     */
+    maxPorts?: number;
+    /**
+     * The answering end only: once a response is out, how long the request body
+     * may go unread before it is abandoned and the exchange ends (default 30 s;
+     * webrun-http-streams' `requestIdleMs`). A handler that answers first and
+     * reads the upload afterwards keeps it as long as it keeps reading.
+     */
+    requestIdleMs?: number;
 }
 /** The calling end of a link: sends requests, gets responses. */
 export interface HttpLink {
@@ -43,13 +57,13 @@ export declare class LinkLostError extends Error {
     constructor(message?: string);
 }
 /** Opens the calling end of a link on `port` (one port per link). */
-export declare function connectHttpLink(port: MessagePort, { streamTimeout }?: HttpLinkOptions): Promise<HttpLink>;
+export declare function connectHttpLink(port: MessagePort, { streamTimeout, maxPorts }?: HttpLinkOptions): Promise<HttpLink>;
 /**
  * Serves `handler` on the answering end of a link. Resolves with a teardown
  * that abandons the requests still running (their handlers see the
  * cancellation) and releases the port.
  */
-export declare function serveHttpLink(port: MessagePort, handler: (request: Request) => Response | Promise<Response>, { streamTimeout }?: HttpLinkOptions): Promise<() => Promise<void>>;
+export declare function serveHttpLink(port: MessagePort, handler: (request: Request) => Response | Promise<Response>, { streamTimeout, maxPorts, requestIdleMs }?: HttpLinkOptions): Promise<() => Promise<void>>;
 /**
  * Wraps a `send` so the link knows its requests in flight (for draining and
  * load-based routing) and can fail them all at once when it is closed.

package/dist/link/http-link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-link.d.ts","sourceRoot":"","sources":["../../src/link/http-link.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AAEvD,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,iEAAiE;AACjE,MAAM,WAAW,QAAQ;IACvB,0EAA0E;IAC1E,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2CAA2C;IAC3C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B;;;OAGG;IACH,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,YAAY,OAAO,SAAuD,EAGzE;CACF;AASD,qEAAqE;AACrE,wBAAsB,eAAe,CACnC,IAAI,EAAE,WAAW,EACjB,EAAE,aAAa,EAAE,GAAE,eAAoB,GACtC,OAAO,CAAC,QAAQ,CAAC,CAcnB;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAC3D,EAAE,aAAa,EAAE,GAAE,eAAoB,GACtC,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAiB9B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAC7C,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GAClC,QAAQ,CAuEV"}
+{"version":3,"file":"http-link.d.ts","sourceRoot":"","sources":["../../src/link/http-link.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AAEvD,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,iEAAiE;AACjE,MAAM,WAAW,QAAQ;IACvB,0EAA0E;IAC1E,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2CAA2C;IAC3C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B;;;OAGG;IACH,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,YAAY,OAAO,SAAuD,EAGzE;CACF;AASD,qEAAqE;AACrE,wBAAsB,eAAe,CACnC,IAAI,EAAE,WAAW,EACjB,EAAE,aAAa,EAAE,QAAQ,EAAE,GAAE,eAAoB,GAChD,OAAO,CAAC,QAAQ,CAAC,CAcnB;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAC3D,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAAE,GAAE,eAAoB,GAC/D,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAiB9B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAC7C,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GAClC,QAAQ,CAwEV"}