hono 4.12.9 → 4.12.18

package/dist/adapter/aws-lambda/handler.js

@@ -62,8 +62,15 @@ var streamHandle = (app) => {
 var handle = (app, { isContentTypeBinary } = { isContentTypeBinary: void 0 }) => {
   return async (event, lambdaContext) => {
     const processor = getProcessor(event);
-    const req = processor.createRequest(event);
-    const requestContext = getRequestContext(event);
+    let req, requestContext;
+    try {
+      req = processor.createRequest(event);
+      requestContext = getRequestContext(event);
+    } catch (error) {
+      console.error("Error processing request:", error);
+      const errorResponse = error instanceof TypeError ? new Response("Invalid request", { status: 400 }) : new Response("Internal Server Error", { status: 500 });
+      return processor.createResult(event, errorResponse, { isContentTypeBinary });
+    }
     const res = await app.fetch(req, {
       event,
       requestContext,

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

@@ -92,8 +92,15 @@ const streamHandle = (app) => {
 const handle = (app, { isContentTypeBinary } = { isContentTypeBinary: void 0 }) => {
   return async (event, lambdaContext) => {
     const processor = getProcessor(event);
-    const req = processor.createRequest(event);
-    const requestContext = getRequestContext(event);
+    let req, requestContext;
+    try {
+      req = processor.createRequest(event);
+      requestContext = getRequestContext(event);
+    } catch (error) {
+      console.error("Error processing request:", error);
+      const errorResponse = error instanceof TypeError ? new Response("Invalid request", { status: 400 }) : new Response("Internal Server Error", { status: 500 });
+      return processor.createResult(event, errorResponse, { isContentTypeBinary });
+    }
     const res = await app.fetch(req, {
       event,
       requestContext,

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

@@ -57,6 +57,23 @@ const toHash = (str) => {
   }
   return "css-" + out;
 };
+const normalizeLabel = (label) => {
+  return label.trim().replace(/\s+/g, "-");
+};
+const isValidClassName = (name) => /^-?[_a-zA-Z][_a-zA-Z0-9-]*$/.test(name);
+const RESERVED_KEYFRAME_NAMES = /* @__PURE__ */ new Set([
+  "default",
+  "inherit",
+  "initial",
+  "none",
+  "revert",
+  "revert-layer",
+  "unset"
+]);
+const isValidKeyframeName = (name) => isValidClassName(name) && !RESERVED_KEYFRAME_NAMES.has(name.toLowerCase());
+const defaultOnInvalidSlug = (slug) => {
+  console.warn(`Invalid slug: ${slug}`);
+};
 const cssStringReStr = [
   '"(?:(?:\\\\[\\s\\S]|[^"\\\\])*)"',
   // double quoted string
@@ -143,13 +160,26 @@ const buildStyleString = (strings, values) => {
   }
   return [label, minify(styleString), selectors, externalClassNames];
 };
-const cssCommon = (strings, values) => {
+const cssCommon = (strings, values, classNameSlug, onInvalidSlug) => {
   let [label, thisStyleString, selectors, externalClassNames] = buildStyleString(strings, values);
   const isPseudoGlobal = isPseudoGlobalSelectorRe.exec(thisStyleString);
   if (isPseudoGlobal) {
     thisStyleString = isPseudoGlobal[1];
   }
-  const selector = (isPseudoGlobal ? PSEUDO_GLOBAL_SELECTOR : "") + toHash(label + thisStyleString);
+  const hash = toHash(label + thisStyleString);
+  let customSlug;
+  if (classNameSlug) {
+    const slug = classNameSlug(hash, normalizeLabel(label), thisStyleString);
+    if (slug) {
+      if (isValidClassName(slug)) {
+        customSlug = slug;
+      } else {
+        ;
+        (onInvalidSlug || defaultOnInvalidSlug)(slug);
+      }
+    }
+  }
+  const selector = (isPseudoGlobal ? PSEUDO_GLOBAL_SELECTOR : "") + (customSlug || hash);
   const className = (isPseudoGlobal ? selectors.map((s) => s[CLASS_NAME]) : [selector, ...externalClassNames]).join(" ");
   return {
     [SELECTOR]: selector,
@@ -174,24 +204,43 @@ const cxCommon = (args) => {
   }
   return args;
 };
-const keyframesCommon = (strings, ...values) => {
+const keyframesCommon = (strings, values, classNameSlug, onInvalidSlug) => {
   const [label, styleString] = buildStyleString(strings, values);
+  const hash = toHash(label + styleString);
+  let customSlug;
+  if (classNameSlug) {
+    const slug = classNameSlug(hash, normalizeLabel(label), styleString);
+    if (slug) {
+      if (isValidKeyframeName(slug)) {
+        customSlug = slug;
+      } else {
+        ;
+        (onInvalidSlug || defaultOnInvalidSlug)(slug);
+      }
+    }
+  }
   return {
     [SELECTOR]: "",
-    [CLASS_NAME]: `@keyframes ${toHash(label + styleString)}`,
+    [CLASS_NAME]: `@keyframes ${customSlug || hash}`,
     [STYLE_STRING]: styleString,
     [SELECTORS]: [],
     [EXTERNAL_CLASS_NAMES]: []
   };
 };
 let viewTransitionNameIndex = 0;
-const viewTransitionCommon = ((strings, values) => {
+const viewTransitionCommon = ((strings, values, classNameSlug, onInvalidSlug) => {
   if (!strings) {
     strings = [`/* h-v-t ${viewTransitionNameIndex++} */`];
   }
-  const content = Array.isArray(strings) ? cssCommon(strings, values) : strings;
+  const content = Array.isArray(strings) ? cssCommon(strings, values, classNameSlug, onInvalidSlug) : strings;
   const transitionName = content[CLASS_NAME];
-  const res = cssCommon(["view-transition-name:", ""], [transitionName]);
+  const res = cssCommon(
+    ["view-transition-name:", ""],
+    // eslint-disable-line @typescript-eslint/no-explicit-any
+    [transitionName],
+    classNameSlug,
+    onInvalidSlug
+  );
   content[CLASS_NAME] = PSEUDO_GLOBAL_SELECTOR + content[CLASS_NAME];
   content[STYLE_STRING] = content[STYLE_STRING].replace(
     /(?<=::view-transition(?:[a-z-]*)\()(?=\))/g,

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

@@ -31,7 +31,11 @@ var import_constants = require("../../jsx/constants");
 var import_css = require("../../jsx/dom/css");
 var import_common = require("./common");
 var import_common2 = require("./common");
-const createCssContext = ({ id }) => {
+const createCssContext = ({
+  id,
+  classNameSlug,
+  onInvalidSlug
+}) => {
   const [cssJsxDomObject, StyleRenderToDom] = (0, import_css.createCssJsxDomObjects)({ id });
   const contextMap = /* @__PURE__ */ new WeakMap();
   const nonceMap = /* @__PURE__ */ new WeakMap();
@@ -94,15 +98,18 @@ const createCssContext = ({ id }) => {
     return promise;
   };
   const css2 = (strings, ...values) => {
-    return newCssClassNameObject((0, import_common.cssCommon)(strings, values));
+    return newCssClassNameObject((0, import_common.cssCommon)(strings, values, classNameSlug, onInvalidSlug));
   };
   const cx2 = (...args) => {
     args = (0, import_common.cxCommon)(args);
     return css2(Array(args.length).fill(""), ...args);
   };
-  const keyframes2 = import_common.keyframesCommon;
+  const keyframes2 = (strings, ...values) => (0, import_common.keyframesCommon)(strings, values, classNameSlug, onInvalidSlug);
   const viewTransition2 = ((strings, ...values) => {
-    return newCssClassNameObject((0, import_common.viewTransitionCommon)(strings, values));
+    return newCssClassNameObject(
+      (0, import_common.viewTransitionCommon)(strings, values, classNameSlug, onInvalidSlug)
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+    );
   });
   const Style2 = ({ children, nonce } = {}) => (0, import_html.raw)(
     `<style id="${id}"${nonce ? ` nonce="${nonce}"` : ""}>${children ? children[import_common.STYLE_STRING] : ""}</style>`,

package/dist/cjs/helper/ssg/ssg.js

@@ -38,16 +38,18 @@ const DEFAULT_CONTENT_TYPE = "text/plain";
 const DEFAULT_OUTPUT_DIR = "./static";
 const generateFilePath = (routePath, outDir, mimeType, extensionMap) => {
   const extension = determineExtension(mimeType, extensionMap);
+  let filePath;
   if (routePath.endsWith(`.${extension}`)) {
-    return (0, import_utils2.joinPaths)(outDir, routePath);
+    filePath = (0, import_utils2.joinPaths)(outDir, routePath);
+  } else if (routePath === "/") {
+    filePath = (0, import_utils2.joinPaths)(outDir, `index.${extension}`);
+  } else if (routePath.endsWith("/")) {
+    filePath = (0, import_utils2.joinPaths)(outDir, routePath, `index.${extension}`);
+  } else {
+    filePath = (0, import_utils2.joinPaths)(outDir, `${routePath}.${extension}`);
   }
-  if (routePath === "/") {
-    return (0, import_utils2.joinPaths)(outDir, `index.${extension}`);
-  }
-  if (routePath.endsWith("/")) {
-    return (0, import_utils2.joinPaths)(outDir, routePath, `index.${extension}`);
-  }
-  return (0, import_utils2.joinPaths)(outDir, `${routePath}.${extension}`);
+  (0, import_utils2.ensureWithinOutDir)(outDir, filePath);
+  return filePath;
 };
 const parseResponseContent = async (response) => {
   const contentType = response.headers.get("Content-Type");
@@ -67,6 +69,8 @@ const defaultExtensionMap = {
   "text/html": "html",
   "text/xml": "xml",
   "application/xml": "xml",
+  "application/atom+xml": "xml",
+  "application/rss+xml": "xml",
   "application/yaml": "yaml"
 };
 const determineExtension = (mimeType, userExtensionMap) => {

package/dist/cjs/helper/ssg/utils.js

@@ -18,6 +18,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 __export(utils_exports, {
   dirname: () => dirname,
+  ensureWithinOutDir: () => ensureWithinOutDir,
   filterStaticGenerateRoutes: () => filterStaticGenerateRoutes,
   isDynamicRoute: () => isDynamicRoute,
   joinPaths: () => joinPaths
@@ -75,9 +76,17 @@ const filterStaticGenerateRoutes = (hono) => {
 const isDynamicRoute = (path) => {
   return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
 };
+const ensureWithinOutDir = (outDir, filePath) => {
+  const normalizedOutDir = joinPaths("/", outDir);
+  const normalizedFilePath = joinPaths("/", filePath);
+  if (normalizedFilePath !== normalizedOutDir && !normalizedFilePath.startsWith(`${normalizedOutDir}/`)) {
+    throw new Error(`Path traversal detected: "${filePath}" is outside the output directory`);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   dirname,
+  ensureWithinOutDir,
   filterStaticGenerateRoutes,
   isDynamicRoute,
   joinPaths

package/dist/cjs/jsx/base.js

@@ -127,6 +127,9 @@ class JSXNode {
   isEscaped = true;
   localContexts;
   constructor(tag, props, children) {
+    if (typeof tag !== "function" && !(0, import_utils.isValidTagName)(tag)) {
+      throw new Error(`Invalid JSX tag name: ${tag}`);
+    }
     this.tag = tag;
     this.props = props;
     this.children = children;
@@ -158,9 +161,12 @@ class JSXNode {
     const props = this.props;
     let { children } = this;
     buffer[0] += `<${tag}`;
-    const normalizeKey = nameSpaceContext && (0, import_context.useContext)(nameSpaceContext) === "svg" ? (key) => toSVGAttributeName((0, import_utils.normalizeIntrinsicElementKey)(key)) : (key) => (0, import_utils.normalizeIntrinsicElementKey)(key);
+    const normalizeKey = tag === "svg" || nameSpaceContext && (0, import_context.useContext)(nameSpaceContext) === "svg" ? (key) => toSVGAttributeName((0, import_utils.normalizeIntrinsicElementKey)(key)) : (key) => (0, import_utils.normalizeIntrinsicElementKey)(key);
     for (let [key, v] of Object.entries(props)) {
       key = normalizeKey(key);
+      if (!(0, import_utils.isValidAttributeName)(key)) {
+        continue;
+      }
       if (key === "children") {
       } else if (key === "style" && typeof v === "object") {
         let styleStr = "";

package/dist/cjs/jsx/dom/css.js

@@ -117,22 +117,29 @@ const createCssJsxDomObjects = ({ id }) => {
   });
   return [cssObject, Style2];
 };
-const createCssContext = ({ id }) => {
+const createCssContext = ({
+  id,
+  classNameSlug,
+  onInvalidSlug
+}) => {
   const [cssObject, Style2] = createCssJsxDomObjects({ id });
   const newCssClassNameObject = (cssClassName) => {
     cssClassName.toString = cssObject.toString;
     return cssClassName;
   };
   const css2 = (strings, ...values) => {
-    return newCssClassNameObject((0, import_common.cssCommon)(strings, values));
+    return newCssClassNameObject((0, import_common.cssCommon)(strings, values, classNameSlug, onInvalidSlug));
   };
   const cx2 = (...args) => {
     args = (0, import_common.cxCommon)(args);
     return css2(Array(args.length).fill(""), ...args);
   };
-  const keyframes2 = import_common.keyframesCommon;
+  const keyframes2 = (strings, ...values) => (0, import_common.keyframesCommon)(strings, values, classNameSlug, onInvalidSlug);
   const viewTransition2 = ((strings, ...values) => {
-    return newCssClassNameObject((0, import_common.viewTransitionCommon)(strings, values));
+    return newCssClassNameObject(
+      (0, import_common.viewTransitionCommon)(strings, values, classNameSlug, onInvalidSlug)
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+    );
   });
   return {
     css: css2,

package/dist/cjs/jsx/dom/render.js

@@ -68,6 +68,17 @@ const getEventSpec = (key) => {
 };
 const toAttributeName = (element, key) => nameSpaceContext && element instanceof SVGElement && /[A-Z]/.test(key) && (key in element.style || // Presentation attributes are findable in style object. "clip-path", "font-size", "stroke-width", etc.
 key.match(/^(?:o|pai|str|u|ve)/)) ? key.replace(/([A-Z])/g, "-$1").toLowerCase() : key;
+const normalizeFormValue = (value) => value === null || value === void 0 || value === false ? null : value;
+const applySelectValue = (select, props) => {
+  if (!("value" in props)) {
+    return;
+  }
+  select.value = normalizeFormValue(props["value"]);
+  if (!select.multiple && select.selectedIndex === -1) {
+    select.selectedIndex = 0;
+  }
+};
+const isIgnorableAttributeError = (error) => error instanceof DOMException && error.name === "InvalidCharacterError";
 const applyProps = (container, attributes, oldAttributes) => {
   attributes ||= {};
   for (let key in attributes) {
@@ -111,18 +122,14 @@ const applyProps = (container, attributes, oldAttributes) => {
       } else {
         if (key === "value") {
           const nodeName = container.nodeName;
-          if (nodeName === "INPUT" || nodeName === "TEXTAREA" || nodeName === "SELECT") {
+          if (nodeName === "SELECT") {
+            continue;
+          } else if (nodeName === "INPUT" || nodeName === "TEXTAREA") {
             ;
-            container.value = value === null || value === void 0 || value === false ? null : value;
+            container.value = normalizeFormValue(value);
             if (nodeName === "TEXTAREA") {
               container.textContent = value;
               continue;
-            } else if (nodeName === "SELECT") {
-              if (container.selectedIndex === -1) {
-                ;
-                container.selectedIndex = 0;
-              }
-              continue;
             }
           }
         } else if (key === "checked" && container.nodeName === "INPUT" || key === "selected" && container.nodeName === "OPTION") {
@@ -130,14 +137,20 @@ const applyProps = (container, attributes, oldAttributes) => {
           container[key] = value;
         }
         const k = toAttributeName(container, key);
-        if (value === null || value === void 0 || value === false) {
-          container.removeAttribute(k);
-        } else if (value === true) {
-          container.setAttribute(k, "");
-        } else if (typeof value === "string" || typeof value === "number") {
-          container.setAttribute(k, value);
-        } else {
-          container.setAttribute(k, value.toString());
+        try {
+          if (value === null || value === void 0 || value === false) {
+            container.removeAttribute(k);
+          } else if (value === true) {
+            container.setAttribute(k, "");
+          } else if (typeof value === "string" || typeof value === "number") {
+            container.setAttribute(k, value);
+          } else {
+            container.setAttribute(k, value.toString());
+          }
+        } catch (e) {
+          if (!isIgnorableAttributeError(e)) {
+            throw e;
+          }
         }
       }
     }
@@ -153,7 +166,13 @@ const applyProps = (container, attributes, oldAttributes) => {
         } else if (key === "ref") {
           refCleanupMap.get(container)?.();
         } else {
-          container.removeAttribute(toAttributeName(container, key));
+          try {
+            container.removeAttribute(toAttributeName(container, key));
+          } catch (e) {
+            if (!isIgnorableAttributeError(e)) {
+              throw e;
+            }
+          }
         }
       }
     }
@@ -291,6 +310,9 @@ const applyNodeObject = (node, container, isNew) => {
         el = child.e ||= child.n ? document.createElementNS(child.n, child.tag) : document.createElement(child.tag);
         applyProps(el, child.props, child.pP);
         applyNodeObject(child, el, isNewLocal);
+        if (child.tag === "select") {
+          applySelectValue(el, child.props);
+        }
       }
     }
     if (child.tag === HONO_PORTAL_ELEMENT) {

package/dist/cjs/jsx/jsx-runtime.js

@@ -31,6 +31,9 @@ var import_html = require("../helper/html");
 var import_html2 = require("../utils/html");
 var import_utils = require("./utils");
 const jsxAttr = (key, v) => {
+  if (!(0, import_utils.isValidAttributeName)(key)) {
+    return (0, import_html.raw)("");
+  }
   const buffer = [`${key}="`];
   if (key === "style" && typeof v === "object") {
     let styleStr = "";

package/dist/cjs/jsx/utils.js

@@ -17,6 +17,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
+  isValidAttributeName: () => isValidAttributeName,
+  isValidTagName: () => isValidTagName,
   normalizeIntrinsicElementKey: () => normalizeIntrinsicElementKey,
   styleObjectForEach: () => styleObjectForEach
 });
@@ -32,19 +34,167 @@ const normalizeElementKeyMap = /* @__PURE__ */ new Map([
   ["formAction", "formaction"]
 ]);
 const normalizeIntrinsicElementKey = (key) => normalizeElementKeyMap.get(key) || key;
+const invalidAttributeNameCharRe = /[\s"'<>/=`\\\x00-\x1f\x7f-\x9f]/;
+const validAttributeNameCache = /* @__PURE__ */ new Set();
+const validAttributeNameCacheMax = 1024;
+const invalidTagNameCharRe = /^[!?]|[\s"'<>/=`\\\x00-\x1f\x7f-\x9f]/;
+const validTagNameCache = /* @__PURE__ */ new Set();
+const validTagNameCacheMax = 256;
+const cacheValidName = (cache, max, name) => {
+  if (cache.size >= max) {
+    cache.clear();
+  }
+  cache.add(name);
+};
+const isValidTagName = (name) => {
+  if (validTagNameCache.has(name)) {
+    return true;
+  }
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (name.length === 0) {
+    return true;
+  }
+  if (invalidTagNameCharRe.test(name)) {
+    return false;
+  }
+  cacheValidName(validTagNameCache, validTagNameCacheMax, name);
+  return true;
+};
+const isValidAttributeName = (name) => {
+  if (validAttributeNameCache.has(name)) {
+    return true;
+  }
+  const len = name.length;
+  if (len === 0) {
+    return false;
+  }
+  for (let i = 0; i < len; i++) {
+    const c = name.charCodeAt(i);
+    if (!(c >= 97 && c <= 122 || // a-z
+    c >= 65 && c <= 90 || // A-Z
+    c >= 48 && c <= 57 || // 0-9
+    c === 45 || // -
+    c === 95 || // _
+    c === 46 || // .
+    c === 58)) {
+      if (!invalidAttributeNameCharRe.test(name)) {
+        cacheValidName(validAttributeNameCache, validAttributeNameCacheMax, name);
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+  cacheValidName(validAttributeNameCache, validAttributeNameCacheMax, name);
+  return true;
+};
+const invalidStylePropertyNameCharRe = /[\s"'():;\\/\[\]{}\x00-\x1f\x7f-\x9f]/;
+const validStylePropertyNameCache = /* @__PURE__ */ new Set();
+const validStylePropertyNameCacheMax = 1024;
+const isValidStylePropertyName = (name) => {
+  if (validStylePropertyNameCache.has(name)) {
+    return true;
+  }
+  const len = name.length;
+  if (len === 0) {
+    return false;
+  }
+  for (let i = 0; i < len; i++) {
+    const c = name.charCodeAt(i);
+    if (!(c >= 97 && c <= 122 || // a-z
+    c >= 65 && c <= 90 || // A-Z
+    c >= 48 && c <= 57 || // 0-9
+    c === 45 || // -
+    c === 95)) {
+      if (!invalidStylePropertyNameCharRe.test(name)) {
+        cacheValidName(validStylePropertyNameCache, validStylePropertyNameCacheMax, name);
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+  cacheValidName(validStylePropertyNameCache, validStylePropertyNameCacheMax, name);
+  return true;
+};
+const unsafeStyleValueCharRe = /[;"'\\/\[\](){}]/;
+const hasUnsafeStyleValue = (value) => {
+  if (!unsafeStyleValueCharRe.test(value)) {
+    return false;
+  }
+  let quote = 0;
+  const blockStack = [];
+  for (let i = 0, len = value.length; i < len; i++) {
+    const c = value.charCodeAt(i);
+    if (c === 92) {
+      if (i === len - 1) {
+        return true;
+      }
+      i++;
+    } else if (quote !== 0) {
+      if (c === 10 || c === 12 || c === 13) {
+        return true;
+      }
+      if (c === quote) {
+        quote = 0;
+      }
+    } else if (c === 47 && value.charCodeAt(i + 1) === 42) {
+      const end = value.indexOf("*/", i + 2);
+      if (end === -1) {
+        return true;
+      }
+      i = end + 1;
+    } else if (c === 34 || c === 39) {
+      quote = c;
+    } else if (c === 40) {
+      blockStack.push(41);
+    } else if (c === 91) {
+      blockStack.push(93);
+    } else if (c === 123 || c === 125) {
+      return true;
+    } else if (c === 41 || c === 93) {
+      if (blockStack[blockStack.length - 1] !== c) {
+        return true;
+      }
+      blockStack.pop();
+    } else if (c === 59 && blockStack.length === 0) {
+      return true;
+    }
+  }
+  return quote !== 0 || blockStack.length !== 0;
+};
 const styleObjectForEach = (style, fn) => {
   for (const [k, v] of Object.entries(style)) {
     const key = k[0] === "-" || !/[A-Z]/.test(k) ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-    fn(
-      key,
-      v == null ? null : typeof v === "number" ? !key.match(
+    if (!isValidStylePropertyName(key)) {
+      continue;
+    }
+    if (v == null) {
+      fn(key, null);
+      continue;
+    }
+    let value;
+    if (typeof v === "number") {
+      value = !key.match(
         /^(?:a|border-im|column(?:-c|s)|flex(?:$|-[^b])|grid-(?:ar|[^a])|font-w|li|or|sca|st|ta|wido|z)|ty$/
-      ) ? `${v}px` : `${v}` : v
-    );
+      ) ? `${v}px` : `${v}`;
+    } else if (typeof v === "string") {
+      if (hasUnsafeStyleValue(v)) {
+        continue;
+      }
+      value = v;
+    } else {
+      continue;
+    }
+    fn(key, value);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  isValidAttributeName,
+  isValidTagName,
   normalizeIntrinsicElementKey,
   styleObjectForEach
 });

package/dist/cjs/middleware/body-limit/index.js

@@ -22,12 +22,6 @@ __export(body_limit_exports, {
 module.exports = __toCommonJS(body_limit_exports);
 var import_http_exception = require("../../http-exception");
 const ERROR_MESSAGE = "Payload Too Large";
-class BodyLimitError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BodyLimitError";
-  }
-}
 const bodyLimit = (options) => {
   const onError = options.onError || (() => {
     const res = new Response(ERROR_MESSAGE, {
@@ -42,40 +36,37 @@ const bodyLimit = (options) => {
     }
     const hasTransferEncoding = c.req.raw.headers.has("transfer-encoding");
     const hasContentLength = c.req.raw.headers.has("content-length");
-    if (hasTransferEncoding && hasContentLength) {
-    }
     if (hasContentLength && !hasTransferEncoding) {
       const contentLength = parseInt(c.req.raw.headers.get("content-length") || "0", 10);
       return contentLength > maxSize ? onError(c) : next();
     }
     let size = 0;
+    const chunks = [];
     const rawReader = c.req.raw.body.getReader();
-    const reader = new ReadableStream({
-      async start(controller) {
-        try {
-          for (; ; ) {
-            const { done, value } = await rawReader.read();
-            if (done) {
-              break;
-            }
-            size += value.length;
-            if (size > maxSize) {
-              controller.error(new BodyLimitError(ERROR_MESSAGE));
-              break;
-            }
-            controller.enqueue(value);
+    for (; ; ) {
+      const { done, value } = await rawReader.read();
+      if (done) {
+        break;
+      }
+      size += value.length;
+      if (size > maxSize) {
+        return onError(c);
+      }
+      chunks.push(value);
+    }
+    const requestInit = {
+      body: new ReadableStream({
+        start(controller) {
+          for (const chunk of chunks) {
+            controller.enqueue(chunk);
           }
-        } finally {
           controller.close();
         }
-      }
-    });
-    const requestInit = { body: reader, duplex: "half" };
+      }),
+      duplex: "half"
+    };
     c.req.raw = new Request(c.req.raw, requestInit);
-    await next();
-    if (c.error instanceof BodyLimitError) {
-      c.res = await onError(c);
-    }
+    return next();
   };
 };
 // Annotate the CommonJS export names for ESM import in node: