h3-nightly 2.0.1-rc.2 → 3.0.0-20251021-151501-4247682

package/dist/h3.d.mts

@@ -282,7 +282,7 @@ declare class HTTPError<DataT = unknown> extends Error implements ErrorBody<Data
   * @deprecated Use `statusText`
   */
   get statusMessage(): string | undefined;
-  toJSON(): ErrorBody;
+  toJSON(): Omit<ErrorBody, "body"> & ErrorBody["body"];
 }
 //#endregion
 //#region src/types/h3.d.ts

package/dist/h3.mjs

@@ -1,6 +1,5 @@
 import { NullProtoObj as EmptyObject, addRoute, createRouter, findRoute, routeToRegExp } from "rou3";
 import { FastResponse, FastURL } from "srvx";
-import { parse, parseSetCookie, serialize, splitSetCookieString } from "cookie-es";
 
 //#region src/_entries/_common.ts
 function freezeApp(app) {
@@ -1567,10 +1566,10 @@ async function proxy(event, target, opts = {}) {
 		if (key === "content-encoding") continue;
 		if (key === "content-length") continue;
 		if (key === "set-cookie") {
-			cookies.push(...splitSetCookieString(value));
+			cookies.push(value);
 			continue;
 		}
-		headers.set(key, value);
+		headers.append(key, value);
 	}
 	if (cookies.length > 0) {
 		const _cookies = cookies.map((cookie) => {
@@ -1699,6 +1698,178 @@ async function readValidatedBody(event, validate) {
 	return validateData(_body, validate);
 }
 
+//#endregion
+//#region node_modules/.pnpm/cookie-es@2.0.0/node_modules/cookie-es/dist/index.mjs
+function parse(str, options) {
+	if (typeof str !== "string") throw new TypeError("argument str must be a string");
+	const obj = {};
+	const opt = options || {};
+	const dec = opt.decode || decode;
+	let index = 0;
+	while (index < str.length) {
+		const eqIdx = str.indexOf("=", index);
+		if (eqIdx === -1) break;
+		let endIdx = str.indexOf(";", index);
+		if (endIdx === -1) endIdx = str.length;
+		else if (endIdx < eqIdx) {
+			index = str.lastIndexOf(";", eqIdx - 1) + 1;
+			continue;
+		}
+		const key = str.slice(index, eqIdx).trim();
+		if (opt?.filter && !opt?.filter(key)) {
+			index = endIdx + 1;
+			continue;
+		}
+		if (void 0 === obj[key]) {
+			let val = str.slice(eqIdx + 1, endIdx).trim();
+			if (val.codePointAt(0) === 34) val = val.slice(1, -1);
+			obj[key] = tryDecode(val, dec);
+		}
+		index = endIdx + 1;
+	}
+	return obj;
+}
+function decode(str) {
+	return str.includes("%") ? decodeURIComponent(str) : str;
+}
+function tryDecode(str, decode2) {
+	try {
+		return decode2(str);
+	} catch {
+		return str;
+	}
+}
+const fieldContentRegExp = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;
+function serialize(name, value, options) {
+	const opt = options || {};
+	const enc = opt.encode || encodeURIComponent;
+	if (typeof enc !== "function") throw new TypeError("option encode is invalid");
+	if (!fieldContentRegExp.test(name)) throw new TypeError("argument name is invalid");
+	const encodedValue = enc(value);
+	if (encodedValue && !fieldContentRegExp.test(encodedValue)) throw new TypeError("argument val is invalid");
+	let str = name + "=" + encodedValue;
+	if (void 0 !== opt.maxAge && opt.maxAge !== null) {
+		const maxAge = opt.maxAge - 0;
+		if (Number.isNaN(maxAge) || !Number.isFinite(maxAge)) throw new TypeError("option maxAge is invalid");
+		str += "; Max-Age=" + Math.floor(maxAge);
+	}
+	if (opt.domain) {
+		if (!fieldContentRegExp.test(opt.domain)) throw new TypeError("option domain is invalid");
+		str += "; Domain=" + opt.domain;
+	}
+	if (opt.path) {
+		if (!fieldContentRegExp.test(opt.path)) throw new TypeError("option path is invalid");
+		str += "; Path=" + opt.path;
+	}
+	if (opt.expires) {
+		if (!isDate(opt.expires) || Number.isNaN(opt.expires.valueOf())) throw new TypeError("option expires is invalid");
+		str += "; Expires=" + opt.expires.toUTCString();
+	}
+	if (opt.httpOnly) str += "; HttpOnly";
+	if (opt.secure) str += "; Secure";
+	if (opt.priority) {
+		const priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
+		switch (priority) {
+			case "low": {
+				str += "; Priority=Low";
+				break;
+			}
+			case "medium": {
+				str += "; Priority=Medium";
+				break;
+			}
+			case "high": {
+				str += "; Priority=High";
+				break;
+			}
+			default: throw new TypeError("option priority is invalid");
+		}
+	}
+	if (opt.sameSite) {
+		const sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
+		switch (sameSite) {
+			case true: {
+				str += "; SameSite=Strict";
+				break;
+			}
+			case "lax": {
+				str += "; SameSite=Lax";
+				break;
+			}
+			case "strict": {
+				str += "; SameSite=Strict";
+				break;
+			}
+			case "none": {
+				str += "; SameSite=None";
+				break;
+			}
+			default: throw new TypeError("option sameSite is invalid");
+		}
+	}
+	if (opt.partitioned) str += "; Partitioned";
+	return str;
+}
+function isDate(val) {
+	return Object.prototype.toString.call(val) === "[object Date]" || val instanceof Date;
+}
+function parseSetCookie(setCookieValue, options) {
+	const parts = (setCookieValue || "").split(";").filter((str) => typeof str === "string" && !!str.trim());
+	const nameValuePairStr = parts.shift() || "";
+	const parsed = _parseNameValuePair(nameValuePairStr);
+	const name = parsed.name;
+	let value = parsed.value;
+	try {
+		value = options?.decode === false ? value : (options?.decode || decodeURIComponent)(value);
+	} catch {}
+	const cookie = {
+		name,
+		value
+	};
+	for (const part of parts) {
+		const sides = part.split("=");
+		const partKey = (sides.shift() || "").trimStart().toLowerCase();
+		const partValue = sides.join("=");
+		switch (partKey) {
+			case "expires": {
+				cookie.expires = new Date(partValue);
+				break;
+			}
+			case "max-age": {
+				cookie.maxAge = Number.parseInt(partValue, 10);
+				break;
+			}
+			case "secure": {
+				cookie.secure = true;
+				break;
+			}
+			case "httponly": {
+				cookie.httpOnly = true;
+				break;
+			}
+			case "samesite": {
+				cookie.sameSite = partValue;
+				break;
+			}
+			default: cookie[partKey] = partValue;
+		}
+	}
+	return cookie;
+}
+function _parseNameValuePair(nameValuePairStr) {
+	let name = "";
+	let value = "";
+	const nameValueArr = nameValuePairStr.split("=");
+	if (nameValueArr.length > 1) {
+		name = nameValueArr.shift();
+		value = nameValueArr.join("=");
+	} else value = nameValuePairStr;
+	return {
+		name,
+		value
+	};
+}
+
 //#endregion
 //#region src/utils/cookie.ts
 const CHUNKED_COOKIE = "__chunked__";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "h3-nightly",
-  "version": "2.0.1-rc.2",
+  "version": "3.0.0-20251021-151501-4247682",
   "description": "Minimal H(TTP) framework built for high performance and portability.",
   "homepage": "https://h3.dev",
   "repository": "h3js/h3",
@@ -48,39 +48,40 @@
     "h3": "link:."
   },
   "dependencies": {
-    "cookie-es": "^2.0.0",
-    "fetchdts": "^0.1.7",
-    "rou3": "^0.7.7",
-    "srvx": "^0.8.15"
+    "rou3": "^0.7.8",
+    "srvx": "^0.9.1"
   },
   "devDependencies": {
     "@mitata/counters": "^0.0.8",
     "@types/connect": "^3.4.38",
     "@types/express": "^5.0.3",
-    "@types/node": "^24.7.0",
+    "@types/node": "^24.9.1",
     "@types/react": "^19.2.2",
-    "@types/react-dom": "^19.2.1",
+    "@types/react-dom": "^19.2.2",
     "@vitest/coverage-v8": "^3.2.4",
     "automd": "^0.4.2",
     "changelogen": "^0.6.2",
     "connect": "^3.7.0",
+    "cookie-es": "^2.0.0",
     "crossws": "^0.4.1",
-    "elysia": "^1.4.9",
-    "esbuild": "^0.25.10",
-    "eslint": "^9.37.0",
+    "elysia": "^1.4.12",
+    "esbuild": "^0.25.11",
+    "eslint": "^9.38.0",
     "eslint-config-unjs": "^0.5.0",
     "express": "^5.1.0",
+    "fetchdts": "^0.1.7",
     "get-port-please": "^3.2.0",
-    "h3-nightly": "latest",
+    "h3-nightly": "^2.0.1-20251021-150207-c090e78",
     "h3-v1": "npm:h3@^1.15.4",
-    "hono": "^4.9.10",
+    "hono": "^4.10.1",
+    "memoirist": "^0.4.0",
     "mitata": "^1.0.34",
     "obuild": "^0.2.1",
     "prettier": "^3.6.2",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "typescript": "^5.9.3",
-    "vite": "^7.1.9",
+    "vite": "^7.1.11",
     "vitest": "^3.2.4",
     "zod": "^4.1.12"
   },
@@ -92,7 +93,7 @@
       "optional": true
     }
   },
-  "packageManager": "pnpm@10.17.1",
+  "packageManager": "pnpm@10.19.0",
   "engines": {
     "node": ">=20.11.1"
   }