acrylblends 0.7.3 → 0.7.4

package/lib/aws-lambda.d.ts

@@ -0,0 +1,324 @@
+import { Y as Schema, v as Env } from "./context-DS3fYyG-.js";
+import { r as GetConnInfo } from "./types-Dv_nV2cv.js";
+import { t as Acryl } from "./app-D8riatvv.js";
+
+//#region ../../plugins/acryl-router/src/core/adapter/aws-lambda/types.d.ts
+interface CognitoIdentity {
+  cognitoIdentityId: string;
+  cognitoIdentityPoolId: string;
+}
+interface ClientContext {
+  client: ClientContextClient;
+  Custom?: any;
+  env: ClientContextEnv;
+}
+interface ClientContextClient {
+  installationId: string;
+  appTitle: string;
+  appVersionName: string;
+  appVersionCode: string;
+  appPackageName: string;
+}
+interface ClientContextEnv {
+  platformVersion: string;
+  platform: string;
+  make: string;
+  model: string;
+  locale: string;
+}
+/**
+ * {@link Handler} context parameter.
+ * See {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html AWS documentation}.
+ */
+interface LambdaContext {
+  callbackWaitsForEmptyEventLoop: boolean;
+  functionName: string;
+  functionVersion: string;
+  invokedFunctionArn: string;
+  memoryLimitInMB: string;
+  awsRequestId: string;
+  logGroupName: string;
+  logStreamName: string;
+  identity?: CognitoIdentity | undefined;
+  clientContext?: ClientContext | undefined;
+  getRemainingTimeInMillis(): number;
+}
+type Callback<TResult = any> = (error?: Error | string | null, result?: TResult) => void;
+type Handler<TEvent = any, TResult = any> = (event: TEvent, context: LambdaContext, callback: Callback<TResult>) => void | Promise<TResult>;
+interface ClientCert {
+  clientCertPem: string;
+  subjectDN: string;
+  issuerDN: string;
+  serialNumber: string;
+  validity: {
+    notBefore: string;
+    notAfter: string;
+  };
+}
+interface Identity {
+  accessKey?: string;
+  accountId?: string;
+  caller?: string;
+  cognitoAuthenticationProvider?: string;
+  cognitoAuthenticationType?: string;
+  cognitoIdentityId?: string;
+  cognitoIdentityPoolId?: string;
+  principalOrgId?: string;
+  sourceIp: string;
+  user?: string;
+  userAgent: string;
+  userArn?: string;
+  clientCert?: ClientCert;
+}
+interface ApiGatewayRequestContext {
+  accountId: string;
+  apiId: string;
+  authorizer: {
+    claims?: unknown;
+    scopes?: unknown;
+  };
+  domainName: string;
+  domainPrefix: string;
+  extendedRequestId: string;
+  httpMethod: string;
+  identity: Identity;
+  path: string;
+  protocol: string;
+  requestId: string;
+  requestTime: string;
+  requestTimeEpoch: number;
+  resourceId?: string;
+  resourcePath: string;
+  stage: string;
+}
+interface Authorizer {
+  iam?: {
+    accessKey: string;
+    accountId: string;
+    callerId: string;
+    cognitoIdentity: null;
+    principalOrgId: null;
+    userArn: string;
+    userId: string;
+  };
+  jwt?: {
+    claims: Record<string, string | number | boolean | string[]>;
+    scopes: string[] | null;
+  };
+  /**
+   * The `context` object returned by a Lambda (REQUEST) authorizer.
+   * It is `null` when the authorizer returns no context.
+   */
+  lambda?: Record<string, unknown> | null;
+}
+interface ApiGatewayRequestContextV2 {
+  accountId: string;
+  apiId: string;
+  authentication: null;
+  authorizer: Authorizer;
+  domainName: string;
+  domainPrefix: string;
+  http: {
+    method: string;
+    path: string;
+    protocol: string;
+    sourceIp: string;
+    userAgent: string;
+  };
+  requestId: string;
+  routeKey: string;
+  stage: string;
+  time: string;
+  timeEpoch: number;
+}
+interface ALBRequestContext {
+  elb: {
+    targetGroupArn: string;
+  };
+}
+interface LatticeRequestContextV2 {
+  serviceNetworkArn: string;
+  serviceArn: string;
+  targetGroupArn: string;
+  region: string;
+  timeEpoch: string;
+  identity: {
+    sourceVpcArn?: string;
+    type?: string;
+    principal?: string;
+    principalOrgID?: string;
+    sessionName?: string;
+    x509IssuerOu?: string;
+    x509SanDns?: string;
+    x509SanNameCn?: string;
+    x509SanUri?: string;
+    x509SubjectCn?: string;
+  };
+}
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/aws-lambda/handler.d.ts
+type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent | LatticeProxyEventV2;
+interface LatticeProxyEventV2 {
+  version: string;
+  path: string;
+  method: string;
+  headers: Record<string, string[] | undefined>;
+  queryStringParameters: Record<string, string[] | undefined>;
+  body: string | null;
+  isBase64Encoded: boolean;
+  requestContext: LatticeRequestContextV2;
+}
+interface APIGatewayProxyEventV2 {
+  version: string;
+  routeKey: string;
+  headers: Record<string, string | undefined>;
+  multiValueHeaders?: undefined;
+  cookies?: string[];
+  rawPath: string;
+  rawQueryString: string;
+  body: string | null;
+  isBase64Encoded: boolean;
+  requestContext: ApiGatewayRequestContextV2;
+  queryStringParameters?: {
+    [name: string]: string | undefined;
+  };
+  pathParameters?: {
+    [name: string]: string | undefined;
+  };
+  stageVariables?: {
+    [name: string]: string | undefined;
+  };
+}
+interface APIGatewayProxyEvent {
+  version: string;
+  httpMethod: string;
+  headers: Record<string, string | undefined>;
+  multiValueHeaders?: {
+    [headerKey: string]: string[];
+  };
+  path: string;
+  body: string | null;
+  isBase64Encoded: boolean;
+  queryStringParameters?: Record<string, string | undefined>;
+  requestContext: ApiGatewayRequestContext;
+  resource: string;
+  multiValueQueryStringParameters?: {
+    [parameterKey: string]: string[];
+  };
+  pathParameters?: Record<string, string>;
+  stageVariables?: Record<string, string>;
+}
+interface ALBProxyEvent {
+  httpMethod: string;
+  headers?: Record<string, string | undefined>;
+  multiValueHeaders?: Record<string, string[] | undefined>;
+  path: string;
+  body: string | null;
+  isBase64Encoded: boolean;
+  queryStringParameters?: Record<string, string | undefined>;
+  multiValueQueryStringParameters?: {
+    [parameterKey: string]: string[];
+  };
+  requestContext: ALBRequestContext;
+}
+type WithHeaders = {
+  headers: Record<string, string | string[]>;
+  multiValueHeaders?: undefined;
+};
+type WithMultiValueHeaders = {
+  headers?: undefined;
+  multiValueHeaders: Record<string, string[]>;
+};
+type APIGatewayProxyResult = {
+  statusCode: number;
+  statusDescription?: string;
+  body: string;
+  cookies?: string[];
+  isBase64Encoded: boolean;
+} & (WithHeaders | WithMultiValueHeaders);
+declare const streamHandle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Acryl<E, S, BasePath>) => Handler;
+type HandleOptions = {
+  isContentTypeBinary: ((contentType: string) => boolean) | undefined;
+};
+/**
+ * Converts a Acryl application to an AWS Lambda handler.
+ *
+ * Accepts events from API Gateway (v1 and v2), Application Load Balancer (ALB),
+ * and Lambda Function URLs.
+ *
+ * @param app - The Acryl application instance
+ * @param options - Optional configuration
+ * @param options.isContentTypeBinary - A function to determine if the content type is binary.
+ *                                      If not provided, the default function will be used.
+ * @returns Lambda handler function
+ *
+ * @example
+ * ```js
+ * import { Acryl } from 'acrylblends'
+ * import { handle } from 'acrylblends/aws-lambda'
+ *
+ * const app = new Acryl()
+ *
+ * app.get('/', (c) => c.text('Hello from Lambda'))
+ * app.get('/json', (c) => c.json({ message: 'Hello JSON' }))
+ *
+ * export const handler = handle(app)
+ * ```
+ *
+ * @example
+ * ```js
+ * // With custom binary content type detection
+ * import { handle, defaultIsContentTypeBinary } from 'acrylblends/aws-lambda'
+ * export const handler = handle(app, {
+ *   isContentTypeBinary: (contentType) => {
+ *     if (defaultIsContentTypeBinary(contentType)) {
+ *       // default logic same as prior to v4.8.4
+ *       return true
+ *     }
+ *     return contentType.startsWith('image/') || contentType === 'application/pdf'
+ *   }
+ * })
+ * ```
+ */
+declare const handle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Acryl<E, S, BasePath>, {
+  isContentTypeBinary
+}?: HandleOptions) => (<L extends LambdaEvent>(event: L, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult & (L extends {
+  multiValueHeaders: Record<string, string[]>;
+} ? WithMultiValueHeaders : WithHeaders)>);
+/**
+ * Check if the given content type is binary.
+ * This is a default function and may be overwritten by the user via `isContentTypeBinary` option in handler().
+ * @param contentType The content type to check.
+ * @returns True if the content type is binary, false otherwise.
+ */
+declare const defaultIsContentTypeBinary: (contentType: string) => boolean;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/aws-lambda/conninfo.d.ts
+/**
+ * Get connection information from AWS Lambda
+ *
+ * Extracts client IP from various Lambda event sources:
+ * - API Gateway v1 (REST API): requestContext.identity.sourceIp
+ * - API Gateway v2 (HTTP API/Function URLs): requestContext.http.sourceIp
+ * - ALB: Falls back to x-forwarded-for header
+ *
+ * @param c - Context
+ * @returns Connection information including remote address
+ * @example
+ * ```ts
+ * import { Acryl } from 'acrylblends'
+ * import { handle, getConnInfo } from 'acrylblends/aws-lambda'
+ *
+ * const app = new Acryl()
+ *
+ * app.get('/', (c) => {
+ *   const info = getConnInfo(c)
+ *   return c.text(`Your IP: ${info.remote.address}`)
+ * })
+ *
+ * export const handler = handle(app)
+ * ```
+ */
+declare const getConnInfo: GetConnInfo;
+//#endregion
+export { type ALBRequestContext, type APIGatewayProxyResult, type ApiGatewayRequestContext, type ApiGatewayRequestContextV2, type LambdaContext, type LambdaEvent, defaultIsContentTypeBinary, getConnInfo, handle, streamHandle };

package/lib/aws-lambda.js

@@ -0,0 +1,357 @@
+import { decodeBase64, encodeBase64 } from "./utils/encode.js";
+import { pipeline } from "node:stream/promises";
+//#region ../../plugins/acryl-router/src/core/adapter/aws-lambda/handler.ts
+function sanitizeHeaderValue(value) {
+	if (!/[^\x00-\x7F]/.test(value)) return value;
+	return encodeURIComponent(value);
+}
+const getRequestContext = (event) => {
+	return event.requestContext;
+};
+async function* readWebStream(reader) {
+	let readResult = await reader.read();
+	while (!readResult.done) {
+		yield readResult.value;
+		readResult = await reader.read();
+	}
+}
+const streamToNodeStream = (reader, writer) => pipeline(readWebStream(reader), writer);
+const streamHandle = (app) => {
+	return awslambda.streamifyResponse(async (event, responseStream, context) => {
+		const processor = getProcessor(event);
+		try {
+			const req = processor.createRequest(event);
+			const requestContext = getRequestContext(event);
+			const res = await app.fetch(req, {
+				event,
+				requestContext,
+				context
+			});
+			const headers = {};
+			const cookies = [];
+			res.headers.forEach((value, name) => {
+				if (name === "set-cookie") cookies.push(value);
+				else headers[name] = value;
+			});
+			const httpResponseMetadata = {
+				statusCode: res.status,
+				headers,
+				cookies
+			};
+			responseStream = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata);
+			if (res.body) await streamToNodeStream(res.body.getReader(), responseStream);
+			else responseStream.write("");
+		} catch (error) {
+			console.error("Error processing request:", error);
+			responseStream.write("Internal Server Error");
+		} finally {
+			responseStream.end();
+		}
+	});
+};
+/**
+* Converts a Acryl application to an AWS Lambda handler.
+*
+* Accepts events from API Gateway (v1 and v2), Application Load Balancer (ALB),
+* and Lambda Function URLs.
+*
+* @param app - The Acryl application instance
+* @param options - Optional configuration
+* @param options.isContentTypeBinary - A function to determine if the content type is binary.
+*                                      If not provided, the default function will be used.
+* @returns Lambda handler function
+*
+* @example
+* ```js
+* import { Acryl } from 'acrylblends'
+* import { handle } from 'acrylblends/aws-lambda'
+*
+* const app = new Acryl()
+*
+* app.get('/', (c) => c.text('Hello from Lambda'))
+* app.get('/json', (c) => c.json({ message: 'Hello JSON' }))
+*
+* export const handler = handle(app)
+* ```
+*
+* @example
+* ```js
+* // With custom binary content type detection
+* import { handle, defaultIsContentTypeBinary } from 'acrylblends/aws-lambda'
+* export const handler = handle(app, {
+*   isContentTypeBinary: (contentType) => {
+*     if (defaultIsContentTypeBinary(contentType)) {
+*       // default logic same as prior to v4.8.4
+*       return true
+*     }
+*     return contentType.startsWith('image/') || contentType === 'application/pdf'
+*   }
+* })
+* ```
+*/
+const handle = (app, { isContentTypeBinary } = { isContentTypeBinary: void 0 }) => {
+	return async (event, lambdaContext) => {
+		const processor = getProcessor(event);
+		let req, requestContext;
+		try {
+			req = processor.createRequest(event);
+			requestContext = getRequestContext(event);
+		} catch (error) {
+			console.error("Error processing request:", error);
+			const errorResponse = error instanceof TypeError ? new Response("Invalid request", { status: 400 }) : new Response("Internal Server Error", { status: 500 });
+			return processor.createResult(event, errorResponse, { isContentTypeBinary });
+		}
+		const res = await app.fetch(req, {
+			event,
+			requestContext,
+			lambdaContext
+		});
+		return processor.createResult(event, res, { isContentTypeBinary });
+	};
+};
+var EventProcessor = class {
+	getHeaderValue(headers, key) {
+		return headers ? Array.isArray(headers[key]) ? headers[key][0] : headers[key] : void 0;
+	}
+	getDomainName(event) {
+		if (event.requestContext && "domainName" in event.requestContext) return event.requestContext.domainName;
+		const hostFromHeaders = this.getHeaderValue(event.headers, "host");
+		if (hostFromHeaders) return hostFromHeaders;
+		const multiValueHeaders = "multiValueHeaders" in event ? event.multiValueHeaders : {};
+		return this.getHeaderValue(multiValueHeaders, "host");
+	}
+	createRequest(event) {
+		const queryString = this.getQueryString(event);
+		const urlPath = `https://${this.getDomainName(event)}${this.getPath(event)}`;
+		const url = queryString ? `${urlPath}?${queryString}` : urlPath;
+		const headers = this.getHeaders(event);
+		const requestInit = {
+			headers,
+			method: this.getMethod(event)
+		};
+		if (event.body) {
+			const body = event.isBase64Encoded ? decodeBase64(event.body) : new TextEncoder().encode(event.body);
+			requestInit.body = body;
+			headers.set("content-length", body.length.toString());
+		}
+		return new Request(url, requestInit);
+	}
+	async createResult(event, res, options) {
+		const contentType = res.headers.get("content-type");
+		const isContentTypeBinary = options.isContentTypeBinary ?? defaultIsContentTypeBinary;
+		let isBase64Encoded = contentType && isContentTypeBinary(contentType) ? true : false;
+		if (!isBase64Encoded) {
+			const contentEncoding = res.headers.get("content-encoding");
+			isBase64Encoded = isContentEncodingBinary(contentEncoding);
+		}
+		const result = {
+			body: isBase64Encoded ? encodeBase64(await res.arrayBuffer()) : await res.text(),
+			statusCode: res.status,
+			isBase64Encoded,
+			..."multiValueHeaders" in event && event.multiValueHeaders ? { multiValueHeaders: {} } : { headers: {} }
+		};
+		this.setCookies(event, res, result);
+		if (result.multiValueHeaders) res.headers.forEach((value, key) => {
+			result.multiValueHeaders[key] = [value];
+		});
+		else res.headers.forEach((value, key) => {
+			result.headers[key] = value;
+		});
+		return result;
+	}
+	setCookies(_event, res, result) {
+		if (res.headers.has("set-cookie")) {
+			const cookies = res.headers.getSetCookie ? res.headers.getSetCookie() : Array.from(res.headers.entries()).filter(([k]) => k === "set-cookie").map(([, v]) => v);
+			if (Array.isArray(cookies)) {
+				this.setCookiesToResult(result, cookies);
+				res.headers.delete("set-cookie");
+			}
+		}
+	}
+};
+var EventV2Processor = class extends EventProcessor {
+	getPath(event) {
+		return event.rawPath;
+	}
+	getMethod(event) {
+		return event.requestContext.http.method;
+	}
+	getQueryString(event) {
+		return event.rawQueryString;
+	}
+	getCookies(event, headers) {
+		if (Array.isArray(event.cookies)) headers.set("Cookie", event.cookies.join("; "));
+	}
+	setCookiesToResult(result, cookies) {
+		result.cookies = cookies;
+	}
+	getHeaders(event) {
+		const headers = new Headers();
+		this.getCookies(event, headers);
+		if (event.headers) {
+			for (const [k, v] of Object.entries(event.headers)) if (v) headers.set(k, v);
+		}
+		return headers;
+	}
+};
+const v2Processor = new EventV2Processor();
+var EventV1Processor = class extends EventProcessor {
+	getPath(event) {
+		return event.path;
+	}
+	getMethod(event) {
+		return event.httpMethod;
+	}
+	getQueryString(event) {
+		if (event.multiValueQueryStringParameters) return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(([key, values]) => values.map((value) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&")).join("&");
+		else return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value || "")}`).join("&");
+	}
+	getCookies(_event, _headers) {}
+	getHeaders(event) {
+		const headers = new Headers();
+		this.getCookies(event, headers);
+		if (event.multiValueHeaders) {
+			for (const [k, values] of Object.entries(event.multiValueHeaders)) if (values) values.forEach((v) => headers.append(k, sanitizeHeaderValue(v)));
+		}
+		if (event.headers) {
+			for (const [k, v] of Object.entries(event.headers)) if (v && !headers.has(k)) headers.set(k, sanitizeHeaderValue(v));
+		}
+		return headers;
+	}
+	setCookiesToResult(result, cookies) {
+		result.multiValueHeaders = { "set-cookie": cookies };
+	}
+};
+const v1Processor = new EventV1Processor();
+var ALBProcessor = class extends EventProcessor {
+	getHeaders(event) {
+		const headers = new Headers();
+		if (event.multiValueHeaders) {
+			for (const [key, values] of Object.entries(event.multiValueHeaders)) if (values && Array.isArray(values)) {
+				const sanitizedValue = sanitizeHeaderValue(values.join("; "));
+				headers.set(key, sanitizedValue);
+			}
+		} else for (const [key, value] of Object.entries(event.headers ?? {})) if (value) headers.set(key, sanitizeHeaderValue(value));
+		return headers;
+	}
+	getPath(event) {
+		return event.path;
+	}
+	getMethod(event) {
+		return event.httpMethod;
+	}
+	getQueryString(event) {
+		if (event.multiValueQueryStringParameters) return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value.join(`&${key}=`)}`).join("&");
+		else return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value !== void 0).map(([key, value]) => `${key}=${value}`).join("&");
+	}
+	getCookies(event, headers) {
+		let cookie;
+		if (event.multiValueHeaders) cookie = event.multiValueHeaders["cookie"]?.join("; ");
+		else cookie = event.headers ? event.headers["cookie"] : void 0;
+		if (cookie) headers.append("Cookie", cookie);
+	}
+	setCookiesToResult(result, cookies) {
+		if (result.multiValueHeaders) result.multiValueHeaders["set-cookie"] = cookies;
+		else result.headers["set-cookie"] = cookies[0];
+	}
+};
+const albProcessor = new ALBProcessor();
+var LatticeV2Processor = class extends EventProcessor {
+	getPath(event) {
+		return event.path;
+	}
+	getMethod(event) {
+		return event.method;
+	}
+	getQueryString() {
+		return "";
+	}
+	getHeaders(event) {
+		const headers = new Headers();
+		if (event.headers) {
+			for (const [k, values] of Object.entries(event.headers)) if (values) values.forEach((v) => headers.append(k, sanitizeHeaderValue(v)));
+		}
+		return headers;
+	}
+	getCookies() {}
+	setCookiesToResult(result, cookies) {
+		result.headers = {
+			...result.headers,
+			"set-cookie": cookies
+		};
+	}
+};
+const latticeV2Processor = new LatticeV2Processor();
+const getProcessor = (event) => {
+	if (isProxyEventALB(event)) return albProcessor;
+	if (isProxyEventV2(event)) return v2Processor;
+	if (isLatticeEventV2(event)) return latticeV2Processor;
+	return v1Processor;
+};
+const isProxyEventALB = (event) => {
+	if (event.requestContext) return Object.hasOwn(event.requestContext, "elb");
+	return false;
+};
+const isProxyEventV2 = (event) => {
+	return Object.hasOwn(event, "rawPath") && Object.hasOwn(event.requestContext ?? {}, "http");
+};
+const isLatticeEventV2 = (event) => {
+	if (event.requestContext) return Object.hasOwn(event.requestContext, "serviceArn");
+	return false;
+};
+/**
+* Check if the given content type is binary.
+* This is a default function and may be overwritten by the user via `isContentTypeBinary` option in handler().
+* @param contentType The content type to check.
+* @returns True if the content type is binary, false otherwise.
+*/
+const defaultIsContentTypeBinary = (contentType) => {
+	if (/^application\/vnd\.(?:apple\.installer|mozilla\.xul)\+xml\s*(?:;|$)/i.test(contentType)) return true;
+	return !/^text\/(?:plain|html|css|javascript|csv)|(?:\/|\+)(?:json|xml)\s*(?:;|$)/i.test(contentType);
+};
+const isContentEncodingBinary = (contentEncoding) => {
+	return !!contentEncoding && !/^identity$/i.test(contentEncoding);
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/aws-lambda/conninfo.ts
+/**
+* Get connection information from AWS Lambda
+*
+* Extracts client IP from various Lambda event sources:
+* - API Gateway v1 (REST API): requestContext.identity.sourceIp
+* - API Gateway v2 (HTTP API/Function URLs): requestContext.http.sourceIp
+* - ALB: Falls back to x-forwarded-for header
+*
+* @param c - Context
+* @returns Connection information including remote address
+* @example
+* ```ts
+* import { Acryl } from 'acrylblends'
+* import { handle, getConnInfo } from 'acrylblends/aws-lambda'
+*
+* const app = new Acryl()
+*
+* app.get('/', (c) => {
+*   const info = getConnInfo(c)
+*   return c.text(`Your IP: ${info.remote.address}`)
+* })
+*
+* export const handler = handle(app)
+* ```
+*/
+const getConnInfo = (c) => {
+	const requestContext = c.env.requestContext;
+	let address;
+	if ("identity" in requestContext && requestContext.identity?.sourceIp) address = requestContext.identity.sourceIp;
+	else if ("http" in requestContext && requestContext.http?.sourceIp) address = requestContext.http.sourceIp;
+	else {
+		const xff = c.req.header("x-forwarded-for");
+		if (xff) {
+			const ips = xff.split(",");
+			address = ips[ips.length - 1].trim();
+		}
+	}
+	return { remote: { address } };
+};
+//#endregion
+export { defaultIsContentTypeBinary, getConnInfo, handle, streamHandle };