@noodleseed/one 0.22.0 → 0.24.0

package/node_modules/hono/dist/adapter/lambda-edge/handler.js

@@ -45,11 +45,17 @@ var createRequest = (event) => {
   const url = queryString ? `${urlPath}?${queryString}` : urlPath;
   const headers = new Headers();
   Object.entries(event.Records[0].cf.request.headers).forEach(([k, v]) => {
-    v.forEach((header) => headers.set(k, header.value));
+    v.forEach((header) => headers.append(k, header.value));
   });
   const requestBody = event.Records[0].cf.request.body;
   const method = event.Records[0].cf.request.method;
-  const body = createBody(method, requestBody);
+  const rawBody = createBody(method, requestBody);
+  let body = rawBody;
+  if (rawBody !== void 0) {
+    const bytes = typeof rawBody === "string" ? new TextEncoder().encode(rawBody) : rawBody;
+    body = bytes;
+    headers.set("content-length", bytes.length.toString());
+  }
   return new Request(url, {
     headers,
     method,

package/node_modules/hono/dist/cjs/adapter/aws-lambda/handler.js

@@ -139,7 +139,9 @@ class EventProcessor {
       method
     };
     if (event.body) {
-      requestInit.body = event.isBase64Encoded ? (0, import_encode.decodeBase64)(event.body) : event.body;
+      const body = event.isBase64Encoded ? (0, import_encode.decodeBase64)(event.body) : new TextEncoder().encode(event.body);
+      requestInit.body = body;
+      headers.set("content-length", body.length.toString());
     }
     return new Request(url, requestInit);
   }
@@ -237,21 +239,17 @@ class EventV1Processor extends EventProcessor {
   getHeaders(event) {
     const headers = new Headers();
     this.getCookies(event, headers);
-    if (event.headers) {
-      for (const [k, v] of Object.entries(event.headers)) {
-        if (v) {
-          headers.set(k, sanitizeHeaderValue(v));
-        }
-      }
-    }
     if (event.multiValueHeaders) {
       for (const [k, values] of Object.entries(event.multiValueHeaders)) {
         if (values) {
-          const foundK = headers.get(k);
-          values.forEach((v) => {
-            const sanitizedValue = sanitizeHeaderValue(v);
-            return (!foundK || !foundK.includes(sanitizedValue)) && headers.append(k, sanitizedValue);
-          });
+          values.forEach((v) => headers.append(k, sanitizeHeaderValue(v)));
+        }
+      }
+    }
+    if (event.headers) {
+      for (const [k, v] of Object.entries(event.headers)) {
+        if (v && !headers.has(k)) {
+          headers.set(k, sanitizeHeaderValue(v));
         }
       }
     }
@@ -311,7 +309,7 @@ class ALBProcessor extends EventProcessor {
     if (result.multiValueHeaders) {
       result.multiValueHeaders["set-cookie"] = cookies;
     } else {
-      result.headers["set-cookie"] = cookies.join(", ");
+      result.headers["set-cookie"] = cookies[0];
     }
   }
 }
@@ -331,11 +329,7 @@ class LatticeV2Processor extends EventProcessor {
     if (event.headers) {
       for (const [k, values] of Object.entries(event.headers)) {
         if (values) {
-          const foundK = headers.get(k);
-          values.forEach((v) => {
-            const sanitizedValue = sanitizeHeaderValue(v);
-            return (!foundK || !foundK.includes(sanitizedValue)) && headers.append(k, sanitizedValue);
-          });
+          values.forEach((v) => headers.append(k, sanitizeHeaderValue(v)));
         }
       }
     }
@@ -346,7 +340,7 @@ class LatticeV2Processor extends EventProcessor {
   setCookiesToResult(result, cookies) {
     result.headers = {
       ...result.headers,
-      "set-cookie": cookies.join(", ")
+      "set-cookie": cookies
     };
   }
 }
@@ -370,7 +364,7 @@ const isProxyEventALB = (event) => {
   return false;
 };
 const isProxyEventV2 = (event) => {
-  return Object.hasOwn(event, "rawPath");
+  return Object.hasOwn(event, "rawPath") && Object.hasOwn(event.requestContext ?? {}, "http");
 };
 const isLatticeEventV2 = (event) => {
   if (event.requestContext) {

package/node_modules/hono/dist/cjs/adapter/bun/websocket.js

@@ -48,7 +48,9 @@ const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)((c, events)
     data: {
       events,
       url: new URL(c.req.url),
-      protocol: c.req.url
+      // The first requested subprotocol, exposed via WSContext.protocol to
+      // match the deno and cloudflare adapters.
+      protocol: c.req.header("sec-websocket-protocol")?.split(",")[0]?.trim() ?? ""
     }
   });
   if (upgradeResult) {

package/node_modules/hono/dist/cjs/adapter/lambda-edge/handler.js

@@ -78,11 +78,17 @@ const createRequest = (event) => {
   const url = queryString ? `${urlPath}?${queryString}` : urlPath;
   const headers = new Headers();
   Object.entries(event.Records[0].cf.request.headers).forEach(([k, v]) => {
-    v.forEach((header) => headers.set(k, header.value));
+    v.forEach((header) => headers.append(k, header.value));
   });
   const requestBody = event.Records[0].cf.request.body;
   const method = event.Records[0].cf.request.method;
-  const body = createBody(method, requestBody);
+  const rawBody = createBody(method, requestBody);
+  let body = rawBody;
+  if (rawBody !== void 0) {
+    const bytes = typeof rawBody === "string" ? new TextEncoder().encode(rawBody) : rawBody;
+    body = bytes;
+    headers.set("content-length", bytes.length.toString());
+  }
   return new Request(url, {
     headers,
     method,

package/node_modules/hono/dist/cjs/helper/css/common.js

@@ -61,6 +61,7 @@ const normalizeLabel = (label) => {
   return label.trim().replace(/\s+/g, "-");
 };
 const isValidClassName = (name) => /^-?[_a-zA-Z][_a-zA-Z0-9-]*$/.test(name);
+const hasUnsafeSelectorChar = (name) => /[<{}]/.test(name);
 const RESERVED_KEYFRAME_NAMES = /* @__PURE__ */ new Set([
   "default",
   "inherit",
@@ -198,7 +199,8 @@ const cxCommon = (args) => {
         [CLASS_NAME]: "",
         [STYLE_STRING]: "",
         [SELECTORS]: [],
-        [EXTERNAL_CLASS_NAMES]: [arg]
+        // drop names that are unsafe to emit as a selector
+        [EXTERNAL_CLASS_NAMES]: hasUnsafeSelectorChar(arg) ? [] : [arg]
       };
     }
   }

package/node_modules/hono/dist/cjs/helper/css/index.js

@@ -29,6 +29,7 @@ module.exports = __toCommonJS(css_exports);
 var import_html = require("../../helper/html");
 var import_constants = require("../../jsx/constants");
 var import_css = require("../../jsx/dom/css");
+var import_html2 = require("../../utils/html");
 var import_common = require("./common");
 var import_common2 = require("./common");
 const createCssContext = ({
@@ -88,7 +89,14 @@ const createCssContext = ({
       }
       return Promise.resolve((0, import_html.raw)("", [appendStyle]));
     };
-    const className = new String(cssClassName[import_common.CLASS_NAME]);
+    const rawClassName = cssClassName[import_common.CLASS_NAME];
+    let escapedClassName = rawClassName;
+    if (/[&<>'"]/.test(rawClassName)) {
+      const escapedBuffer = [""];
+      (0, import_html2.escapeToBuffer)(rawClassName, escapedBuffer);
+      escapedClassName = escapedBuffer[0];
+    }
+    const className = new String(escapedClassName);
     Object.assign(className, cssClassName);
     className.isEscaped = true;
     className.callbacks = [addClassNameToContext];

package/node_modules/hono/dist/cjs/jsx/base.js

@@ -125,7 +125,7 @@ class JSXNode {
   key;
   children;
   isEscaped = true;
-  localContexts;
+  suspendedContext;
   constructor(tag, props, children) {
     if (typeof tag !== "function" && !(0, import_utils.isValidTagName)(tag)) {
       throw new Error(`Invalid JSX tag name: ${tag}`);
@@ -143,18 +143,12 @@ class JSXNode {
     return this.props.ref || null;
   }
   toString() {
-    const buffer = [""];
-    this.localContexts?.forEach(([context, value]) => {
-      context.values.push(value);
-    });
-    try {
+    const render = () => {
+      const buffer = [""];
       this.toStringToBuffer(buffer);
-    } finally {
-      this.localContexts?.forEach(([context]) => {
-        context.values.pop();
-      });
-    }
-    return buffer.length === 1 ? "callbacks" in buffer ? (0, import_html2.resolveCallbackSync)((0, import_html.raw)(buffer[0], buffer.callbacks)).toString() : buffer[0] : (0, import_html2.stringBufferToString)(buffer, buffer.callbacks);
+      return buffer.length === 1 ? "callbacks" in buffer ? (0, import_html2.resolveCallbackSync)((0, import_html.raw)(buffer[0], buffer.callbacks)).toString() : buffer[0] : (0, import_html2.stringBufferToString)(buffer, buffer.callbacks);
+    };
+    return this.suspendedContext ? this.suspendedContext(render) : (0, import_context.runWithRenderContext)(render);
   }
   toStringToBuffer(buffer) {
     const tag = this.tag;
@@ -230,12 +224,12 @@ class JSXFunctionNode extends JSXNode {
       if (import_context.globalContexts.length === 0) {
         buffer.unshift("", res);
       } else {
-        const currentContexts = import_context.globalContexts.map((c) => [c, c.values.at(-1)]);
+        const suspendedContext = (0, import_context.captureRenderContext)();
         buffer.unshift(
           "",
           res.then((childRes) => {
             if (childRes instanceof JSXNode) {
-              childRes.localContexts = currentContexts;
+              childRes.suspendedContext = suspendedContext;
             }
             return childRes;
           })

package/node_modules/hono/dist/cjs/jsx/components.js

@@ -34,8 +34,9 @@ const childrenToString = async (children) => {
     return children.flat().map((c) => c == null || typeof c === "boolean" ? "" : c.toString());
   } catch (e) {
     if (e instanceof Promise) {
+      const resume = (0, import_context.captureRenderContext)();
       await e;
-      return childrenToString(children);
+      return resume(() => childrenToString(children));
     } else {
       throw e;
     }
@@ -63,51 +64,68 @@ const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) =>
     children = [children];
   }
   const nonce = (0, import_context.useContext)(import_streaming.StreamingContext)?.scriptNonce;
-  let fallbackStr;
-  const resolveFallbackStr = async () => {
+  let resume;
+  const getResume = () => resume ||= (0, import_context.captureRenderContext)();
+  let fallbackStrPromise;
+  const resolveFallbackStr = () => fallbackStrPromise ||= (async () => {
     const awaitedFallback = await fallback;
     if (typeof awaitedFallback === "string") {
-      fallbackStr = awaitedFallback;
+      return awaitedFallback;
     } else {
-      fallbackStr = await awaitedFallback?.toString();
-      if (typeof fallbackStr === "string") {
-        fallbackStr = (0, import_html.raw)(fallbackStr);
+      const fallbackResult = await getResume()(() => awaitedFallback?.toString());
+      if (typeof fallbackResult === "string") {
+        return (0, import_html.raw)(
+          fallbackResult,
+          fallbackResult.callbacks || awaitedFallback?.callbacks
+        );
       }
     }
-  };
-  const fallbackRes = (error) => {
-    onError?.(error);
-    return fallbackStr || fallbackRender && (0, import_base.jsx)(import_base.Fragment, {}, fallbackRender(error)) || "";
+  })();
+  const renderFallback = async (error) => {
+    const fallbackStr = await resolveFallbackStr();
+    return getResume()(async () => {
+      onError?.(error);
+      const fallbackRes = fallbackStr !== void 0 ? fallbackStr : fallbackRender && (0, import_base.jsx)(import_base.Fragment, {}, fallbackRender(error)) || "";
+      const fallbackResString = await (0, import_base.Fragment)({
+        children: fallbackRes
+      }).toString();
+      return (0, import_html.raw)(
+        fallbackResString,
+        fallbackResString.callbacks || fallbackRes.callbacks
+      );
+    });
   };
   let resArray = [];
   try {
     resArray = children.map(resolveChildEarly);
   } catch (e) {
-    await resolveFallbackStr();
+    const resume2 = getResume();
     if (e instanceof Promise) {
       resArray = [
-        e.then(() => childrenToString(children)).catch((e2) => fallbackRes(e2))
+        e.then(() => resume2(() => childrenToString(children))).catch((e2) => renderFallback(e2))
       ];
     } else {
-      resArray = [fallbackRes(e)];
+      resArray = [await renderFallback(e)];
     }
   }
   if (resArray.some((res) => res instanceof Promise)) {
-    await resolveFallbackStr();
+    getResume();
     const index = errorBoundaryCounter++;
     const replaceRe = RegExp(`(<template id="E:${index}"></template>.*?)(.*?)(<!--E:${index}-->)`);
-    const caught = false;
+    let caught = false;
     const catchCallback = async ({ error: error2, buffer }) => {
       if (caught) {
         return "";
       }
-      const fallbackResString = await (0, import_base.Fragment)({
-        children: fallbackRes(error2)
-      }).toString();
+      caught = true;
+      const fallbackResString = await renderFallback(error2);
+      const fallbackCallbacks = fallbackResString.callbacks;
       if (buffer) {
         buffer[0] = buffer[0].replace(replaceRe, fallbackResString);
+        return fallbackCallbacks?.length ? (0, import_html.raw)("", fallbackCallbacks) : "";
       }
-      return buffer ? "" : `<template data-hono-target="E:${index}">${fallbackResString}</template><script>
+      return (0, import_html.raw)(
+        `<template data-hono-target="E:${index}">${fallbackResString}</template><script>
 ((d,c,n) => {
 c=d.currentScript.previousSibling
 d=d.getElementById('E:${index}')
@@ -115,7 +133,9 @@ if(!d)return
 do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='E:${index}')
 d.replaceWith(c.content)
 })(document)
-</script>`;
+</script>`,
+        fallbackCallbacks
+      );
     };
     let error;
     const promiseAll = Promise.all(resArray).catch((e) => error = e);

package/node_modules/hono/dist/cjs/jsx/context.js

@@ -17,8 +17,10 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var context_exports = {};
 __export(context_exports, {
+  captureRenderContext: () => captureRenderContext,
   createContext: () => createContext,
   globalContexts: () => globalContexts,
+  runWithRenderContext: () => runWithRenderContext,
   useContext: () => useContext
 });
 module.exports = __toCommonJS(context_exports);
@@ -27,21 +29,143 @@ var import_base = require("./base");
 var import_constants = require("./constants");
 var import_context = require("./dom/context");
 const globalContexts = [];
+let alsProbed = false;
+let asyncLocalStorage;
+let fallbackStore;
+let fallbackRendersInFlight = 0;
+let warnedFallbackDefault = false;
+const loadAsyncLocalStorage = () => {
+  if (alsProbed) {
+    return asyncLocalStorage;
+  }
+  alsProbed = true;
+  const global = globalThis;
+  let AsyncLocalStorage;
+  for (const probe of [
+    // Node.js >= 20.16, Deno, Bun, Cloudflare Workers (nodejs_compat). Property
+    // access only, so bundlers don't statically resolve `node:async_hooks`.
+    () => global.process?.getBuiltinModule?.("node:async_hooks")?.AsyncLocalStorage,
+    // Node.js < 20.16 has no `process.getBuiltinModule`, but a CJS entrypoint
+    // exposes the main module's `require` here.
+    () => global.process?.mainModule?.require?.("node:async_hooks")?.AsyncLocalStorage
+  ]) {
+    try {
+      AsyncLocalStorage = probe();
+    } catch {
+    }
+    if (AsyncLocalStorage) {
+      break;
+    }
+  }
+  if (AsyncLocalStorage) {
+    asyncLocalStorage = new AsyncLocalStorage();
+  }
+  return asyncLocalStorage;
+};
+const getCurrentStore = () => {
+  return loadAsyncLocalStorage()?.getStore() || fallbackStore;
+};
+const warnIfStorelessAccess = () => {
+  if (fallbackRendersInFlight > 0 && !warnedFallbackDefault) {
+    warnedFallbackDefault = true;
+    console.warn(
+      "hono/jsx: AsyncLocalStorage is unavailable in this runtime, so useContext() after an await in an async component falls back to the context default value during server-side rendering. To get provided values across await boundaries, use a runtime with AsyncLocalStorage (Node.js >= 20.16, Deno, Bun, or Cloudflare Workers with the nodejs_compat flag)."
+    );
+  }
+};
+const getContextValuesIn = (store, context) => {
+  if (!store) {
+    warnIfStorelessAccess();
+    return context.values;
+  }
+  let values = store.get(context);
+  if (!values) {
+    values = [context.values[0]];
+    store.set(context, values);
+  }
+  return values;
+};
+const readContextValueIn = (store, context) => {
+  if (!store) {
+    warnIfStorelessAccess();
+    return context.values.at(-1);
+  }
+  const values = store.get(context);
+  return values?.length ? values.at(-1) : context.values[0];
+};
+const captureContextValues = (store) => (store ? globalContexts.filter((c) => store.has(c)) : globalContexts).map((c) => [
+  c,
+  readContextValueIn(store, c)
+]);
+const resumeWithContextValues = (callback, store, contexts) => runWithRenderContext(() => {
+  const currentStore = getCurrentStore();
+  const valuesPerContext = contexts.map(([context, value]) => {
+    const values = getContextValuesIn(currentStore, context);
+    values.push(value);
+    return values;
+  });
+  const popContextValues = () => {
+    valuesPerContext.forEach((values) => {
+      values.pop();
+    });
+  };
+  try {
+    const result = callback();
+    if (result instanceof Promise) {
+      return result.finally(popContextValues);
+    }
+    popContextValues();
+    return result;
+  } catch (e) {
+    popContextValues();
+    throw e;
+  }
+}, store);
+const runWithRenderContext = (callback, resumeStore) => {
+  if (getCurrentStore()) {
+    return callback();
+  }
+  const store = resumeStore ?? /* @__PURE__ */ new WeakMap();
+  const storage = loadAsyncLocalStorage();
+  if (storage) {
+    return storage.run(store, callback);
+  }
+  fallbackStore = store;
+  let result;
+  try {
+    result = callback();
+  } finally {
+    fallbackStore = void 0;
+  }
+  if (!warnedFallbackDefault && result instanceof Promise) {
+    fallbackRendersInFlight++;
+    result = result.finally(() => {
+      fallbackRendersInFlight--;
+    });
+  }
+  return result;
+};
+const captureRenderContext = () => {
+  const store = getCurrentStore();
+  const contexts = captureContextValues(store);
+  return (callback) => resumeWithContextValues(callback, store, contexts);
+};
 const createContext = (defaultValue) => {
   const values = [defaultValue];
   const context = ((props) => {
-    values.push(props.value);
+    const contextValues = getContextValuesIn(getCurrentStore(), context);
+    contextValues.push(props.value);
     let string;
     try {
       string = props.children ? (Array.isArray(props.children) ? new import_base.JSXFragmentNode("", {}, props.children) : props.children).toString() : "";
     } catch (e) {
-      values.pop();
+      contextValues.pop();
       throw e;
     }
     if (string instanceof Promise) {
-      return string.finally(() => values.pop()).then((resString) => (0, import_html.raw)(resString, resString.callbacks));
+      return string.finally(() => contextValues.pop()).then((resString) => (0, import_html.raw)(resString, resString.callbacks));
     } else {
-      values.pop();
+      contextValues.pop();
       return (0, import_html.raw)(string);
     }
   });
@@ -52,11 +176,13 @@ const createContext = (defaultValue) => {
   return context;
 };
 const useContext = (context) => {
-  return context.values.at(-1);
+  return readContextValueIn(getCurrentStore(), context);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  captureRenderContext,
   createContext,
   globalContexts,
+  runWithRenderContext,
   useContext
 });

package/node_modules/hono/dist/cjs/jsx/streaming.js

@@ -42,9 +42,8 @@ const Suspense = async ({
   const nonce = (0, import_context.useContext)(StreamingContext)?.scriptNonce;
   let resArray = [];
   const stackNode = { [import_constants.DOM_STASH]: [0, []] };
-  const popNodeStack = (value) => {
+  const popNodeStack = () => {
     import_render.buildDataStack.pop();
-    return value;
   };
   try {
     stackNode[import_constants.DOM_STASH][0] = 0;
@@ -54,12 +53,15 @@ const Suspense = async ({
     );
   } catch (e) {
     if (e instanceof Promise) {
+      const resume = (0, import_context.captureRenderContext)();
       resArray = [
-        e.then(() => {
-          stackNode[import_constants.DOM_STASH][0] = 0;
-          import_render.buildDataStack.push([[], stackNode]);
-          return (0, import_components.childrenToString)(children).then(popNodeStack);
-        })
+        e.then(
+          () => resume(() => {
+            stackNode[import_constants.DOM_STASH][0] = 0;
+            import_render.buildDataStack.push([[], stackNode]);
+            return (0, import_components.childrenToString)(children).finally(popNodeStack);
+          })
+        )
       ];
     } else {
       throw e;

package/node_modules/hono/dist/cjs/middleware/cors/index.js

@@ -31,9 +31,6 @@ const cors = (options) => {
   const findAllowOrigin = ((optsOrigin) => {
     if (typeof optsOrigin === "string") {
       if (optsOrigin === "*") {
-        if (opts.credentials) {
-          return (origin) => origin || null;
-        }
         return () => optsOrigin;
       } else {
         return (origin) => optsOrigin === origin ? origin : null;
@@ -68,7 +65,7 @@ const cors = (options) => {
       set("Access-Control-Expose-Headers", opts.exposeHeaders.join(","));
     }
     if (c.req.method === "OPTIONS") {
-      if (opts.origin !== "*" || opts.credentials) {
+      if (opts.origin !== "*") {
         set("Vary", "Origin");
       }
       if (opts.maxAge != null) {
@@ -98,7 +95,7 @@ const cors = (options) => {
       });
     }
     await next();
-    if (opts.origin !== "*" || opts.credentials) {
+    if (opts.origin !== "*") {
       c.header("Vary", "Origin", { append: true });
     }
   };

package/node_modules/hono/dist/cjs/middleware/serve-static/index.js

@@ -45,7 +45,7 @@ const serveStatic = (options) => {
     } else {
       try {
         filename = (0, import_url.tryDecodeURI)(c.req.path);
-        if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}/.test(filename)) {
+        if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}|\\/.test(filename)) {
           throw new Error();
         }
       } catch {
@@ -65,7 +65,7 @@ const serveStatic = (options) => {
     if (content instanceof Response) {
       return c.newResponse(content.body, content);
     }
-    if (content) {
+    if (content != null) {
       const mimeType = options.mimes && (0, import_mime.getMimeType)(path, options.mimes) || (0, import_mime.getMimeType)(path);
       c.header("Content-Type", mimeType || "application/octet-stream");
       if (options.precompressed && (!mimeType || import_compress.COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {

package/node_modules/hono/dist/cjs/utils/body.js

@@ -20,18 +20,26 @@ __export(body_exports, {
   parseBody: () => parseBody
 });
 module.exports = __toCommonJS(body_exports);
-var import_request = require("../request");
+var import_buffer = require("./buffer");
+const isRawRequest = (request) => "headers" in request;
 const parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
   const { all = false, dot = false } = options;
-  const headers = request instanceof import_request.HonoRequest ? request.raw.headers : request.headers;
+  const headers = isRawRequest(request) ? request.headers : request.raw.headers;
   const contentType = headers.get("Content-Type");
-  if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) {
+  const mediaType = contentType?.split(";")[0].trim().toLowerCase();
+  if (mediaType === "multipart/form-data" || mediaType === "application/x-www-form-urlencoded") {
     return parseFormData(request, { all, dot });
   }
   return {};
 };
 async function parseFormData(request, options) {
-  const formData = await request.formData();
+  const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+  const arrayBuffer = await request.arrayBuffer();
+  const formDataPromise = (0, import_buffer.bufferToFormData)(arrayBuffer, headers.get("Content-Type") || "");
+  if (!isRawRequest(request)) {
+    request.bodyCache.formData = formDataPromise;
+  }
+  const formData = await formDataPromise;
   if (formData) {
     return convertFormDataToBodyData(formData, options);
   }

package/node_modules/hono/dist/cjs/utils/buffer.js

@@ -88,7 +88,8 @@ const bufferToString = (buffer) => {
 const bufferToFormData = (arrayBuffer, contentType) => {
   const response = new Response(arrayBuffer, {
     headers: {
-      "Content-Type": contentType
+      // Normalize the media type (case-insensitive) while keeping parameters like the boundary
+      "Content-Type": contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase())
     }
   });
   return response.formData();

package/node_modules/hono/dist/cjs/validator/validator.js

@@ -23,9 +23,9 @@ module.exports = __toCommonJS(validator_exports);
 var import_cookie = require("../helper/cookie");
 var import_http_exception = require("../http-exception");
 var import_buffer = require("../utils/buffer");
-const jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
-const multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/;
-const urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
+const jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/i;
+const multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/i;
+const urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/i;
 const validator = (target, validationFunc) => {
   return async (c, next) => {
     let value = {};

package/node_modules/hono/dist/helper/css/common.js

@@ -25,6 +25,7 @@ var normalizeLabel = (label) => {
   return label.trim().replace(/\s+/g, "-");
 };
 var isValidClassName = (name) => /^-?[_a-zA-Z][_a-zA-Z0-9-]*$/.test(name);
+var hasUnsafeSelectorChar = (name) => /[<{}]/.test(name);
 var RESERVED_KEYFRAME_NAMES = /* @__PURE__ */ new Set([
   "default",
   "inherit",
@@ -162,7 +163,8 @@ var cxCommon = (args) => {
         [CLASS_NAME]: "",
         [STYLE_STRING]: "",
         [SELECTORS]: [],
-        [EXTERNAL_CLASS_NAMES]: [arg]
+        // drop names that are unsafe to emit as a selector
+        [EXTERNAL_CLASS_NAMES]: hasUnsafeSelectorChar(arg) ? [] : [arg]
       };
     }
   }