@geostrategists/react-router-aws 2.2.0 → 2.3.0-rc.0

package/dist/index.mjs

@@ -1,348 +1,345 @@
 /**
-* @geostrategists/react-router-aws v2.2.0
+* @geostrategists/react-router-aws v2.3.0-rc.0
 *
 * Copyright (c) Geostrategists Consulting GmbH
 *
 * This source code is licensed under the MIT license found in the
-* LICENSE.md file in the root directory of this source tree.
+* LICENSE file in the root directory of this source tree.
 *
 * @license MIT
 */
-
-// src/server.ts
-import {
-  createRequestHandler as createReactRouterRequestHandler
-} from "react-router";
-
-// src/adapters/api-gateway-v2.ts
-import { readableStreamToString } from "@react-router/node";
-
-// src/binaryTypes.ts
-var binaryTypes = [
-  "application/octet-stream",
-  // Docs
-  "application/epub+zip",
-  "application/msword",
-  "application/pdf",
-  "application/rtf",
-  "application/vnd.amazon.ebook",
-  "application/vnd.ms-excel",
-  "application/vnd.ms-powerpoint",
-  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  // Fonts
-  "font/otf",
-  "font/woff",
-  "font/woff2",
-  // Images
-  "image/avif",
-  "image/bmp",
-  "image/gif",
-  "image/jpeg",
-  "image/png",
-  "image/tiff",
-  "image/vnd.microsoft.icon",
-  "image/webp",
-  // Audio
-  "audio/3gpp",
-  "audio/aac",
-  "audio/basic",
-  "audio/mpeg",
-  "audio/ogg",
-  "audio/wav",
-  "audio/webm",
-  "audio/x-aiff",
-  "audio/x-midi",
-  "audio/x-wav",
-  // Video
-  "video/3gpp",
-  "video/mp2t",
-  "video/mpeg",
-  "video/ogg",
-  "video/quicktime",
-  "video/webm",
-  "video/x-msvideo",
-  // Archives
-  "application/java-archive",
-  "application/vnd.apple.installer+xml",
-  "application/x-7z-compressed",
-  "application/x-apple-diskimage",
-  "application/x-bzip",
-  "application/x-bzip2",
-  "application/x-gzip",
-  "application/x-java-archive",
-  "application/x-rar-compressed",
-  "application/x-tar",
-  "application/x-zip",
-  "application/zip"
+import { createRequestHandler as createRequestHandler$1 } from "react-router";
+import { readableStreamToString, writeReadableStreamToWritable } from "@react-router/node";
+import { URLSearchParams } from "url";
+//#region src/binaryTypes.ts
+/**
+* Common binary MIME types
+* @see https://github.com/architect/functions/blob/45254fc1936a1794c185aac07e9889b241a2e5c6/src/http/helpers/binary-types.js
+*/
+const binaryTypes = [
+	"application/octet-stream",
+	"application/epub+zip",
+	"application/msword",
+	"application/pdf",
+	"application/rtf",
+	"application/vnd.amazon.ebook",
+	"application/vnd.ms-excel",
+	"application/vnd.ms-powerpoint",
+	"application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	"font/otf",
+	"font/woff",
+	"font/woff2",
+	"image/avif",
+	"image/bmp",
+	"image/gif",
+	"image/jpeg",
+	"image/png",
+	"image/tiff",
+	"image/vnd.microsoft.icon",
+	"image/webp",
+	"audio/3gpp",
+	"audio/aac",
+	"audio/basic",
+	"audio/mpeg",
+	"audio/ogg",
+	"audio/wav",
+	"audio/webm",
+	"audio/x-aiff",
+	"audio/x-midi",
+	"audio/x-wav",
+	"video/3gpp",
+	"video/mp2t",
+	"video/mpeg",
+	"video/ogg",
+	"video/quicktime",
+	"video/webm",
+	"video/x-msvideo",
+	"application/java-archive",
+	"application/vnd.apple.installer+xml",
+	"application/x-7z-compressed",
+	"application/x-apple-diskimage",
+	"application/x-bzip",
+	"application/x-bzip2",
+	"application/x-gzip",
+	"application/x-java-archive",
+	"application/x-rar-compressed",
+	"application/x-tar",
+	"application/x-zip",
+	"application/zip"
 ];
 function isBinaryType(contentType) {
-  if (!contentType) return false;
-  const [test] = contentType.split(";");
-  return binaryTypes.includes(test);
+	if (!contentType) return false;
+	const [test] = contentType.split(";");
+	return binaryTypes.includes(test);
 }
-
-// src/adapters/api-gateway-v2.ts
-function createReactRouterRequestAPIGateywayV2(event) {
-  const host = event.headers["x-forwarded-host"] || event.headers.host;
-  const search = event.rawQueryString.length ? `?${event.rawQueryString}` : "";
-  const scheme = event.headers["x-forwarded-proto"] || "http";
-  const url = new URL(event.rawPath + search, `${scheme}://${host}`);
-  const isFormData = event.headers["content-type"]?.includes("multipart/form-data");
-  const controller = new AbortController();
-  return new Request(url.href, {
-    method: event.requestContext.http.method,
-    headers: createReactRouterHeadersAPIGatewayV2(event.headers, event.cookies),
-    signal: controller.signal,
-    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body
-  });
+//#endregion
+//#region src/adapters/host.ts
+/**
+* Resolves the host used to build the `Request` URL from a raw host value
+* (e.g. an `x-forwarded-host`/`host` header or an API Gateway domain name).
+*
+* React Router derives the host for its built-in cross-origin (CSRF) check on
+* action requests from `new URL(request.url).host`, so the host constructed
+* here must be trustworthy and well-formed. Invalid characters are stripped and
+* the port is validated to avoid constructing a malformed URL (or leaking a
+* spoofed host) from a garbled header value.
+*
+* Mirrors the hardening done by the upstream `@react-router/architect` adapter.
+*/
+function resolveHost(rawHost) {
+	const [rawHostname = "", portStr] = (rawHost ?? "").split(":");
+	const hostname = rawHostname.split(/[\\/?#@]/)[0] || "localhost";
+	const hostPort = Number.parseInt(portStr ?? "", 10);
+	const port = Number.isSafeInteger(hostPort) ? hostPort : void 0;
+	return `${hostname}${port ? `:${port}` : ""}`;
 }
-function createReactRouterHeadersAPIGatewayV2(requestHeaders, requestCookies) {
-  const headers = new Headers();
-  for (const [header, value] of Object.entries(requestHeaders)) {
-    if (value) {
-      headers.append(header, value);
-    }
-  }
-  if (requestCookies) {
-    headers.append("Cookie", requestCookies.join("; "));
-  }
-  return headers;
+//#endregion
+//#region src/adapters/api-gateway-v1.ts
+function createReactRouterRequestAPIGatewayV1(event, getHost) {
+	const host = resolveHost(getHost?.(event) ?? (event.headers["x-forwarded-host"] || event.headers.Host));
+	const scheme = event.headers["x-forwarded-proto"] || "http";
+	const rawQueryString = new URLSearchParams(event.queryStringParameters).toString();
+	const search = rawQueryString.length > 0 ? `?${rawQueryString}` : "";
+	const url = new URL(event.path + search, `${scheme}://${host}`);
+	const isFormData = event.headers["content-type"]?.includes("multipart/form-data");
+	const controller = new AbortController();
+	return new Request(url.href, {
+		method: event.requestContext.httpMethod,
+		headers: createReactRouterHeadersAPIGatewayV1(event.headers),
+		signal: controller.signal,
+		body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body || void 0
+	});
 }
-function extractAPIGatewayV2ResponseMetadata(nodeResponse) {
-  const cookies = nodeResponse.headers.getSetCookie();
-  if (cookies.length) {
-    nodeResponse.headers.delete("Set-Cookie");
-  }
-  return {
-    statusCode: nodeResponse.status,
-    headers: Object.fromEntries(nodeResponse.headers.entries()),
-    cookies
-  };
+function createReactRouterHeadersAPIGatewayV1(requestHeaders) {
+	const headers = new Headers();
+	for (const [header, value] of Object.entries(requestHeaders)) if (value) headers.append(header, value);
+	return headers;
 }
-async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
-  const result = extractAPIGatewayV2ResponseMetadata(nodeResponse);
-  const contentType = nodeResponse.headers.get("Content-Type");
-  result.isBase64Encoded = isBinaryType(contentType);
-  if (nodeResponse.body) {
-    if (result.isBase64Encoded) {
-      result.body = await readableStreamToString(nodeResponse.body, "base64");
-    } else {
-      result.body = await nodeResponse.text();
-    }
-  }
-  return result;
+async function sendReactRouterResponseAPIGatewayV1(nodeResponse) {
+	const isBase64Encoded = isBinaryType(nodeResponse.headers.get("Content-Type"));
+	let body;
+	if (nodeResponse.body) if (isBase64Encoded) body = await readableStreamToString(nodeResponse.body, "base64");
+	else body = await nodeResponse.text();
+	return {
+		statusCode: nodeResponse.status,
+		headers: Object.fromEntries(nodeResponse.headers.entries()),
+		body: body || "",
+		isBase64Encoded
+	};
 }
-var apiGatewayV2Adapter = {
-  wrapHandler: (handler) => (e) => handler(e),
-  createReactRouterRequest: createReactRouterRequestAPIGateywayV2,
-  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV2
+const apiGatewayV1Adapter = {
+	wrapHandler: (handler) => (e) => handler(e),
+	createReactRouterRequest: createReactRouterRequestAPIGatewayV1,
+	sendReactRouterResponse: sendReactRouterResponseAPIGatewayV1
 };
-
-// src/adapters/api-gateway-v1.ts
-import { readableStreamToString as readableStreamToString2 } from "@react-router/node";
-import { URLSearchParams } from "url";
-function createReactRouterRequestAPIGatewayV1(event) {
-  const host = event.headers["x-forwarded-host"] || event.headers.Host;
-  const scheme = event.headers["x-forwarded-proto"] || "http";
-  const rawQueryString = new URLSearchParams(event.queryStringParameters).toString();
-  const search = rawQueryString.length > 0 ? `?${rawQueryString}` : "";
-  const url = new URL(event.path + search, `${scheme}://${host}`);
-  const isFormData = event.headers["content-type"]?.includes("multipart/form-data");
-  const controller = new AbortController();
-  return new Request(url.href, {
-    method: event.requestContext.httpMethod,
-    headers: createReactRouterHeadersAPIGatewayV1(event.headers),
-    signal: controller.signal,
-    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body || void 0
-  });
+//#endregion
+//#region src/adapters/api-gateway-v2.ts
+function createReactRouterRequestAPIGateywayV2(event, getHost) {
+	const host = resolveHost(getHost?.(event) ?? (event.headers["x-forwarded-host"] || event.headers.host));
+	const search = event.rawQueryString.length ? `?${event.rawQueryString}` : "";
+	const scheme = event.headers["x-forwarded-proto"] || "http";
+	const url = new URL(event.rawPath + search, `${scheme}://${host}`);
+	const isFormData = event.headers["content-type"]?.includes("multipart/form-data");
+	const controller = new AbortController();
+	return new Request(url.href, {
+		method: event.requestContext.http.method,
+		headers: createReactRouterHeadersAPIGatewayV2(event.headers, event.cookies),
+		signal: controller.signal,
+		body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body
+	});
 }
-function createReactRouterHeadersAPIGatewayV1(requestHeaders) {
-  const headers = new Headers();
-  for (const [header, value] of Object.entries(requestHeaders)) {
-    if (value) {
-      headers.append(header, value);
-    }
-  }
-  return headers;
+function createReactRouterHeadersAPIGatewayV2(requestHeaders, requestCookies) {
+	const headers = new Headers();
+	for (const [header, value] of Object.entries(requestHeaders)) if (value) headers.append(header, value);
+	if (requestCookies) headers.append("Cookie", requestCookies.join("; "));
+	return headers;
 }
-async function sendReactRouterResponseAPIGatewayV1(nodeResponse) {
-  const contentType = nodeResponse.headers.get("Content-Type");
-  const isBase64Encoded = isBinaryType(contentType);
-  let body;
-  if (nodeResponse.body) {
-    if (isBase64Encoded) {
-      body = await readableStreamToString2(nodeResponse.body, "base64");
-    } else {
-      body = await nodeResponse.text();
-    }
-  }
-  return {
-    statusCode: nodeResponse.status,
-    headers: Object.fromEntries(nodeResponse.headers.entries()),
-    body: body || "",
-    isBase64Encoded
-  };
+function extractAPIGatewayV2ResponseMetadata(nodeResponse) {
+	const cookies = nodeResponse.headers.getSetCookie();
+	if (cookies.length) nodeResponse.headers.delete("Set-Cookie");
+	return {
+		statusCode: nodeResponse.status,
+		headers: Object.fromEntries(nodeResponse.headers.entries()),
+		cookies
+	};
+}
+async function sendReactRouterResponseAPIGatewayV2(nodeResponse) {
+	const result = extractAPIGatewayV2ResponseMetadata(nodeResponse);
+	result.isBase64Encoded = isBinaryType(nodeResponse.headers.get("Content-Type"));
+	if (nodeResponse.body) if (result.isBase64Encoded) result.body = await readableStreamToString(nodeResponse.body, "base64");
+	else result.body = await nodeResponse.text();
+	return result;
 }
-var apiGatewayV1Adapter = {
-  wrapHandler: (handler) => (e) => handler(e),
-  createReactRouterRequest: createReactRouterRequestAPIGatewayV1,
-  sendReactRouterResponse: sendReactRouterResponseAPIGatewayV1
+const apiGatewayV2Adapter = {
+	wrapHandler: (handler) => (e) => handler(e),
+	createReactRouterRequest: createReactRouterRequestAPIGateywayV2,
+	sendReactRouterResponse: sendReactRouterResponseAPIGatewayV2
 };
-
-// src/adapters/application-load-balancer.ts
-import { readableStreamToString as readableStreamToString3 } from "@react-router/node";
-import { URLSearchParams as URLSearchParams2 } from "url";
-function createReactRouterRequestALB(event) {
-  const headers = event?.headers || {};
-  const host = headers["x-forwarded-host"] || headers.Host;
-  const scheme = headers["x-forwarded-proto"] || "http";
-  const rawQueryString = new URLSearchParams2(event.queryStringParameters).toString();
-  const search = rawQueryString.length > 0 ? `?${rawQueryString}` : "";
-  const url = new URL(event.path + search, `${scheme}://${host}`);
-  const isFormData = headers["content-type"]?.includes("multipart/form-data");
-  const controller = new AbortController();
-  return new Request(url.href, {
-    method: event.httpMethod,
-    headers: createReactRouterHeadersALB(headers),
-    signal: controller.signal,
-    body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body || void 0
-  });
+//#endregion
+//#region src/adapters/application-load-balancer.ts
+function createReactRouterRequestALB(event, getHost) {
+	const headers = event?.headers || {};
+	const host = resolveHost(getHost?.(event) ?? (headers["x-forwarded-host"] || headers.Host));
+	const scheme = headers["x-forwarded-proto"] || "http";
+	const rawQueryString = new URLSearchParams(event.queryStringParameters).toString();
+	const search = rawQueryString.length > 0 ? `?${rawQueryString}` : "";
+	const url = new URL(event.path + search, `${scheme}://${host}`);
+	const isFormData = headers["content-type"]?.includes("multipart/form-data");
+	const controller = new AbortController();
+	return new Request(url.href, {
+		method: event.httpMethod,
+		headers: createReactRouterHeadersALB(headers),
+		signal: controller.signal,
+		body: event.body && event.isBase64Encoded ? isFormData ? Buffer.from(event.body, "base64") : Buffer.from(event.body, "base64").toString() : event.body || void 0
+	});
 }
 function createReactRouterHeadersALB(requestHeaders) {
-  const headers = new Headers();
-  for (const [header, value] of Object.entries(requestHeaders)) {
-    if (value) {
-      headers.append(header, value);
-    }
-  }
-  return headers;
+	const headers = new Headers();
+	for (const [header, value] of Object.entries(requestHeaders)) if (value) headers.append(header, value);
+	return headers;
 }
 async function sendReactRouterResponseALB(nodeResponse) {
-  const contentType = nodeResponse.headers.get("Content-Type");
-  const isBase64Encoded = isBinaryType(contentType);
-  let body;
-  if (nodeResponse.body) {
-    if (isBase64Encoded) {
-      body = await readableStreamToString3(nodeResponse.body, "base64");
-    } else {
-      body = await nodeResponse.text();
-    }
-  }
-  return {
-    statusCode: nodeResponse.status,
-    headers: Object.fromEntries(nodeResponse.headers.entries()),
-    body: body || "",
-    isBase64Encoded
-  };
+	const isBase64Encoded = isBinaryType(nodeResponse.headers.get("Content-Type"));
+	let body;
+	if (nodeResponse.body) if (isBase64Encoded) body = await readableStreamToString(nodeResponse.body, "base64");
+	else body = await nodeResponse.text();
+	return {
+		statusCode: nodeResponse.status,
+		headers: Object.fromEntries(nodeResponse.headers.entries()),
+		body: body || "",
+		isBase64Encoded
+	};
 }
-var applicationLoadBalancerAdapter = {
-  wrapHandler: (handler) => (e) => handler(e),
-  createReactRouterRequest: createReactRouterRequestALB,
-  sendReactRouterResponse: sendReactRouterResponseALB
+const applicationLoadBalancerAdapter = {
+	wrapHandler: (handler) => (e) => handler(e),
+	createReactRouterRequest: createReactRouterRequestALB,
+	sendReactRouterResponse: sendReactRouterResponseALB
 };
-
-// src/adapters/function-url-streaming.ts
-import { writeReadableStreamToWritable } from "@react-router/node";
-var emptyStream = () => new ReadableStream({
-  start(controller) {
-    controller.enqueue("");
-    controller.close();
-  }
-});
-var sendReactRouterResponseFunctionUrlStreaming = async (response, responseStream) => {
-  const metadata = extractAPIGatewayV2ResponseMetadata(response);
-  let body = response.body;
-  if (!body) {
-    body = emptyStream();
-  }
-  const httpResponseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
-  await writeReadableStreamToWritable(body, httpResponseStream);
+//#endregion
+//#region src/adapters/function-url-streaming.ts
+const emptyStream = () => new ReadableStream({ start(controller) {
+	controller.enqueue("");
+	controller.close();
+} });
+const sendReactRouterResponseFunctionUrlStreaming = async (response, responseStream) => {
+	const metadata = extractAPIGatewayV2ResponseMetadata(response);
+	let body = response.body;
+	if (!body) body = emptyStream();
+	const httpResponseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
+	await writeReadableStreamToWritable(body, httpResponseStream);
 };
-var functionUrlStreamingAdapter = {
-  wrapHandler: awslambda.streamifyResponse,
-  createReactRouterRequest: createReactRouterRequestAPIGateywayV2,
-  sendReactRouterResponse: sendReactRouterResponseFunctionUrlStreaming
+const functionUrlStreamingAdapter = {
+	wrapHandler: awslambda.streamifyResponse,
+	createReactRouterRequest: createReactRouterRequestAPIGateywayV2,
+	sendReactRouterResponse: sendReactRouterResponseFunctionUrlStreaming
 };
-
-// src/server.ts
+//#endregion
+//#region src/server.ts
+/**
+* Returns a request handler for AWS API Gateway V1
+*
+*/
+/**
+* Returns a request handler for AWS API Gateway V1 events.
+*
+* @param options - The handler options, including the React Router server build,
+*   optional getLoadContext function, and mode string.
+* @returns An AWS API Gateway V1 handler compatible with APIGatewayProxyHandler.
+*/
 function createAPIGatewayV1RequestHandler(options) {
-  return createRequestHandlerForAdapter(apiGatewayV1Adapter, options);
+	return createRequestHandlerForAdapter(apiGatewayV1Adapter, options);
 }
+/**
+* Returns a request handler for AWS API Gateway V2 events.
+*
+* @param options - The handler options, including the React Router server build,
+*   optional getLoadContext function, and mode string.
+* @returns An AWS API Gateway V2 handler compatible with APIGatewayProxyHandlerV2.
+*/
 function createAPIGatewayV2RequestHandler(options) {
-  return createRequestHandlerForAdapter(apiGatewayV2Adapter, options);
+	return createRequestHandlerForAdapter(apiGatewayV2Adapter, options);
 }
+/**
+* Returns a request handler for AWS Application Load Balancer events.
+*
+* @param options - The handler options, including the React Router server build,
+*   optional getLoadContext function, and mode string.
+* @returns An AWS ALB handler compatible with ALBHandler.
+*/
 function createALBRequestHandler(options) {
-  return createRequestHandlerForAdapter(applicationLoadBalancerAdapter, options);
+	return createRequestHandlerForAdapter(applicationLoadBalancerAdapter, options);
 }
+/**
+* Returns a request handler for AWS Lambda Function URL events (invoke mode BUFFERED).
+*
+* @param options - The handler options, including the React Router server build,
+*   optional getLoadContext function, and mode string.
+* @returns An AWS Lambda Function URL handler compatible with Lambda Function URLs with InvokeMode BUFFERED.
+*/
 function createFunctionURLRequestHandler(options) {
-  return createRequestHandlerForAdapter(apiGatewayV2Adapter, options);
+	return createRequestHandlerForAdapter(apiGatewayV2Adapter, options);
 }
+/**
+* Returns a request handler for AWS Lambda Function URL events (invoke mode RESPONSE_STREAM).
+*
+* @param options - The handler options, including the React Router server build,
+*   optional getLoadContext function, and mode string.
+* @returns A streaming AWS Lambda Function URL handler compatible with Lambda Function URLs with InvokeMode RESPONSE_STREAM.
+*/
 function createFunctionURLStreamingRequestHandler(options) {
-  return createRequestHandlerForAdapter(functionUrlStreamingAdapter, options);
+	return createRequestHandlerForAdapter(functionUrlStreamingAdapter, options);
 }
-function createRequestHandlerForAdapter(awsAdapter, { build, getLoadContext, mode = process.env.NODE_ENV }) {
-  const handleRequest = createReactRouterRequestHandler(build, mode);
-  return awsAdapter.wrapHandler(async (event, res) => {
-    let request;
-    try {
-      request = awsAdapter.createReactRouterRequest(event);
-    } catch (e) {
-      return await awsAdapter.sendReactRouterResponse(
-        new Response(`Bad Request: ${e instanceof Error ? e.message : e}`, { status: 400 }),
-        res
-      );
-    }
-    const loadContext = await getLoadContext?.(event);
-    const response = await handleRequest(request, loadContext);
-    return await awsAdapter.sendReactRouterResponse(response, res);
-  });
+function createRequestHandlerForAdapter(awsAdapter, { build, getLoadContext, mode = process.env.NODE_ENV, getHost }) {
+	const handleRequest = createRequestHandler$1(build, mode);
+	return awsAdapter.wrapHandler(async (event, res) => {
+		let request;
+		try {
+			request = awsAdapter.createReactRouterRequest(event, getHost);
+		} catch (e) {
+			return await awsAdapter.sendReactRouterResponse(new Response(`Bad Request: ${e instanceof Error ? e.message : e}`, { status: 400 }), res);
+		}
+		const loadContext = await getLoadContext?.(event);
+		const response = await handleRequest(request, loadContext);
+		return await awsAdapter.sendReactRouterResponse(response, res);
+	});
 }
-
-// src/legacy.ts
-var AWSProxy = /* @__PURE__ */ ((AWSProxy2) => {
-  AWSProxy2["APIGatewayV1"] = "APIGatewayV1";
-  AWSProxy2["APIGatewayV2"] = "APIGatewayV2";
-  AWSProxy2["ALB"] = "ALB";
-  AWSProxy2["FunctionURL"] = "FunctionURL";
-  AWSProxy2["FunctionURLStreaming"] = "FunctionURLStreaming";
-  return AWSProxy2;
-})(AWSProxy || {});
+//#endregion
+//#region src/legacy.ts
+let AWSProxy = /* @__PURE__ */ function(AWSProxy) {
+	AWSProxy["APIGatewayV1"] = "APIGatewayV1";
+	AWSProxy["APIGatewayV2"] = "APIGatewayV2";
+	AWSProxy["ALB"] = "ALB";
+	AWSProxy["FunctionURL"] = "FunctionURL";
+	AWSProxy["FunctionURLStreaming"] = "FunctionURLStreaming";
+	return AWSProxy;
+}({});
+/**
+* Returns a request handler for AWS that serves the response using React Router.
+*
+* @deprecated Use one of the gateway-specific create*RequestHandler methods instead for better tree-shaking.
+*  - `createAPIGatewayV1RequestHandler`
+*  - `createAPIGatewayV2RequestHandler`
+*  - `createALBRequestHandler`
+*  - `createFunctionURLRequestHandler`
+*  - `createFunctionURLStreamingRequestHandler`
+*/
 function createRequestHandler(options) {
-  const { awsProxy = "APIGatewayV2" /* APIGatewayV2 */, ...opts } = options;
-  switch (awsProxy) {
-    case "APIGatewayV1" /* APIGatewayV1 */:
-      return createAPIGatewayV1RequestHandler(
-        opts
-      );
-    case "APIGatewayV2" /* APIGatewayV2 */:
-      return createAPIGatewayV2RequestHandler(
-        opts
-      );
-    case "ALB" /* ALB */:
-      return createALBRequestHandler(opts);
-    case "FunctionURL" /* FunctionURL */:
-      return createFunctionURLRequestHandler(
-        opts
-      );
-    case "FunctionURLStreaming" /* FunctionURLStreaming */:
-      return createFunctionURLStreamingRequestHandler(
-        opts
-      );
-    default:
-      return assertNever(awsProxy, `Unsupported buffered AWS Proxy type: ${awsProxy}`);
-  }
+	const { awsProxy = "APIGatewayV2", ...opts } = options;
+	switch (awsProxy) {
+		case "APIGatewayV1": return createAPIGatewayV1RequestHandler(opts);
+		case "APIGatewayV2": return createAPIGatewayV2RequestHandler(opts);
+		case "ALB": return createALBRequestHandler(opts);
+		case "FunctionURL": return createFunctionURLRequestHandler(opts);
+		case "FunctionURLStreaming": return createFunctionURLStreamingRequestHandler(opts);
+		default: return assertNever(awsProxy, `Unsupported buffered AWS Proxy type: ${awsProxy}`);
+	}
 }
 function assertNever(_x, message) {
-  throw new Error(message);
+	throw new Error(message);
 }
-export {
-  AWSProxy,
-  createALBRequestHandler,
-  createAPIGatewayV1RequestHandler,
-  createAPIGatewayV2RequestHandler,
-  createFunctionURLRequestHandler,
-  createFunctionURLStreamingRequestHandler,
-  createRequestHandler
-};
+//#endregion
+export { AWSProxy, createALBRequestHandler, createAPIGatewayV1RequestHandler, createAPIGatewayV2RequestHandler, createFunctionURLRequestHandler, createFunctionURLStreamingRequestHandler, createRequestHandler };
+
+//# sourceMappingURL=index.mjs.map