elysia 1.4.28 → 2.0.0-beta.0

package/dist/adapter/utils.js

@@ -1,320 +1,570 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: !0 });
-}, __copyProps = (to, from, except, desc) => {
-  if (from && typeof from == "object" || typeof from == "function")
-    for (let key of __getOwnPropNames(from))
-      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  createResponseHandler: () => createResponseHandler,
-  createStreamHandler: () => createStreamHandler,
-  handleFile: () => handleFile,
-  handleSet: () => handleSet,
-  mergeHeaders: () => mergeHeaders,
-  mergeStatus: () => mergeStatus,
-  parseSetCookies: () => parseSetCookies,
-  responseToSetHeaders: () => responseToSetHeaders,
-  streamResponse: () => streamResponse,
-  tee: () => tee
-});
-module.exports = __toCommonJS(utils_exports);
-var import_cookies = require('../cookies.js'), import_utils = require('../utils.js'), import_utils2 = require('../universal/utils.js');
-const handleFile = (response, set, request) => {
-  if (!import_utils2.isBun && response instanceof Promise)
-    return response.then((res) => handleFile(res, set, request));
-  const size = response.size, rangeHeader = request?.headers.get("range");
-  if (rangeHeader) {
-    const match = /bytes=(\d*)-(\d*)/.exec(rangeHeader);
-    if (match) {
-      if (!match[1] && !match[2])
-        return new Response(null, {
-          status: 416,
-          headers: mergeHeaders(
-            new Headers({ "content-range": `bytes */${size}` }),
-            set?.headers ?? {}
-          )
-        });
-      let start, end;
-      if (!match[1] && match[2]) {
-        const suffix = parseInt(match[2]);
-        start = Math.max(0, size - suffix), end = size - 1;
-      } else
-        start = match[1] ? parseInt(match[1]) : 0, end = match[2] ? Math.min(parseInt(match[2]), size - 1) : size - 1;
-      if (start >= size || start > end)
-        return new Response(null, {
-          status: 416,
-          headers: mergeHeaders(
-            new Headers({ "content-range": `bytes */${size}` }),
-            set?.headers ?? {}
-          )
-        });
-      const contentLength = end - start + 1, rangeHeaders = new Headers({
-        "accept-ranges": "bytes",
-        "content-range": `bytes ${start}-${end}/${size}`,
-        "content-length": String(contentLength)
-      });
-      return new Response(
-        response.slice(start, end + 1, response.type),
-        {
-          status: 206,
-          headers: mergeHeaders(rangeHeaders, set?.headers ?? {})
-        }
-      );
-    }
-  }
-  const immutable = set && (set.status === 206 || set.status === 304 || set.status === 412 || set.status === 416), defaultHeader = immutable ? {} : {
-    "accept-ranges": "bytes",
-    "content-range": size ? `bytes 0-${size - 1}/${size}` : void 0
-  };
-  if (!set && !size) return new Response(response);
-  if (!set)
-    return new Response(response, {
-      headers: defaultHeader
-    });
-  if (set.headers instanceof Headers) {
-    for (const key of Object.keys(defaultHeader))
-      key in set.headers && set.headers.append(key, defaultHeader[key]);
-    return immutable && (set.headers.delete("content-length"), set.headers.delete("accept-ranges")), new Response(response, set);
-  }
-  return (0, import_utils.isNotEmpty)(set.headers) ? new Response(response, {
-    status: set.status,
-    headers: Object.assign(defaultHeader, set.headers)
-  }) : new Response(response, {
-    status: set.status,
-    headers: defaultHeader
-  });
-}, parseSetCookies = (headers, setCookie) => {
-  if (!headers) return headers;
-  headers.delete("set-cookie");
-  for (let i = 0; i < setCookie.length; i++) {
-    const index = setCookie[i].indexOf("=");
-    headers.append(
-      "set-cookie",
-      `${setCookie[i].slice(0, index)}=${setCookie[i].slice(index + 1) || ""}`
-    );
-  }
-  return headers;
-}, responseToSetHeaders = (response, set) => {
-  if (set?.headers) {
-    if (response)
-      if (import_utils.hasHeaderShorthand)
-        Object.assign(set.headers, response.headers.toJSON());
-      else
-        for (const [key, value] of response.headers.entries())
-          key in set.headers && (set.headers[key] = value);
-    return set.status === 200 && (set.status = response.status), set.headers["content-encoding"] && delete set.headers["content-encoding"], set;
-  }
-  if (!response)
-    return {
-      headers: {},
-      status: set?.status ?? 200
-    };
-  if (import_utils.hasHeaderShorthand)
-    return set = {
-      headers: response.headers.toJSON(),
-      status: set?.status ?? 200
-    }, set.headers["content-encoding"] && delete set.headers["content-encoding"], set;
-  set = {
-    headers: {},
-    status: set?.status ?? 200
-  };
-  for (const [key, value] of response.headers.entries())
-    key !== "content-encoding" && key in set.headers && (set.headers[key] = value);
-  return set;
-}, enqueueBinaryChunk = (controller, chunk) => chunk instanceof Blob ? chunk.arrayBuffer().then((buffer) => (controller.enqueue(new Uint8Array(buffer)), !0)) : chunk instanceof Uint8Array ? (controller.enqueue(chunk), !0) : chunk instanceof ArrayBuffer ? (controller.enqueue(new Uint8Array(chunk)), !0) : ArrayBuffer.isView(chunk) ? (controller.enqueue(
-  new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength)
-), !0) : !1, createStreamHandler = ({ mapResponse, mapCompactResponse }) => async (generator, set, request, skipFormat) => {
-  let init = generator.next?.();
-  if (set && handleSet(set), init instanceof Promise && (init = await init), init?.value instanceof ReadableStream)
-    generator = init.value;
-  else if (init && (typeof init?.done > "u" || init?.done))
-    return set ? mapResponse(init.value, set, request) : mapCompactResponse(init.value, request);
-  const isSSE = !skipFormat && // @ts-ignore First SSE result is wrapped with sse()
-  (init?.value?.sse ?? // @ts-ignore ReadableStream is wrapped with sse()
-  generator?.sse ?? // User explicitly set content-type to SSE
-  set?.headers["content-type"]?.startsWith("text/event-stream")), format = isSSE ? (data) => `data: ${data}
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_universal_constants = require('../universal/constants.js');
+const require_constants = require('../constants.js');
+const require_utils = require('../utils.js');
+const require_adapter_skip_clone = require('./skip-clone.js');
+const require_cookie_serialize = require('../cookie/serialize.js');
+const require_adapter_response_ownership = require('./response-ownership.js');
+const require_adapter_default_headers = require('./default-headers.js');
 
-` : (data) => data, contentType = isSSE ? "text/event-stream" : init?.value && typeof init?.value == "object" ? "application/json" : "text/plain";
-  set?.headers ? (set.headers["transfer-encoding"] || (set.headers["transfer-encoding"] = "chunked"), set.headers["content-type"] || (set.headers["content-type"] = contentType), set.headers["cache-control"] || (set.headers["cache-control"] = "no-cache")) : set = {
-    status: 200,
-    headers: {
-      "content-type": contentType,
-      "transfer-encoding": "chunked",
-      "cache-control": "no-cache",
-      connection: "keep-alive"
-    }
-  };
-  const iterator = typeof generator.next == "function" ? generator : generator[Symbol.asyncIterator]();
-  let end = !1;
-  return new Response(
-    new ReadableStream({
-      start(controller) {
-        if (request?.signal?.addEventListener("abort", () => {
-          end = !0, iterator.return?.();
-          try {
-            controller.close();
-          } catch {
-          }
-        }), !(!init || init.value instanceof ReadableStream || init.value === void 0 || init.value === null))
-          if (init.value.toSSE)
-            controller.enqueue(init.value.toSSE());
-          else {
-            if (enqueueBinaryChunk(controller, init.value)) return;
-            if (typeof init.value == "object")
-              try {
-                controller.enqueue(
-                  format(JSON.stringify(init.value))
-                );
-              } catch {
-                controller.enqueue(format(init.value.toString()));
-              }
-            else controller.enqueue(format(init.value.toString()));
-          }
-      },
-      async pull(controller) {
-        if (end) {
-          try {
-            controller.close();
-          } catch {
-          }
-          return;
-        }
-        try {
-          const { value: chunk, done } = await iterator.next();
-          if (done || end) {
-            try {
-              controller.close();
-            } catch {
-            }
-            return;
-          }
-          if (chunk == null) return;
-          if (chunk.toSSE)
-            controller.enqueue(chunk.toSSE());
-          else {
-            if (enqueueBinaryChunk(controller, chunk)) return;
-            if (typeof chunk == "object")
-              try {
-                controller.enqueue(
-                  format(JSON.stringify(chunk))
-                );
-              } catch {
-                controller.enqueue(format(chunk.toString()));
-              }
-            else controller.enqueue(format(chunk.toString()));
-          }
-        } catch (error) {
-          console.warn(error);
-          try {
-            controller.close();
-          } catch {
-          }
-        }
-      },
-      cancel() {
-        end = !0, iterator.return?.();
-      }
-    }),
-    set
-  );
-};
+//#region src/adapter/utils.ts
+const setCookie = "set-cookie";
+function materializeSetHeaders(set) {
+	const headers = set.headers;
+	if (headers["\0"] !== headers) return headers;
+	return set.headers = Object.assign(require_utils.nullObject(), headers);
+}
+const sseFormat = (data) => `data: ${data}\n\n`;
+const identityFormat = (data) => data;
+const textEncoder = new TextEncoder();
+const encodeChunk = (s) => textEncoder.encode(s);
+function normalizeContentType(contentType) {
+	if (contentType === "application/json") return contentType;
+	const end = contentType.indexOf(";");
+	return (end === -1 ? contentType : contentType.slice(0, end)).trim().toLowerCase();
+}
+function handleFile(response, set, request, size = response.size) {
+	if (!require_universal_constants.isBun && response instanceof Promise) return response.then((res) => handleFile(res, set, request, size));
+	const rangeHeader = request?.headers.get("range");
+	if (rangeHeader) {
+		const match = /bytes=(\d*)-(\d*)/.exec(rangeHeader);
+		if (match) {
+			if (!match[1] && !match[2]) return new Response(null, {
+				status: 416,
+				headers: mergeHeaders(new Headers({ "content-range": `bytes */${size}` }), set?.headers ?? require_utils.nullObject())
+			});
+			let start;
+			let end;
+			if (!match[1] && match[2]) {
+				const suffix = parseInt(match[2]);
+				start = Math.max(0, size - suffix);
+				end = size - 1;
+			} else {
+				start = match[1] ? parseInt(match[1]) : 0;
+				end = match[2] ? Math.min(parseInt(match[2]), size - 1) : size - 1;
+			}
+			if (start >= size || start > end) return new Response(null, {
+				status: 416,
+				headers: mergeHeaders(new Headers({ "content-range": `bytes */${size}` }), set?.headers ?? require_utils.nullObject())
+			});
+			const contentLength = end - start + 1;
+			const rangeHeaders = new Headers({
+				"accept-ranges": "bytes",
+				"content-range": `bytes ${start}-${end}/${size}`,
+				"content-length": String(contentLength)
+			});
+			return new Response(response.slice(start, end + 1, response.type), {
+				status: 206,
+				headers: mergeHeaders(rangeHeaders, set?.headers ?? require_utils.nullObject())
+			});
+		}
+	}
+	const body = "value" in response ? response.value : response;
+	const immutable = set && (set.status === 206 || set.status === 304 || set.status === 412 || set.status === 416);
+	const defaultHeader = immutable ? require_utils.nullObject() : {
+		"accept-ranges": "bytes",
+		"content-range": size ? `bytes 0-${size - 1}/${size}` : void 0
+	};
+	if (!set && !size) return new Response(body);
+	if (!set) return new Response(body, { headers: defaultHeader });
+	if (set.headers instanceof Headers) {
+		for (const key of Object.keys(defaultHeader)) if (!set.headers.has(key)) set.headers.append(key, defaultHeader[key]);
+		if (immutable) {
+			set.headers.delete("content-length");
+			set.headers.delete("accept-ranges");
+		}
+		return new Response(body, set);
+	}
+	if (require_utils.isNotEmpty(set.headers)) return new Response(body, {
+		status: set.status,
+		headers: Object.assign(defaultHeader, set.headers)
+	});
+	return new Response(body, {
+		status: set.status,
+		headers: defaultHeader
+	});
+}
+function normalizeHeaders(set) {
+	const headers = set.headers;
+	if (!(headers instanceof Headers)) return;
+	const flat = Object.create(null);
+	for (const [key, value] of headers) if (key !== setCookie) flat[key] = value;
+	const cookies = headers.getSetCookie();
+	if (cookies.length) flat[setCookie] = cookies;
+	set.headers = flat;
+}
+function parseSetCookies(headers, setCookie) {
+	if (!headers) return headers;
+	headers.delete("set-cookie");
+	for (let i = 0; i < setCookie.length; i++) headers.append("set-cookie", setCookie[i]);
+	return headers;
+}
+function responseToSetHeaders(response, set) {
+	if (set && set.headers instanceof Headers) normalizeHeaders(set);
+	if (set) materializeSetHeaders(set);
+	if (set?.headers) {
+		if (response) if (require_universal_constants.hasHeaderShorthand) Object.assign(set.headers, response.headers.toJSON());
+		else for (const [key, value] of response.headers.entries()) set.headers[key] = value;
+		if (set.status === void 0 || set.status === 200) set.status = response.status;
+	} else if (!response) return {
+		headers: require_utils.nullObject(),
+		status: set?.status ?? 200
+	};
+	else if (require_universal_constants.hasHeaderShorthand) set = {
+		headers: response.headers.toJSON(),
+		status: set?.status ?? 200
+	};
+	else {
+		set = {
+			headers: require_utils.nullObject(),
+			status: set?.status ?? 200
+		};
+		for (const [key, value] of response.headers.entries()) set.headers[key] = value;
+	}
+	if (set.headers["content-encoding"]) delete set.headers["content-encoding"];
+	return set;
+}
+function enqueueBinaryChunk(controller, chunk) {
+	if (chunk instanceof Blob) return chunk.arrayBuffer().then((buffer) => {
+		controller.enqueue(new Uint8Array(buffer));
+		return true;
+	});
+	if (chunk instanceof Uint8Array) {
+		controller.enqueue(chunk);
+		return true;
+	}
+	if (chunk instanceof ArrayBuffer) {
+		controller.enqueue(new Uint8Array(chunk));
+		return true;
+	}
+	if (ArrayBuffer.isView(chunk)) {
+		controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+		return true;
+	}
+	return false;
+}
+function createStreamHandler({ mapResponse, mapCompactResponse }) {
+	return async (generator, set, request, skipFormat, owned = false) => {
+		if (require_utils.isByteStream(generator)) {
+			if (generator.locked) throw new TypeError("Cannot transfer a locked or consumed byte stream");
+			if (set) {
+				handleSet(set);
+				const headers = materializeSetHeaders(set);
+				if (headers instanceof Headers) {
+					if (!headers.has("content-type")) headers.set("content-type", "application/octet-stream");
+				} else if (!headers["content-type"]) headers["content-type"] = "application/octet-stream";
+				return new Response(generator, set);
+			}
+			return new Response(generator, { headers: { "content-type": "application/octet-stream" } });
+		}
+		const typedSSE = !skipFormat && "sse" in generator && generator.sse === true;
+		let init = typedSSE ? void 0 : generator.next?.();
+		if (set) handleSet(set);
+		if (init instanceof Promise) init = await init;
+		if (init?.value instanceof ReadableStream) generator = init.value;
+		else if (init && (typeof init?.done === "undefined" || init?.done)) {
+			if (set) return mapResponse(init.value, set, request, owned);
+			return mapCompactResponse(init.value, request, owned);
+		}
+		const isSSE = typedSSE || !skipFormat && (init?.value?.sse ?? generator?.sse ?? (set?.headers instanceof Headers ? set.headers.get("content-type")?.startsWith("text/event-stream") : set?.headers["content-type"]?.startsWith("text/event-stream")));
+		const format = isSSE ? sseFormat : identityFormat;
+		const contentType = isSSE ? "text/event-stream" : init?.value && typeof init?.value === "object" ? ArrayBuffer.isView(init.value) ? "application/octet-stream" : "application/json" : "text/plain";
+		if (set) materializeSetHeaders(set);
+		const headers = set?.headers;
+		if (headers instanceof Headers) {
+			if (!typedSSE && !headers.has("transfer-encoding")) headers.set("transfer-encoding", "chunked");
+			if (!headers.has("content-type")) headers.set("content-type", contentType);
+			if (!headers.has("cache-control")) headers.set("cache-control", "no-cache");
+		} else if (headers) {
+			if (!typedSSE && !headers["transfer-encoding"]) headers["transfer-encoding"] = "chunked";
+			if (!headers["content-type"]) headers["content-type"] = contentType;
+			if (!headers["cache-control"]) headers["cache-control"] = "no-cache";
+		} else if (typedSSE) set = {
+			status: 200,
+			headers: {
+				"content-type": contentType,
+				"cache-control": "no-cache"
+			}
+		};
+		else set = {
+			status: 200,
+			headers: {
+				"content-type": contentType,
+				"transfer-encoding": "chunked",
+				"cache-control": "no-cache",
+				connection: "keep-alive"
+			}
+		};
+		const iterator = typeof generator.next === "function" ? generator : generator[Symbol.asyncIterator]();
+		let end = false;
+		const signal = request?.signal;
+		let onAbort;
+		const cleanupAbort = () => {
+			if (signal && onAbort) {
+				signal.removeEventListener("abort", onAbort);
+				onAbort = void 0;
+			}
+		};
+		const safeReturn = () => {
+			try {
+				const r = iterator.return?.();
+				if (r && typeof r.then === "function") r.catch(() => {});
+			} catch {}
+		};
+		const closeSafely = (controller) => {
+			try {
+				controller.close();
+			} catch {}
+			cleanupAbort();
+		};
+		const enqueueValue = async (controller, value) => {
+			if (value.toSSE) {
+				controller.enqueue(encodeChunk(value.toSSE()));
+				return;
+			}
+			const p = enqueueBinaryChunk(controller, value);
+			if (p !== false) return void await p;
+			if (typeof value === "object") try {
+				controller.enqueue(encodeChunk(format(JSON.stringify(value))));
+			} catch {
+				controller.enqueue(encodeChunk(format(value.toString())));
+			}
+			else controller.enqueue(encodeChunk(format(value.toString())));
+		};
+		return new Response(new ReadableStream({
+			async start(controller) {
+				if (signal) {
+					onAbort = () => {
+						cleanupAbort();
+						end = true;
+						safeReturn();
+						try {
+							controller.close();
+						} catch {}
+					};
+					if (signal.aborted) onAbort();
+					else signal.addEventListener("abort", onAbort, { once: true });
+				}
+				if (!init || init.value instanceof ReadableStream || init.value === void 0 || init.value === null) return;
+				await enqueueValue(controller, init.value);
+			},
+			async pull(controller) {
+				if (end) {
+					closeSafely(controller);
+					return;
+				}
+				try {
+					const { value: chunk, done } = await iterator.next();
+					if (done || end) {
+						closeSafely(controller);
+						return;
+					}
+					if (chunk === void 0 || chunk === null) return;
+					await enqueueValue(controller, chunk);
+				} catch (error) {
+					cleanupAbort();
+					controller.error(error);
+				}
+			},
+			cancel() {
+				end = true;
+				cleanupAbort();
+				safeReturn();
+			}
+		}, typedSSE ? { highWaterMark: 0 } : void 0), set);
+	};
+}
 async function* streamResponse(response) {
-  const body = response.body;
-  if (!body) return;
-  const reader = body.getReader(), decoder = new TextDecoder();
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      typeof value == "string" ? yield value : yield decoder.decode(value);
-    }
-  } finally {
-    reader.releaseLock();
-  }
+	const body = response.body;
+	if (body) yield* body;
+}
+function handleSet(set) {
+	if (typeof set.status === "string") set.status = require_constants.StatusMap[set.status];
+	if (set.headers instanceof Headers) normalizeHeaders(set);
+	const proto = Object.getPrototypeOf(set.headers);
+	if (proto !== null && proto !== Object.prototype) {
+		const flat = Object.create(null);
+		for (const key in set.headers) flat[key] = set.headers[key];
+		set.headers = flat;
+	}
+	if (set.cookie && require_utils.isNotEmpty(set.cookie)) {
+		materializeSetHeaders(set);
+		const cookie = require_cookie_serialize.serializeCookie(set.cookie);
+		if (cookie) {
+			const existing = set.headers[setCookie];
+			if (Array.isArray(existing)) set.headers[setCookie] = existing.concat(cookie);
+			else set.headers[setCookie] = cookie;
+		}
+	}
+	if (set.headers[setCookie] && Array.isArray(set.headers[setCookie])) set.headers = parseSetCookies(new Headers(set.headers), set.headers[setCookie]);
+}
+function applySetHeaders(target, setHeaders, present) {
+	if (setHeaders instanceof Headers) {
+		const incoming = setHeaders.getSetCookie();
+		if (incoming.length) {
+			const cookies = target.getSetCookie();
+			for (const cookie of incoming) if (!cookies.includes(cookie)) {
+				target.append(setCookie, cookie);
+				cookies.push(cookie);
+			}
+		}
+		for (const key of setHeaders.keys()) if (key !== setCookie && !present.has(key)) target.set(key, setHeaders.get(key) ?? "");
+	} else {
+		let cookies;
+		for (const key in setHeaders) if (key === setCookie) {
+			const cookie = setHeaders[key];
+			cookies ??= target.getSetCookie();
+			if (!cookies.includes(cookie)) {
+				target.append(key, cookie);
+				cookies.push(cookie);
+			}
+		} else if (!present.has(key)) target.set(key, setHeaders[key]);
+	}
 }
-const handleSet = (set) => {
-  if (typeof set.status == "string" && (set.status = import_utils.StatusMap[set.status]), set.cookie && (0, import_utils.isNotEmpty)(set.cookie)) {
-    const cookie = (0, import_cookies.serializeCookie)(set.cookie);
-    cookie && (set.headers["set-cookie"] = cookie);
-  }
-  set.headers["set-cookie"] && Array.isArray(set.headers["set-cookie"]) && (set.headers = parseSetCookies(
-    new Headers(set.headers),
-    set.headers["set-cookie"]
-  ));
-};
 function mergeHeaders(responseHeaders, setHeaders) {
-  const headers = new Headers(responseHeaders);
-  if (setHeaders instanceof Headers)
-    for (const key of setHeaders.keys())
-      if (key === "set-cookie") {
-        if (headers.has("set-cookie")) continue;
-        for (const cookie of setHeaders.getSetCookie())
-          headers.append("set-cookie", cookie);
-      } else responseHeaders.has(key) || headers.set(key, setHeaders?.get(key) ?? "");
-  else
-    for (const key in setHeaders)
-      key === "set-cookie" ? headers.append(key, setHeaders[key]) : responseHeaders.has(key) || headers.set(key, setHeaders[key]);
-  return headers;
+	const headers = new Headers(responseHeaders);
+	applySetHeaders(headers, setHeaders, responseHeaders);
+	return headers;
 }
 function mergeStatus(responseStatus, setStatus) {
-  return typeof setStatus == "string" && (setStatus = import_utils.StatusMap[setStatus]), responseStatus === 200 ? setStatus : responseStatus;
+	if (typeof setStatus === "string") setStatus = require_constants.StatusMap[setStatus];
+	if (responseStatus === 200) return setStatus;
+	return responseStatus;
 }
-const createResponseHandler = (handler) => {
-  const handleStream = createStreamHandler(handler);
-  return (response, set, request) => {
-    const newResponse = new Response(response.body, {
-      headers: mergeHeaders(response.headers, set.headers),
-      status: mergeStatus(response.status, set.status)
-    });
-    return !newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked" ? handleStream(
-      streamResponse(newResponse),
-      responseToSetHeaders(newResponse, set),
-      request,
-      !0
-      // don't auto-format SSE for pre-formatted Response
-    ) : newResponse;
-  };
+function cancelPropagatingBody(clonedBody, orphanedBranch, preserveOrphan = false) {
+	const reader = clonedBody.getReader();
+	return new ReadableStream({
+		async pull(controller) {
+			const { done, value } = await reader.read();
+			if (done) controller.close();
+			else controller.enqueue(value);
+		},
+		cancel(reason) {
+			if (preserveOrphan) {
+				reader.cancel(reason).catch(() => {});
+				return;
+			}
+			orphanedBranch.cancel(reason);
+			return reader.cancel(reason);
+		}
+	});
+}
+const warnedStreamBorrows = /* @__PURE__ */ new WeakSet();
+function createResponseHandler(handler) {
+	const handleStream = createStreamHandler(handler);
+	return (response, set, request, owned = false) => {
+		if (require_adapter_skip_clone.skipClone.has(response) && !response.bodyUsed) {
+			require_adapter_skip_clone.skipClone.delete(response);
+			owned = true;
+		}
+		const explicitlyBorrowed = require_adapter_response_ownership.isBorrowedResponse(response);
+		const borrowed = !owned || explicitlyBorrowed;
+		const mustClone = owned && explicitlyBorrowed;
+		if (!borrowed && response.bodyUsed) throw new TypeError("Cannot reuse a consumed Response across requests");
+		if (set) {
+			const status = mergeStatus(response.status, set.status);
+			const statusUnchanged = status === void 0 || status === response.status;
+			if (!mustClone && statusUnchanged && !set.cookie && !require_utils.isNotEmpty(set.headers)) return response;
+		} else if (!mustClone) return response;
+		if (!borrowed && response.body?.locked) throw new TypeError("Cannot patch a Response whose body is locked");
+		let body = response.body;
+		if (borrowed) {
+			const bodyBefore = body;
+			const cloned = response.clone();
+			if (explicitlyBorrowed && bodyBefore && response.body !== bodyBefore && !warnedStreamBorrows.has(response)) {
+				warnedStreamBorrows.add(response);
+				console.warn("[elysia] borrow() was called on a stream-backed Response");
+			}
+			body = cloned.body && response.body ? cancelPropagatingBody(cloned.body, response.body, explicitlyBorrowed) : cloned.body;
+		}
+		const newResponse = new Response(body, set ? {
+			headers: mergeHeaders(response.headers, set.headers),
+			status: mergeStatus(response.status, set.status),
+			statusText: response.statusText
+		} : {
+			headers: response.headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+		if (borrowed && !newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked") return handleStream(streamResponse(newResponse), responseToSetHeaders(newResponse, set), request, true);
+		return newResponse;
+	};
+}
+function teeChunkCost(chunk) {
+	if (typeof chunk === "string") return chunk.length;
+	if (typeof chunk !== "object" || chunk === null) return 64;
+	const byteLength = chunk.byteLength;
+	if (typeof byteLength === "number") return byteLength;
+	const size = chunk.size;
+	if (typeof size === "number") return size;
+	return 64;
+}
+const doneResult = {
+	done: true,
+	value: void 0
 };
-async function tee(source, branches = 2) {
-  const buffer = [];
-  let done = !1, waiting = [];
-  (async () => {
-    for await (const value of source)
-      buffer.push(value), waiting.forEach((w) => w.resolve()), waiting = [];
-    done = !0, waiting.forEach((w) => w.resolve());
-  })();
-  async function* makeIterator() {
-    let i = 0;
-    for (; ; )
-      if (i < buffer.length)
-        yield buffer[i++];
-      else {
-        if (done)
-          return;
-        await new Promise((resolve) => waiting.push({ resolve }));
-      }
-  }
-  return Array.from({ length: branches }, makeIterator);
+/**
+* Split async source into `branches` independent iterators
+*
+* A producer drains the source ahead of consumers
+*
+* To prevent long/infinite stream, the unconsumed window is capped:
+* Consumed-by-every-branch entries are trimmed off the front
+* Producer backpressures whenever the window hits `cap` ENTRIES or
+* `capBytes` bytes, whichever comes first
+*
+* Streams below both caps buffer eagerly
+* Only streams exceeding one gate on the slowest consumer
+*
+* Branch 0 is the value consumer (response/client)
+* When `return()` (client abort / early exit), source is stopped
+* so the observer branches can still reach completion instead of spinning
+* an infinite source
+*/
+function tee(source, branches = 2, cap = 64, capBytes = 1 << 22) {
+	const iterator = source[Symbol.asyncIterator]?.() ?? source[Symbol.iterator]();
+	const buffer = [];
+	const sizes = [];
+	let base = 0;
+	let windowBytes = 0;
+	let done = false;
+	let stopped = false;
+	let failed = false;
+	let sourceError;
+	let drainResume = null;
+	const cursors = new Array(branches).fill(0);
+	let active = branches;
+	const pending = new Array(branches).fill(null);
+	const resumeProducer = () => {
+		if (drainResume) {
+			const resume = drainResume;
+			drainResume = null;
+			resume();
+		}
+	};
+	const trim = () => {
+		if (active > 0) {
+			let min = Infinity;
+			for (const c of cursors) if (c < min) min = c;
+			const consumed = min - base;
+			if (min !== Infinity && consumed > 0) {
+				for (let i = 0; i < consumed; i++) windowBytes -= sizes[i];
+				buffer.splice(0, consumed);
+				sizes.splice(0, consumed);
+				base = min;
+			}
+		}
+		if (buffer.length < cap && windowBytes < capBytes) resumeProducer();
+	};
+	const closeBranch = (me) => {
+		if (cursors[me] === Infinity) return;
+		cursors[me] = Infinity;
+		active--;
+		if (me === 0 && !stopped) {
+			stopped = true;
+			done = true;
+			resumeProducer();
+			try {
+				const r = iterator.return?.();
+				if (r && typeof r.then === "function") r.catch(() => {});
+			} catch {}
+			wakeAll();
+		}
+		if (active === 0) {
+			buffer.length = 0;
+			sizes.length = 0;
+			windowBytes = 0;
+		} else trim();
+	};
+	const serve = (me, p) => {
+		const i = cursors[me];
+		if (i === Infinity) return p.resolve(doneResult);
+		if (i < base + buffer.length) {
+			const value = buffer[i - base];
+			cursors[me] = i + 1;
+			trim();
+			return p.resolve({
+				done: false,
+				value
+			});
+		}
+		if (failed) return p.reject(sourceError);
+		if (done) {
+			closeBranch(me);
+			return p.resolve(doneResult);
+		}
+		pending[me] = p;
+	};
+	const wakeAll = () => {
+		for (let b = 0; b < branches; b++) {
+			const p = pending[b];
+			if (!p) continue;
+			pending[b] = null;
+			serve(b, p);
+		}
+	};
+	(async () => {
+		try {
+			while (!stopped) {
+				const result = await iterator.next();
+				if (result.done || stopped) break;
+				buffer.push(result.value);
+				sizes.push(teeChunkCost(result.value));
+				windowBytes += sizes[sizes.length - 1];
+				wakeAll();
+				if ((buffer.length >= cap || windowBytes >= capBytes) && active > 0 && !stopped) await new Promise((resolve) => {
+					drainResume = resolve;
+				});
+			}
+		} catch (error) {
+			failed = true;
+			sourceError = error;
+		} finally {
+			done = true;
+			wakeAll();
+		}
+	})();
+	const makeBranch = (me) => ({
+		[Symbol.asyncIterator]() {
+			return this;
+		},
+		next: () => new Promise((resolve, reject) => serve(me, {
+			resolve,
+			reject
+		})),
+		return: (value) => {
+			const p = pending[me];
+			if (p) {
+				pending[me] = null;
+				p.resolve(doneResult);
+			}
+			closeBranch(me);
+			return Promise.resolve({
+				done: true,
+				value
+			});
+		},
+		throw: (error) => {
+			const p = pending[me];
+			if (p) {
+				pending[me] = null;
+				p.resolve(doneResult);
+			}
+			closeBranch(me);
+			return Promise.reject(error);
+		}
+	});
+	return Array.from({ length: branches }, (_, b) => makeBranch(b));
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createResponseHandler,
-  createStreamHandler,
-  handleFile,
-  handleSet,
-  mergeHeaders,
-  mergeStatus,
-  parseSetCookies,
-  responseToSetHeaders,
-  streamResponse,
-  tee
-});
+
+//#endregion
+exports.createResponseHandler = createResponseHandler;
+exports.createStreamHandler = createStreamHandler;
+exports.handleFile = handleFile;
+exports.handleSet = handleSet;
+exports.materializeSetHeaders = materializeSetHeaders;
+exports.normalizeContentType = normalizeContentType;
+exports.parseSetCookies = parseSetCookies;
+exports.responseToSetHeaders = responseToSetHeaders;
+exports.streamResponse = streamResponse;
+exports.tee = tee;