@solidjs/web 2.0.0-experimental.9 → 2.0.0-rc.0

package/server-functions/dist/server.dev.js

@@ -0,0 +1,1045 @@
+import { sharedConfig } from 'solid-js';
+
+const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
+function isResponseEnvelope(value) {
+  return !!(value && typeof value === "object" && value[ENVELOPE]);
+}
+const SAFE_ERROR = Symbol.for("solid.SafeError");
+function isSafeError(value) {
+  return !!(value && (typeof value === "object" || typeof value === "function") && value[SAFE_ERROR]);
+}
+const REVALIDATE_HEADER = "X-Revalidate";
+
+const SERVER_FUNCTION_METADATA = Symbol.for("solid.ServerFunctionMetadata");
+function getServerFunctionMetadata(fn) {
+  if (typeof fn !== "function") return undefined;
+  return fn[SERVER_FUNCTION_METADATA] || undefined;
+}
+function isServerFunction(fn) {
+  return typeof fn === "function" && !!fn[SERVER_FUNCTION_METADATA];
+}
+function withMeta(fn, meta) {
+  const metadata = getServerFunctionMetadata(fn);
+  if (!metadata) {
+    throw new Error("withMeta expects a server function reference");
+  }
+  Object.assign(metadata, meta);
+  return fn;
+}
+const SERVER_FUNCTION_RPC = Symbol.for("solid.ServerFunctionRPC");
+function provideServerFunctionRPC(rpc) {
+  globalThis[SERVER_FUNCTION_RPC] || (globalThis[SERVER_FUNCTION_RPC] = rpc);
+}
+
+function parseCookieHeader(header) {
+  const cookies = {};
+  if (!header) return cookies;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq < 0) continue;
+    const name = decodeSafe(part.slice(0, eq).trim());
+    let value = part.slice(eq + 1).trim();
+    if (value.length > 1 && value[0] === '"' && value[value.length - 1] === '"') {
+      value = value.slice(1, -1);
+    }
+    cookies[name] = decodeSafe(value);
+  }
+  return cookies;
+}
+function decodeSafe(text) {
+  try {
+    return decodeURIComponent(text);
+  } catch {
+    return text;
+  }
+}
+function serializeCookie(name, value, options = {}) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  cookie += `; Path=${options.path === undefined ? "/" : options.path}`;
+  if (options.domain) cookie += `; Domain=${options.domain}`;
+  if (options.maxAge !== undefined) cookie += `; Max-Age=${Math.trunc(options.maxAge)}`;
+  if (options.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
+  if (options.httpOnly) cookie += "; HttpOnly";
+  if (options.secure) cookie += "; Secure";
+  if (options.sameSite) {
+    const sameSite = options.sameSite.toLowerCase();
+    cookie += `; SameSite=${sameSite === "none" ? "None" : sameSite === "strict" ? "Strict" : "Lax"}`;
+  }
+  return cookie;
+}
+const FLASH_COOKIE = "flash";
+const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
+function hasFlashCookie(cookieHeader) {
+  return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
+}
+function clearFlashCookie() {
+  return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
+}
+
+const codecConfig = {
+  codec: undefined
+};
+function configureServerFunctionsCodec(codec) {
+  codecConfig.codec = codec;
+}
+function getServerFunctionsCodec() {
+  return codecConfig.codec;
+}
+function subscribeFlightData(consumer) {
+  return () => {
+  };
+}
+const FUNCTION_HEADER = "X-Server-Function-Id";
+const ERROR_HEADER = "X-Server-Function-Error";
+const ERROR_HEADER_MARKER = "=?1?";
+const NEEDS_ENCODING = /[^\x20-\x7e\xa0-\xff]/;
+function encodeErrorHeaderValue(value) {
+  let stripped = String(value).replace(/[\r\n]+/g, "");
+  if (!NEEDS_ENCODING.test(stripped) && !stripped.startsWith(ERROR_HEADER_MARKER) && stripped === stripped.trim()) {
+    return stripped;
+  }
+  if (typeof stripped.toWellFormed === "function") {
+    stripped = stripped.toWellFormed();
+  } else {
+    stripped = stripped.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD");
+  }
+  return ERROR_HEADER_MARKER + encodeURIComponent(stripped);
+}
+function decodeErrorHeaderValue(value) {
+  if (typeof value !== "string" || !value.startsWith(ERROR_HEADER_MARKER)) {
+    return value;
+  }
+  try {
+    return decodeURIComponent(value.slice(ERROR_HEADER_MARKER.length));
+  } catch {
+    return value;
+  }
+}
+const INSTANCE_HEADER = "X-Server-Function-Instance";
+const BODY_FORMAT_HEADER = "X-Server-Function-Format";
+const SINGLE_FLIGHT_HEADER = "X-Single-Flight";
+const FILE_FORM_KEY = "__server_function_file__";
+const BodyFormat = {
+  Serialized: "0",
+  String: "1",
+  FormData: "2",
+  URLSearchParams: "3",
+  Blob: "4",
+  File: "5",
+  ArrayBuffer: "6",
+  Uint8Array: "7",
+  Json: "8"
+};
+const JSON_SAFE_DEPTH_LIMIT = 10000;
+const EXIT = {};
+function isJSONSafe(value) {
+  const stack = [value];
+  const ancestors = new Set();
+  while (stack.length) {
+    const v = stack.pop();
+    if (v === EXIT) {
+      ancestors.delete(stack.pop());
+      continue;
+    }
+    if (v === null) continue;
+    const t = typeof v;
+    if (t === "string" || t === "boolean") continue;
+    if (t === "number") {
+      if (!Number.isFinite(v)) return false;
+      continue;
+    }
+    if (t !== "object") return false;
+    if (ancestors.has(v) || ancestors.size >= JSON_SAFE_DEPTH_LIMIT) return false;
+    ancestors.add(v);
+    stack.push(v, EXIT);
+    if (Array.isArray(v)) {
+      for (let i = 0; i < v.length; i++) stack.push(v[i]);
+    } else {
+      const proto = Object.getPrototypeOf(v);
+      if (proto !== Object.prototype && proto !== null) return false;
+      for (const k in v) stack.push(v[k]);
+    }
+  }
+  return true;
+}
+function getHeadersAndBody(body) {
+  switch (true) {
+    case typeof body === "string":
+      return {
+        headers: {
+          "Content-Type": "text/plain",
+          [BODY_FORMAT_HEADER]: BodyFormat.String
+        },
+        body
+      };
+    case body instanceof FormData:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.FormData
+        },
+        body
+      };
+    case body instanceof URLSearchParams:
+      return {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          [BODY_FORMAT_HEADER]: BodyFormat.URLSearchParams
+        },
+        body
+      };
+    case typeof File !== "undefined" && body instanceof File:
+      {
+        const formData = new FormData();
+        formData.append(FILE_FORM_KEY, body, body.name);
+        return {
+          headers: {
+            [BODY_FORMAT_HEADER]: BodyFormat.File
+          },
+          body: formData
+        };
+      }
+    case body instanceof Blob:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.Blob
+        },
+        body
+      };
+    case body instanceof ArrayBuffer:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.ArrayBuffer
+        },
+        body
+      };
+    case body instanceof Uint8Array:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.Uint8Array
+        },
+        body: new Uint8Array(body)
+      };
+    default:
+      return undefined;
+  }
+}
+async function extractBody(source, codecOptions) {
+  const contentType = source.headers.get("content-type");
+  const format = source.headers.get(BODY_FORMAT_HEADER);
+  const clone = source.clone();
+  switch (true) {
+    case format === BodyFormat.Serialized:
+      return await deserializeStream(clone, codecOptions);
+    case format === BodyFormat.Json:
+      return JSON.parse(await clone.text());
+    case format === BodyFormat.String:
+      return await clone.text();
+    case format === BodyFormat.File:
+      {
+        const formData = await clone.formData();
+        return formData.get(FILE_FORM_KEY);
+      }
+    case format === BodyFormat.FormData:
+    case contentType && contentType.startsWith("multipart/form-data"):
+      return await clone.formData();
+    case format === BodyFormat.URLSearchParams:
+    case contentType && contentType.startsWith("application/x-www-form-urlencoded"):
+      return new URLSearchParams(await clone.text());
+    case format === BodyFormat.Blob:
+      return await clone.blob();
+    case format === BodyFormat.ArrayBuffer:
+      return await clone.arrayBuffer();
+    case format === BodyFormat.Uint8Array:
+      return new Uint8Array(await clone.arrayBuffer());
+  }
+  return undefined;
+}
+function createChunk(data) {
+  const encoder = new TextEncoder();
+  const encodeData = encoder.encode(data);
+  const bytes = encodeData.length;
+  const chunk = new Uint8Array(12 + bytes);
+  chunk.set(encoder.encode(`;0x${bytes.toString(16).padStart(8, "0")};`));
+  chunk.set(encodeData, 12);
+  return chunk;
+}
+class ChunkReader {
+  constructor(stream) {
+    this.reader = stream.getReader();
+    this.buffer = new Uint8Array(0);
+    this.done = false;
+  }
+  async readChunk() {
+    const chunk = await this.reader.read();
+    if (!chunk.done) {
+      const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
+      newBuffer.set(this.buffer);
+      newBuffer.set(chunk.value, this.buffer.length);
+      this.buffer = newBuffer;
+    } else {
+      this.done = true;
+    }
+  }
+  async next() {
+    while (this.buffer.length < 12) {
+      if (this.done) {
+        if (this.buffer.length === 0) return {
+          done: true,
+          value: undefined
+        };
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const decoder = new TextDecoder();
+    const bytes = Number.parseInt(decoder.decode(this.buffer.subarray(1, 11)), 16);
+    if (Number.isNaN(bytes)) {
+      throw new Error("Malformed server function stream.");
+    }
+    while (bytes > this.buffer.length - 12) {
+      if (this.done) {
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const partial = decoder.decode(this.buffer.subarray(12, 12 + bytes));
+    this.buffer = this.buffer.subarray(12 + bytes);
+    return {
+      done: false,
+      value: partial
+    };
+  }
+  async drain(interpret) {
+    while (true) {
+      const result = await this.next();
+      if (result.done) {
+        break;
+      }
+      interpret(result.value);
+    }
+  }
+}
+function serializeStream(value, codecOptions) {
+  return new ReadableStream({
+    async start(controller) {
+      const {
+        serializeJSON
+      } = await import('@solidjs/web/serialization');
+      serializeJSON(value, {
+        ...codecOptions,
+        onParse(node) {
+          controller.enqueue(createChunk(JSON.stringify(node)));
+        },
+        onDone() {
+          controller.close();
+        },
+        onError(error) {
+          controller.error(error);
+        }
+      });
+    }
+  });
+}
+async function deserializeStream(source, codecOptions) {
+  if (!source.body) {
+    throw new Error("missing body");
+  }
+  const reader = new ChunkReader(source.body);
+  const result = await reader.next();
+  if (!result.done) {
+    const {
+      createJSONDeserializer
+    } = await import('@solidjs/web/serialization/decode');
+    const deserializeChunk = createJSONDeserializer(codecOptions);
+    function interpretChunk(chunk) {
+      return deserializeChunk(JSON.parse(chunk));
+    }
+    void reader.drain(interpretChunk);
+    return interpretChunk(result.value);
+  }
+  return undefined;
+}
+async function deserializeString(text, codecOptions) {
+  return await deserializeStream(new Response(text), codecOptions);
+}
+async function decodeResponse(response, codecOptions) {
+  if (!response.body) return undefined;
+  return await extractBody(response, codecOptions === undefined ? codecConfig.codec : codecOptions);
+}
+async function decodeResponsePayload(response, codecOptions) {
+  const decoded = await decodeResponse(response, codecOptions);
+  if (decoded !== undefined && response.headers.has(SINGLE_FLIGHT_HEADER)) {
+    return {
+      value: decoded.value,
+      flightData: decoded.data
+    };
+  }
+  return {
+    value: decoded
+  };
+}
+
+const RequestContext = Symbol.for("solid.RequestContext");
+function getRequestEvent() {
+  return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || sharedConfig.context && sharedConfig.context.event || console.warn("RequestEvent is missing. This is most likely due to accessing `getRequestEvent` non-managed async scope in a partially polyfilled environment. Try moving it above all `await` calls.") : undefined;
+}
+function reportLostHeaderWrite(method, name) {
+  const message = `Response header write dropped: headers.${method}(${JSON.stringify(String(name))}) ` + "ran after the response head was sent. Write headers before the shell flushes " + "(or before the handler returns).";
+  throw new Error(message);
+}
+function commitResponseStub(stub, {
+  allowLateLocation = false
+} = {}) {
+  if (!stub || stub.committed) return stub;
+  stub.committed = true;
+  const headers = stub.headers;
+  if (!headers || typeof headers.set !== "function") return stub;
+  for (const method of ["set", "append", "delete"]) {
+    const original = headers[method].bind(headers);
+    headers[method] = function (name, ...rest) {
+      if (allowLateLocation && method === "set" && String(name).toLowerCase() === "location") {
+        return original(name, ...rest);
+      }
+      reportLostHeaderWrite(method, name);
+    };
+  }
+  return stub;
+}
+function copyInitHeaders(init) {
+  if (!init || !init.getSetCookie) return new Headers(init);
+  const headers = new Headers();
+  init.forEach((value, key) => {
+    if (key !== "set-cookie") headers.append(key, value);
+  });
+  for (const cookie of init.getSetCookie()) headers.append("Set-Cookie", cookie);
+  return headers;
+}
+const STUB_GAP_FILL_EXCLUDED = /*#__PURE__*/new Set([ERROR_HEADER, BODY_FORMAT_HEADER, SINGLE_FLIGHT_HEADER, REVALIDATE_HEADER, "Location"].map(header => header.toLowerCase()));
+function fillsStubGap(key, headers, response) {
+  if (key === "set-cookie" || STUB_GAP_FILL_EXCLUDED.has(key)) return false;
+  if (response.body === null && (key === "content-type" || key === "content-length")) return false;
+  return !headers.has(key);
+}
+function commitEventResponse(response, event = getRequestEvent()) {
+  const stub = event && event.response;
+  if (!stub || !stub.headers || stub.committed) return response;
+  const cookies = stub.headers.getSetCookie ? stub.headers.getSetCookie() : [];
+  commitResponseStub(stub);
+  let hasGaps = false;
+  stub.headers.forEach((value, key) => {
+    if (fillsStubGap(key, response.headers, response)) hasGaps = true;
+  });
+  if (!cookies.length && !hasGaps) return response;
+  try {
+    for (const cookie of cookies) response.headers.append("Set-Cookie", cookie);
+    stub.headers.forEach((value, key) => {
+      if (fillsStubGap(key, response.headers, response)) response.headers.set(key, value);
+    });
+    return response;
+  } catch {
+    const headers = copyInitHeaders(response.headers);
+    for (const cookie of cookies) headers.append("Set-Cookie", cookie);
+    stub.headers.forEach((value, key) => {
+      if (fillsStubGap(key, headers, response)) headers.set(key, value);
+    });
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+}
+
+function encodeInputValue(value) {
+  if (value instanceof FormData) return {
+    $f: [...value.entries()].filter(([, v]) => typeof v === "string")
+  };
+  if (value instanceof URLSearchParams) return {
+    $u: [...value.entries()]
+  };
+  return value;
+}
+function decodeInputValue(value) {
+  if (value && typeof value === "object") {
+    if (Array.isArray(value.$f)) {
+      const form = new FormData();
+      for (const [k, v] of value.$f) form.append(k, v);
+      return form;
+    }
+    if (Array.isArray(value.$u)) return new URLSearchParams(value.$u);
+  }
+  return value;
+}
+function encodeFlashCookie(url, result, input, thrown) {
+  const isError = result instanceof Error;
+  const payload = {
+    url,
+    result: isError ? result.message : result,
+    error: isError,
+    thrown: !!thrown,
+    input: input.map(encodeInputValue)
+  };
+  return serializeCookie(FLASH_COOKIE, JSON.stringify(payload), {
+    secure: true,
+    httpOnly: true
+  });
+}
+function decodeFlashCookie(cookieHeader) {
+  const match = parseCookieHeader(cookieHeader)[FLASH_COOKIE];
+  if (!match) return;
+  try {
+    const payload = JSON.parse(match);
+    if (!payload || !payload.result) return;
+    const result = payload.error ? new Error(payload.result) : payload.result;
+    return {
+      input: Array.isArray(payload.input) ? payload.input.map(decodeInputValue) : [],
+      url: payload.url,
+      result: payload.thrown ? undefined : result,
+      error: payload.thrown ? result : undefined
+    };
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+const config = {
+  provideEvent: undefined,
+  wrapInvocation: undefined,
+  collectFlightData: undefined,
+  transformResult: undefined,
+  transformFlightResult: undefined,
+  transformDirectResult: undefined,
+  handleNoJS: undefined,
+  endpoint: "/_server"
+};
+function configureServerFunctionsServer({
+  provideEvent,
+  wrapInvocation,
+  collectFlightData,
+  transformResult,
+  transformFlightResult,
+  transformDirectResult,
+  handleNoJS,
+  endpoint,
+  codec
+} = {}) {
+  if (provideEvent !== undefined) config.provideEvent = provideEvent;
+  if (wrapInvocation !== undefined) config.wrapInvocation = wrapInvocation;
+  if (collectFlightData !== undefined) config.collectFlightData = collectFlightData;
+  if (transformResult !== undefined) config.transformResult = transformResult;
+  if (transformFlightResult !== undefined) config.transformFlightResult = transformFlightResult;
+  if (transformDirectResult !== undefined) config.transformDirectResult = transformDirectResult;
+  if (handleNoJS !== undefined) config.handleNoJS = handleNoJS;
+  if (endpoint !== undefined) config.endpoint = endpoint;
+  if (codec !== undefined) configureServerFunctionsCodec(codec);
+}
+function provideEvent(event, fn) {
+  if (config.provideEvent) return config.provideEvent(event, fn);
+  const ctx = globalThis[RequestContext];
+  if (ctx) return ctx.run(event, fn);
+  throw new Error("No request event provider. Configure one with configureServerFunctionsServer({ provideEvent }).");
+}
+const REGISTRATIONS = new Map();
+const METHODS = new Map();
+const INVOCATIONS = new WeakMap();
+let rpcProvided = false;
+function provideRPC() {
+  if (rpcProvided) return;
+  rpcProvided = true;
+  provideServerFunctionRPC({
+    GET,
+    decodeResponse
+  });
+}
+function registerServerFunction(id, callback) {
+  provideRPC();
+  REGISTRATIONS.set(id, callback);
+  return callback;
+}
+function getServerFunction(id) {
+  const fn = REGISTRATIONS.get(id);
+  if (fn) {
+    return fn;
+  }
+  throw new Error("invalid server function: " + id);
+}
+function registerServerReference(id, fn, name) {
+  registerServerFunction(id, fn);
+  return {
+    id,
+    fn,
+    name
+  };
+}
+function createServerReference({
+  id,
+  fn,
+  name
+}) {
+  if (typeof fn !== "function") throw new Error("Export from a 'use server' module must be a function");
+  provideRPC();
+  const metadata = name === undefined ? {} : {
+    name
+  };
+  return new Proxy(fn, {
+    get(target, prop) {
+      if (prop === "id") return id;
+      if (prop === "url") {
+        return `${config.endpoint}?id=${encodeURIComponent(id)}`;
+      }
+      if (prop === SERVER_FUNCTION_METADATA) return metadata;
+      return target[prop];
+    },
+    apply(target, thisArg, args) {
+      const ogEvt = getRequestEvent();
+      if (!ogEvt) throw new Error("Cannot call server function outside of a request");
+      const evt = {
+        ...ogEvt
+      };
+      INVOCATIONS.set(evt, {
+        id
+      });
+      evt.serverOnly = true;
+      const result = provideEvent(evt, () => {
+        const run = () => fn.apply(thisArg, args);
+        return config.wrapInvocation ? config.wrapInvocation(run, {
+          id,
+          args,
+          event: evt,
+          direct: true
+        }) : run();
+      });
+      const transform = config.transformDirectResult;
+      if (transform && result && typeof result.then === "function") {
+        return result.then(value => transform(value, {
+          id,
+          args,
+          event: evt
+        }));
+      }
+      return transform ? transform(result, {
+        id,
+        args,
+        event: evt
+      }) : result;
+    }
+  });
+}
+function GET(fn) {
+  if (!isServerFunction(fn) || typeof fn.id !== "string") {
+    throw new Error("GET expects a server function reference");
+  }
+  METHODS.set(fn.id, "GET");
+  return withMeta(fn, {
+    method: "GET"
+  });
+}
+function getServerFunctionInvocation() {
+  return getEventServerFunctionInvocation(getRequestEvent());
+}
+function getEventServerFunctionInvocation(event) {
+  return event && INVOCATIONS.get(event);
+}
+function resolveFunctionId(request, url) {
+  const reference = request.headers.get(FUNCTION_HEADER);
+  if (reference) {
+    return reference.split("#")[0];
+  }
+  return url.searchParams.get("id");
+}
+async function parseArguments(request, url, instance, codec) {
+  const parsed = [];
+  const bodyFormat = request.method === "POST" ? request.headers.get(BODY_FORMAT_HEADER) : null;
+  if (!instance || request.method === "GET" || bodyFormat !== BodyFormat.Serialized) {
+    const args = url.searchParams.get("args");
+    if (args) {
+      const result = args.startsWith(";0x") ? await deserializeString(args, codec) : JSON.parse(args);
+      for (const arg of result) {
+        parsed.push(arg);
+      }
+    }
+  }
+  if (request.method === "POST" && request.body !== null) {
+    const decoded = await extractBody(request.clone(), codec);
+    if (bodyFormat === BodyFormat.Serialized || bodyFormat === BodyFormat.Json) {
+      return decoded;
+    }
+    parsed.push(decoded);
+  }
+  return parsed;
+}
+async function foldFlightData(hook, event, headers, outcome, context = {}) {
+  if (outcome.value instanceof Response && outcome.value.body) return outcome.value;
+  digestOutcome(event, outcome);
+  const data = await hook(event, outcome);
+  if (data === undefined) return outcome.value;
+  headers.set(SINGLE_FLIGHT_HEADER, "true");
+  if (context.transformFlightResult) {
+    const transformed = await context.transformFlightResult(event, {
+      value: outcome.value,
+      data
+    }, context);
+    if (transformed !== undefined) {
+      for (const cookie of headers.getSetCookie()) transformed.headers.append("Set-Cookie", cookie);
+      headers.forEach((value, key) => {
+        if (key !== "set-cookie" && !transformed.headers.has(key)) {
+          transformed.headers.set(key, value);
+        }
+      });
+      return transformed;
+    }
+  }
+  return outcome.value === undefined ? {
+    data
+  } : {
+    value: outcome.value,
+    data
+  };
+}
+function digestOutcome(event, outcome) {
+  const {
+    request,
+    response
+  } = outcome;
+  outcome.revalidateKeys = response?.headers.get(REVALIDATE_HEADER)?.split(",");
+  outcome.foldedHeaders = foldSetCookies(request.headers, [...(event.response?.headers?.getSetCookie() ?? []), ...(response?.headers?.getSetCookie() ?? [])]);
+  try {
+    const referrer = request.headers.get("referer");
+    if (referrer) {
+      const location = response?.headers.get("Location");
+      const target = location ? new URL(location, request.url) : new URL(referrer);
+      if (target.origin === new URL(request.url).origin) outcome.targetUrl = target.toString();
+    }
+  } catch {
+  }
+}
+function parseSetCookie(setCookie) {
+  const [pair, ...attributes] = setCookie.split(";");
+  const eq = pair.indexOf("=");
+  if (eq < 0) return undefined;
+  const parsed = {
+    name: pair.slice(0, eq).trim(),
+    value: pair.slice(eq + 1).trim()
+  };
+  for (const attribute of attributes) {
+    const attrEq = attribute.indexOf("=");
+    const key = (attrEq < 0 ? attribute : attribute.slice(0, attrEq)).trim().toLowerCase();
+    const value = attrEq < 0 ? "" : attribute.slice(attrEq + 1).trim();
+    if (key === "max-age") parsed.maxAge = Number(value);else if (key === "expires") parsed.expires = new Date(value);
+  }
+  return parsed;
+}
+function foldSetCookies(headers, setCookies) {
+  const folded = new Headers(headers);
+  if (!setCookies.length) return folded;
+  const cookies = {};
+  for (const pair of folded.get("cookie")?.split(";") ?? []) {
+    const eq = pair.indexOf("=");
+    if (eq > -1) cookies[pair.slice(0, eq).trim()] = pair.slice(eq + 1).trim();
+  }
+  for (const setCookie of setCookies) {
+    const parsed = parseSetCookie(setCookie);
+    if (!parsed) continue;
+    if (parsed.maxAge != null && parsed.maxAge <= 0 || parsed.expires != null && parsed.expires.getTime() <= Date.now()) {
+      delete cookies[parsed.name];
+    } else {
+      cookies[parsed.name] = parsed.value;
+    }
+  }
+  folded.delete("cookie");
+  const serialized = Object.entries(cookies).map(([name, value]) => `${name}=${value}`).join("; ");
+  if (serialized) folded.set("cookie", serialized);
+  return folded;
+}
+function mergeResponseHeaders(target, source) {
+  source.forEach((value, key) => {
+    if (key !== "set-cookie") target.append(key, value);
+  });
+  if (source.getSetCookie) {
+    for (const cookie of source.getSetCookie()) target.append("Set-Cookie", cookie);
+  } else if (source.has("set-cookie")) {
+    target.append("Set-Cookie", source.get("set-cookie"));
+  }
+}
+const validRedirectStatuses = new Set([301, 302, 303, 307, 308]);
+function createNoJSHandler({
+  base = ""
+} = {}) {
+  return function handleNoJS(result, request, args, thrown) {
+    const url = new URL(request.url);
+    let back = new URL(base || "/", url.origin).toString();
+    try {
+      const referer = request.headers.get("referer");
+      if (referer) back = new URL(referer).toString();
+    } catch {}
+    let status = 303;
+    let headers;
+    if (result instanceof Response) {
+      headers = new Headers();
+      mergeResponseHeaders(headers, result.headers);
+      if (result.headers.has("Location")) {
+        headers.set("Location", new URL(result.headers.get("Location"), url.origin + base).toString());
+        if (validRedirectStatuses.has(result.status)) status = result.status;
+      } else {
+        headers.set("Location", back);
+      }
+      headers.delete("Content-Type");
+      headers.delete("Content-Length");
+    } else {
+      headers = new Headers({
+        Location: back
+      });
+    }
+    if (result && !(result instanceof Response)) {
+      headers.append("Set-Cookie", encodeFlashCookie(url.pathname + url.search, result, args, thrown));
+    }
+    return new Response(null, {
+      status,
+      headers
+    });
+  };
+}
+let defaultNoJSHandler;
+function isFormPost(request) {
+  if (request.method !== "POST" || request.headers.has(BODY_FORMAT_HEADER)) return false;
+  const type = request.headers.get("content-type") || "";
+  return type.startsWith("application/x-www-form-urlencoded") || type.startsWith("multipart/form-data");
+}
+function serializedResponse(value, headers, codec) {
+  headers.set(BODY_FORMAT_HEADER, BodyFormat.Serialized);
+  headers.set("Content-Type", "text/plain");
+  return new Response(serializeStream(value, codec), {
+    headers
+  });
+}
+function encodeResult(value, headers, status, codec) {
+  const direct = getHeadersAndBody(value);
+  if (direct) {
+    for (const [key, val] of Object.entries(direct.headers || {})) {
+      headers.set(key, val);
+    }
+    return new Response(direct.body, {
+      status,
+      headers
+    });
+  }
+  if (value === undefined) {
+    return new Response(null, {
+      status,
+      headers
+    });
+  }
+  try {
+    if (isJSONSafe(value)) {
+      headers.set(BODY_FORMAT_HEADER, BodyFormat.Json);
+      headers.set("Content-Type", "application/json");
+      return new Response(JSON.stringify(value), {
+        status,
+        headers
+      });
+    }
+  } catch {
+  }
+  const response = serializedResponse(value, headers, codec);
+  return status === 200 ? response : new Response(response.body, {
+    status,
+    headers
+  });
+}
+const GENERIC_SERVER_ERROR_MESSAGE = "Internal Server Error";
+let DEV = true === true;
+function setServerFunctionsDev(dev) {
+  DEV = !!dev;
+}
+function sanitizeServerError(value) {
+  if (DEV) return value;
+  if (isSafeError(value)) return value;
+  return new Error(GENERIC_SERVER_ERROR_MESSAGE);
+}
+async function handleServerFunctionRequest(request, options = {}) {
+  const codec = options.codec !== undefined ? options.codec : getServerFunctionsCodec();
+  const url = new URL(request.url);
+  const instance = request.headers.get(INSTANCE_HEADER);
+  const functionId = resolveFunctionId(request, url);
+  if (!functionId) {
+    return new Response(DEV ? "Server function not found" : null, {
+      status: 404
+    });
+  }
+  let serverFunction;
+  try {
+    serverFunction = getServerFunction(functionId);
+  } catch {
+    return new Response(DEV ? `Unknown server function: ${functionId}` : null, {
+      status: 404
+    });
+  }
+  if (request.method === "GET" && METHODS.get(functionId) !== "GET") {
+    return new Response(DEV ? `Method not allowed for server function: ${functionId}` : null, {
+      status: 405,
+      headers: {
+        Allow: "POST"
+      }
+    });
+  }
+  const event = options.createEvent ? options.createEvent(request) : {
+    request,
+    locals: {}
+  };
+  const provide = options.provideEvent || provideEvent;
+  const flightHook = options.collectFlightData !== undefined ? options.collectFlightData : config.collectFlightData;
+  const transformResult = options.transformResult !== undefined ? options.transformResult : config.transformResult;
+  const wrapInvocation = options.wrapInvocation !== undefined ? options.wrapInvocation : config.wrapInvocation;
+  const transformFlightResult = options.transformFlightResult !== undefined ? options.transformFlightResult : config.transformFlightResult;
+  const handleNoJS = options.handleNoJS !== undefined ? options.handleNoJS : config.handleNoJS !== undefined ? config.handleNoJS : isFormPost(request) ? defaultNoJSHandler || (defaultNoJSHandler = createNoJSHandler()) : undefined;
+  const collectsFlight = !!(flightHook && instance && request.headers.has(SINGLE_FLIGHT_HEADER));
+  const parsed = await parseArguments(request, url, instance, codec);
+  const flightContext = {
+    id: functionId,
+    args: parsed,
+    instance,
+    request,
+    collectsFlight,
+    codec,
+    transformFlightResult
+  };
+  const headers = new Headers();
+  const dispatch = async () => {
+    try {
+      let result = await provide(event, async () => {
+        INVOCATIONS.set(event, {
+          id: functionId
+        });
+        const run = () => serverFunction(...parsed);
+        return wrapInvocation ? wrapInvocation(run, {
+          id: functionId,
+          args: parsed,
+          event,
+          request,
+          direct: false
+        }) : run();
+      });
+      if (transformResult) {
+        result = await transformResult(event, result, flightContext);
+      }
+      let status = 200;
+      let metadata;
+      if (isResponseEnvelope(result)) {
+        const {
+          response,
+          value
+        } = result;
+        if (!instance && !handleNoJS && response && response.body) {
+          return response;
+        }
+        if (response && response.headers) {
+          mergeResponseHeaders(headers, response.headers);
+        }
+        if (response && response.status && (response.status < 300 || response.status >= 400)) {
+          status = response.status;
+        }
+        metadata = response;
+        result = value;
+      } else if (result instanceof Response) {
+        if (result.headers && result.headers.has("X-Content-Raw")) return result;
+        if (instance) {
+          if (result.headers) {
+            mergeResponseHeaders(headers, result.headers);
+          }
+          if (result.status && (result.status < 300 || result.status >= 400)) {
+            status = result.status;
+          }
+          metadata = result;
+          if (result.body == null) {
+            result = null;
+          }
+        }
+      }
+      if (collectsFlight) {
+        result = await foldFlightData(flightHook, event, headers, {
+          id: functionId,
+          value: result,
+          response: metadata,
+          request,
+          thrown: false
+        }, flightContext);
+        if (result instanceof Response && result.headers.has("X-Content-Raw")) return result;
+      }
+      if (!instance) {
+        if (handleNoJS) return handleNoJS(result, request, parsed);
+        if (result instanceof Response) return result;
+        return encodeResult(result, headers, 200, codec);
+      }
+      return encodeResult(result, headers, status, codec);
+    } catch (x) {
+      if (x instanceof Response || isResponseEnvelope(x)) {
+        if (transformResult) {
+          x = await transformResult(event, x, {
+            ...flightContext,
+            thrown: true
+          });
+        }
+        let status = 200;
+        let metadata;
+        if (isResponseEnvelope(x)) {
+          const {
+            response,
+            value
+          } = x;
+          if (response && response.headers) {
+            mergeResponseHeaders(headers, response.headers);
+          }
+          if (response && response.status && (!instance || response.status < 300 || response.status >= 400)) {
+            status = response.status;
+          }
+          metadata = response;
+          x = value;
+        } else if (x instanceof Response) {
+          if (x.headers) {
+            mergeResponseHeaders(headers, x.headers);
+          }
+          if (x.status && (!instance || x.status < 300 || x.status >= 400)) {
+            status = x.status;
+          }
+          metadata = x;
+          if (x.body == null) {
+            x = null;
+          }
+        }
+        if (collectsFlight) {
+          x = await foldFlightData(flightHook, event, headers, {
+            id: functionId,
+            value: x,
+            response: metadata,
+            request,
+            thrown: true
+          }, flightContext);
+          if (x instanceof Response && x.headers.has("X-Content-Raw")) {
+            x.headers.set(ERROR_HEADER, "true");
+            return x;
+          }
+        }
+        headers.set(ERROR_HEADER, "true");
+        if (!instance) {
+          if (handleNoJS) return handleNoJS(x ?? metadata, request, parsed, true);
+          if (x instanceof Response) return x;
+        }
+        return encodeResult(x, headers, status, codec);
+      }
+      const safe = sanitizeServerError(x);
+      if (!instance) {
+        if (handleNoJS) return handleNoJS(safe, request, parsed, true);
+        const message = safe instanceof Error ? safe.message : String(safe);
+        return new Response(DEV ? message : null, {
+          status: 500
+        });
+      }
+      const error = safe instanceof Error ? safe.message : typeof safe === "string" ? safe : "true";
+      headers.set(ERROR_HEADER, encodeErrorHeaderValue(error));
+      return encodeResult(safe, headers, 200, codec);
+    }
+  };
+  return commitEventResponse(await dispatch(), event);
+}
+
+export { ERROR_HEADER, FLASH_COOKIE, FUNCTION_HEADER, GENERIC_SERVER_ERROR_MESSAGE, GET, INSTANCE_HEADER, SINGLE_FLIGHT_HEADER, clearFlashCookie, configureServerFunctionsServer, createNoJSHandler, createServerReference, decodeErrorHeaderValue, decodeFlashCookie, decodeResponse, decodeResponsePayload, encodeErrorHeaderValue, encodeFlashCookie, foldSetCookies, getEventServerFunctionInvocation, getServerFunction, getServerFunctionInvocation, getServerFunctionMetadata, handleServerFunctionRequest, hasFlashCookie, isServerFunction, registerServerFunction, registerServerReference, sanitizeServerError, setServerFunctionsDev, subscribeFlightData, withMeta };