elysia 0.4.14 → 0.5.0-beta.0

package/dist/cjs/compose.d.ts

@@ -0,0 +1,17 @@
+import type { Elysia } from '.';
+import { SCHEMA, DEFS } from './utils';
+import type { ComposedHandler, HTTPMethod, LocalHandler, RegisteredHook, SchemaValidator } from './types';
+import { TAnySchema } from '@sinclair/typebox';
+export declare const hasReturn: (fnLiteral: string) => boolean;
+export declare const isFnUse: (keyword: string, fnLiteral: string) => boolean;
+export declare const findElysiaMeta: (type: string, schema: TAnySchema, found?: string[], parent?: string) => string[] | "root" | null;
+export declare const composeHandler: ({ path, method, hooks, validator, handler, handleError, meta }: {
+    path: string;
+    method: HTTPMethod;
+    hooks: RegisteredHook<any>;
+    validator: SchemaValidator;
+    handler: LocalHandler<any, any>;
+    handleError: Elysia['handleError'];
+    meta?: (Record<typeof SCHEMA, {}> & Record<typeof DEFS, {}> & Record<typeof import("./utils").EXPOSED, {}>) | undefined;
+}) => ComposedHandler;
+export declare const composeGeneralHandler: (app: Elysia<any>) => any;

package/dist/cjs/compose.js

@@ -0,0 +1,257 @@
+import{parse as e}from"fast-querystring";import{mapEarlyResponse as r,mapResponse as t}from"./handler";import{SCHEMA as a,DEFS as s}from"./utils";import{ParseError as o,NotFoundError as n,ValidationError as c,InternalServerError as l}from"./error";let i="AsyncFunction",f=e=>e.constructor.name===i,d=new Headers,u=RegExp(" (\\w+) = context","g");export const hasReturn=e=>{let r=e.indexOf(")");return 61===e.charCodeAt(r+2)&&123!==e.charCodeAt(r+5)||e.includes("return")};export const isFnUse=(e,r)=>{let t=r.slice(r.indexOf("(")+1,r.indexOf(")"));if(""===t)return!1;if(123===t.charCodeAt(0))return!!(t.includes(`{ ${e}`)||t.includes(`, ${e}`));if(r.match(RegExp(`${t}(.${e}|\\["${e}"\\])`)))return!0;let a=[t];for(let e of r.matchAll(u))a.push(e[1]);let s=RegExp(`{.*?} = (${a.join("|")})`,"g");for(let[t]of r.matchAll(s))if(t.includes(`{ ${e}`)||t.includes(`, ${e}`))return!0;return!1};export const findElysiaMeta=(e,r,t=[],a="")=>{if("object"===r.type){let s=r.properties;for(let r in s){let o=s[r],n=a?a+"."+r:r;if("object"===o.type){findElysiaMeta(e,o,t,n);continue}if(o.anyOf){for(let r of o.anyOf)findElysiaMeta(e,r,t,n);continue}o.elysiaMeta===e&&t.push(n)}return 0===t.length?null:t}return r?.elysiaMeta===e?(a&&t.push(a),"root"):null};export const composeHandler=({path:u,method:p,hooks:y,validator:h,handler:m,handleError:$,meta:b})=>{let w="try {\n",E="string"==typeof y.type,q=h||"GET"!==p?[m,...y.transform,...y.beforeHandle,...y.afterHandle].map(e=>e.toString()):[],g="GET"!==p&&(h.body||E||q.some(e=>isFnUse("body",e))),k=h.headers||q.some(e=>isFnUse("headers",e));k&&(w+=d.toJSON?`c.headers = c.request.headers.toJSON()
+`:`c.headers = {}
+                for (const key of c.request.headers.keys())
+					h[key] = c.request.headers.get(key)
+
+                if (headers.Check(h) === false) {
+                    throw throw new ValidationError(
+                        'header',
+                        headers,
+                        h
+                    )
+				}
+			`);let x=h.query||q.some(e=>isFnUse("query",e));x&&(w+=`const url = c.request.url
+
+		if(url.charCodeAt(c.query) === 63 || (c.query = url.indexOf("?", ${11+u.split("/").map(e=>e.startsWith(":")?"-":"").length})) !== -1) {
+			c.query = parseQuery(url.substring(c.query + 1))
+		} else {
+			c.query = {}
+		}
+		`);let H=g||m.constructor.name===i||y.parse.length||y.afterHandle.find(f)||y.beforeHandle.find(f)||y.transform.find(f);if(g){let e=h?.body?.schema;if(e&&"anyOf"in e){let r=!1,t=e.anyOf[0].type;for(let a of e.anyOf)if(a.type!==t){r=!0;break}r&&(e=void 0)}if(E||e){if(e)"object"===e.type?"URLEncoded"===e.elysiaMeta?w+="c.body = parseQuery(await c.request.text())":h.body.Code().includes("custom('File")?w+=`c.body = {}
+
+				await c.request.formData().then((form) => {
+					for (const key of form.keys()) {
+						if (c.body[key])
+							continue
+
+						const value = form.getAll(key)
+						if (value.length === 1)
+							c.body[key] = value[0]
+						else c.body[key] = value
+					}
+				})`:w+="c.body = JSON.parse(await c.request.text())":w+="c.body = await c.request.text()";else switch(y.type){case"application/json":w+="c.body = JSON.parse(await c.request.text());";break;case"text/plain":w+="c.body = await c.request.text();";break;case"application/x-www-form-urlencoded":w+="c.body = parseQuery(await c.request.text());";break;case"multipart/form-data":w+=`c.body = {}
+
+					for (const key of (await c.request.formData()).keys()) {
+						if (c.body[key])
+							continue
+
+						const value = form.getAll(key)
+						if (value.length === 1)
+							c.body[key] = value[0]
+						else c.body[key] = value
+					}`}}else{if(w+="\n"+(k?"let contentType = c.headers['content-type']":"let contentType = c.request.headers.get('content-type')")+`
+            if (contentType) {
+				const index = contentType.indexOf(';')
+				if (index !== -1) contentType = contentType.substring(0, index)
+`,y.parse.length){w+=`let used = false
+`;for(let e=0;e<y.parse.length;e++){let r=`bo${e}`;w+=`if(!c.request.bodyUsed) { 
+					let ${r} = parse[${e}](c, contentType);
+					if(${r} instanceof Promise) ${r} = await ${r}
+					if(${r} !== undefined) { c.body = ${r}; used = true }
+				}`}w+="if (!used)"}w+=`switch (contentType) {
+			case 'application/json':
+				c.body = JSON.parse(await c.request.text())
+				break
+
+			case 'text/plain':
+				c.body = await c.request.text()
+				break
+
+			case 'application/x-www-form-urlencoded':
+				c.body = parseQuery(await c.request.text())
+				break
+
+			case 'multipart/form-data':
+				c.body = {}
+
+				for (const key of (await c.request.formData()).keys()) {
+					if (c.body[key])
+						continue
+
+					const value = form.getAll(key)
+					if (value.length === 1)
+						c.body[key] = value[0]
+					else c.body[key] = value
+				}
+
+				break
+			}
+		}
+`}w+="\n"}if(h.params){let e=findElysiaMeta("Numeric",h.params.schema);if(e){if("object"==typeof e)for(let r of e)w+=`c.params.${r} = +c.params.${r}`;w+="\n"}}if(h.query){let e=findElysiaMeta("Numeric",h.query.schema);if(e){if("object"==typeof e)for(let r of e)w+=`c.query.${r} = +c.query.${r}`;w+="\n"}}if(h.headers){let e=findElysiaMeta("Numeric",h.headers.schema);if(e){if("object"==typeof e)for(let r of e)w+=`c.headers.${r} = +c.headers.${r}`;w+="\n"}}if(h.body){let e=findElysiaMeta("Numeric",h.body.schema);if(e){switch(typeof e){case"string":w+="c.body = +c.body";break;case"object":for(let r of e)w+=`c.body.${r} = +c.body.${r}`}w+="\n"}}if(y?.transform)for(let e=0;e<y.transform.length;e++)w+=y.transform[e].constructor.name===i?`await transform[${e}](c);`:`transform[${e}](c);`;if(h&&(h.headers&&(w+=`
+                if (headers.Check(c.headers) === false) {
+                    throw new ValidationError(
+                        'header',
+                        headers,
+                        c.headers
+                    )
+				}
+        `),h.params&&(w+="if(params.Check(c.params) === false) { throw new ValidationError('params', params, c.params) }"),h.query&&(w+="if(query.Check(c.query) === false) { throw new ValidationError('query', query, c.query) }"),h.body&&(w+="if(body.Check(c.body) === false) { throw new ValidationError('body', body, c.body) }")),y?.beforeHandle)for(let e=0;e<y.beforeHandle.length;e++){let r=`be${e}`,t=hasReturn(y.beforeHandle[e].toString());if(t){if(w+=(y.beforeHandle[e].constructor.name===i?`let ${r} = await beforeHandle[${e}](c);
+`:`let ${r} = beforeHandle[${e}](c);
+`)+`if(${r} !== undefined) {
+`,y?.afterHandle)for(let e=0;e<y.afterHandle.length;e++){let t=hasReturn(y.afterHandle[e].toString());if(t){let t=`af${e}`;w+=(y.afterHandle[e].constructor.name===i?`const ${t} = await afterHandle[${e}](c, ${r});
+`:`const ${t} = afterHandle[${e}](c, ${r});
+`)+`if(${t} !== undefined) { ${r} = ${t} }
+`}else w+=y.afterHandle[e].constructor.name===i?`await afterHandle[${e}](c, ${r});
+`:`afterHandle[${e}](c, ${r});
+`}h.response&&(w+=`if(response[c.set.status]?.Check(${r}) === false) { 
+						if(!(response instanceof Error))
+							throw new ValidationError('response', response[c.set.status], ${r}) 
+					}
+`),w+=`return mapEarlyResponse(${r}, c.set)}
+`}else w+=y.beforeHandle[e].constructor.name===i?`await beforeHandle[${e}](c);
+`:`beforeHandle[${e}](c);
+`}if(y?.afterHandle.length){w+=m.constructor.name===i?`let r = await handler(c);
+`:`let r = handler(c);
+`;for(let e=0;e<y.afterHandle.length;e++){let r=`af${e}`,t=hasReturn(y.afterHandle[e].toString());t?(w+=y.afterHandle[e].constructor.name===i?`let ${r} = await afterHandle[${e}](c, r)
+`:`let ${r} = afterHandle[${e}](c, r)
+`,h.response?w+=`if(response[c.set.status]?.Check(${r}) === false) { 
+						if(!(response instanceof Error))
+							throw new ValidationError('response', response[c.set.status], ${r}) 
+					}
+${r} = mapEarlyResponse(${r}, c.set)
+if(${r}) return ${r};
+`:w+=`if(${r}) return ${r};
+`):w+=y.afterHandle[e].constructor.name===i?`await afterHandle[${e}](c, r)
+`:`afterHandle[${e}](c, r)
+`}h.response&&(w+=`if(response[c.set.status]?.Check(r) === false) { 
+				if(!(response instanceof Error))
+					throw new ValidationError('response', response[c.set.status], r) 
+			}
+`),w+=`return mapResponse(r, c.set);
+`}else h.response?w+=(m.constructor.name===i?`const r = await handler(c);
+`:`const r = handler(c);
+`)+`if(response[c.set.status]?.Check(r) === false) { 
+				if(!(response instanceof Error))
+					throw new ValidationError('response', response[c.set.status], r) 
+			}
+`+"return mapResponse(r, c.set);":w+=m.constructor.name===i?"return mapResponse(await handler(c), c.set);":"return mapResponse(handler(c), c.set);";w+=`
+} catch(error) {
+	
+
+	${H?"":"return (async () => {"}
+		const set = c.set
+
+		if (!set.status || set.status < 300) set.status = 500
+
+		${y.error.length?`for (let i = 0; i < handleErrors.length; i++) {
+				let handled = handleErrors[i]({
+					request: c.request,
+					error: error,
+					set,
+					code: error.code ?? "UNKNOWN"
+				})
+				if (handled instanceof Promise) handled = await handled
+
+				const response = mapEarlyResponse(handled, set)
+				if (response) return response
+			}`:""}
+
+		return handleError(c.request, error, set)
+	${H?"":"})()"}
+}`,w=`const { 
+		handler,
+		handleError,
+		hooks: {
+			transform,
+			beforeHandle,
+			afterHandle,
+			parse,
+			error: handleErrors
+		},
+		validator: {
+			body,
+			headers,
+			params,
+			query,
+			response
+		},
+		utils: {
+			mapResponse,
+			mapEarlyResponse,
+			mapErrorCode,
+			parseQuery
+		},
+		error: {
+			ParseError,
+			NotFoundError,
+			ValidationError,
+			InternalServerError
+		},
+		${b?`
+			meta,
+			SCHEMA,
+			DEFS,`:""}
+	} = hooks
+
+	const parseError = new ParseError()
+
+	return ${H?"async":""} function(c) {
+		${b?"c[SCHEMA] = meta[SCHEMA]; c[DEFS] = meta[DEFS];":""}
+		${w}
+	}`;let v=Function("hooks",w);return v({handler:m,hooks:y,validator:h,handleError:$,utils:{mapResponse:t,mapEarlyResponse:r,parseQuery:e},error:{ParseError:o,NotFoundError:n,ValidationError:c,InternalServerError:l},meta:b,SCHEMA:b?a:void 0,DEFS:b?s:void 0})};export const composeGeneralHandler=e=>{let t="";for(let r of Object.keys(e.decorators))t+=`,${r}: app.decorators.${r}`;let a=e.staticRouter,s="";for(let[e,r]of Object.entries(a.map))s+=`case '${e}':
+switch(method) {
+${r}}
+
+`;let o=`const {
+		app,
+		app: { store, router, staticRouter },
+		${e.event.request.length?"mapEarlyResponse,":""}
+		NotFoundError
+	} = data
+
+	const getPath = /\\/[^?#]+/g
+	const notFound = new NotFoundError()
+
+	${e.event.request.length?`const onRequest = app.event.request
+			   const requestLength = app.event.request.length`:""}
+
+	${a.variables}
+
+	const find = router.find.bind(router)
+
+	return function(request) {
+		const ctx = {
+			request,
+			store,
+			set: {
+				headers: {},
+				status: 200
+			}
+			${t}
+		}
+
+		${e.event.request.length?`			
+				try {
+					for (let i = 0; i < requestLength; i++) {
+						const response = mapEarlyResponse(
+							onRequest[i](ctx),
+							ctx.set
+						)
+						if (response) return response
+					}
+				} catch (error) {
+					return app.handleError(request, error, ctx.set)
+				}`:""}
+
+		getPath.lastIndex = 11
+		const { url, method } = request,
+			path = getPath.exec(url)?.[0] ?? '/'
+
+		ctx.query = getPath.lastIndex
+
+		switch(path) {
+			${s}
+		}
+	
+		const route = find(method, path)
+		if (route === null)
+			return app.handleError(
+				request,
+				notFound,
+				ctx.set
+			)
+
+		ctx.params = route.params
+
+		return route.store(ctx)
+	}`;return Function("data",o)({app:e,mapEarlyResponse:r,NotFoundError:n})};

package/dist/cjs/context.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="bun-types" />
+import type { Elysia, TypedRoute, DEFS, SCHEMA, TypedSchema } from '.';
+export interface Context<Route extends TypedRoute = TypedRoute, Store extends Elysia['store'] = Elysia['store']> {
+    request: Request;
+    headers: undefined extends Route['headers'] ? Record<string, unknown> : Route['headers'];
+    query: undefined extends Route['query'] ? Record<string, unknown> : Route['query'];
+    params: Route['params'];
+    body: Route['body'];
+    store: Store;
+    [SCHEMA]?: TypedSchema;
+    [DEFS]?: {
+        [index: string]: Record<string, unknown>;
+    };
+    set: {
+        headers: Record<string, string>;
+        status?: number;
+        redirect?: string;
+    };
+}
+export type PreContext<Route extends TypedRoute = TypedRoute, Store extends Elysia['store'] = Elysia['store']> = Omit<Context<Route, Store>, 'query' | 'params' | 'body'>;

package/dist/cjs/context.js

@@ -0,0 +1 @@
+export{};

package/dist/cjs/custom-types.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="bun-types" />
+import { Type, type SchemaOptions, type NumericOptions } from '@sinclair/typebox';
+type MaybeArray<T> = T | T[];
+export declare namespace ElysiaTypeOptions {
+    type Numeric = NumericOptions<number>;
+    type FileUnit = number | `${number}${'k' | 'm'}`;
+    interface File extends SchemaOptions {
+        type?: MaybeArray<(string & {}) | 'image' | 'image/jpeg' | 'image/png' | 'image/gif' | 'image/tiff' | 'image/x-icon' | 'image/svg' | 'image/webp' | 'image/avif' | 'audio' | 'audio/mpeg' | 'audio/x-ms-wma' | 'audio/vnd.rn-realaudio' | 'audio/x-wav' | 'video' | 'video/mpeg' | 'video/mp4' | 'video/quicktime' | 'video/x-ms-wmv' | 'video/x-msvideo' | 'video/x-flv' | 'video/webm' | 'text' | 'text/css' | 'text/csv' | 'text/html' | 'text/javascript' | 'text/plain' | 'text/xml' | 'application' | 'application/ogg' | 'application/pdf' | 'application/xhtml' | 'application/html' | 'application/json' | 'application/ld+json' | 'application/xml' | 'application/zip'>;
+        minSize?: FileUnit;
+        maxSize?: FileUnit;
+    }
+    interface Files extends File {
+        minItems?: number;
+        maxItems?: number;
+    }
+}
+export declare const ElysiaType: {
+    readonly Numeric: (options?: Partial<NumericOptions<number>> | undefined) => import("@sinclair/typebox").TUnsafe<number>;
+    readonly File: (options?: Partial<ElysiaTypeOptions.File> | undefined) => import("@sinclair/typebox").TUnsafe<Blob>;
+    readonly Files: (options?: Partial<ElysiaTypeOptions.Files> | undefined) => import("@sinclair/typebox").TUnsafe<Blob[]>;
+};
+declare module '@sinclair/typebox' {
+    interface TypeBuilder {
+        Numeric: typeof ElysiaType.Numeric;
+        File: typeof ElysiaType.File;
+        Files: typeof ElysiaType.Files;
+        URLEncoded: (typeof Type)['Object'];
+    }
+}
+export { Type as t };

package/dist/cjs/custom-types.js

@@ -0,0 +1 @@
+import{Type as e}from"@sinclair/typebox";import{TypeSystem as t}from"@sinclair/typebox/system";try{t.Format("email",e=>/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(e)),t.Format("uuid",e=>/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(e)),t.Format("date",e=>!Number.isNaN(new Date(e).getTime())),t.Format("date-time",e=>!Number.isNaN(new Date(e).getTime()))}catch(e){}let i=e=>{if("string"==typeof e)switch(e.slice(-1)){case"k":return 1024*+e.slice(0,e.length-1);case"m":return 1048576*+e.slice(0,e.length-1);default:return+e}return e},r=(e,t)=>{if(!(t instanceof Blob)||e.minSize&&t.size<i(e.minSize)||e.maxSize&&t.size>i(e.maxSize))return!1;if(e.extension){if("string"==typeof e.extension){if(!t.type.startsWith(e.extension))return!1}else{for(let i=0;i<e.extension.length;i++)if(t.type.startsWith(e.extension[i]))return!0;return!1}}return!0};export const ElysiaType={Numeric:t.Type("Numeric",{}),File:t.Type("File",r),Files:t.Type("Files",(e,t)=>{if(!Array.isArray(t)||e.minItems&&t.length<e.minItems||e.maxItems&&t.length>e.maxItems)return!1;for(let i=0;i<t.length;i++)if(!r(e,t[i]))return!1;return!0})};e.Numeric=t=>e.Number({...t,elysiaMeta:"Numeric"}),e.URLEncoded=(t,i)=>e.Object(t,{...i,elysiaMeta:"URLEncoded"}),e.File=e=>ElysiaType.File({elysiaMeta:"File",default:"File",...e,extension:e?.type,type:"string",format:"binary"}),e.Files=e=>ElysiaType.Files({...e,elysiaMeta:"Files",default:"Files",extension:e?.type,type:"array",items:{...e,default:"Files",type:"string",format:"binary"}});export{e as t};

package/dist/cjs/error.d.ts

@@ -0,0 +1,24 @@
+import type { TypeCheck } from '@sinclair/typebox/compiler';
+export declare class InternalServerError extends Error {
+    code: string;
+    status: number;
+    constructor();
+}
+export declare class NotFoundError extends Error {
+    code: string;
+    status: number;
+    constructor();
+}
+export declare class ParseError extends Error {
+    code: string;
+    status: number;
+    constructor();
+}
+export declare class ValidationError extends Error {
+    validator: TypeCheck<any>;
+    value: unknown;
+    code: string;
+    status: number;
+    constructor(type: string, validator: TypeCheck<any>, value: unknown);
+    get all(): import("@sinclair/typebox/compiler").ValueError[];
+}

package/dist/cjs/error.js

@@ -0,0 +1 @@
+export class InternalServerError extends Error{code="NOT_FOUND";status=500;constructor(){super("INTERNAL_SERVER_ERROR")}}export class NotFoundError extends Error{code="NOT_FOUND";status=404;constructor(){super("NOT_FOUND")}}export class ParseError extends Error{code="PARSE";status=400;constructor(){super("PARSE")}}export class ValidationError extends Error{validator;value;code;status;constructor(r,t,s){let o=t.Errors(s).First();super(`Invalid ${r}: '${o?.path?.slice(1)||"root"}'. ${o?.message}`),this.validator=t,this.value=s,this.code="VALIDATION",this.status=400}get all(){return[...this.validator.Errors(this.value)]}}

package/dist/cjs/handler.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="bun-types" />
+import type { Context } from './context';
+export declare const isNotEmpty: (obj: Object) => boolean;
+export declare const mapEarlyResponse: (response: unknown, set: Context['set']) => Response | undefined;
+export declare const mapResponse: (response: unknown, set: Context['set']) => Response;
+export declare const errorToResponse: (error: Error, headers?: HeadersInit) => Response;

package/dist/cjs/handler.js

@@ -0,0 +1 @@
+export const isNotEmpty=e=>{for(let s in e)return!0;return!1};let e=(e,s)=>{e.delete("Set-Cookie");for(let r=0;r<s.length;r++){let t=s[r].indexOf("=");e.append("Set-Cookie",`${s[r].slice(0,t)}=${s[r].slice(t+1)}`)}return e};export const mapEarlyResponse=(s,r)=>{if(isNotEmpty(r.headers)||200!==r.status||r.redirect)switch(r.redirect&&(r.headers.Location=r.redirect,r.status=302),r.headers["Set-Cookie"]&&Array.isArray(r.headers["Set-Cookie"])&&(r.headers=e(new Headers(r.headers),r.headers["Set-Cookie"])),typeof s){case"string":return new Response(s,{status:r.status,headers:r.headers});case"object":switch(s.constructor.name){case"Object":case"Array":case void 0:return Response.json(s,{status:r.status,headers:r.headers});case"Error":return errorToResponse(s,r.headers);case"Response":for(let e in r.headers)s.headers.append(e,r.headers[e]);return s;case"Blob":default:return new Response(s,{status:r.status,headers:r.headers});case"Promise":return s.then(e=>{let s=mapEarlyResponse(e,r);if(void 0!==s)return s})}case"function":if(s instanceof Blob)return new Response(s,{status:r.status,headers:r.headers});for(let e in r.headers)s.headers.append(e,r.headers[e]);return s;case"number":case"boolean":return new Response(s.toString(),{status:r.status,headers:r.headers})}else switch(typeof s){case"string":return new Response(s);case"object":switch(s.constructor?.name){case"Object":case"Array":case void 0:return Response.json(s);case"Response":return s;case"Error":return errorToResponse(s,r.headers);case"Blob":default:return new Response(s);case"Promise":return s.then(e=>{let s=mapEarlyResponse(e,r);if(void 0!==s)return s})}case"function":if(s instanceof Blob)return new Response(s);return s;case"number":case"boolean":return new Response(s.toString())}};export const mapResponse=(s,r)=>{if(isNotEmpty(r.headers)||200!==r.status||r.redirect)switch(r.redirect&&(r.headers.Location=r.redirect,r.status=302),r.headers["Set-Cookie"]&&Array.isArray(r.headers["Set-Cookie"])&&(r.headers=e(new Headers(r.headers),r.headers["Set-Cookie"])),typeof s){case"string":return new Response(s,{status:r.status,headers:r.headers});case"object":switch(s.constructor?.name){case"Object":case"Array":case void 0:return Response.json(s,{status:r.status,headers:r.headers});case"Error":return errorToResponse(s,r.headers);case"Response":for(let e in r.headers)s.headers.append(e,r.headers[e]);return s;case"Blob":default:return new Response(s,{status:r.status,headers:r.headers});case"Promise":return s.then(e=>mapResponse(e,r))}case"function":if(s instanceof Blob)return new Response(s,{status:r.status,headers:r.headers});return s();case"number":case"boolean":return new Response(s.toString(),{status:r.status,headers:r.headers});case"undefined":return new Response("",{status:r.status,headers:r.headers});default:return new Response(s,{status:r.status,headers:r.headers})}else switch(typeof s){case"string":return new Response(s);case"object":switch(s.constructor?.name){case"Object":case"Array":case void 0:return Response.json(s);case"Response":return s;case"Error":return errorToResponse(s,r.headers);case"Blob":default:return new Response(s);case"Promise":return s.then(e=>{let s=mapEarlyResponse(e,r);return void 0!==s?s:new Response("")})}case"function":if(s instanceof Blob)return new Response(s);return s();case"number":case"boolean":return new Response(s.toString());case"undefined":return new Response("");default:return new Response(s)}};export const errorToResponse=(e,s)=>new Response(JSON.stringify({name:e?.name,message:e?.message,cause:e?.cause}),{status:500,headers:s});