@qwik.dev/router 2.0.0-beta.35 → 2.0.0-beta.37

package/lib/chunks/action-handler.mjs

@@ -0,0 +1,782 @@
+import { isDev as isDev$1 } from '@qwik.dev/core';
+import { o as getRouteLoaderValues, p as loadRouteLoader, x as getLoaderRequestEvent, y as resolveRouteLoaderByHash, z as getRouteLoaderResponse, n as getRouteLoaderCtx, q as setRouteLoaders, F as FULLPATH_HEADER, t as RedirectMessage, S as ServerError } from './deepFreeze.qwik.mjs';
+import { Q as QLoaderId, I as IsQLoader, c as resolveValidInternalFullPathname, b as IsQAction, a as QActionId } from './request-path.mjs';
+import { isDev, _deserialize, _serialize, _verifySerializable } from '@qwik.dev/core/internal';
+
+const MAX_CACHE_SIZE = typeof globalThis.__SSR_CACHE_SIZE__ === "number" ? globalThis.__SSR_CACHE_SIZE__ : 50;
+function createLruCache() {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const entry = cache.get(key);
+      if (entry !== void 0) {
+        cache.delete(key);
+        cache.set(key, entry);
+      }
+      return entry;
+    },
+    set(key, entry) {
+      if (MAX_CACHE_SIZE <= 0) {
+        return;
+      }
+      if (cache.size >= MAX_CACHE_SIZE) {
+        const firstKey = cache.keys().next().value;
+        cache.delete(firstKey);
+      }
+      cache.set(key, entry);
+    },
+    clear(key) {
+      if (key != null) {
+        cache.delete(key);
+      } else {
+        cache.clear();
+      }
+    }
+  };
+}
+const ssrCache = createLruCache();
+const loaderCache = createLruCache();
+function resolveETag(eTagExport, headProps) {
+  if (eTagExport === void 0) {
+    return null;
+  }
+  if (typeof eTagExport === "function") {
+    return eTagExport(headProps);
+  }
+  return eTagExport;
+}
+function resolveCacheKey(cacheKeyExport, defaultKey, requestEv, eTag) {
+  if (cacheKeyExport === true) {
+    return defaultKey(requestEv, eTag);
+  }
+  if (typeof cacheKeyExport !== "function") {
+    return "";
+  }
+  return cacheKeyExport(requestEv, eTag) || "";
+}
+function defaultSsrCacheKey(requestEv, eTag) {
+  const status = requestEv.status();
+  const pathname = requestEv.url.pathname;
+  return eTag ? `${status}|${eTag}|${pathname}` : `${status}|${pathname}`;
+}
+function defaultLoaderCacheKey(requestEv, eTag) {
+  const loaderId = requestEv.sharedMap.get(QLoaderId);
+  const base = `${requestEv.url.pathname}|${requestEv.url.search}|${loaderId}`;
+  return eTag ? `${base}|${eTag}` : base;
+}
+function getCachedSsr(key) {
+  return ssrCache.get(key);
+}
+function setCachedSsr(key, entry) {
+  ssrCache.set(key, entry);
+}
+function getCachedLoader(key) {
+  return loaderCache.get(key);
+}
+function setCachedLoader(key, entry) {
+  loaderCache.set(key, entry);
+}
+function clearSsrCache(cacheKey) {
+  ssrCache.clear(cacheKey);
+}
+function clearLoaderCache(cacheKey) {
+  loaderCache.clear(cacheKey);
+}
+
+const RequestEvMode = /* @__PURE__ */ Symbol("RequestEvMode");
+const RequestEvRoute = /* @__PURE__ */ Symbol("RequestEvRoute");
+const RequestRouteName = "@routeName";
+const RequestEvSharedActionId = "@actionId";
+const RequestEvSharedActionFormData = "@actionFormData";
+const RequestEvSharedNonce = "@nonce";
+const RequestEvIsRewrite = "@rewrite";
+const RequestEvShareServerTiming = "@serverTiming";
+const RequestEvETagCacheKey = "@eTagCacheKey";
+const RequestEvHttpStatusMessage = "@httpStatusMessage";
+function getRequestRoute(requestEv) {
+  return requestEv[RequestEvRoute];
+}
+function getRequestMode(requestEv) {
+  return requestEv[RequestEvMode];
+}
+const ABORT_INDEX = Number.MAX_SAFE_INTEGER;
+const isDangerousKey = (k) => k === "__proto__" || k === "constructor" || k === "prototype";
+const isArrayIndexKey = (k) => /^(0|[1-9]\d*)$/.test(k);
+const getArrayPaths = (formData) => {
+  const arrayCandidates = /* @__PURE__ */ new Map();
+  for (const [name] of formData) {
+    const keys = name.split(".");
+    let hasDangerousKey = false;
+    for (const key of keys) {
+      if (isDangerousKey(key)) {
+        hasDangerousKey = true;
+        break;
+      }
+    }
+    if (hasDangerousKey) {
+      continue;
+    }
+    let path = "";
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (key.endsWith("[]")) {
+        break;
+      }
+      path = path ? `${path}.${key}` : key;
+      if (!arrayCandidates.has(path)) {
+        arrayCandidates.set(path, true);
+      }
+      if (!isArrayIndexKey(keys[i + 1])) {
+        arrayCandidates.set(path, false);
+      }
+    }
+  }
+  return new Set(Array.from(arrayCandidates.entries()).filter(([, isArrayPath]) => isArrayPath).map(([path]) => path));
+};
+const formToObj = (formData) => {
+  const values = /* @__PURE__ */ Object.create(null);
+  const arrayPaths = getArrayPaths(formData);
+  for (const [name, value] of formData) {
+    const keys = name.split(".");
+    let hasDangerousKey = false;
+    for (let i = 0; i < keys.length; i++) {
+      if (isDangerousKey(keys[i])) {
+        hasDangerousKey = true;
+        break;
+      }
+    }
+    if (hasDangerousKey) {
+      continue;
+    }
+    let object = values;
+    let path = "";
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (key.endsWith("[]")) {
+        const arrayKey = key.slice(0, -2);
+        if (isDangerousKey(arrayKey)) {
+          break;
+        }
+        const existingValue = object[arrayKey];
+        if (existingValue !== void 0 && !Array.isArray(existingValue)) {
+          break;
+        }
+        object[arrayKey] = existingValue || [];
+        object[arrayKey].push(value);
+        break;
+      }
+      if (Array.isArray(object) && !isArrayIndexKey(key)) {
+        break;
+      }
+      if (i < keys.length - 1) {
+        path = path ? `${path}.${key}` : key;
+        const nextValue = object[key];
+        if (nextValue !== void 0) {
+          object = nextValue;
+          continue;
+        }
+        object = object[key] = arrayPaths.has(path) ? [] : /* @__PURE__ */ Object.create(null);
+      } else {
+        object[key] = value;
+      }
+    }
+  }
+  return values;
+};
+const parseRequest = async (deps, { request, method, query }, sharedMap) => {
+  const type = deps.getContentType(request.headers);
+  if (type === "application/x-www-form-urlencoded" || type === "multipart/form-data") {
+    const formData = await request.formData();
+    sharedMap.set(RequestEvSharedActionFormData, formData);
+    return formToObj(formData);
+  } else if (type === "application/json") {
+    const data = await request.json();
+    return data;
+  } else if (type === "application/qwik-json") {
+    if (method === "GET" && query.has(deps.QDATA_KEY)) {
+      const data = query.get(deps.QDATA_KEY);
+      if (data) {
+        try {
+          return _deserialize(decodeURIComponent(data));
+        } catch {
+        }
+      }
+    }
+    return _deserialize(await request.text());
+  }
+  return void 0;
+};
+function createRequestEventWithDeps(deps, serverRequestEv, loadedRoute, requestHandlers, basePathname, resolved) {
+  const { request, platform, env } = serverRequestEv;
+  const sharedMap = /* @__PURE__ */ new Map();
+  const cookie = new deps.Cookie(request.headers.get("cookie"));
+  const headers = new Headers();
+  const url = new URL(request.url);
+  let internalRequest = false;
+  const recognized = deps.recognizeRequest(url.pathname);
+  if (recognized) {
+    url.pathname = deps.trimRecognizedInternalPathname(url.pathname, recognized);
+    sharedMap.set(recognized.type, true);
+    internalRequest = "loader";
+    if (recognized.data?.loaderId) {
+      sharedMap.set(deps.QLoaderId, recognized.data.loaderId);
+    }
+  }
+  const actionId = url.searchParams.get(deps.QACTION_KEY);
+  if (actionId) {
+    sharedMap.set(deps.IsQAction, true);
+    sharedMap.set(deps.QActionId, actionId);
+    if (request.method === "POST" && request.headers.get("accept")?.includes("application/json")) {
+      internalRequest = "action";
+    }
+  }
+  let routeModuleIndex = -1;
+  let writableStream = null;
+  let requestData = void 0;
+  let locale = serverRequestEv.locale;
+  let status = loadedRoute?.$notFound$ ? 404 : 200;
+  const next = async () => {
+    routeModuleIndex++;
+    while (routeModuleIndex < requestHandlers.length) {
+      const moduleRequestHandler = requestHandlers[routeModuleIndex];
+      const result = moduleRequestHandler(requestEv);
+      if (deps.isPromise(result)) {
+        await result;
+      }
+      routeModuleIndex++;
+    }
+  };
+  const resetRoute = (_loadedRoute, _requestHandlers, _url = url) => {
+    loadedRoute = _loadedRoute;
+    status = loadedRoute?.$notFound$ ? 404 : 200;
+    requestHandlers = _requestHandlers;
+    url.pathname = _url.pathname;
+    url.search = _url.search;
+    routeModuleIndex = -1;
+  };
+  const check = () => {
+    if (writableStream !== null) {
+      throw new Error("Response already sent");
+    }
+  };
+  const send = (statusOrResponse, body) => {
+    check();
+    if (typeof statusOrResponse === "number") {
+      status = statusOrResponse;
+      const writableStream2 = requestEv.getWritableStream();
+      const writer = writableStream2.getWriter();
+      writer.write(typeof body === "string" ? deps.encoder.encode(body) : body);
+      writer.close();
+    } else {
+      status = statusOrResponse.status;
+      statusOrResponse.headers.forEach((value, key) => {
+        if (key.toLowerCase() === "set-cookie") {
+          return;
+        }
+        headers.append(key, value);
+      });
+      statusOrResponse.headers.getSetCookie().forEach((ck) => {
+        const index = ck.indexOf("=");
+        if (index === -1) {
+          return;
+        }
+        const key = ck.slice(0, index).trim();
+        const value = ck.slice(index + 1).trim();
+        cookie.set(key, value);
+      });
+      if (statusOrResponse.body) {
+        const writableStream2 = requestEv.getWritableStream();
+        statusOrResponse.body.pipeTo(writableStream2);
+      } else {
+        requestEv.getWritableStream().getWriter().close();
+      }
+    }
+    return exit();
+  };
+  const exit = (message = new deps.AbortMessage()) => {
+    routeModuleIndex = ABORT_INDEX;
+    return message;
+  };
+  const requestEv = {
+    [RequestEvMode]: serverRequestEv.mode,
+    get [RequestEvRoute]() {
+      return loadedRoute;
+    },
+    cookie,
+    headers,
+    env,
+    method: request.method,
+    signal: request.signal,
+    originalUrl: new URL(url),
+    get params() {
+      return loadedRoute?.$params$ ?? {};
+    },
+    get pathname() {
+      return url.pathname;
+    },
+    platform,
+    get query() {
+      return url.searchParams;
+    },
+    request,
+    url,
+    internalRequest,
+    basePathname,
+    sharedMap,
+    get headersSent() {
+      return writableStream !== null;
+    },
+    get exited() {
+      return routeModuleIndex >= ABORT_INDEX;
+    },
+    get clientConn() {
+      return serverRequestEv.getClientConn();
+    },
+    next,
+    resetRoute,
+    exit,
+    cacheControl: (cacheControl, target = "Cache-Control") => {
+      check();
+      headers.set(target, deps.createCacheControl(cacheControl));
+    },
+    resolveValue: async (loaderOrAction) => {
+      if (loaderOrAction.__brand === "server_loader") {
+        const loaderValues = getRouteLoaderValues(requestEv);
+        if (loaderOrAction.__id in loaderValues) {
+          return loaderValues[loaderOrAction.__id];
+        }
+        return loadRouteLoader(loaderOrAction, requestEv);
+      }
+      return void 0;
+    },
+    status: (statusCode) => {
+      if (typeof statusCode === "number") {
+        check();
+        status = statusCode;
+        return statusCode;
+      }
+      return status;
+    },
+    locale: (_locale) => {
+      if (typeof _locale === "string") {
+        locale = _locale;
+      }
+      return locale || "";
+    },
+    error: (statusCode, message) => {
+      status = statusCode;
+      headers.delete("Cache-Control");
+      return new deps.ServerError(statusCode, message);
+    },
+    redirect: (statusCode, url2) => {
+      check();
+      status = statusCode;
+      if (url2) {
+        if (
+          // //test.com
+          /^\/\//.test(url2) || // /test//path
+          /([^:])\/\/+/.test(url2)
+        ) {
+          const fixedURL = url2.replace(/^\/\/+/, "/").replace(/([^:])\/\/+/g, "$1/");
+          console.warn(`Redirect URL ${url2} is invalid, fixing to ${fixedURL}`);
+          url2 = fixedURL;
+        }
+        headers.set("Location", url2);
+      }
+      headers.delete("Cache-Control");
+      if (statusCode > 301) {
+        headers.set("Cache-Control", "no-store");
+      }
+      if (internalRequest === "loader") {
+        return new deps.RedirectMessage();
+      }
+      return exit(new deps.RedirectMessage());
+    },
+    rewrite: (pathname) => {
+      check();
+      if (pathname.startsWith("http")) {
+        throw new deps.ServerError(400, isDev ? "Rewrite does not support absolute urls" : "Bad Request");
+      }
+      sharedMap.set(RequestEvIsRewrite, true);
+      return exit(new deps.RewriteMessage(pathname.replace(/\/+/g, "/")));
+    },
+    defer: (returnData) => {
+      return typeof returnData === "function" ? returnData : () => returnData;
+    },
+    fail: (statusCode, data) => {
+      check();
+      status = statusCode;
+      headers.delete("Cache-Control");
+      return {
+        failed: true,
+        ...data
+      };
+    },
+    text: (statusCode, text) => {
+      headers.set("Content-Type", "text/plain; charset=utf-8");
+      return send(statusCode, text);
+    },
+    html: (statusCode, html) => {
+      headers.set("Content-Type", "text/html; charset=utf-8");
+      return send(statusCode, html);
+    },
+    parseBody: async () => {
+      if (requestData !== void 0) {
+        return requestData;
+      }
+      return requestData = parseRequest(deps, requestEv, sharedMap);
+    },
+    json: (statusCode, data) => {
+      headers.set("Content-Type", "application/json; charset=utf-8");
+      return send(statusCode, JSON.stringify(data));
+    },
+    send,
+    isDirty: () => {
+      return writableStream !== null;
+    },
+    getWritableStream: () => {
+      if (writableStream === null) {
+        if (isDev) {
+          const serverTiming = sharedMap.get(RequestEvShareServerTiming);
+          if (serverTiming) {
+            headers.set("Server-Timing", serverTiming.map(([name, duration]) => `${name};dur=${duration}`).join(","));
+          }
+        }
+        writableStream = serverRequestEv.getWritableStream(status, headers, cookie, resolved, requestEv);
+      }
+      return writableStream;
+    }
+  };
+  return requestEv;
+}
+
+function hash(str) {
+  let hash2 = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash2 ^= str.charCodeAt(i);
+    hash2 = hash2 * 16777619 | 0;
+  }
+  return (hash2 >>> 0).toString(36);
+}
+function normalizeETag(raw) {
+  let tag = raw.trim();
+  if (tag.endsWith('"') && tag.startsWith('W/"')) {
+    tag = tag.slice(3);
+  }
+  tag = tag.replace(/[^!#-~]/g, "");
+  return tag;
+}
+function setETagHeader(requestEv, normalizedETag) {
+  const headerETag = `"${normalizedETag}"`;
+  requestEv.headers.set("ETag", headerETag);
+}
+function performETagMatch(requestEv, normalizedETag) {
+  setETagHeader(requestEv, normalizedETag);
+  const ifNoneMatch = requestEv.request.headers.get("If-None-Match");
+  if (ifNoneMatch) {
+    let found = ifNoneMatch.trim() === "*";
+    if (!found) {
+      for (const entry of ifNoneMatch.split(",")) {
+        const normalizedEntry = normalizeETag(entry);
+        if (normalizedEntry === normalizedETag) {
+          found = true;
+          break;
+        }
+      }
+    }
+    if (found) {
+      requestEv.status(304);
+      requestEv.send(304, "");
+      return true;
+    }
+  }
+  return false;
+}
+
+function createLoaderRequestEventFactory(requestEv) {
+  return (loader) => getLoaderRequestEvent(loader, requestEv);
+}
+
+function setLoaderData(requestEv, routeLoaders, loaderPaths) {
+  if (loaderPaths) {
+    Object.assign(getRouteLoaderCtx(requestEv).loaderPaths, loaderPaths);
+  }
+  setRouteLoaders(requestEv, routeLoaders);
+}
+function resolvePreETag(eTagOption, requestEv) {
+  if (typeof eTagOption === "string") {
+    return normalizeETag(eTagOption);
+  }
+  const result = eTagOption(requestEv);
+  return result ? normalizeETag(result) : "";
+}
+function addVaryHeader(requestEv, value) {
+  const vary = requestEv.headers.get("Vary");
+  if (!vary) {
+    requestEv.headers.set("Vary", value);
+    return;
+  }
+  const existing = vary.split(",").map((item) => item.trim().toLowerCase());
+  if (!existing.includes(value.toLowerCase())) {
+    requestEv.headers.set("Vary", `${vary}, ${value}`);
+  }
+}
+async function sendLoaderResponse(requestEv, data, loader) {
+  requestEv.headers.set("Content-Type", "application/json; charset=utf-8");
+  addVaryHeader(requestEv, FULLPATH_HEADER);
+  if (loader?.__expires && loader.__expires > 0) {
+    requestEv.cacheControl({
+      maxAge: Math.ceil(loader.__expires / 1e3)
+    });
+  }
+  requestEv.send(200, data);
+}
+function loaderHandler(routeLoaders, loaderPaths) {
+  return async (requestEvent) => {
+    const requestEv = requestEvent;
+    if (!requestEv.sharedMap.has(IsQLoader)) {
+      return;
+    }
+    if (requestEv.headersSent || requestEv.exited) {
+      return;
+    }
+    const loaderId = requestEv.sharedMap.get(QLoaderId);
+    const loader = resolveRouteLoaderByHash(routeLoaders, loaderId);
+    if (!loader) {
+      requestEv.json(404, {
+        error: "Loader not found"
+      });
+      return;
+    }
+    setLoaderData(requestEv, routeLoaders, loaderPaths);
+    const loaderRequestEv = createLoaderRequestEventFactory(requestEv)(loader);
+    const normalizedETag = loader.__eTag !== void 0 ? resolvePreETag(loader.__eTag, loaderRequestEv) : "";
+    if (normalizedETag && performETagMatch(loaderRequestEv, normalizedETag)) {
+      return;
+    }
+    let cacheKey = "";
+    if (loader.__cacheKey) {
+      cacheKey = resolveCacheKey(loader.__cacheKey, defaultLoaderCacheKey, loaderRequestEv, normalizedETag);
+    }
+    if (cacheKey) {
+      const cached = getCachedLoader(cacheKey);
+      if (cached) {
+        if (!normalizedETag) {
+          if (performETagMatch(loaderRequestEv, cached.eTag)) {
+            return;
+          }
+        } else {
+          setETagHeader(loaderRequestEv, cached.eTag);
+        }
+        await sendLoaderResponse(requestEv, cached.body, loader);
+        return;
+      }
+    }
+    const responseData = await getRouteLoaderResponse(loader.__qrl, loader.__validators, loaderRequestEv);
+    const data = await _serialize(responseData);
+    const cacheable = cacheKey && !responseData.r && !responseData.e;
+    const finalETag = normalizedETag || (cacheable ? hash(data) : "");
+    if (cacheable && finalETag) {
+      setCachedLoader(cacheKey, {
+        eTag: finalETag,
+        body: data
+      });
+    }
+    if (!normalizedETag && finalETag && performETagMatch(loaderRequestEv, finalETag)) {
+      return;
+    }
+    await sendLoaderResponse(requestEv, data, loader);
+  };
+}
+async function sendJsonResponse(requestEv, responseData, status = 200) {
+  const data = await _serialize(responseData);
+  requestEv.headers.set("Content-Type", "application/json; charset=utf-8");
+  requestEv.send(status, data);
+}
+async function sendActionResponse(requestEv, responseData) {
+  const data = await _serialize(responseData);
+  requestEv.headers.set("Content-Type", "application/json; charset=utf-8");
+  requestEv.send(responseData.s || 200, data);
+}
+
+function jsonRequestWrapper() {
+  return async (requestEvent) => {
+    const requestEv = requestEvent;
+    const isLoader = requestEv.internalRequest === "loader";
+    const isActionJson = requestEv.internalRequest === "action";
+    if (!isLoader && !isActionJson) {
+      return;
+    }
+    if (isLoader) {
+      addVaryHeader(requestEv, FULLPATH_HEADER);
+      const pagePath = requestEv.request.headers.get(FULLPATH_HEADER);
+      const pagePathname = resolveValidInternalFullPathname(requestEv.url.pathname, pagePath);
+      if (pagePathname) {
+        requestEv.url.pathname = pagePathname;
+      }
+    }
+    try {
+      await requestEv.next();
+    } catch (err) {
+      if (requestEv.headersSent) {
+        return;
+      }
+      if (err instanceof RedirectMessage) {
+        if (isLoader) {
+          const location = requestEv.headers.get("Location") || "/";
+          requestEv.headers.delete("Location");
+          await sendJsonResponse(requestEv, {
+            r: location
+          });
+        } else {
+          throw err;
+        }
+      } else if (err instanceof ServerError) {
+        if (isLoader) {
+          await sendJsonResponse(requestEv, {
+            e: err
+          });
+        } else {
+          await sendActionResponse(requestEv, {
+            e: err,
+            s: err.status
+          });
+        }
+      } else if (err instanceof Error) {
+        console.error("JSON request error:", err);
+        const message = isDev$1 ? `${err.message}
+(this is only visible in dev mode)` : "Internal Server Error";
+        const se = new ServerError(500, message);
+        if (isLoader) {
+          await sendJsonResponse(requestEv, {
+            e: se
+          });
+        } else {
+          await sendActionResponse(requestEv, {
+            e: se,
+            s: 500
+          });
+        }
+      } else {
+        throw err;
+      }
+    }
+  };
+}
+
+function verifySerializable(data, qrl) {
+  try {
+    _verifySerializable(data, void 0);
+  } catch (e) {
+    if (e instanceof Error && qrl.dev) {
+      e.loc = qrl.dev;
+    }
+    throw e;
+  }
+}
+async function measure(requestEv, name, fn) {
+  const start = performance.now();
+  try {
+    return await fn();
+  } finally {
+    const duration = performance.now() - start;
+    let measurements = requestEv.sharedMap.get("@serverTiming");
+    if (!measurements) {
+      requestEv.sharedMap.set("@serverTiming", measurements = []);
+    }
+    measurements.push([
+      name,
+      duration
+    ]);
+  }
+}
+async function runValidators(requestEv, validators, data, devMode) {
+  let lastResult = {
+    success: true,
+    data
+  };
+  if (validators) {
+    for (const validator of validators) {
+      if (devMode) {
+        lastResult = await measure(requestEv, `validator$`, () => validator.validate(requestEv, data));
+      } else {
+        lastResult = await validator.validate(requestEv, data);
+      }
+      if (!lastResult.success) {
+        return lastResult;
+      } else {
+        data = lastResult.data;
+      }
+    }
+  }
+  return lastResult;
+}
+function actionHandler(routeActions) {
+  return async (requestEvent) => {
+    const requestEv = requestEvent;
+    if (!requestEv.sharedMap.has(IsQAction)) {
+      return;
+    }
+    if (!requestEv.request.headers.get("accept")?.includes("application/json")) {
+      return;
+    }
+    if (requestEv.headersSent || requestEv.exited) {
+      return;
+    }
+    const actionId = requestEv.sharedMap.get(QActionId);
+    const method = requestEv.method;
+    const devMode = isDev;
+    if (devMode && method === "GET") {
+      console.warn('Seems like you are submitting a Qwik Action via GET request. Qwik Actions should be submitted via POST request.\nMake sure your <form> has method="POST" attribute, like this: <form method="POST">');
+    }
+    if (method !== "POST") {
+      return;
+    }
+    let action;
+    for (const routeAction of routeActions) {
+      if (routeAction.__id === actionId) {
+        action = routeAction;
+      }
+    }
+    if (!action) {
+      const serverActionsMap = globalThis._qwikActionsMap;
+      action = serverActionsMap?.get(actionId);
+    }
+    if (!action) {
+      requestEv.json(404, {
+        error: "Action not found"
+      });
+      return;
+    }
+    const data = await requestEv.parseBody();
+    if (!data || typeof data !== "object") {
+      throw new Error(`Expected request data for the action id ${actionId} to be an object`);
+    }
+    let actionResult;
+    const result = await runValidators(requestEv, action.__validators, data, devMode);
+    if (!result.success) {
+      actionResult = requestEv.fail(result.status ?? 500, result.error);
+    } else {
+      const actionResolved = devMode ? await measure(requestEv, action.__qrl.getHash(), () => action.__qrl.call(requestEv, result.data, requestEv)) : await action.__qrl.call(requestEv, result.data, requestEv);
+      if (devMode) {
+        verifySerializable(actionResolved, action.__qrl);
+      }
+      actionResult = actionResolved;
+    }
+    const responseData = {
+      result: actionResult
+    };
+    requestEv.sharedMap.set(RequestEvSharedActionId, actionId);
+    requestEv.sharedMap.set("@actionResult", actionResult);
+    if (action.__invalidate) {
+      responseData.loaderHashes = action.__invalidate;
+    } else if (globalThis.__STRICT_LOADERS__) {
+      responseData.loaderHashes = [];
+    }
+    const serialized = await _serialize(responseData);
+    requestEv.headers.set("Content-Type", "application/json; charset=utf-8");
+    requestEv.send(requestEv.status(), serialized);
+  };
+}
+
+export { MAX_CACHE_SIZE as M, RequestRouteName as R, getRequestMode as a, RequestEvSharedNonce as b, RequestEvSharedActionId as c, RequestEvSharedActionFormData as d, RequestEvHttpStatusMessage as e, actionHandler as f, getRequestRoute as g, hash as h, setCachedLoader as i, jsonRequestWrapper as j, setCachedSsr as k, loaderHandler as l, resolveCacheKey as m, normalizeETag as n, getCachedLoader as o, performETagMatch as p, getCachedSsr as q, resolveETag as r, setETagHeader as s, defaultLoaderCacheKey as t, defaultSsrCacheKey as u, RequestEvShareServerTiming as v, RequestEvETagCacheKey as w, createRequestEventWithDeps as x, clearLoaderCache as y, clearSsrCache as z };