hadars 0.1.35 → 0.1.37

package/dist/lambda.cjs

@@ -0,0 +1,1405 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lambda.ts
+var lambda_exports = {};
+__export(lambda_exports, {
+  createLambdaHandler: () => createLambdaHandler
+});
+module.exports = __toCommonJS(lambda_exports);
+var import_react = require("react");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+
+// src/utils/proxyHandler.tsx
+var cloneHeaders = (headers) => {
+  return new Headers(headers);
+};
+var getCORSHeaders = (req) => {
+  const origin = req.headers.get("Origin") || "*";
+  return {
+    "Access-Control-Allow-Origin": origin,
+    "Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
+    "Access-Control-Allow-Headers": req.headers.get("Access-Control-Request-Headers") || "*",
+    "Access-Control-Allow-Credentials": "true"
+  };
+};
+var createProxyHandler = (options) => {
+  const { proxy, proxyCORS } = options;
+  if (!proxy) {
+    return () => void 0;
+  }
+  if (typeof proxy === "function") {
+    return async (req) => {
+      if (req.method === "OPTIONS" && options.proxyCORS) {
+        return new Response(null, {
+          status: 204,
+          headers: getCORSHeaders(req)
+        });
+      }
+      const res = await proxy(req);
+      if (res && proxyCORS) {
+        const modifiedHeaders = new Headers(res.headers);
+        Object.entries(getCORSHeaders(req)).forEach(([key, value]) => {
+          modifiedHeaders.set(key, value);
+        });
+        return new Response(res.body, {
+          status: res.status,
+          statusText: res.statusText,
+          headers: modifiedHeaders
+        });
+      }
+      return res || void 0;
+    };
+  }
+  const proxyRules = Object.entries(proxy).sort((a, b) => b[0].length - a[0].length);
+  return async (req) => {
+    for (const [path, target] of proxyRules) {
+      if (req.pathname.startsWith(path)) {
+        if (req.method === "OPTIONS" && proxyCORS) {
+          return new Response(null, {
+            status: 204,
+            headers: getCORSHeaders(req)
+          });
+        }
+        const targetURL = new URL(target);
+        targetURL.pathname = targetURL.pathname.replace(/\/$/, "") + req.pathname.slice(path.length);
+        targetURL.search = req.search;
+        const sendHeaders = cloneHeaders(req.headers);
+        sendHeaders.set("Host", targetURL.host);
+        const hasBody = !["GET", "HEAD"].includes(req.method);
+        const proxyReq = new Request(targetURL.toString(), {
+          method: req.method,
+          headers: sendHeaders,
+          body: hasBody ? req.body : void 0,
+          redirect: "follow",
+          // Node.js (undici) requires duplex:'half' when body is a ReadableStream
+          ...hasBody ? { duplex: "half" } : {}
+        });
+        const res = await fetch(proxyReq);
+        const body = await res.arrayBuffer();
+        const clonedRes = new Headers(res.headers);
+        clonedRes.delete("content-length");
+        clonedRes.delete("content-encoding");
+        if (proxyCORS) {
+          Object.entries(getCORSHeaders(req)).forEach(([key, value]) => {
+            clonedRes.set(key, value);
+          });
+        }
+        return new Response(body, {
+          status: res.status,
+          statusText: res.statusText,
+          headers: clonedRes
+        });
+      }
+    }
+    return void 0;
+  };
+};
+
+// src/utils/cookies.ts
+var parseCookies = (cookieString) => {
+  const cookies = {};
+  if (!cookieString) {
+    return cookies;
+  }
+  const pairs = cookieString.split(";");
+  for (const pair of pairs) {
+    const index = pair.indexOf("=");
+    if (index > -1) {
+      const key = pair.slice(0, index).trim();
+      const value = pair.slice(index + 1).trim();
+      cookies[key] = decodeURIComponent(value);
+    }
+  }
+  return cookies;
+};
+
+// src/utils/request.tsx
+var parseRequest = (request) => {
+  const url = new URL(request.url);
+  const cookies = request.headers.get("Cookie") || "";
+  const cookieRecord = parseCookies(cookies);
+  return Object.assign(request, { pathname: url.pathname, search: url.search, location: url.pathname + url.search, cookies: cookieRecord });
+};
+
+// src/utils/staticFile.ts
+var import_promises = require("fs/promises");
+var MIME = {
+  html: "text/html; charset=utf-8",
+  htm: "text/html; charset=utf-8",
+  css: "text/css",
+  js: "application/javascript",
+  mjs: "application/javascript",
+  cjs: "application/javascript",
+  json: "application/json",
+  map: "application/json",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  txt: "text/plain",
+  xml: "application/xml",
+  pdf: "application/pdf"
+};
+async function tryServeFile(filePath) {
+  try {
+    await (0, import_promises.stat)(filePath);
+  } catch {
+    return null;
+  }
+  try {
+    const data = await (0, import_promises.readFile)(filePath);
+    const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+    const contentType = MIME[ext] ?? "application/octet-stream";
+    return new Response(data.buffer, { headers: { "Content-Type": contentType } });
+  } catch {
+    return null;
+  }
+}
+
+// src/slim-react/types.ts
+var SLIM_ELEMENT = Symbol.for("react.element");
+var REACT19_ELEMENT = Symbol.for("react.transitional.element");
+var FRAGMENT_TYPE = Symbol.for("react.fragment");
+var SUSPENSE_TYPE = Symbol.for("react.suspense");
+
+// src/slim-react/jsx.ts
+function createElement(type, props, ...children) {
+  const normalizedProps = { ...props || {} };
+  if (children.length === 1) {
+    normalizedProps.children = children[0];
+  } else if (children.length > 1) {
+    normalizedProps.children = children;
+  }
+  const key = normalizedProps.key ?? null;
+  delete normalizedProps.key;
+  return {
+    $$typeof: SLIM_ELEMENT,
+    type,
+    props: normalizedProps,
+    key
+  };
+}
+
+// src/slim-react/renderContext.ts
+var MAP_KEY = "__slimReactContextMap";
+var _g = globalThis;
+if (!("__slimReactContextMap" in _g)) _g[MAP_KEY] = null;
+function swapContextMap(map) {
+  const prev = _g[MAP_KEY];
+  _g[MAP_KEY] = map;
+  return prev;
+}
+function captureMap() {
+  return _g[MAP_KEY];
+}
+function getContextValue(context) {
+  const map = _g[MAP_KEY];
+  if (map && map.has(context)) return map.get(context);
+  const c = context;
+  return "_defaultValue" in c ? c._defaultValue : c._currentValue;
+}
+function pushContextValue(context, value) {
+  const map = _g[MAP_KEY];
+  const c = context;
+  const prev = map && map.has(context) ? map.get(context) : "_defaultValue" in c ? c._defaultValue : c._currentValue;
+  map?.set(context, value);
+  return prev;
+}
+function popContextValue(context, prev) {
+  _g[MAP_KEY]?.set(context, prev);
+}
+var GLOBAL_KEY = "__slimReactRenderState";
+var EMPTY = { id: 1, overflow: "" };
+function s() {
+  const g = globalThis;
+  if (!g[GLOBAL_KEY]) {
+    g[GLOBAL_KEY] = { currentTreeContext: { ...EMPTY }, localIdCounter: 0, idPrefix: "" };
+  }
+  return g[GLOBAL_KEY];
+}
+function resetRenderState(idPrefix = "") {
+  const st = s();
+  st.currentTreeContext = { ...EMPTY };
+  st.localIdCounter = 0;
+  st.idPrefix = idPrefix;
+}
+function pushTreeContext(totalChildren, index) {
+  const st = s();
+  const saved = { ...st.currentTreeContext };
+  const baseIdWithLeadingBit = st.currentTreeContext.id;
+  const baseOverflow = st.currentTreeContext.overflow;
+  const baseLength = 31 - Math.clz32(baseIdWithLeadingBit);
+  let baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  const slot = index + 1;
+  const newBits = 32 - Math.clz32(totalChildren);
+  const length = newBits + baseLength;
+  if (30 < length) {
+    const numberOfOverflowBits = baseLength - baseLength % 5;
+    const overflowStr = (baseId & (1 << numberOfOverflowBits) - 1).toString(32);
+    baseId >>= numberOfOverflowBits;
+    const newBaseLength = baseLength - numberOfOverflowBits;
+    st.currentTreeContext = {
+      id: 1 << newBits + newBaseLength | slot << newBaseLength | baseId,
+      overflow: overflowStr + baseOverflow
+    };
+  } else {
+    st.currentTreeContext = {
+      id: 1 << length | slot << baseLength | baseId,
+      overflow: baseOverflow
+    };
+  }
+  return saved;
+}
+function popTreeContext(saved) {
+  s().currentTreeContext = saved;
+}
+function pushComponentScope() {
+  const st = s();
+  const saved = st.localIdCounter;
+  st.localIdCounter = 0;
+  return saved;
+}
+function popComponentScope(saved) {
+  s().localIdCounter = saved;
+}
+function componentCalledUseId() {
+  return s().localIdCounter > 0;
+}
+function snapshotContext() {
+  const st = s();
+  return { tree: { ...st.currentTreeContext }, localId: st.localIdCounter };
+}
+function restoreContext(snap) {
+  const st = s();
+  st.currentTreeContext = { ...snap.tree };
+  st.localIdCounter = snap.localId;
+}
+function getTreeId() {
+  const { id, overflow } = s().currentTreeContext;
+  if (id === 1) return overflow;
+  const stripped = (id & ~(1 << 31 - Math.clz32(id))).toString(32);
+  return stripped + overflow;
+}
+function makeId() {
+  const st = s();
+  const treeId = getTreeId();
+  const n = st.localIdCounter++;
+  let id = "_R_" + st.idPrefix + treeId;
+  if (n > 0) id += "H" + n.toString(32);
+  return id + "_";
+}
+
+// src/slim-react/hooks.ts
+function useState(initialState) {
+  const value = typeof initialState === "function" ? initialState() : initialState;
+  return [value, () => {
+  }];
+}
+function useReducer(_reducer, initialState) {
+  return [initialState, () => {
+  }];
+}
+function useEffect(_effect, _deps) {
+}
+function useLayoutEffect(_effect, _deps) {
+}
+function useInsertionEffect(_effect, _deps) {
+}
+function useRef(initialValue) {
+  return { current: initialValue };
+}
+function useMemo(factory, _deps) {
+  return factory();
+}
+function useCallback(callback, _deps) {
+  return callback;
+}
+function useDebugValue(_value, _format) {
+}
+function useImperativeHandle(_ref, _createHandle, _deps) {
+}
+function useSyncExternalStore(_subscribe, getSnapshot, getServerSnapshot) {
+  return (getServerSnapshot || getSnapshot)();
+}
+function useTransition() {
+  return [false, (cb) => cb()];
+}
+function useDeferredValue(value) {
+  return value;
+}
+function useOptimistic(passthrough) {
+  return [passthrough, () => {
+  }];
+}
+function useActionState(_action, initialState, _permalink) {
+  return [initialState, () => {
+  }, false];
+}
+function use(usable) {
+  if (typeof usable === "object" && usable !== null && ("_currentValue" in usable || "_defaultValue" in usable)) {
+    return getContextValue(usable);
+  }
+  const promise = usable;
+  if (promise.status === "fulfilled") return promise.value;
+  if (promise.status === "rejected") throw promise.reason;
+  throw promise;
+}
+
+// src/slim-react/dispatcher.ts
+var ReactNS = __toESM(require("react"), 1);
+var _internals = ReactNS.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+var slimDispatcher = {
+  useId: makeId,
+  readContext: (ctx) => getContextValue(ctx),
+  useContext: (ctx) => getContextValue(ctx),
+  useState,
+  useReducer,
+  useEffect,
+  useLayoutEffect,
+  useInsertionEffect,
+  useRef,
+  useMemo,
+  useCallback,
+  useDebugValue,
+  useImperativeHandle,
+  useSyncExternalStore,
+  useTransition,
+  useDeferredValue,
+  useOptimistic,
+  useActionState,
+  use,
+  // React internals that compiled output may call
+  useMemoCache: (size) => new Array(size).fill(void 0),
+  useCacheRefresh: () => () => {
+  },
+  useHostTransitionStatus: () => false
+};
+function installDispatcher() {
+  if (!_internals) return null;
+  const prev = _internals.H;
+  _internals.H = slimDispatcher;
+  return prev;
+}
+function restoreDispatcher(prev) {
+  if (_internals) _internals.H = prev;
+}
+
+// src/slim-react/render.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var HTML_ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", "'": "&#x27;" };
+function escapeHtml(str) {
+  return str.replace(/[&<>']/g, (c) => HTML_ESC[c]);
+}
+var ATTR_ESC = { "&": "&amp;", '"': "&quot;", "<": "&lt;", ">": "&gt;" };
+function escapeAttr(str) {
+  return str.replace(/[&"<>]/g, (c) => ATTR_ESC[c]);
+}
+function styleObjectToString(style) {
+  let result = "";
+  for (const key in style) {
+    if (result) result += ";";
+    const cssKey = key.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+    result += cssKey + ":" + style[key];
+  }
+  return result;
+}
+var SVG_ATTR_MAP = {
+  // Presentation / geometry
+  accentHeight: "accent-height",
+  alignmentBaseline: "alignment-baseline",
+  arabicForm: "arabic-form",
+  baselineShift: "baseline-shift",
+  capHeight: "cap-height",
+  clipPath: "clip-path",
+  clipRule: "clip-rule",
+  colorInterpolation: "color-interpolation",
+  colorInterpolationFilters: "color-interpolation-filters",
+  colorProfile: "color-profile",
+  dominantBaseline: "dominant-baseline",
+  enableBackground: "enable-background",
+  fillOpacity: "fill-opacity",
+  fillRule: "fill-rule",
+  floodColor: "flood-color",
+  floodOpacity: "flood-opacity",
+  fontFamily: "font-family",
+  fontSize: "font-size",
+  fontSizeAdjust: "font-size-adjust",
+  fontStretch: "font-stretch",
+  fontStyle: "font-style",
+  fontVariant: "font-variant",
+  fontWeight: "font-weight",
+  glyphName: "glyph-name",
+  glyphOrientationHorizontal: "glyph-orientation-horizontal",
+  glyphOrientationVertical: "glyph-orientation-vertical",
+  horizAdvX: "horiz-adv-x",
+  horizOriginX: "horiz-origin-x",
+  imageRendering: "image-rendering",
+  letterSpacing: "letter-spacing",
+  lightingColor: "lighting-color",
+  markerEnd: "marker-end",
+  markerMid: "marker-mid",
+  markerStart: "marker-start",
+  overlinePosition: "overline-position",
+  overlineThickness: "overline-thickness",
+  paintOrder: "paint-order",
+  panose1: "panose-1",
+  pointerEvents: "pointer-events",
+  renderingIntent: "rendering-intent",
+  shapeRendering: "shape-rendering",
+  stopColor: "stop-color",
+  stopOpacity: "stop-opacity",
+  strikethroughPosition: "strikethrough-position",
+  strikethroughThickness: "strikethrough-thickness",
+  strokeDasharray: "stroke-dasharray",
+  strokeDashoffset: "stroke-dashoffset",
+  strokeLinecap: "stroke-linecap",
+  strokeLinejoin: "stroke-linejoin",
+  strokeMiterlimit: "stroke-miterlimit",
+  strokeOpacity: "stroke-opacity",
+  strokeWidth: "stroke-width",
+  textAnchor: "text-anchor",
+  textDecoration: "text-decoration",
+  textRendering: "text-rendering",
+  underlinePosition: "underline-position",
+  underlineThickness: "underline-thickness",
+  unicodeBidi: "unicode-bidi",
+  unicodeRange: "unicode-range",
+  unitsPerEm: "units-per-em",
+  vAlphabetic: "v-alphabetic",
+  vHanging: "v-hanging",
+  vIdeographic: "v-ideographic",
+  vMathematical: "v-mathematical",
+  vertAdvY: "vert-adv-y",
+  vertOriginX: "vert-origin-x",
+  vertOriginY: "vert-origin-y",
+  wordSpacing: "word-spacing",
+  writingMode: "writing-mode",
+  xHeight: "x-height",
+  // Namespace-prefixed
+  xlinkActuate: "xlink:actuate",
+  xlinkArcrole: "xlink:arcrole",
+  xlinkHref: "xlink:href",
+  xlinkRole: "xlink:role",
+  xlinkShow: "xlink:show",
+  xlinkTitle: "xlink:title",
+  xlinkType: "xlink:type",
+  xmlBase: "xml:base",
+  xmlLang: "xml:lang",
+  xmlSpace: "xml:space",
+  xmlns: "xmlns",
+  xmlnsXlink: "xmlns:xlink",
+  // Filter / lighting
+  baseFrequency: "baseFrequency",
+  colorInterpolation_filters: "color-interpolation-filters",
+  diffuseConstant: "diffuseConstant",
+  edgeMode: "edgeMode",
+  filterUnits: "filterUnits",
+  gradientTransform: "gradientTransform",
+  gradientUnits: "gradientUnits",
+  kernelMatrix: "kernelMatrix",
+  kernelUnitLength: "kernelUnitLength",
+  lengthAdjust: "lengthAdjust",
+  limitingConeAngle: "limitingConeAngle",
+  markerHeight: "markerHeight",
+  markerWidth: "markerWidth",
+  maskContentUnits: "maskContentUnits",
+  maskUnits: "maskUnits",
+  numOctaves: "numOctaves",
+  pathLength: "pathLength",
+  patternContentUnits: "patternContentUnits",
+  patternTransform: "patternTransform",
+  patternUnits: "patternUnits",
+  pointsAtX: "pointsAtX",
+  pointsAtY: "pointsAtY",
+  pointsAtZ: "pointsAtZ",
+  preserveAspectRatio: "preserveAspectRatio",
+  primitiveUnits: "primitiveUnits",
+  refX: "refX",
+  refY: "refY",
+  repeatCount: "repeatCount",
+  repeatDur: "repeatDur",
+  specularConstant: "specularConstant",
+  specularExponent: "specularExponent",
+  spreadMethod: "spreadMethod",
+  startOffset: "startOffset",
+  stdDeviation: "stdDeviation",
+  stitchTiles: "stitchTiles",
+  surfaceScale: "surfaceScale",
+  systemLanguage: "systemLanguage",
+  tableValues: "tableValues",
+  targetX: "targetX",
+  targetY: "targetY",
+  textLength: "textLength",
+  viewBox: "viewBox",
+  xChannelSelector: "xChannelSelector",
+  yChannelSelector: "yChannelSelector"
+};
+function renderAttributes(props, isSvg) {
+  let attrs = "";
+  for (const key in props) {
+    const value = props[key];
+    if (key === "children" || key === "key" || key === "ref" || key === "dangerouslySetInnerHTML" || key === "suppressHydrationWarning" || key === "suppressContentEditableWarning")
+      continue;
+    if (key.startsWith("on") && key.length > 2 && key[2] === key[2].toUpperCase())
+      continue;
+    let attrName;
+    if (isSvg && key in SVG_ATTR_MAP) {
+      attrName = SVG_ATTR_MAP[key];
+    } else {
+      attrName = key === "className" ? "class" : key === "htmlFor" ? "for" : key === "tabIndex" ? "tabindex" : key === "defaultValue" ? "value" : key === "defaultChecked" ? "checked" : key;
+    }
+    if (value === false || value == null) {
+      if (value === false && (attrName.startsWith("aria-") || attrName.startsWith("data-"))) {
+        attrs += ` ${attrName}="false"`;
+      }
+      continue;
+    }
+    if (value === true) {
+      if (attrName.startsWith("aria-") || attrName.startsWith("data-")) {
+        attrs += ` ${attrName}="true"`;
+      } else {
+        attrs += ` ${attrName}=""`;
+      }
+      continue;
+    }
+    if (key === "style" && typeof value === "object") {
+      const styleStr = styleObjectToString(value);
+      if (styleStr) attrs += ` style="${escapeAttr(styleStr)}"`;
+      continue;
+    }
+    attrs += ` ${attrName}="${escapeAttr(String(value))}"`;
+  }
+  return attrs;
+}
+var BufferWriter = class {
+  chunks = [];
+  lastWasText = false;
+  write(chunk) {
+    this.chunks.push(chunk);
+    this.lastWasText = false;
+  }
+  text(s2) {
+    this.chunks.push(s2);
+    this.lastWasText = true;
+  }
+  flush(target) {
+    for (const c of this.chunks) target.write(c);
+    target.lastWasText = this.lastWasText;
+  }
+};
+function renderNode(node, writer, isSvg = false) {
+  if (node == null || typeof node === "boolean") return;
+  if (typeof node === "string") {
+    writer.text(escapeHtml(node));
+    return;
+  }
+  if (typeof node === "number") {
+    writer.text(String(node));
+    return;
+  }
+  if (Array.isArray(node)) {
+    return renderChildArray(node, writer, isSvg);
+  }
+  if (typeof node === "object" && node !== null && Symbol.iterator in node && !("$$typeof" in node)) {
+    return renderChildArray(
+      Array.from(node),
+      writer,
+      isSvg
+    );
+  }
+  if (typeof node === "object" && node !== null && "$$typeof" in node) {
+    const elType = node["$$typeof"];
+    if (elType !== SLIM_ELEMENT && elType !== REACT19_ELEMENT) return;
+    const element = node;
+    const { type, props } = element;
+    if (type === FRAGMENT_TYPE) {
+      return renderChildren(props.children, writer, isSvg);
+    }
+    if (type === SUSPENSE_TYPE) {
+      return renderSuspense(props, writer, isSvg);
+    }
+    if (typeof type === "function") {
+      return renderComponent(type, props, writer, isSvg);
+    }
+    if (typeof type === "object" && type !== null) {
+      return renderComponent(type, props, writer, isSvg);
+    }
+    if (typeof type === "string") {
+      return renderHostElement(type, props, writer, isSvg);
+    }
+  }
+}
+function markSelectedOptionsMulti(children, selectedValues) {
+  if (children == null || typeof children === "boolean") return children;
+  if (typeof children === "string" || typeof children === "number") return children;
+  if (Array.isArray(children)) {
+    return children.map((c) => markSelectedOptionsMulti(c, selectedValues));
+  }
+  if (typeof children === "object" && "$$typeof" in children) {
+    const elType = children["$$typeof"];
+    if (elType !== SLIM_ELEMENT && elType !== REACT19_ELEMENT) return children;
+    const el = children;
+    if (el.type === "option") {
+      const optValue = el.props.value !== void 0 ? el.props.value : el.props.children;
+      const isSelected = selectedValues.has(String(optValue));
+      return { ...el, props: { ...el.props, selected: isSelected || void 0 } };
+    }
+    if (el.type === "optgroup" || el.type === FRAGMENT_TYPE) {
+      const newChildren = markSelectedOptionsMulti(el.props.children, selectedValues);
+      return { ...el, props: { ...el.props, children: newChildren } };
+    }
+  }
+  return children;
+}
+function renderHostElement(tag, props, writer, isSvg) {
+  const enteringSvg = tag === "svg";
+  const childSvg = isSvg || enteringSvg;
+  if (tag === "textarea") {
+    const textContent = props.value ?? props.defaultValue ?? props.children ?? "";
+    const filteredProps = {};
+    for (const k of Object.keys(props)) {
+      if (k !== "value" && k !== "defaultValue" && k !== "children") filteredProps[k] = props[k];
+    }
+    writer.write(`<textarea${renderAttributes(filteredProps, false)}>`);
+    writer.text(escapeHtml(String(textContent)));
+    writer.write("</textarea>");
+    return;
+  }
+  if (tag === "select") {
+    const selectedValue = props.value ?? props.defaultValue;
+    const filteredProps = {};
+    for (const k of Object.keys(props)) {
+      if (k !== "value" && k !== "defaultValue") filteredProps[k] = props[k];
+    }
+    writer.write(`<select${renderAttributes(filteredProps, false)}>`);
+    const selectedSet = selectedValue == null ? null : Array.isArray(selectedValue) ? new Set(selectedValue.map(String)) : /* @__PURE__ */ new Set([String(selectedValue)]);
+    const patchedChildren = selectedSet != null ? markSelectedOptionsMulti(props.children, selectedSet) : props.children;
+    const inner2 = renderChildren(patchedChildren, writer, false);
+    if (inner2 && typeof inner2.then === "function") {
+      return inner2.then(() => {
+        writer.write("</select>");
+      });
+    }
+    writer.write("</select>");
+    return;
+  }
+  writer.write(`<${tag}${renderAttributes(props, childSvg)}`);
+  if (VOID_ELEMENTS.has(tag)) {
+    writer.write("/>");
+    return;
+  }
+  writer.write(">");
+  const childContext = tag === "foreignObject" ? false : childSvg;
+  let inner = void 0;
+  if (props.dangerouslySetInnerHTML) {
+    writer.write(props.dangerouslySetInnerHTML.__html);
+  } else {
+    inner = renderChildren(props.children, writer, childContext);
+  }
+  if (inner && typeof inner.then === "function") {
+    return inner.then(() => {
+      writer.write(`</${tag}>`);
+    });
+  }
+  writer.write(`</${tag}>`);
+}
+var REACT_MEMO = Symbol.for("react.memo");
+var REACT_FORWARD_REF = Symbol.for("react.forward_ref");
+var REACT_PROVIDER = Symbol.for("react.provider");
+var REACT_CONTEXT = Symbol.for("react.context");
+var REACT_CONSUMER = Symbol.for("react.consumer");
+var REACT_LAZY = Symbol.for("react.lazy");
+function renderComponent(type, props, writer, isSvg) {
+  const typeOf = type?.$$typeof;
+  if (typeOf === REACT_MEMO) {
+    return renderNode(
+      { $$typeof: SLIM_ELEMENT, type: type.type, props, key: null },
+      writer,
+      isSvg
+    );
+  }
+  if (typeOf === REACT_FORWARD_REF) {
+    return renderComponent(type.render, props, writer, isSvg);
+  }
+  if (typeOf === REACT_LAZY) {
+    const resolved = type._init(type._payload);
+    const LazyComp = resolved?.default ?? resolved;
+    return renderComponent(LazyComp, props, writer, isSvg);
+  }
+  if (typeOf === REACT_CONSUMER) {
+    const ctx2 = type._context;
+    const value = ctx2 ? getContextValue(ctx2) : void 0;
+    const result2 = typeof props.children === "function" ? props.children(value) : null;
+    const savedScope2 = pushComponentScope();
+    const finish2 = () => popComponentScope(savedScope2);
+    const r2 = renderNode(result2, writer, isSvg);
+    if (r2 && typeof r2.then === "function") {
+      return r2.then(finish2);
+    }
+    finish2();
+    return;
+  }
+  const isProvider = "_context" in type || typeOf === REACT_PROVIDER || typeOf === REACT_CONTEXT && "value" in props;
+  let prevCtxValue;
+  let ctx;
+  if (isProvider) {
+    ctx = type._context ?? type;
+    prevCtxValue = pushContextValue(ctx, props.value);
+  }
+  const savedScope = pushComponentScope();
+  if (isProvider && typeof type !== "function") {
+    const finish2 = () => {
+      popComponentScope(savedScope);
+      popContextValue(ctx, prevCtxValue);
+    };
+    const r2 = renderChildren(props.children, writer, isSvg);
+    if (r2 && typeof r2.then === "function") {
+      const m = captureMap();
+      return r2.then(
+        () => {
+          swapContextMap(m);
+          finish2();
+        },
+        (e) => {
+          swapContextMap(m);
+          finish2();
+          throw e;
+        }
+      );
+    }
+    finish2();
+    return;
+  }
+  let result;
+  const prevDispatcher = installDispatcher();
+  try {
+    if (type.prototype && typeof type.prototype.render === "function") {
+      const instance = new type(props);
+      if (typeof type.getDerivedStateFromProps === "function") {
+        const derived = type.getDerivedStateFromProps(props, instance.state ?? {});
+        if (derived != null) instance.state = { ...instance.state ?? {}, ...derived };
+      }
+      result = instance.render();
+    } else {
+      result = type(props);
+    }
+  } catch (e) {
+    restoreDispatcher(prevDispatcher);
+    popComponentScope(savedScope);
+    if (isProvider) popContextValue(ctx, prevCtxValue);
+    throw e;
+  }
+  restoreDispatcher(prevDispatcher);
+  let savedIdTree;
+  if (!(result instanceof Promise) && componentCalledUseId()) {
+    savedIdTree = pushTreeContext(1, 0);
+  }
+  const finish = () => {
+    if (savedIdTree !== void 0) popTreeContext(savedIdTree);
+    popComponentScope(savedScope);
+    if (isProvider) popContextValue(ctx, prevCtxValue);
+  };
+  if (result instanceof Promise) {
+    const m = captureMap();
+    return result.then((resolved) => {
+      swapContextMap(m);
+      let asyncSavedIdTree;
+      if (componentCalledUseId()) {
+        asyncSavedIdTree = pushTreeContext(1, 0);
+      }
+      const asyncFinish = () => {
+        if (asyncSavedIdTree !== void 0) popTreeContext(asyncSavedIdTree);
+        popComponentScope(savedScope);
+        if (isProvider) popContextValue(ctx, prevCtxValue);
+      };
+      const r2 = renderNode(resolved, writer, isSvg);
+      if (r2 && typeof r2.then === "function") {
+        const m2 = captureMap();
+        return r2.then(
+          () => {
+            swapContextMap(m2);
+            asyncFinish();
+          },
+          (e) => {
+            swapContextMap(m2);
+            asyncFinish();
+            throw e;
+          }
+        );
+      }
+      asyncFinish();
+    }, (e) => {
+      swapContextMap(m);
+      finish();
+      throw e;
+    });
+  }
+  const r = renderNode(result, writer, isSvg);
+  if (r && typeof r.then === "function") {
+    const m = captureMap();
+    return r.then(
+      () => {
+        swapContextMap(m);
+        finish();
+      },
+      (e) => {
+        swapContextMap(m);
+        finish();
+        throw e;
+      }
+    );
+  }
+  finish();
+}
+function isTextLike(node) {
+  return typeof node === "string" || typeof node === "number";
+}
+function renderChildArray(children, writer, isSvg) {
+  const totalChildren = children.length;
+  for (let i = 0; i < totalChildren; i++) {
+    if (isTextLike(children[i]) && writer.lastWasText) {
+      writer.write("<!-- -->");
+    }
+    const savedTree = pushTreeContext(totalChildren, i);
+    const r = renderNode(children[i], writer, isSvg);
+    if (r && typeof r.then === "function") {
+      const m = captureMap();
+      return r.then(() => {
+        swapContextMap(m);
+        popTreeContext(savedTree);
+        return renderChildArrayFrom(children, i + 1, writer, isSvg);
+      });
+    }
+    popTreeContext(savedTree);
+  }
+}
+function renderChildArrayFrom(children, startIndex, writer, isSvg) {
+  const totalChildren = children.length;
+  for (let i = startIndex; i < totalChildren; i++) {
+    if (isTextLike(children[i]) && writer.lastWasText) {
+      writer.write("<!-- -->");
+    }
+    const savedTree = pushTreeContext(totalChildren, i);
+    const r = renderNode(children[i], writer, isSvg);
+    if (r && typeof r.then === "function") {
+      const m = captureMap();
+      return r.then(() => {
+        swapContextMap(m);
+        popTreeContext(savedTree);
+        return renderChildArrayFrom(children, i + 1, writer, isSvg);
+      });
+    }
+    popTreeContext(savedTree);
+  }
+}
+function renderChildren(children, writer, isSvg = false) {
+  if (children == null) return;
+  if (Array.isArray(children)) {
+    return renderChildArray(children, writer, isSvg);
+  }
+  return renderNode(children, writer, isSvg);
+}
+var MAX_SUSPENSE_RETRIES = 25;
+async function renderSuspense(props, writer, isSvg = false) {
+  const { children, fallback } = props;
+  let attempts = 0;
+  const snap = snapshotContext();
+  while (attempts < MAX_SUSPENSE_RETRIES) {
+    restoreContext(snap);
+    let buffer = new BufferWriter();
+    try {
+      const r = renderNode(children, buffer, isSvg);
+      if (r && typeof r.then === "function") {
+        const m = captureMap();
+        await r;
+        swapContextMap(m);
+      }
+      writer.write("<!--$-->");
+      buffer.flush(writer);
+      writer.write("<!--/$-->");
+      return;
+    } catch (error) {
+      if (error && typeof error.then === "function") {
+        const m = captureMap();
+        await error;
+        swapContextMap(m);
+        attempts++;
+      } else {
+        throw error;
+      }
+    }
+  }
+  restoreContext(snap);
+  writer.write("<!--$?-->");
+  if (fallback) {
+    const r = renderNode(fallback, writer, isSvg);
+    if (r && typeof r.then === "function") {
+      const m = captureMap();
+      await r;
+      swapContextMap(m);
+    }
+  }
+  writer.write("<!--/$-->");
+}
+async function renderToString(element, options) {
+  const idPrefix = options?.identifierPrefix ?? "";
+  const contextMap = /* @__PURE__ */ new Map();
+  const prev = swapContextMap(contextMap);
+  try {
+    for (let attempt = 0; attempt < MAX_SUSPENSE_RETRIES; attempt++) {
+      resetRenderState(idPrefix);
+      swapContextMap(contextMap);
+      const chunks = [];
+      const writer = {
+        lastWasText: false,
+        write(c) {
+          chunks.push(c);
+          this.lastWasText = false;
+        },
+        text(s2) {
+          chunks.push(s2);
+          this.lastWasText = true;
+        }
+      };
+      try {
+        const r = renderNode(element, writer);
+        if (r && typeof r.then === "function") {
+          const m = captureMap();
+          await r;
+          swapContextMap(m);
+        }
+        return chunks.join("");
+      } catch (error) {
+        if (error && typeof error.then === "function") {
+          const m = captureMap();
+          await error;
+          swapContextMap(m);
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error("[slim-react] renderToString exceeded maximum retries");
+  } finally {
+    swapContextMap(prev);
+  }
+}
+
+// src/utils/segmentCache.ts
+function getStore() {
+  const g = globalThis;
+  if (!g.__hadarsSegmentStore) {
+    g.__hadarsSegmentStore = /* @__PURE__ */ new Map();
+  }
+  return g.__hadarsSegmentStore;
+}
+function setSegment(key, html, ttl) {
+  getStore().set(key, {
+    html,
+    expiresAt: ttl != null ? Date.now() + ttl : null
+  });
+}
+function processSegmentCache(html) {
+  let prev;
+  do {
+    prev = html;
+    html = html.replace(
+      /<hadars-c([^>]*)>([\s\S]*?)<\/hadars-c>/g,
+      (match, attrs, content) => {
+        const cacheM = /data-cache="([^"]+)"/.exec(attrs);
+        const keyM = /data-key="([^"]+)"/.exec(attrs);
+        const ttlM = /data-ttl="(\d+)"/.exec(attrs);
+        if (!cacheM || !keyM) return match;
+        if (cacheM[1] === "miss") {
+          setSegment(keyM[1], content, ttlM ? Number(ttlM[1]) : void 0);
+          return content;
+        }
+        if (cacheM[1] === "hit") return content;
+        return match;
+      }
+    );
+  } while (html !== prev);
+  return html;
+}
+
+// src/utils/response.tsx
+var ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
+var escAttr = (s2) => s2.replace(/[&<>"]/g, (c) => ESC[c] ?? c);
+var escText = (s2) => s2.replace(/[&<>]/g, (c) => ESC[c] ?? c);
+var ATTR = {
+  className: "class",
+  htmlFor: "for",
+  httpEquiv: "http-equiv",
+  charSet: "charset",
+  crossOrigin: "crossorigin",
+  noModule: "nomodule",
+  referrerPolicy: "referrerpolicy",
+  fetchPriority: "fetchpriority"
+};
+function renderHeadTag(tag, id, opts, selfClose = false) {
+  let attrs = ` id="${escAttr(id)}"`;
+  let inner = "";
+  for (const [k, v] of Object.entries(opts)) {
+    if (k === "key" || k === "children") continue;
+    if (k === "dangerouslySetInnerHTML") {
+      inner = v.__html ?? "";
+      continue;
+    }
+    const attr = ATTR[k] ?? k;
+    if (v === true) attrs += ` ${attr}`;
+    else if (v !== false && v != null) attrs += ` ${attr}="${escAttr(String(v))}"`;
+  }
+  return selfClose ? `<${tag}${attrs}>` : `<${tag}${attrs}>${inner}</${tag}>`;
+}
+var getHeadHtml = (seoData) => {
+  let html = `<title>${escText(seoData.title ?? "")}</title>`;
+  for (const [id, opts] of Object.entries(seoData.meta))
+    html += renderHeadTag("meta", id, opts, true);
+  for (const [id, opts] of Object.entries(seoData.link))
+    html += renderHeadTag("link", id, opts, true);
+  for (const [id, opts] of Object.entries(seoData.style))
+    html += renderHeadTag("style", id, opts);
+  for (const [id, opts] of Object.entries(seoData.script))
+    html += renderHeadTag("script", id, opts);
+  return html;
+};
+var getReactResponse = async (req, opts) => {
+  const App = opts.document.body;
+  const { getInitProps, getAfterRenderProps, getFinalProps } = opts.document;
+  const context = {
+    head: { title: "Hadars App", meta: {}, link: {}, style: {}, script: {}, status: 200 }
+  };
+  let props = {
+    ...getInitProps ? await getInitProps(req) : {},
+    location: req.location,
+    context
+  };
+  const unsuspend = { cache: /* @__PURE__ */ new Map() };
+  globalThis.__hadarsUnsuspend = unsuspend;
+  let bodyHtml;
+  try {
+    bodyHtml = await renderToString(createElement(App, props));
+    if (getAfterRenderProps) {
+      props = await getAfterRenderProps(props, bodyHtml);
+      bodyHtml = await renderToString(
+        createElement(App, { ...props, location: req.location, context })
+      );
+    }
+  } finally {
+    globalThis.__hadarsUnsuspend = null;
+  }
+  const { context: _, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
+  const serverData = {};
+  for (const [key, entry] of unsuspend.cache) {
+    if (entry.status === "fulfilled") serverData[key] = entry.value;
+  }
+  const clientProps = {
+    ...restProps,
+    location: req.location,
+    ...Object.keys(serverData).length > 0 ? { __serverData: serverData } : {}
+  };
+  return {
+    bodyHtml: processSegmentCache(bodyHtml),
+    clientProps,
+    status: context.head.status,
+    headHtml: getHeadHtml(context.head)
+  };
+};
+
+// src/utils/ssrHandler.ts
+var HEAD_MARKER = '<meta name="HADARS_HEAD">';
+var BODY_MARKER = '<meta name="HADARS_BODY">';
+var encoder = new TextEncoder();
+async function buildSsrHtml(bodyHtml, clientProps, headHtml, getPrecontentHtml) {
+  const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
+  const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c");
+  return precontentHtml + `<div id="app">${bodyHtml}</div><script id="hadars" type="application/json">${scriptContent}</script>` + postContent;
+}
+var makePrecontentHtmlGetter = (htmlFilePromise) => {
+  let preHead = null;
+  let postHead = null;
+  let postContent = null;
+  return async (headHtml) => {
+    if (preHead === null || postHead === null || postContent === null) {
+      const html = await htmlFilePromise;
+      const headEnd = html.indexOf(HEAD_MARKER);
+      const contentStart = html.indexOf(BODY_MARKER);
+      preHead = html.slice(0, headEnd);
+      postHead = html.slice(headEnd + HEAD_MARKER.length, contentStart);
+      postContent = html.slice(contentStart + BODY_MARKER.length);
+    }
+    return [preHead + headHtml + postHead, postContent];
+  };
+};
+async function transformStream(data, stream) {
+  const writer = stream.writable.getWriter();
+  writer.write(data);
+  writer.close();
+  const chunks = [];
+  const reader = stream.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const total = chunks.reduce((n, c) => n + c.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.length;
+  }
+  return out;
+}
+var gzipCompress = (d) => transformStream(d, new globalThis.CompressionStream("gzip"));
+var gzipDecompress = (d) => transformStream(d, new globalThis.DecompressionStream("gzip"));
+async function buildCacheEntry(res, ttl) {
+  const buf = await res.arrayBuffer();
+  const body = await gzipCompress(new Uint8Array(buf));
+  const headers = [];
+  res.headers.forEach((v, k) => {
+    if (k.toLowerCase() !== "content-encoding" && k.toLowerCase() !== "content-length") {
+      headers.push([k, v]);
+    }
+  });
+  headers.push(["content-encoding", "gzip"]);
+  return { body, status: res.status, headers, expiresAt: ttl != null ? Date.now() + ttl : null };
+}
+async function serveFromEntry(entry, req) {
+  const accept = req.headers.get("Accept-Encoding") ?? "";
+  if (accept.includes("gzip")) {
+    return new Response(entry.body.buffer, { status: entry.status, headers: entry.headers });
+  }
+  const plain = await gzipDecompress(entry.body);
+  const headers = entry.headers.filter(([k]) => k.toLowerCase() !== "content-encoding");
+  return new Response(plain.buffer, { status: entry.status, headers });
+}
+function createRenderCache(opts, handler) {
+  const store = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  return async (req, ctx) => {
+    const hadarsReq = parseRequest(req);
+    const cacheOpts = await opts(hadarsReq);
+    const key = cacheOpts?.key ?? null;
+    if (key != null) {
+      const entry = store.get(key);
+      if (entry) {
+        const expired = entry.expiresAt != null && Date.now() >= entry.expiresAt;
+        if (!expired) return serveFromEntry(entry, req);
+        store.delete(key);
+      }
+      let flight = inFlight.get(key);
+      if (!flight) {
+        const ttl = cacheOpts?.ttl;
+        flight = handler(new Request(req), ctx).then(async (res) => {
+          if (!res || res.status < 200 || res.status >= 300 || res.headers.has("set-cookie")) {
+            return null;
+          }
+          const newEntry2 = await buildCacheEntry(res, ttl);
+          store.set(key, newEntry2);
+          return newEntry2;
+        }).catch(() => null).finally(() => inFlight.delete(key));
+        inFlight.set(key, flight);
+      }
+      const newEntry = await flight;
+      if (newEntry) return serveFromEntry(newEntry, req);
+    }
+    return handler(req, ctx);
+  };
+}
+
+// src/lambda.ts
+function eventToRequest(event) {
+  let method;
+  let path;
+  let queryString;
+  let headers;
+  let rawBody;
+  let isBase64;
+  let host;
+  if ("version" in event && event.version === "2.0") {
+    method = event.requestContext.http.method;
+    path = event.rawPath;
+    queryString = event.rawQueryString;
+    headers = { ...event.headers };
+    if (event.cookies?.length) headers["cookie"] = event.cookies.join("; ");
+    rawBody = event.body;
+    isBase64 = event.isBase64Encoded;
+    host = event.requestContext.domainName;
+  } else {
+    const e = event;
+    method = e.httpMethod;
+    path = e.path;
+    const qs = e.queryStringParameters;
+    queryString = qs ? new URLSearchParams(qs).toString() : "";
+    headers = e.headers ?? {};
+    rawBody = e.body;
+    isBase64 = e.isBase64Encoded;
+    host = headers["host"] ?? "lambda";
+  }
+  const url = `https://${host}${path}${queryString ? "?" + queryString : ""}`;
+  let body;
+  if (rawBody) body = isBase64 ? Buffer.from(rawBody, "base64") : rawBody;
+  return new Request(url, {
+    method,
+    headers,
+    body: ["GET", "HEAD"].includes(method) ? void 0 : body
+  });
+}
+var TEXT_RE = /\b(?:text\/|application\/(?:json|javascript|xml)|image\/svg\+xml)/;
+async function responseToLambda(response) {
+  const headers = {};
+  response.headers.forEach((v, k) => {
+    headers[k] = v;
+  });
+  const contentType = response.headers.get("Content-Type") ?? "";
+  if (TEXT_RE.test(contentType)) {
+    return {
+      statusCode: response.status,
+      headers,
+      body: await response.text(),
+      isBase64Encoded: false
+    };
+  }
+  return {
+    statusCode: response.status,
+    headers,
+    body: Buffer.from(await response.arrayBuffer()).toString("base64"),
+    isBase64Encoded: true
+  };
+}
+var HadarsFolder = "./.hadars";
+var StaticPath = `${HadarsFolder}/static`;
+var SSR_FILENAME = "index.ssr.js";
+var noopCtx = { upgrade: () => false };
+function createLambdaHandler(options, bundled) {
+  const cwd = process.cwd();
+  const fetchHandler = options.fetch;
+  const handleProxy = createProxyHandler(options);
+  const getPrecontentHtml = bundled ? makePrecontentHtmlGetter(Promise.resolve(bundled.outHtml)) : makePrecontentHtmlGetter(import_promises2.default.readFile(import_node_path.default.join(cwd, StaticPath, "out.html"), "utf-8"));
+  let ssrModulePromise = null;
+  const getSsrModule = () => {
+    if (bundled) return Promise.resolve(bundled.ssrModule);
+    if (!ssrModulePromise) {
+      ssrModulePromise = import((0, import_node_url.pathToFileURL)(import_node_path.default.resolve(cwd, HadarsFolder, SSR_FILENAME)).href);
+    }
+    return ssrModulePromise;
+  };
+  const runHandler = async (req) => {
+    const request = parseRequest(req);
+    if (fetchHandler) {
+      const res = await fetchHandler(request);
+      if (res) return res;
+    }
+    const proxied = await handleProxy(request);
+    if (proxied) return proxied;
+    const urlPath = new URL(request.url).pathname;
+    if (!bundled) {
+      const staticRes = await tryServeFile(import_node_path.default.join(cwd, StaticPath, urlPath));
+      if (staticRes) return staticRes;
+      const projectStaticPath = import_node_path.default.resolve(cwd, "static");
+      const projectRes = await tryServeFile(import_node_path.default.join(projectStaticPath, urlPath));
+      if (projectRes) return projectRes;
+      const routeClean = urlPath.replace(/(^\/|\/$)/g, "");
+      if (routeClean) {
+        const routeRes = await tryServeFile(
+          import_node_path.default.join(cwd, StaticPath, routeClean, "index.html")
+        );
+        if (routeRes) return routeRes;
+      }
+    }
+    try {
+      const {
+        default: Component,
+        getInitProps,
+        getAfterRenderProps,
+        getFinalProps
+      } = await getSsrModule();
+      const { bodyHtml, clientProps, status, headHtml } = await getReactResponse(request, {
+        document: {
+          body: Component,
+          lang: "en",
+          getInitProps,
+          getAfterRenderProps,
+          getFinalProps
+        }
+      });
+      if (request.headers.get("Accept") === "application/json") {
+        const serverData = clientProps.__serverData ?? {};
+        return new Response(JSON.stringify({ serverData }), {
+          status,
+          headers: { "Content-Type": "application/json; charset=utf-8" }
+        });
+      }
+      const html = await buildSsrHtml(bodyHtml, clientProps, headHtml, getPrecontentHtml);
+      return new Response(html, {
+        status,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    } catch (err) {
+      console.error("[hadars] SSR render error:", err);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  };
+  const finalHandler = options.cache ? createRenderCache(options.cache, (req) => runHandler(req)) : (req) => runHandler(req);
+  return async (event) => {
+    const req = eventToRequest(event);
+    const response = await finalHandler(req, noopCtx) ?? new Response("Not Found", { status: 404 });
+    return responseToLambda(response);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLambdaHandler
+});