elysia 1.4.28 → 2.0.0-beta.0

package/dist/compose.js

@@ -1,1324 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf, __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
-  mod
-)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
-var compose_exports = {};
-__export(compose_exports, {
-  composeErrorHandler: () => composeErrorHandler,
-  composeGeneralHandler: () => composeGeneralHandler,
-  composeHandler: () => composeHandler,
-  createHoc: () => createHoc,
-  createOnRequestHandler: () => createOnRequestHandler,
-  isAsync: () => isAsync
-});
-module.exports = __toCommonJS(compose_exports);
-var import_index = require('./index.js'), import_value = require("@sinclair/typebox/value"), import_typebox = require("@sinclair/typebox"), import_fast_decode_uri_component = __toESM(require("fast-decode-uri-component")), import_parse_query = require('./parse-query.js'), import_utils = require('./utils.js'), import_utils2 = require('./universal/utils.js'), import_error = require('./error.js'), import_error2 = require('./error.js'), import_trace = require('./trace.js'), import_schema = require('./schema.js'), import_sucrose = require('./sucrose.js'), import_cookies = require('./cookies.js'), import_utils3 = require('./type-system/utils.js'), import_utils4 = require('./adapter/utils.js'), import_replace_schema = require('./replace-schema.js');
-const allocateIf = (value, condition) => condition ? value : "", defaultParsers = [
-  "json",
-  "text",
-  "urlencoded",
-  "arrayBuffer",
-  "formdata",
-  "application/json",
-  // eslint-disable-next-line sonarjs/no-duplicate-string
-  "text/plain",
-  // eslint-disable-next-line sonarjs/no-duplicate-string
-  "application/x-www-form-urlencoded",
-  // eslint-disable-next-line sonarjs/no-duplicate-string
-  "application/octet-stream",
-  // eslint-disable-next-line sonarjs/no-duplicate-string
-  "multipart/form-data"
-], createReport = ({
-  context = "c",
-  trace = [],
-  addFn
-}) => {
-  if (!trace.length)
-    return () => ({
-      resolveChild() {
-        return () => {
-        };
-      },
-      resolve() {
-      }
-    });
-  for (let i = 0; i < trace.length; i++)
-    addFn(
-      `let report${i},reportChild${i},reportErr${i},reportErrChild${i};let trace${i}=${context}[ELYSIA_TRACE]?.[${i}]??trace[${i}](${context});
-`
-    );
-  return (event, {
-    name,
-    total = 0,
-    alias
-  } = {}) => {
-    name || (name = "anonymous");
-    const reporter = event === "error" ? "reportErr" : "report";
-    for (let i = 0; i < trace.length; i++)
-      addFn(
-        `${alias ? "const " : ""}${alias ?? reporter}${i}=trace${i}.${event}({id,event:'${event}',name:'${name}',begin:performance.now(),total:${total}})
-`
-      ), alias && addFn(`${reporter}${i}=${alias}${i}
-`);
-    return {
-      resolve() {
-        for (let i = 0; i < trace.length; i++)
-          addFn(`${alias ?? reporter}${i}.resolve()
-`);
-      },
-      resolveChild(name2) {
-        for (let i = 0; i < trace.length; i++)
-          addFn(
-            `${reporter}Child${i}=${reporter}${i}.resolveChild?.shift()?.({id,event:'${event}',name:'${name2}',begin:performance.now()})
-`
-          );
-        return (binding) => {
-          for (let i = 0; i < trace.length; i++)
-            addFn(
-              binding ? `if(${binding} instanceof Error){${reporter}Child${i}?.(${binding}) }else{${reporter}Child${i}?.()}` : `${reporter}Child${i}?.()
-`
-            );
-        };
-      }
-    };
-  };
-}, composeCleaner = ({
-  schema,
-  name,
-  type,
-  typeAlias = type,
-  normalize,
-  ignoreTryCatch = !1
-}) => !normalize || !schema.Clean ? "" : normalize === !0 || normalize === "exactMirror" ? ignoreTryCatch ? `${name}=validator.${typeAlias}.Clean(${name})
-` : `try{${name}=validator.${typeAlias}.Clean(${name})
-}catch{}` : normalize === "typebox" ? `${name}=validator.${typeAlias}.Clean(${name})
-` : "", composeValidationFactory = ({
-  injectResponse = "",
-  normalize = !1,
-  validator,
-  encodeSchema = !1,
-  isStaticResponse = !1,
-  hasSanitize = !1,
-  allowUnsafeValidationDetails = !1
-}) => ({
-  validate: (type, value = `c.${type}`, error) => `c.set.status=422;throw new ValidationError('${type}',validator.${type},${value},${allowUnsafeValidationDetails}${error ? "," + error : ""})`,
-  response: (name = "r") => {
-    if (isStaticResponse || !validator.response) return "";
-    let code = injectResponse + `
-`;
-    code += `if(${name} instanceof ElysiaCustomStatusResponse){c.set.status=${name}.code
-${name}=${name}.response}if(${name} instanceof Response === false && typeof ${name}?.next !== 'function' && !(${name} instanceof ReadableStream))switch(c.set.status){`;
-    for (const [status2, value] of Object.entries(validator.response)) {
-      if (code += `
-case ${status2}:
-`, value.provider === "standard") {
-        code += `let vare${status2}=validator.response[${status2}].Check(${name})
-if(vare${status2} instanceof Promise)vare${status2}=await vare${status2}
-if(vare${status2}.issues)throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails},vare${status2}.issues)
-${name}=vare${status2}.value
-c.set.status=${status2}
-break
-`;
-        continue;
-      }
-      let noValidate = value.schema?.noValidate === !0;
-      if (!noValidate && value.schema?.$ref && value.schema?.$defs) {
-        const refKey = value.schema.$ref, defKey = typeof refKey == "string" && refKey.includes("/") ? refKey.split("/").pop() : refKey;
-        value.schema.$defs[defKey]?.noValidate === !0 && (noValidate = !0);
-      }
-      const appliedCleaner = noValidate || hasSanitize, clean = ({ ignoreTryCatch = !1 } = {}) => composeCleaner({
-        name,
-        schema: value,
-        type: "response",
-        typeAlias: `response[${status2}]`,
-        normalize,
-        ignoreTryCatch
-      });
-      appliedCleaner && (code += clean());
-      const applyErrorCleaner = !appliedCleaner && normalize && !noValidate;
-      encodeSchema && value.hasTransform && !noValidate ? (code += `try{${name}=validator.response[${status2}].Encode(${name})
-`, appliedCleaner || (code += clean({ ignoreTryCatch: !0 })), code += `c.set.status=${status2}}catch{` + (applyErrorCleaner ? `try{
-` + clean({ ignoreTryCatch: !0 }) + `${name}=validator.response[${status2}].Encode(${name})
-}catch{throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails})}` : `throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails})`) + "}") : (appliedCleaner || (code += clean()), noValidate || (code += `if(validator.response[${status2}].Check(${name})===false)throw new ValidationError('response',validator.response[${status2}],${name},${allowUnsafeValidationDetails})
-c.set.status=${status2}
-`)), code += `break
-`;
-    }
-    return code + "}";
-  }
-}), isAsyncName = (v) => (v?.fn ?? v).constructor.name === "AsyncFunction", matchResponseClone = /=>\s?response\.clone\(/, matchFnReturn = /(?:return|=>)\s?\S+\(|a(?:sync|wait)/, isAsync = (v) => {
-  const isObject = typeof v == "object";
-  if (isObject && v.isAsync !== void 0) return v.isAsync;
-  const fn = isObject ? v.fn : v;
-  if (fn.constructor.name === "AsyncFunction" || fn.constructor.name === "AsyncGeneratorFunction")
-    return !0;
-  const literal = fn.toString();
-  if (matchResponseClone.test(literal))
-    return isObject && (v.isAsync = !1), !1;
-  const result = matchFnReturn.test(literal);
-  return isObject && (v.isAsync = result), result;
-}, hasReturn = (v) => {
-  const isObject = typeof v == "object";
-  if (isObject && v.hasReturn !== void 0) return v.hasReturn;
-  const fnLiteral = isObject ? v.fn.toString() : v.toString(), parenthesisEnd = fnLiteral.indexOf(")"), arrowIndex = fnLiteral.indexOf("=>", parenthesisEnd);
-  if (arrowIndex !== -1) {
-    let afterArrow = arrowIndex + 2, charCode;
-    for (; afterArrow < fnLiteral.length && ((charCode = fnLiteral.charCodeAt(afterArrow)) === 32 || // space
-    charCode === 9 || // tab
-    charCode === 10 || // newline
-    charCode === 13); )
-      afterArrow++;
-    if (afterArrow < fnLiteral.length && fnLiteral.charCodeAt(afterArrow) !== 123)
-      return isObject && (v.hasReturn = !0), !0;
-  }
-  const result = fnLiteral.includes("return");
-  return isObject && (v.hasReturn = result), result;
-}, isGenerator = (v) => {
-  const fn = v?.fn ?? v;
-  return fn.constructor.name === "AsyncGeneratorFunction" || fn.constructor.name === "GeneratorFunction";
-}, coerceTransformDecodeError = (fnLiteral, type, allowUnsafeValidationDetails = !1, value = `c.${type}`) => `try{${fnLiteral}}catch(error){if(error.constructor.name === 'TransformDecodeError'){c.set.status=422
-throw error.error ?? new ValidationError('${type}',validator.${type},${value},${allowUnsafeValidationDetails})}}`, setImmediateFn = import_utils.hasSetImmediate ? "setImmediate" : "Promise.resolve().then", composeHandler = ({
-  app,
-  path,
-  method,
-  hooks,
-  validator,
-  handler,
-  allowMeta = !1,
-  inference
-}) => {
-  const adapter = app["~adapter"].composeHandler, adapterHandler = app["~adapter"].handler, isHandleFn = typeof handler == "function";
-  if (!isHandleFn) {
-    handler = adapterHandler.mapResponse(handler, {
-      // @ts-expect-error private property
-      headers: app.setHeaders ?? {}
-    });
-    const isResponse = handler instanceof Response || // @ts-ignore If it's not instanceof Response, it might be a polyfill (only on Node)
-    handler?.constructor?.name === "Response" && typeof handler?.clone == "function";
-    if (hooks.parse?.length && hooks.transform?.length && hooks.beforeHandle?.length && hooks.afterHandle?.length)
-      return isResponse ? Function(
-        "a",
-        `"use strict";
-return function(){return a.clone()}`
-      )(handler) : Function(
-        "a",
-        `"use strict";
-return function(){return a}`
-      )(handler);
-    if (isResponse) {
-      const response = handler;
-      handler = () => response.clone();
-    }
-  }
-  const handle = isHandleFn ? "handler(c)" : "handler", hasTrace = !!hooks.trace?.length;
-  let fnLiteral = "";
-  if (inference = (0, import_sucrose.sucrose)(
-    Object.assign({ handler }, hooks),
-    inference,
-    app.config.sucrose
-  ), adapter.declare) {
-    const literal = adapter.declare(inference);
-    literal && (fnLiteral += literal);
-  }
-  inference.server && (fnLiteral += `Object.defineProperty(c,'server',{get:function(){return getServer()}})
-`), validator.createBody?.(), validator.createQuery?.(), validator.createHeaders?.(), validator.createParams?.(), validator.createCookie?.(), validator.createResponse?.();
-  const hasValidation = !!validator.body || !!validator.headers || !!validator.params || !!validator.query || !!validator.cookie || !!validator.response, hasQuery = inference.query || !!validator.query, requestNoBody = hooks.parse?.length === 1 && // @ts-expect-error
-  hooks.parse[0].fn === "none", hasBody = method !== "" && method !== "GET" && method !== "HEAD" && (inference.body || !!validator.body || !!hooks.parse?.length) && !requestNoBody, defaultHeaders = app.setHeaders, hasDefaultHeaders = defaultHeaders && !!Object.keys(defaultHeaders).length, hasHeaders = inference.headers || !!validator.headers || adapter.preferWebstandardHeaders !== !0 && inference.body, hasCookie = inference.cookie || !!validator.cookie, cookieMeta = validator.cookie?.config ? (0, import_utils.mergeCookie)(validator?.cookie?.config, app.config.cookie) : app.config.cookie;
-  let _encodeCookie = "";
-  const encodeCookie = () => {
-    if (_encodeCookie) return _encodeCookie;
-    if (cookieMeta?.sign) {
-      if (cookieMeta.secrets === "")
-        throw new Error(
-          `cookie secret can't be an empty string at (${method}) ${path}`,
-          {
-            cause: `(${method}) ${path}`
-          }
-        );
-      if (!cookieMeta.secrets)
-        throw new Error(
-          `cookie secret must be defined (${method}) ${path}`,
-          {
-            cause: `(${method}) ${path}`
-          }
-        );
-      const secret = cookieMeta.secrets ? typeof cookieMeta.secrets == "string" ? cookieMeta.secrets : cookieMeta.secrets[0] : void 0;
-      if (_encodeCookie += `const _setCookie = c.set.cookie
-if(_setCookie){`, cookieMeta.sign === !0)
-        _encodeCookie += `for(const [key, cookie] of Object.entries(_setCookie)){c.set.cookie[key].value=await signCookie(cookie.value,${secret ? JSON.stringify(secret) : "undefined"})}`;
-      else {
-        typeof cookieMeta.sign == "string" && (cookieMeta.sign = [cookieMeta.sign]);
-        for (const name of cookieMeta.sign)
-          _encodeCookie += `if(_setCookie[${JSON.stringify(name)}]?.value)c.set.cookie[${JSON.stringify(name)}].value=await signCookie(_setCookie[${JSON.stringify(name)}].value,${secret ? JSON.stringify(secret) : "undefined"})
-`;
-      }
-      _encodeCookie += `}
-`;
-    }
-    return _encodeCookie;
-  }, normalize = app.config.normalize, encodeSchema = app.config.encodeSchema, allowUnsafeValidationDetails = app.config.allowUnsafeValidationDetails, validation = composeValidationFactory({
-    normalize,
-    validator,
-    encodeSchema,
-    isStaticResponse: handler instanceof Response,
-    hasSanitize: !!app.config.sanitize,
-    allowUnsafeValidationDetails
-  });
-  hasHeaders && (fnLiteral += adapter.headers), hasTrace && (fnLiteral += `const id=c[ELYSIA_REQUEST_ID]
-`);
-  const report = createReport({
-    trace: hooks.trace,
-    addFn: (word) => {
-      fnLiteral += word;
-    }
-  });
-  if (fnLiteral += "try{", hasCookie) {
-    const get = (name, defaultValue) => {
-      const value = cookieMeta?.[name] ?? defaultValue;
-      return value === void 0 ? "" : value ? typeof value == "string" ? `${name}:${JSON.stringify(value)},` : value instanceof Date ? `${name}: new Date(${value.getTime()}),` : `${name}:${value},` : typeof defaultValue == "string" ? `${name}:"${defaultValue}",` : `${name}:${defaultValue},`;
-    }, options = cookieMeta ? `{secrets:${cookieMeta.secrets !== void 0 && cookieMeta.secrets !== null ? typeof cookieMeta.secrets == "string" ? JSON.stringify(cookieMeta.secrets) : "[" + cookieMeta.secrets.map((x) => JSON.stringify(x)).join(",") + "]" : "undefined"},sign:${cookieMeta.sign === !0 ? !0 : cookieMeta.sign !== void 0 ? typeof cookieMeta.sign == "string" ? JSON.stringify(cookieMeta.sign) : "[" + cookieMeta.sign.map((x) => JSON.stringify(x)).join(",") + "]" : "undefined"},` + get("domain") + get("expires") + get("httpOnly") + get("maxAge") + get("path", "/") + get("priority") + get("sameSite") + get("secure") + "}" : "undefined";
-    hasHeaders ? fnLiteral += `
-c.cookie=await parseCookie(c.set,c.headers.cookie,${options})
-` : fnLiteral += `
-c.cookie=await parseCookie(c.set,c.request.headers.get('cookie'),${options})
-`;
-  }
-  if (hasQuery) {
-    let arrayProperties = {}, objectProperties = {}, hasArrayProperty = !1, hasObjectProperty = !1;
-    if (validator.query?.schema) {
-      const schema = (0, import_schema.unwrapImportSchema)(validator.query?.schema), properties = (0, import_schema.getSchemaProperties)(schema);
-      if (properties)
-        for (const [key, value] of Object.entries(properties))
-          (0, import_schema.hasElysiaMeta)("ArrayQuery", value) && (arrayProperties[key] = !0, hasArrayProperty = !0), (0, import_schema.hasElysiaMeta)("ObjectString", value) && (objectProperties[key] = !0, hasObjectProperty = !0);
-    }
-    fnLiteral += `if(c.qi===-1){c.query=Object.create(null)}else{c.query=parseQueryFromURL(c.url,c.qi+1${//
-    hasArrayProperty ? "," + JSON.stringify(arrayProperties) : hasObjectProperty ? ",undefined" : ""}${//
-    hasObjectProperty ? "," + JSON.stringify(objectProperties) : ""})}`;
-  }
-  const isAsyncHandler = typeof handler == "function" && isAsync(handler), saveResponse = hasTrace || hooks.afterResponse?.length ? "c.response=c.responseValue= " : "", responseKeys = Object.keys(validator.response ?? {}), hasMultipleResponses = responseKeys.length > 1, hasSingle200 = responseKeys.length === 0 || responseKeys.length === 1 && responseKeys[0] === "200", maybeAsync = hasCookie || hasBody || isAsyncHandler || !!hooks.parse?.length || !!hooks.afterHandle?.some(isAsync) || !!hooks.beforeHandle?.some(isAsync) || !!hooks.transform?.some(isAsync) || !!hooks.mapResponse?.some(isAsync) || validator.body?.provider === "standard" || validator.headers?.provider === "standard" || validator.query?.provider === "standard" || validator.params?.provider === "standard" || validator.cookie?.provider === "standard" || Object.values(validator.response ?? {}).find(
-    (x) => x.provider === "standard"
-  ), maybeStream = (typeof handler == "function" ? isGenerator(handler) : !1) || !!hooks.beforeHandle?.some(isGenerator) || !!hooks.afterHandle?.some(isGenerator) || !!hooks.transform?.some(isGenerator), hasSet = inference.cookie || inference.set || hasHeaders || hasTrace || hasMultipleResponses || !hasSingle200 || isHandleFn && hasDefaultHeaders || maybeStream;
-  let _afterResponse;
-  const afterResponse = (hasStream = !0) => {
-    if (_afterResponse !== void 0) return _afterResponse;
-    if (!hooks.afterResponse?.length && !hasTrace) return "";
-    let afterResponse2 = "";
-    afterResponse2 += `
-${setImmediateFn}(async()=>{if(c.responseValue){if(c.responseValue instanceof ElysiaCustomStatusResponse) c.set.status=c.responseValue.code
-` + (hasStream ? `if(typeof afterHandlerStreamListener!=='undefined')for await(const v of afterHandlerStreamListener){}
-` : "") + `}
-`;
-    const reporter = createReport({
-      trace: hooks.trace,
-      addFn: (word) => {
-        afterResponse2 += word;
-      }
-    })("afterResponse", {
-      total: hooks.afterResponse?.length
-    });
-    if (hooks.afterResponse?.length && hooks.afterResponse)
-      for (let i = 0; i < hooks.afterResponse.length; i++) {
-        const endUnit = reporter.resolveChild(
-          hooks.afterResponse[i].fn.name
-        ), prefix = isAsync(hooks.afterResponse[i]) ? "await " : "";
-        afterResponse2 += `
-${prefix}e.afterResponse[${i}](c)
-`, endUnit();
-      }
-    return reporter.resolve(), afterResponse2 += `})
-`, _afterResponse = afterResponse2;
-  }, mapResponse = (r = "r") => {
-    const after = afterResponse(), response = `${maybeStream && maybeAsync ? "await " : ""}${hasSet ? "mapResponse" : "mapCompactResponse"}(${saveResponse}${r}${hasSet ? ",c.set" : ""}${mapResponseContext})
-`;
-    return after ? `const _res=${response}` + after + "return _res" : `return ${response}`;
-  }, mapResponseContext = adapter.mapResponseContext ? `,${adapter.mapResponseContext}` : "";
-  (hasTrace || inference.route) && (fnLiteral += `c.route=\`${path}\`
-`), (hasTrace || hooks.afterResponse?.length) && (fnLiteral += `let afterHandlerStreamListener
-`);
-  const parseReporter = report("parse", {
-    total: hooks.parse?.length
-  });
-  if (hasBody) {
-    const hasBodyInference = !!hooks.parse?.length || inference.body || validator.body;
-    adapter.parser.declare && (fnLiteral += adapter.parser.declare), fnLiteral += `
-try{`;
-    let parser = typeof hooks.parse == "string" ? hooks.parse : Array.isArray(hooks.parse) && hooks.parse.length === 1 ? typeof hooks.parse[0] == "string" ? hooks.parse[0] : typeof hooks.parse[0].fn == "string" ? hooks.parse[0].fn : void 0 : void 0;
-    if (!parser && validator.body && !hooks.parse?.length) {
-      const schema = validator.body.schema;
-      schema && schema.anyOf && schema[import_typebox.Kind] === "Union" && schema.anyOf?.length === 2 && schema.anyOf?.find((x) => x[import_typebox.Kind] === "ElysiaForm") && (parser = "formdata");
-    }
-    if (parser && defaultParsers.includes(parser)) {
-      const reporter = report("parse", {
-        total: hooks.parse?.length
-      }), isOptionalBody = !!validator.body?.isOptional;
-      switch (parser) {
-        case "json":
-        case "application/json":
-          fnLiteral += adapter.parser.json(isOptionalBody);
-          break;
-        case "text":
-        case "text/plain":
-          fnLiteral += adapter.parser.text(isOptionalBody);
-          break;
-        case "urlencoded":
-        case "application/x-www-form-urlencoded":
-          fnLiteral += adapter.parser.urlencoded(isOptionalBody);
-          break;
-        case "arrayBuffer":
-        case "application/octet-stream":
-          fnLiteral += adapter.parser.arrayBuffer(isOptionalBody);
-          break;
-        case "formdata":
-        case "multipart/form-data":
-          fnLiteral += adapter.parser.formData(isOptionalBody);
-          break;
-        default:
-          parser in app["~parser"] && (fnLiteral += hasHeaders ? "let contentType = c.headers['content-type']" : "let contentType = c.request.headers.get('content-type')", fnLiteral += `
-if(contentType){const index=contentType.indexOf(';')
-if(index!==-1)contentType=contentType.substring(0,index)}
-else{contentType=''}c.contentType=contentType
-let result=parser['${parser}'](c, contentType)
-if(result instanceof Promise)result=await result
-if(result instanceof ElysiaCustomStatusResponse)throw result
-if(result!==undefined)c.body=result
-delete c.contentType
-`);
-          break;
-      }
-      reporter.resolve();
-    } else if (hasBodyInference) {
-      fnLiteral += `
-`, fnLiteral += `let contentType
-if(c.request.body)`, fnLiteral += hasHeaders ? `contentType=c.headers['content-type']
-` : `contentType=c.request.headers.get('content-type')
-`;
-      let hasDefaultParser = !1;
-      if (hooks.parse?.length)
-        fnLiteral += `if(contentType){
-const index=contentType.indexOf(';')
-
-if(index!==-1)contentType=contentType.substring(0,index)}else{contentType=''}let used=false
-c.contentType=contentType
-`;
-      else {
-        hasDefaultParser = !0;
-        const isOptionalBody = !!validator.body?.isOptional;
-        fnLiteral += `if(contentType)switch(contentType.charCodeAt(12)){
-case 106:` + adapter.parser.json(isOptionalBody) + `break
-case 120:` + adapter.parser.urlencoded(isOptionalBody) + `break
-case 111:` + adapter.parser.arrayBuffer(isOptionalBody) + `break
-case 114:` + adapter.parser.formData(isOptionalBody) + `break
-default:if(contentType.charCodeAt(0)===116){` + adapter.parser.text(isOptionalBody) + `}break
-}`;
-      }
-      const reporter = report("parse", {
-        total: hooks.parse?.length
-      });
-      if (hooks.parse)
-        for (let i = 0; i < hooks.parse.length; i++) {
-          const name = `bo${i}`;
-          if (i !== 0 && (fnLiteral += `
-if(!used){`), typeof hooks.parse[i].fn == "string") {
-            const endUnit = reporter.resolveChild(
-              hooks.parse[i].fn
-            ), isOptionalBody = !!validator.body?.isOptional;
-            switch (hooks.parse[i].fn) {
-              case "json":
-              case "application/json":
-                hasDefaultParser = !0, fnLiteral += adapter.parser.json(isOptionalBody);
-                break;
-              case "text":
-              case "text/plain":
-                hasDefaultParser = !0, fnLiteral += adapter.parser.text(isOptionalBody);
-                break;
-              case "urlencoded":
-              case "application/x-www-form-urlencoded":
-                hasDefaultParser = !0, fnLiteral += adapter.parser.urlencoded(isOptionalBody);
-                break;
-              case "arrayBuffer":
-              case "application/octet-stream":
-                hasDefaultParser = !0, fnLiteral += adapter.parser.arrayBuffer(isOptionalBody);
-                break;
-              case "formdata":
-              case "multipart/form-data":
-                hasDefaultParser = !0, fnLiteral += adapter.parser.formData(isOptionalBody);
-                break;
-              default:
-                fnLiteral += `let ${name}=parser['${hooks.parse[i].fn}'](c,contentType)
-if(${name} instanceof Promise)${name}=await ${name}
-if(${name}!==undefined){c.body=${name};used=true;}
-`;
-            }
-            endUnit();
-          } else {
-            const endUnit = reporter.resolveChild(
-              hooks.parse[i].fn.name
-            );
-            fnLiteral += `let ${name}=e.parse[${i}]
-${name}=${name}(c,contentType)
-if(${name} instanceof Promise)${name}=await ${name}
-if(${name}!==undefined){c.body=${name};used=true}`, endUnit();
-          }
-          if (i !== 0 && (fnLiteral += "}"), hasDefaultParser) break;
-        }
-      if (reporter.resolve(), !hasDefaultParser) {
-        const isOptionalBody = !!validator.body?.isOptional;
-        hooks.parse?.length && (fnLiteral += `
-if(!used){
-`), fnLiteral += `switch(contentType){case 'application/json':
-` + adapter.parser.json(isOptionalBody) + `break
-case 'text/plain':` + adapter.parser.text(isOptionalBody) + `break
-case 'application/x-www-form-urlencoded':` + adapter.parser.urlencoded(isOptionalBody) + `break
-case 'application/octet-stream':` + adapter.parser.arrayBuffer(isOptionalBody) + `break
-case 'multipart/form-data':` + adapter.parser.formData(isOptionalBody) + `break
-`;
-        for (const key of Object.keys(app["~parser"]))
-          fnLiteral += `case '${key}':let bo${key}=parser['${key}'](c,contentType)
-if(bo${key} instanceof Promise)bo${key}=await bo${key}
-if(bo${key} instanceof ElysiaCustomStatusResponse){` + mapResponse(`bo${key}`) + `}if(bo${key}!==undefined)c.body=bo${key}
-break
-`;
-        hooks.parse?.length && (fnLiteral += "}"), fnLiteral += "}";
-      }
-      hooks.parse?.length && (fnLiteral += `
-delete c.contentType`);
-    }
-    fnLiteral += "}catch(error){throw new ParseError(error)}";
-  }
-  if (parseReporter.resolve(), hooks?.transform || hasTrace) {
-    const reporter = report("transform", {
-      total: hooks.transform?.length
-    });
-    if (hooks.transform?.length) {
-      fnLiteral += `let transformed
-`;
-      for (let i = 0; i < hooks.transform.length; i++) {
-        const transform = hooks.transform[i], endUnit = reporter.resolveChild(transform.fn.name);
-        fnLiteral += isAsync(transform) ? `transformed=await e.transform[${i}](c)
-` : `transformed=e.transform[${i}](c)
-`, transform.subType === "mapDerive" ? fnLiteral += "if(transformed instanceof ElysiaCustomStatusResponse){" + mapResponse("transformed") + `}else{transformed.request=c.request
-transformed.store=c.store
-transformed.qi=c.qi
-transformed.path=c.path
-transformed.url=c.url
-transformed.redirect=c.redirect
-transformed.set=c.set
-transformed.error=c.error
-c=transformed}` : fnLiteral += "if(transformed instanceof ElysiaCustomStatusResponse){" + mapResponse("transformed") + `}else Object.assign(c,transformed)
-`, endUnit();
-      }
-    }
-    reporter.resolve();
-  }
-  const fileUnions = [];
-  if (validator) {
-    if (validator.headers) {
-      if (validator.headers.hasDefault)
-        for (const [key, value] of Object.entries(
-          import_value.Value.Default(
-            // @ts-ignore
-            validator.headers.schema,
-            {}
-          )
-        )) {
-          const parsed = typeof value == "object" ? JSON.stringify(value) : typeof value == "string" ? `'${value}'` : value;
-          parsed !== void 0 && (fnLiteral += `c.headers['${key}']??=${parsed}
-`);
-        }
-      fnLiteral += composeCleaner({
-        name: "c.headers",
-        schema: validator.headers,
-        type: "headers",
-        normalize
-      }), validator.headers.isOptional && (fnLiteral += "if(isNotEmpty(c.headers)){"), validator.headers?.provider === "standard" ? fnLiteral += `let vah=validator.headers.Check(c.headers)
-if(vah instanceof Promise)vah=await vah
-if(vah.issues){` + validation.validate("headers", void 0, "vah.issues") + `}else{c.headers=vah.value}
-` : validator.headers?.schema?.noValidate !== !0 && (fnLiteral += "if(validator.headers.Check(c.headers) === false){" + validation.validate("headers") + "}"), validator.headers.hasTransform && (fnLiteral += coerceTransformDecodeError(
-        `c.headers=validator.headers.Decode(c.headers)
-`,
-        "headers",
-        allowUnsafeValidationDetails
-      )), validator.headers.isOptional && (fnLiteral += "}");
-    }
-    if (validator.params) {
-      if (validator.params.hasDefault)
-        for (const [key, value] of Object.entries(
-          import_value.Value.Default(
-            // @ts-ignore
-            validator.params.schema,
-            {}
-          )
-        )) {
-          const parsed = typeof value == "object" ? JSON.stringify(value) : typeof value == "string" ? `'${value}'` : value;
-          parsed !== void 0 && (fnLiteral += `c.params['${key}']??=${parsed}
-`);
-        }
-      validator.params.provider === "standard" ? fnLiteral += `let vap=validator.params.Check(c.params)
-if(vap instanceof Promise)vap=await vap
-if(vap.issues){` + validation.validate("params", void 0, "vap.issues") + `}else{c.params=vap.value}
-` : validator.params?.schema?.noValidate !== !0 && (fnLiteral += "if(validator.params.Check(c.params)===false){" + validation.validate("params") + "}"), validator.params.hasTransform && (fnLiteral += coerceTransformDecodeError(
-        `c.params=validator.params.Decode(c.params)
-`,
-        "params",
-        allowUnsafeValidationDetails
-      ));
-    }
-    if (validator.query) {
-      if (import_typebox.Kind in validator.query?.schema && validator.query.hasDefault)
-        for (const [key, value] of Object.entries(
-          import_value.Value.Default(
-            // @ts-ignore
-            validator.query.schema,
-            {}
-          )
-        )) {
-          const parsed = typeof value == "object" ? JSON.stringify(value) : typeof value == "string" ? `'${value}'` : value;
-          parsed !== void 0 && (fnLiteral += `if(c.query['${key}']===undefined)c.query['${key}']=${parsed}
-`);
-        }
-      fnLiteral += composeCleaner({
-        name: "c.query",
-        schema: validator.query,
-        type: "query",
-        normalize
-      }), validator.query.isOptional && (fnLiteral += "if(isNotEmpty(c.query)){"), validator.query.provider === "standard" ? fnLiteral += `let vaq=validator.query.Check(c.query)
-if(vaq instanceof Promise)vaq=await vaq
-if(vaq.issues){` + validation.validate("query", void 0, "vaq.issues") + `}else{c.query=vaq.value}
-` : validator.query?.schema?.noValidate !== !0 && (fnLiteral += "if(validator.query.Check(c.query)===false){" + validation.validate("query") + "}"), validator.query.hasTransform && (fnLiteral += coerceTransformDecodeError(
-        `c.query=validator.query.Decode(c.query)
-`,
-        "query",
-        allowUnsafeValidationDetails
-      ), fnLiteral += coerceTransformDecodeError(
-        `c.query=validator.query.Decode(c.query)
-`,
-        "query",
-        allowUnsafeValidationDetails
-      )), validator.query.isOptional && (fnLiteral += "}");
-    }
-    if (hasBody && validator.body) {
-      (validator.body.hasTransform || validator.body.isOptional) && (fnLiteral += `const isNotEmptyObject=c.body&&(typeof c.body==="object"&&(isNotEmpty(c.body)||c.body instanceof ArrayBuffer))
-`);
-      const hasUnion = (0, import_schema.isUnion)(validator.body.schema);
-      let hasNonUnionFileWithDefault = !1;
-      if (validator.body.hasDefault) {
-        let value = import_value.Value.Default(
-          validator.body.schema,
-          validator.body.schema.type === "object" || (0, import_schema.unwrapImportSchema)(validator.body.schema)[import_typebox.Kind] === "Object" ? {} : void 0
-        );
-        const schema = (0, import_schema.unwrapImportSchema)(validator.body.schema);
-        if (!hasUnion && value && typeof value == "object" && ((0, import_schema.hasType)("File", schema) || (0, import_schema.hasType)("Files", schema))) {
-          hasNonUnionFileWithDefault = !0;
-          for (const [k, v] of Object.entries(value))
-            (v === "File" || v === "Files") && delete value[k];
-          (0, import_utils.isNotEmpty)(value) || (value = void 0);
-        }
-        const parsed = typeof value == "object" ? JSON.stringify(value) : typeof value == "string" ? `'${value}'` : value;
-        value != null && (Array.isArray(value) ? fnLiteral += `if(!c.body)c.body=${parsed}
-` : typeof value == "object" ? fnLiteral += `c.body=Object.assign(${parsed},c.body)
-` : fnLiteral += `c.body=${parsed}
-`), fnLiteral += composeCleaner({
-          name: "c.body",
-          schema: validator.body,
-          type: "body",
-          normalize
-        }), validator.body.provider === "standard" ? fnLiteral += `let vab=validator.body.Check(c.body)
-if(vab instanceof Promise)vab=await vab
-if(vab.issues){` + validation.validate("body", void 0, "vab.issues") + `}else{c.body=vab.value}
-` : validator.body?.schema?.noValidate !== !0 && (validator.body.isOptional ? fnLiteral += "if(isNotEmptyObject&&validator.body.Check(c.body)===false){" + validation.validate("body") + "}" : fnLiteral += "if(validator.body.Check(c.body)===false){" + validation.validate("body") + "}");
-      } else
-        fnLiteral += composeCleaner({
-          name: "c.body",
-          schema: validator.body,
-          type: "body",
-          normalize
-        }), validator.body.provider === "standard" ? fnLiteral += `let vab=validator.body.Check(c.body)
-if(vab instanceof Promise)vab=await vab
-if(vab.issues){` + validation.validate("body", void 0, "vab.issues") + `}else{c.body=vab.value}
-` : validator.body?.schema?.noValidate !== !0 && (validator.body.isOptional ? fnLiteral += "if(isNotEmptyObject&&validator.body.Check(c.body)===false){" + validation.validate("body") + "}" : fnLiteral += "if(validator.body.Check(c.body)===false){" + validation.validate("body") + "}");
-      if (validator.body.hasTransform && (fnLiteral += coerceTransformDecodeError(
-        `if(isNotEmptyObject)c.body=validator.body.Decode(c.body)
-`,
-        "body",
-        allowUnsafeValidationDetails
-      )), hasUnion && validator.body.schema.anyOf?.length) {
-        const iterator = Object.values(
-          validator.body.schema.anyOf
-        );
-        for (let i = 0; i < iterator.length; i++) {
-          const type = iterator[i];
-          if ((0, import_schema.hasType)("File", type) || (0, import_schema.hasType)("Files", type)) {
-            const candidate = (0, import_schema.getSchemaValidator)(type, {
-              // @ts-expect-error private property
-              modules: app.definitions.typebox,
-              dynamic: !app.config.aot,
-              // @ts-expect-error private property
-              models: app.definitions.type,
-              normalize: app.config.normalize,
-              additionalCoerce: (0, import_replace_schema.coercePrimitiveRoot)(),
-              sanitize: () => app.config.sanitize
-            });
-            if (candidate) {
-              const isFirst = fileUnions.length === 0, properties = (0, import_schema.getSchemaProperties)(candidate.schema) ?? (0, import_schema.getSchemaProperties)(type);
-              if (!properties) continue;
-              const iterator2 = Object.entries(properties);
-              let validator2 = isFirst ? `
-` : " else ";
-              validator2 += `if(fileUnions[${fileUnions.length}].Check(c.body)){`;
-              let validateFile = "", validatorLength = 0;
-              for (let i2 = 0; i2 < iterator2.length; i2++) {
-                const [k, v] = iterator2[i2];
-                !v.extension || v[import_typebox.Kind] !== "File" && v[import_typebox.Kind] !== "Files" || (validatorLength && (validateFile += ","), validateFile += `fileType(c.body.${k},${JSON.stringify(v.extension)},'body.${k}')`, validatorLength++);
-              }
-              validateFile && (validatorLength === 1 ? validator2 += `await ${validateFile}
-` : validatorLength > 1 && (validator2 += `await Promise.all([${validateFile}])
-`), validator2 += "}", fnLiteral += validator2, fileUnions.push(candidate));
-            }
-          }
-        }
-      } else if (hasNonUnionFileWithDefault || !hasUnion && ((0, import_schema.hasType)(
-        "File",
-        (0, import_schema.unwrapImportSchema)(validator.body.schema)
-      ) || (0, import_schema.hasType)(
-        "Files",
-        (0, import_schema.unwrapImportSchema)(validator.body.schema)
-      ))) {
-        let validateFile = "";
-        const bodyProperties = (0, import_schema.getSchemaProperties)(
-          (0, import_schema.unwrapImportSchema)(validator.body.schema)
-        );
-        let i = 0;
-        if (bodyProperties)
-          for (const [k, v] of Object.entries(bodyProperties))
-            !v.extension || v[import_typebox.Kind] !== "File" && v[import_typebox.Kind] !== "Files" || (i && (validateFile += ","), validateFile += `fileType(c.body.${k},${JSON.stringify(v.extension)},'body.${k}')`, i++);
-        i && (fnLiteral += `
-`), i === 1 ? fnLiteral += `await ${validateFile}
-` : i > 1 && (fnLiteral += `await Promise.all([${validateFile}])
-`);
-      }
-    }
-    validator.cookie && (validator.cookie.config = (0, import_utils.mergeCookie)(
-      validator.cookie.config,
-      app.config.cookie ?? {}
-    ), fnLiteral += `let cookieValue={}
-for(const [key,value] of Object.entries(c.cookie))cookieValue[key]=value.value
-`, validator.cookie.isOptional && (fnLiteral += "if(isNotEmpty(c.cookie)){"), validator.cookie.provider === "standard" ? (fnLiteral += `let vac=validator.cookie.Check(cookieValue)
-if(vac instanceof Promise)vac=await vac
-if(vac.issues){` + validation.validate("cookie", void 0, "vac.issues") + `}else{cookieValue=vac.value}
-`, fnLiteral += `for(const k of Object.keys(cookieValue))c.cookie[k].value=cookieValue[k]
-`) : validator.cookie?.schema?.noValidate !== !0 && (fnLiteral += "if(validator.cookie.Check(cookieValue)===false){" + validation.validate("cookie", "cookieValue") + "}", validator.cookie.hasTransform && (fnLiteral += coerceTransformDecodeError(
-      "for(const [key,value] of Object.entries(validator.cookie.Decode(cookieValue))){c.cookie[key].value = value}",
-      "cookie",
-      allowUnsafeValidationDetails
-    ))), validator.cookie.isOptional && (fnLiteral += "}"));
-  }
-  if (hooks?.beforeHandle || hasTrace) {
-    const reporter = report("beforeHandle", {
-      total: hooks.beforeHandle?.length
-    });
-    let hasResolve = !1;
-    if (hooks.beforeHandle?.length)
-      for (let i = 0; i < hooks.beforeHandle.length; i++) {
-        const beforeHandle = hooks.beforeHandle[i], endUnit = reporter.resolveChild(beforeHandle.fn.name), returning = hasReturn(beforeHandle);
-        if (beforeHandle.subType === "resolve" || beforeHandle.subType === "mapResolve")
-          hasResolve || (hasResolve = !0, fnLiteral += `
-let resolved
-`), fnLiteral += isAsync(beforeHandle) ? `resolved=await e.beforeHandle[${i}](c);
-` : `resolved=e.beforeHandle[${i}](c);
-`, beforeHandle.subType === "mapResolve" ? fnLiteral += "if(resolved instanceof ElysiaCustomStatusResponse){" + mapResponse("resolved") + `}else{resolved.request=c.request
-resolved.store=c.store
-resolved.qi=c.qi
-resolved.path=c.path
-resolved.url=c.url
-resolved.redirect=c.redirect
-resolved.set=c.set
-resolved.error=c.error
-c=resolved}` : fnLiteral += "if(resolved instanceof ElysiaCustomStatusResponse){" + mapResponse("resolved") + `}else Object.assign(c, resolved)
-`, endUnit();
-        else if (!returning)
-          fnLiteral += isAsync(beforeHandle) ? `await e.beforeHandle[${i}](c)
-` : `e.beforeHandle[${i}](c)
-`, endUnit();
-        else {
-          if (fnLiteral += isAsync(beforeHandle) ? `be=await e.beforeHandle[${i}](c)
-` : `be=e.beforeHandle[${i}](c)
-`, endUnit("be"), fnLiteral += "if(be!==undefined){", reporter.resolve(), hooks.afterHandle?.length || hasTrace) {
-            report("handle", {
-              name: isHandleFn ? handler.name : void 0
-            }).resolve();
-            const reporter2 = report("afterHandle", {
-              total: hooks.afterHandle?.length
-            });
-            if (hooks.afterHandle?.length)
-              for (let i2 = 0; i2 < hooks.afterHandle.length; i2++) {
-                const hook = hooks.afterHandle[i2], returning2 = hasReturn(hook), endUnit2 = reporter2.resolveChild(
-                  hook.fn.name
-                );
-                fnLiteral += `c.response=c.responseValue=be
-`, returning2 ? (fnLiteral += isAsync(hook.fn) ? `af=await e.afterHandle[${i2}](c)
-` : `af=e.afterHandle[${i2}](c)
-`, fnLiteral += `if(af!==undefined) c.response=c.responseValue=be=af
-`) : fnLiteral += isAsync(hook.fn) ? `await e.afterHandle[${i2}](c, be)
-` : `e.afterHandle[${i2}](c, be)
-`, endUnit2("af");
-              }
-            reporter2.resolve();
-          }
-          validator.response && (fnLiteral += validation.response("be"));
-          const mapResponseReporter = report("mapResponse", {
-            total: hooks.mapResponse?.length
-          });
-          if (hooks.mapResponse?.length) {
-            fnLiteral += `c.response=c.responseValue=be
-`;
-            for (let i2 = 0; i2 < hooks.mapResponse.length; i2++) {
-              const mapResponse2 = hooks.mapResponse[i2], endUnit2 = mapResponseReporter.resolveChild(
-                mapResponse2.fn.name
-              );
-              fnLiteral += `if(mr===undefined){mr=${isAsyncName(mapResponse2) ? "await " : ""}e.mapResponse[${i2}](c)
-if(mr!==undefined)be=c.response=c.responseValue=mr}`, endUnit2();
-            }
-          }
-          mapResponseReporter.resolve(), fnLiteral += afterResponse(), fnLiteral += encodeCookie(), fnLiteral += `return mapEarlyResponse(${saveResponse}be,c.set${mapResponseContext})}
-`;
-        }
-      }
-    reporter.resolve();
-  }
-  function reportHandler(name) {
-    const handleReporter = report("handle", {
-      name,
-      alias: "reportHandler"
-    });
-    return () => {
-      hasTrace && (fnLiteral += 'if(r&&(r[Symbol.iterator]||r[Symbol.asyncIterator])&&typeof r.next==="function"){' + (maybeAsync ? "" : "(async()=>{") + `const stream=await tee(r,3)
-r=stream[0]
-` + (hooks.afterHandle?.length ? `c.response=c.responseValue=r
-` : "") + `const listener=stream[1]
-` + (hasTrace || hooks.afterResponse?.length ? `afterHandlerStreamListener=stream[2]
-` : "") + `${setImmediateFn}(async ()=>{if(listener)for await(const v of listener){}
-`, handleReporter.resolve(), fnLiteral += "})" + (maybeAsync ? "" : "})()") + "}else{", handleReporter.resolve(), fnLiteral += `}
-`);
-    };
-  }
-  if (hooks.afterHandle?.length || hasTrace) {
-    const resolveHandler = reportHandler(
-      isHandleFn ? handler.name : void 0
-    );
-    hooks.afterHandle?.length ? fnLiteral += isAsyncHandler ? `let r=c.response=c.responseValue=await ${handle}
-` : `let r=c.response=c.responseValue=${handle}
-` : fnLiteral += isAsyncHandler ? `let r=await ${handle}
-` : `let r=${handle}
-`, resolveHandler();
-    const reporter = report("afterHandle", {
-      total: hooks.afterHandle?.length
-    });
-    if (hooks.afterHandle?.length)
-      for (let i = 0; i < hooks.afterHandle.length; i++) {
-        const hook = hooks.afterHandle[i], returning = hasReturn(hook), endUnit = reporter.resolveChild(hook.fn.name);
-        returning ? (fnLiteral += isAsync(hook.fn) ? `af=await e.afterHandle[${i}](c)
-` : `af=e.afterHandle[${i}](c)
-`, endUnit("af"), validator.response ? (fnLiteral += "if(af!==undefined){", reporter.resolve(), fnLiteral += validation.response("af"), fnLiteral += "c.response=c.responseValue=af}") : (fnLiteral += "if(af!==undefined){", reporter.resolve(), fnLiteral += "c.response=c.responseValue=af}")) : (fnLiteral += isAsync(hook.fn) ? `await e.afterHandle[${i}](c)
-` : `e.afterHandle[${i}](c)
-`, endUnit());
-      }
-    reporter.resolve(), hooks.afterHandle?.length && (fnLiteral += `r=c.response
-`), validator.response && (fnLiteral += validation.response()), fnLiteral += encodeCookie();
-    const mapResponseReporter = report("mapResponse", {
-      total: hooks.mapResponse?.length
-    });
-    if (hooks.mapResponse?.length)
-      for (let i = 0; i < hooks.mapResponse.length; i++) {
-        const mapResponse2 = hooks.mapResponse[i], endUnit = mapResponseReporter.resolveChild(
-          mapResponse2.fn.name
-        );
-        fnLiteral += `mr=${isAsyncName(mapResponse2) ? "await " : ""}e.mapResponse[${i}](c)
-if(mr!==undefined)r=c.response=c.responseValue=mr
-`, endUnit();
-      }
-    mapResponseReporter.resolve(), fnLiteral += mapResponse();
-  } else {
-    const resolveHandler = reportHandler(
-      isHandleFn ? handler.name : void 0
-    );
-    if (validator.response || hooks.mapResponse?.length || hasTrace) {
-      fnLiteral += isAsyncHandler ? `let r=await ${handle}
-` : `let r=${handle}
-`, resolveHandler(), validator.response && (fnLiteral += validation.response());
-      const mapResponseReporter = report("mapResponse", {
-        total: hooks.mapResponse?.length
-      });
-      if (hooks.mapResponse?.length) {
-        fnLiteral += `
-c.response=c.responseValue=r
-`;
-        for (let i = 0; i < hooks.mapResponse.length; i++) {
-          const mapResponse2 = hooks.mapResponse[i], endUnit = mapResponseReporter.resolveChild(
-            mapResponse2.fn.name
-          );
-          fnLiteral += `
-if(mr===undefined){mr=${isAsyncName(mapResponse2) ? "await " : ""}e.mapResponse[${i}](c)
-if(mr!==undefined)r=c.response=c.responseValue=mr}
-`, endUnit();
-        }
-      }
-      mapResponseReporter.resolve(), fnLiteral += encodeCookie(), handler instanceof Response ? (fnLiteral += afterResponse(), fnLiteral += inference.set ? `if(isNotEmpty(c.set.headers)||c.set.status!==200||c.set.redirect||c.set.cookie)return mapResponse(${saveResponse}${handle}.clone(),c.set${mapResponseContext})
-else return ${handle}.clone()` : `return ${handle}.clone()`, fnLiteral += `
-`) : fnLiteral += mapResponse();
-    } else if (hasCookie || hasTrace) {
-      fnLiteral += isAsyncHandler ? `let r=await ${handle}
-` : `let r=${handle}
-`, resolveHandler();
-      const mapResponseReporter = report("mapResponse", {
-        total: hooks.mapResponse?.length
-      });
-      if (hooks.mapResponse?.length) {
-        fnLiteral += `c.response=c.responseValue= r
-`;
-        for (let i = 0; i < hooks.mapResponse.length; i++) {
-          const mapResponse2 = hooks.mapResponse[i], endUnit = mapResponseReporter.resolveChild(
-            mapResponse2.fn.name
-          );
-          fnLiteral += `if(mr===undefined){mr=${isAsyncName(mapResponse2) ? "await " : ""}e.mapResponse[${i}](c)
-if(mr!==undefined)r=c.response=c.responseValue=mr}`, endUnit();
-        }
-      }
-      mapResponseReporter.resolve(), fnLiteral += encodeCookie() + mapResponse();
-    } else {
-      resolveHandler();
-      const handled = isAsyncHandler ? `await ${handle}` : handle;
-      handler instanceof Response ? (fnLiteral += afterResponse(), fnLiteral += inference.set ? `if(isNotEmpty(c.set.headers)||c.set.status!==200||c.set.redirect||c.set.cookie)return mapResponse(${saveResponse}${handle}.clone(),c.set${mapResponseContext})
-else return ${handle}.clone()
-` : `return ${handle}.clone()
-`) : fnLiteral += mapResponse(handled);
-    }
-  }
-  if (fnLiteral += `
-}catch(error){`, !maybeAsync && hooks.error?.length && (fnLiteral += "return(async()=>{"), fnLiteral += `const set=c.set
-if(!set.status||set.status<300)set.status=error?.status||500
-`, hasCookie && (fnLiteral += encodeCookie()), hasTrace && hooks.trace)
-    for (let i = 0; i < hooks.trace.length; i++)
-      fnLiteral += `report${i}?.resolve(error);reportChild${i}?.(error)
-`;
-  const errorReporter = report("error", {
-    total: hooks.error?.length
-  });
-  if (hooks.error?.length) {
-    fnLiteral += `c.error=error
-`, hasValidation ? fnLiteral += `if(error instanceof TypeBoxError){c.code="VALIDATION"
-c.set.status=422}else{c.code=error.code??error[ERROR_CODE]??"UNKNOWN"}` : fnLiteral += `c.code=error.code??error[ERROR_CODE]??"UNKNOWN"
-`, fnLiteral += `let er
-`, hooks.mapResponse?.length && (fnLiteral += `let mep
-`);
-    for (let i = 0; i < hooks.error.length; i++) {
-      const endUnit = errorReporter.resolveChild(hooks.error[i].fn.name);
-      if (isAsync(hooks.error[i]) ? fnLiteral += `er=await e.error[${i}](c)
-` : fnLiteral += `er=e.error[${i}](c)
-if(er instanceof Promise)er=await er
-`, endUnit(), hooks.mapResponse?.length) {
-        const mapResponseReporter = report("mapResponse", {
-          total: hooks.mapResponse?.length
-        });
-        for (let i2 = 0; i2 < hooks.mapResponse.length; i2++) {
-          const mapResponse2 = hooks.mapResponse[i2], endUnit2 = mapResponseReporter.resolveChild(
-            mapResponse2.fn.name
-          );
-          fnLiteral += `c.response=c.responseValue=er
-mep=e.mapResponse[${i2}](c)
-if(mep instanceof Promise)mep=await mep
-if(mep!==undefined)er=mep
-`, endUnit2();
-        }
-        mapResponseReporter.resolve();
-      }
-      if (fnLiteral += `er=mapEarlyResponse(er,set${mapResponseContext})
-`, fnLiteral += "if(er){", hasTrace && hooks.trace) {
-        for (let i2 = 0; i2 < hooks.trace.length; i2++)
-          fnLiteral += `report${i2}.resolve()
-`;
-        errorReporter.resolve();
-      }
-      fnLiteral += afterResponse(!1), fnLiteral += "return er}";
-    }
-  }
-  errorReporter.resolve(), fnLiteral += "return handleError(c,error,true)", !maybeAsync && hooks.error?.length && (fnLiteral += "})()"), fnLiteral += "}";
-  const adapterVariables = adapter.inject ? Object.keys(adapter.inject).join(",") + "," : "";
-  let init = "const {handler,handleError,hooks:e, " + allocateIf("validator,", hasValidation) + "mapResponse,mapCompactResponse,mapEarlyResponse,isNotEmpty,utils:{" + allocateIf("parseQuery,", hasBody) + allocateIf("parseQueryFromURL,", hasQuery) + "},error:{" + allocateIf("ValidationError,", hasValidation) + allocateIf("ParseError", hasBody) + "},fileType,schema,definitions,tee,ERROR_CODE," + allocateIf("parseCookie,", hasCookie) + allocateIf("signCookie,", hasCookie) + allocateIf("decodeURIComponent,", hasQuery) + "ElysiaCustomStatusResponse," + allocateIf("ELYSIA_TRACE,", hasTrace) + allocateIf("ELYSIA_REQUEST_ID,", hasTrace) + allocateIf("parser,", hooks.parse?.length) + allocateIf("getServer,", inference.server) + allocateIf("fileUnions,", fileUnions.length) + adapterVariables + allocateIf("TypeBoxError", hasValidation) + `}=hooks
-const trace=e.trace
-return ${maybeAsync ? "async " : ""}function handle(c){`;
-  hooks.beforeHandle?.length && (init += `let be
-`), hooks.afterHandle?.length && (init += `let af
-`), hooks.mapResponse?.length && (init += `let mr
-`), allowMeta && (init += `c.schema=schema
-c.defs=definitions
-`), fnLiteral = init + fnLiteral + "}", init = "";
-  try {
-    return Function(
-      "hooks",
-      `"use strict";
-` + fnLiteral
-    )({
-      handler,
-      hooks: (0, import_utils.lifeCycleToFn)(hooks),
-      validator: hasValidation ? validator : void 0,
-      // @ts-expect-error
-      handleError: app.handleError,
-      mapResponse: adapterHandler.mapResponse,
-      mapCompactResponse: adapterHandler.mapCompactResponse,
-      mapEarlyResponse: adapterHandler.mapEarlyResponse,
-      isNotEmpty: import_utils.isNotEmpty,
-      utils: {
-        parseQuery: hasBody ? import_parse_query.parseQuery : void 0,
-        parseQueryFromURL: hasQuery ? validator.query?.provider === "standard" ? import_parse_query.parseQueryStandardSchema : import_parse_query.parseQueryFromURL : void 0
-      },
-      error: {
-        ValidationError: hasValidation ? import_error2.ValidationError : void 0,
-        ParseError: hasBody ? import_error.ParseError : void 0
-      },
-      fileType: import_utils3.fileType,
-      schema: app.router.history,
-      // @ts-expect-error
-      definitions: app.definitions.type,
-      tee: import_utils4.tee,
-      ERROR_CODE: import_error2.ERROR_CODE,
-      parseCookie: hasCookie ? import_cookies.parseCookie : void 0,
-      signCookie: hasCookie ? import_utils.signCookie : void 0,
-      Cookie: hasCookie ? import_index.Cookie : void 0,
-      decodeURIComponent: hasQuery ? import_fast_decode_uri_component.default : void 0,
-      ElysiaCustomStatusResponse: import_error2.ElysiaCustomStatusResponse,
-      ELYSIA_TRACE: hasTrace ? import_trace.ELYSIA_TRACE : void 0,
-      ELYSIA_REQUEST_ID: hasTrace ? import_utils.ELYSIA_REQUEST_ID : void 0,
-      // @ts-expect-error private property
-      getServer: inference.server ? () => app.getServer() : void 0,
-      fileUnions: fileUnions.length ? fileUnions : void 0,
-      TypeBoxError: hasValidation ? import_typebox.TypeBoxError : void 0,
-      parser: app["~parser"],
-      ...adapter.inject
-    });
-  } catch (error) {
-    const debugHooks = (0, import_utils.lifeCycleToFn)(hooks);
-    return console.log("[Composer] failed to generate optimized handler"), console.log("---"), console.log({
-      handler: typeof handler == "function" ? handler.toString() : handler,
-      instruction: fnLiteral,
-      hooks: {
-        ...debugHooks,
-        // @ts-ignore
-        transform: debugHooks?.transform?.map?.((x) => x.toString()),
-        // @ts-ignore
-        resolve: debugHooks?.resolve?.map?.((x) => x.toString()),
-        // @ts-ignore
-        beforeHandle: debugHooks?.beforeHandle?.map?.(
-          (x) => x.toString()
-        ),
-        // @ts-ignore
-        afterHandle: debugHooks?.afterHandle?.map?.(
-          (x) => x.toString()
-        ),
-        // @ts-ignore
-        mapResponse: debugHooks?.mapResponse?.map?.(
-          (x) => x.toString()
-        ),
-        // @ts-ignore
-        parse: debugHooks?.parse?.map?.((x) => x.toString()),
-        // @ts-ignore
-        error: debugHooks?.error?.map?.((x) => x.toString()),
-        // @ts-ignore
-        afterResponse: debugHooks?.afterResponse?.map?.(
-          (x) => x.toString()
-        ),
-        // @ts-ignore
-        stop: debugHooks?.stop?.map?.((x) => x.toString())
-      },
-      validator,
-      // @ts-expect-error
-      definitions: app.definitions.type,
-      error
-    }), console.log("---"), typeof process?.exit == "function" && process.exit(1), () => new Response("Internal Server Error", { status: 500 });
-  }
-}, createOnRequestHandler = (app, addFn) => {
-  let fnLiteral = "";
-  const reporter = createReport({
-    trace: app.event.trace,
-    addFn: addFn ?? ((word) => {
-      fnLiteral += word;
-    })
-  })("request", {
-    total: app.event.request?.length
-  });
-  if (app.event.request?.length) {
-    fnLiteral += "try{";
-    for (let i = 0; i < app.event.request.length; i++) {
-      const hook = app.event.request[i], withReturn = hasReturn(hook), maybeAsync = isAsync(hook), endUnit = reporter.resolveChild(app.event.request[i].fn.name);
-      withReturn ? (fnLiteral += `re=mapEarlyResponse(${maybeAsync ? "await " : ""}onRequest[${i}](c),c.set)
-`, endUnit("re"), fnLiteral += `if(re!==undefined)return re
-`) : (fnLiteral += `${maybeAsync ? "await " : ""}onRequest[${i}](c)
-`, endUnit());
-    }
-    fnLiteral += "}catch(error){return app.handleError(c,error,false)}";
-  }
-  return reporter.resolve(), fnLiteral;
-}, createHoc = (app, fnName = "map") => {
-  const hoc = app.extender.higherOrderFunctions;
-  if (!hoc.length) return "return " + fnName;
-  const adapter = app["~adapter"].composeGeneralHandler;
-  let handler = fnName;
-  for (let i = 0; i < hoc.length; i++)
-    handler = `hoc[${i}](${handler},${adapter.parameters})`;
-  return `return function hocMap(${adapter.parameters}){return ${handler}(${adapter.parameters})}`;
-}, composeGeneralHandler = (app) => {
-  const adapter = app["~adapter"].composeGeneralHandler;
-  app.router.http.build();
-  const isWebstandard = app["~adapter"].isWebStandard, hasTrace = app.event.trace?.length;
-  let fnLiteral = "";
-  const router = app.router;
-  let findDynamicRoute = router.http.root.WS ? "const route=router.find(r.method==='GET'&&r.headers.get('upgrade')==='websocket'?'WS':r.method,p)" : "const route=router.find(r.method,p)";
-  findDynamicRoute += router.http.root.ALL ? `??router.find('ALL',p)
-` : `
-`, isWebstandard && (findDynamicRoute += 'if(r.method==="HEAD"){const route=router.find("GET",p);if(route){c.params=route.params;const _res=route.store.handler?route.store.handler(c):route.store.compile()(c);if(_res)return Promise.resolve(_res).then((_res)=>{if(!_res.headers)_res.headers=new Headers();return getResponseLength(_res).then((length)=>{_res.headers.set("content-length", length);return new Response(null,{status:_res.status,statusText:_res.statusText,headers:_res.headers});})});}}');
-  let afterResponse = `c.error=notFound
-`;
-  if (app.event.afterResponse?.length && !app.event.error) {
-    afterResponse = `
-c.error=notFound
-`;
-    const prefix = app.event.afterResponse.some(isAsync) ? "async" : "";
-    afterResponse += `
-${setImmediateFn}(${prefix}()=>{if(c.responseValue instanceof ElysiaCustomStatusResponse) c.set.status=c.responseValue.code
-`;
-    for (let i = 0; i < app.event.afterResponse.length; i++) {
-      const fn2 = app.event.afterResponse[i].fn;
-      afterResponse += `
-${isAsyncName(fn2) ? "await " : ""}afterResponse[${i}](c)
-`;
-    }
-    afterResponse += `})
-`;
-  }
-  app.inference.query && (afterResponse += `
-if(c.qi===-1){c.query={}}else{c.query=parseQueryFromURL(c.url,c.qi+1)}`);
-  const error404 = adapter.error404(
-    !!app.event.request?.length,
-    !!app.event.error?.length,
-    afterResponse
-  );
-  findDynamicRoute += error404.code, findDynamicRoute += `
-c.params=route.params
-if(route.store.handler)return route.store.handler(c)
-return route.store.compile()(c)
-`;
-  let switchMap = "";
-  for (const [path, methods] of Object.entries(router.static)) {
-    switchMap += `case'${path}':`, app.config.strictPath !== !0 && (switchMap += `case'${(0, import_utils.getLoosePath)(path)}':`);
-    const encoded = (0, import_utils.encodePath)(path);
-    path !== encoded && (switchMap += `case'${encoded}':`), switchMap += "switch(r.method){", ("GET" in methods || "WS" in methods) && (switchMap += "case 'GET':", "WS" in methods && (switchMap += `if(r.headers.get('upgrade')==='websocket')return ht[${methods.WS}].composed(c)
-`, "GET" in methods || ("ALL" in methods ? switchMap += `return ht[${methods.ALL}].composed(c)
-` : switchMap += `break map
-`)), "GET" in methods && (switchMap += `return ht[${methods.GET}].composed(c)
-`)), isWebstandard && ("GET" in methods || "ALL" in methods) && !("HEAD" in methods) && (switchMap += `case 'HEAD':return Promise.resolve(ht[${methods.GET ?? methods.ALL}].composed(c)).then(_ht=>getResponseLength(_ht).then((length)=>{_ht.headers.set('content-length', length)
-return new Response(null,{status:_ht.status,statusText:_ht.statusText,headers:_ht.headers})
-}))
-`);
-    for (const [method, index] of Object.entries(methods))
-      method === "ALL" || method === "GET" || method === "WS" || (switchMap += `case '${method}':return ht[${index}].composed(c)
-`);
-    "ALL" in methods ? switchMap += `default:return ht[${methods.ALL}].composed(c)
-` : switchMap += `default:break map
-`, switchMap += "}";
-  }
-  const maybeAsync = !!app.event.request?.some(isAsync), adapterVariables = adapter.inject ? Object.keys(adapter.inject).join(",") + "," : "";
-  fnLiteral += `
-const {app,mapEarlyResponse,NotFoundError,randomId,handleError,status,redirect,getResponseLength,ElysiaCustomStatusResponse,` + // @ts-ignore
-  allocateIf("parseQueryFromURL,", app.inference.query) + allocateIf("ELYSIA_TRACE,", hasTrace) + allocateIf("ELYSIA_REQUEST_ID,", hasTrace) + adapterVariables + `}=data
-const store=app.singleton.store
-const decorator=app.singleton.decorator
-const staticRouter=app.router.static.http
-const ht=app.router.history
-const router=app.router.http
-const trace=app.event.trace?.map(x=>typeof x==='function'?x:x.fn)??[]
-const notFound=new NotFoundError()
-const hoc=app.extender.higherOrderFunctions.map(x=>x.fn)
-`, app.event.request?.length && (fnLiteral += `const onRequest=app.event.request.map(x=>x.fn)
-`), app.event.afterResponse?.length && (fnLiteral += `const afterResponse=app.event.afterResponse.map(x=>x.fn)
-`), fnLiteral += error404.declare, app.event.trace?.length && (fnLiteral += "const " + app.event.trace.map((_, i) => `tr${i}=app.event.trace[${i}].fn`).join(",") + `
-`), fnLiteral += `${maybeAsync ? "async " : ""}function map(${adapter.parameters}){`, app.event.request?.length && (fnLiteral += `let re
-`), fnLiteral += adapter.createContext(app), app.event.trace?.length && (fnLiteral += "c[ELYSIA_TRACE]=[" + app.event.trace.map((_, i) => `tr${i}(c)`).join(",") + `]
-`), fnLiteral += createOnRequestHandler(app), switchMap && (fnLiteral += `
-map: switch(p){
-` + switchMap + "}"), fnLiteral += findDynamicRoute + `}
-` + createHoc(app);
-  const handleError = composeErrorHandler(app);
-  app.handleError = handleError;
-  const fn = Function(
-    "data",
-    `"use strict";
-` + fnLiteral
-  )({
-    app,
-    mapEarlyResponse: app["~adapter"].handler.mapEarlyResponse,
-    NotFoundError: import_error2.NotFoundError,
-    randomId: import_utils.randomId,
-    handleError,
-    status: import_error.status,
-    redirect: import_utils.redirect,
-    getResponseLength: import_utils.getResponseLength,
-    ElysiaCustomStatusResponse: import_error2.ElysiaCustomStatusResponse,
-    // @ts-ignore
-    parseQueryFromURL: app.inference.query ? import_parse_query.parseQueryFromURL : void 0,
-    ELYSIA_TRACE: hasTrace ? import_trace.ELYSIA_TRACE : void 0,
-    ELYSIA_REQUEST_ID: hasTrace ? import_utils.ELYSIA_REQUEST_ID : void 0,
-    ...adapter.inject
-  });
-  return import_utils2.isBun && Bun.gc(!1), fn;
-}, composeErrorHandler = (app) => {
-  const hooks = app.event;
-  let fnLiteral = "";
-  const adapter = app["~adapter"].composeError, adapterVariables = adapter.inject ? Object.keys(adapter.inject).join(",") + "," : "", hasTrace = !!app.event.trace?.length;
-  fnLiteral += "const {mapResponse,ERROR_CODE,ElysiaCustomStatusResponse,ValidationError,TransformDecodeError," + allocateIf("onError,", app.event.error) + allocateIf("afterResponse,", app.event.afterResponse) + allocateIf("trace,", app.event.trace) + allocateIf("onMapResponse,", app.event.mapResponse) + allocateIf("ELYSIA_TRACE,", hasTrace) + allocateIf("ELYSIA_REQUEST_ID,", hasTrace) + adapterVariables + `}=inject
-`, fnLiteral += "return async function(context,error,skipGlobal){", fnLiteral += "", hasTrace && (fnLiteral += `const id=context[ELYSIA_REQUEST_ID]
-`);
-  const report = createReport({
-    context: "context",
-    trace: hooks.trace,
-    addFn: (word) => {
-      fnLiteral += word;
-    }
-  }), afterResponse = () => {
-    if (!hooks.afterResponse?.length && !hasTrace) return "";
-    let afterResponse2 = "";
-    const prefix = hooks.afterResponse?.some(isAsync) ? "async" : "";
-    afterResponse2 += `
-${setImmediateFn}(${prefix}()=>{`;
-    const reporter = createReport({
-      context: "context",
-      trace: hooks.trace,
-      addFn: (word) => {
-        afterResponse2 += word;
-      }
-    })("afterResponse", {
-      total: hooks.afterResponse?.length,
-      name: "context"
-    });
-    if (hooks.afterResponse?.length && hooks.afterResponse)
-      for (let i = 0; i < hooks.afterResponse.length; i++) {
-        const fn = hooks.afterResponse[i].fn, endUnit = reporter.resolveChild(fn.name);
-        afterResponse2 += `
-${isAsyncName(fn) ? "await " : ""}afterResponse[${i}](context)
-`, endUnit();
-      }
-    return reporter.resolve(), afterResponse2 += `})
-`, afterResponse2;
-  };
-  fnLiteral += `const set=context.set
-let _r
-if(!context.code)context.code=error.code??error[ERROR_CODE]
-if(!(context.error instanceof Error))context.error=error
-if(error instanceof ElysiaCustomStatusResponse){set.status=error.status=error.code
-error.message=error.response}`, adapter.declare && (fnLiteral += adapter.declare);
-  const saveResponse = hasTrace || hooks.afterResponse?.length ? "context.response = " : "";
-  if (fnLiteral += `if(typeof error?.toResponse==='function'&&!(error instanceof ValidationError)&&!(error instanceof TransformDecodeError)){try{let raw=error.toResponse()
-if(typeof raw?.then==='function')raw=await raw
-if(raw instanceof Response)set.status=raw.status
-context.response=context.responseValue=raw
-}catch(toResponseError){
-}
-}
-`, app.event.error)
-    for (let i = 0; i < app.event.error.length; i++) {
-      const handler = app.event.error[i], response = `${isAsync(handler) ? "await " : ""}onError[${i}](context)
-`;
-      if (fnLiteral += "if(skipGlobal!==true&&!context.response){", hasReturn(handler)) {
-        fnLiteral += `_r=${response}
-if(_r!==undefined){if(_r instanceof Response){` + afterResponse() + `return mapResponse(_r,set${adapter.mapResponseContext})}if(_r instanceof ElysiaCustomStatusResponse){error.status=error.code
-error.message=error.response}if(set.status===200||!set.status)set.status=error.status
-`;
-        const mapResponseReporter2 = report("mapResponse", {
-          total: hooks.mapResponse?.length,
-          name: "context"
-        });
-        if (hooks.mapResponse?.length)
-          for (let i2 = 0; i2 < hooks.mapResponse.length; i2++) {
-            const mapResponse = hooks.mapResponse[i2], endUnit = mapResponseReporter2.resolveChild(
-              mapResponse.fn.name
-            );
-            fnLiteral += `context.response=context.responseValue=_r
-_r=${isAsyncName(mapResponse) ? "await " : ""}onMapResponse[${i2}](context)
-`, endUnit();
-          }
-        mapResponseReporter2.resolve(), fnLiteral += afterResponse() + `return mapResponse(${saveResponse}_r,set${adapter.mapResponseContext})}`;
-      } else fnLiteral += response;
-      fnLiteral += "}";
-    }
-  fnLiteral += `if(error instanceof ValidationError||error instanceof TransformDecodeError){
-if(error.error)error=error.error
-set.status=error.status??422
-` + afterResponse() + adapter.validationError + `
-}
-`, fnLiteral += "if(!context.response&&error instanceof Error){" + afterResponse() + adapter.unknownError + `
-}`;
-  const mapResponseReporter = report("mapResponse", {
-    total: hooks.mapResponse?.length,
-    name: "context"
-  });
-  if (fnLiteral += `
-if(!context.response)context.response=context.responseValue=error.message??error
-`, hooks.mapResponse?.length) {
-    fnLiteral += `let mr
-`;
-    for (let i = 0; i < hooks.mapResponse.length; i++) {
-      const mapResponse = hooks.mapResponse[i], endUnit = mapResponseReporter.resolveChild(
-        mapResponse.fn.name
-      );
-      fnLiteral += `if(mr===undefined){mr=${isAsyncName(mapResponse) ? "await " : ""}onMapResponse[${i}](context)
-if(mr!==undefined)error=context.response=context.responseValue=mr}`, endUnit();
-    }
-  }
-  mapResponseReporter.resolve(), fnLiteral += afterResponse() + `
-return mapResponse(${saveResponse}error,set${adapter.mapResponseContext})}`;
-  const mapFn = (x) => typeof x == "function" ? x : x.fn;
-  return Function(
-    "inject",
-    `"use strict";
-` + fnLiteral
-  )({
-    mapResponse: app["~adapter"].handler.mapResponse,
-    ERROR_CODE: import_error2.ERROR_CODE,
-    ElysiaCustomStatusResponse: import_error2.ElysiaCustomStatusResponse,
-    ValidationError: import_error2.ValidationError,
-    TransformDecodeError: import_value.TransformDecodeError,
-    onError: app.event.error?.map(mapFn),
-    afterResponse: app.event.afterResponse?.map(mapFn),
-    trace: app.event.trace?.map(mapFn),
-    onMapResponse: app.event.mapResponse?.map(mapFn),
-    ELYSIA_TRACE: hasTrace ? import_trace.ELYSIA_TRACE : void 0,
-    ELYSIA_REQUEST_ID: hasTrace ? import_utils.ELYSIA_REQUEST_ID : void 0,
-    ...adapter.inject
-  });
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  composeErrorHandler,
-  composeGeneralHandler,
-  composeHandler,
-  createHoc,
-  createOnRequestHandler,
-  isAsync
-});