@mpen/routekit 0.1.0 → 0.1.2

package/dist/request-Dn0zc-xm.mjs

@@ -0,0 +1,1025 @@
+import { a as response } from "./core-DbmQauwS.mjs";
+import { CommonContentTypes, CommonHeaders, HttpStatus, StatusText } from "@mpen/http";
+//#region src/router/lib/charset.ts
+/**
+* Normalize a charset label to a lowercase "Preferred MIME Name" where possible.
+*
+* - Charset comparison is case-insensitive (IANA).
+* - Uses Preferred MIME Names when mapped.
+* - Unknown charsets return a cleaned lowercase form.
+*/
+function normalizeCharsetName(input) {
+	if (!input?.length) return "";
+	const raw = input.trim();
+	if (raw.length === 0) return "";
+	const keyA = normalizeKey(raw);
+	const hitA = ALIAS_TO_PREFERRED_LOWER.get(keyA);
+	if (hitA) return hitA;
+	const keyB = stripKey(keyA);
+	const hitB = STRIPPED_ALIAS_TO_PREFERRED_LOWER.get(keyB);
+	if (hitB) return hitB;
+	return keyA;
+}
+function normalizeKey(s) {
+	return s.trim().toLowerCase().replace(/\s+/g, "").replace(/_/g, "-");
+}
+function stripKey(s) {
+	return s.replace(/[^a-z0-9]+/g, "");
+}
+/**
+* Minimal, practical alias set.
+* Extend this map as needed (ideally generated from IANA CSV for full coverage). :contentReference[oaicite:5]{index=5}
+*/
+const ALIAS_TO_PREFERRED_LOWER = new Map([
+	["utf-8", "utf-8"],
+	["utf8", "utf-8"],
+	["unicode-1-1-utf-8", "utf-8"],
+	["utf-16", "utf-16"],
+	["utf16", "utf-16"],
+	["utf-16le", "utf-16le"],
+	["utf-16be", "utf-16be"],
+	["us-ascii", "us-ascii"],
+	["ascii", "us-ascii"],
+	["ansi_x3.4-1968", "us-ascii"],
+	["ansi_x3.4-1986", "us-ascii"],
+	["iso646-us", "us-ascii"],
+	["cp367", "us-ascii"],
+	["ibm367", "us-ascii"],
+	["iso-8859-1", "iso-8859-1"],
+	["iso_8859-1:1987", "iso-8859-1"],
+	["iso_8859-1", "iso-8859-1"],
+	["latin1", "iso-8859-1"],
+	["l1", "iso-8859-1"],
+	["cp819", "iso-8859-1"],
+	["ibm819", "iso-8859-1"],
+	["iso-8859-2", "iso-8859-2"],
+	["latin2", "iso-8859-2"],
+	["l2", "iso-8859-2"],
+	["iso-8859-3", "iso-8859-3"],
+	["latin3", "iso-8859-3"],
+	["l3", "iso-8859-3"],
+	["iso-8859-4", "iso-8859-4"],
+	["latin4", "iso-8859-4"],
+	["l4", "iso-8859-4"],
+	["iso-8859-5", "iso-8859-5"],
+	["cyrillic", "iso-8859-5"],
+	["iso-8859-6", "iso-8859-6"],
+	["arabic", "iso-8859-6"],
+	["iso-8859-7", "iso-8859-7"],
+	["greek", "iso-8859-7"],
+	["greek8", "iso-8859-7"],
+	["iso-8859-8", "iso-8859-8"],
+	["hebrew", "iso-8859-8"],
+	["iso-8859-9", "iso-8859-9"],
+	["latin5", "iso-8859-9"],
+	["l5", "iso-8859-9"],
+	["windows-1252", "windows-1252"],
+	["cp1252", "windows-1252"],
+	["windows-1251", "windows-1251"],
+	["cp1251", "windows-1251"],
+	["shift_jis", "shift_jis"],
+	["shift-jis", "shift_jis"],
+	["sjis", "shift_jis"],
+	["ms_kanji", "shift_jis"],
+	["euc-jp", "euc-jp"],
+	["eucjp", "euc-jp"],
+	["euc-kr", "euc-kr"],
+	["euckr", "euc-kr"],
+	["iso-2022-jp", "iso-2022-jp"],
+	["iso-2022-kr", "iso-2022-kr"],
+	["big5", "big5"],
+	["gbk", "gbk"],
+	["gb18030", "gb18030"]
+]);
+const STRIPPED_ALIAS_TO_PREFERRED_LOWER = new Map(Array.from(ALIAS_TO_PREFERRED_LOWER.entries(), ([k, v]) => [stripKey(k), v]));
+//#endregion
+//#region src/router/lib/media-type.ts
+const tokenPattern = /^[!#$%&'*+.^_`|~0-9a-z-]+$/i;
+const rangeTokenPattern = /^(?:\*|[!#$%&'*+.^_`|~0-9a-z-]+)$/i;
+function normalizeToken(value) {
+	return value.trim();
+}
+function normalizeType(value) {
+	return normalizeToken(value).toLowerCase();
+}
+function isValidType(value, allowRange) {
+	const [type, subtype, extra] = value.split("/");
+	if (!type || !subtype || extra !== void 0) return false;
+	if (!allowRange && (type.includes("*") || subtype.includes("*"))) return false;
+	const pattern = allowRange ? rangeTokenPattern : tokenPattern;
+	if (!pattern.test(type) || !pattern.test(subtype)) return false;
+	if (type === "*" && subtype !== "*") return false;
+	return true;
+}
+function splitParameters(value) {
+	const parts = [];
+	let current = "";
+	let inQuote = false;
+	let escaped = false;
+	for (const char of value) {
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\" && inQuote) {
+			escaped = true;
+			current += char;
+			continue;
+		}
+		if (char === "\"") {
+			inQuote = !inQuote;
+			current += char;
+			continue;
+		}
+		if (char === ";" && !inQuote) {
+			parts.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	parts.push(current);
+	return parts;
+}
+function unquote(value) {
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("\"") || !trimmed.endsWith("\"")) return trimmed;
+	return trimmed.slice(1, -1).replace(/\\(["\\])/g, "$1");
+}
+function parseParameterizedMediaType(value, options) {
+	const [rawType = "", ...rawParams] = splitParameters(value);
+	const type = normalizeType(rawType);
+	if (!type || !isValidType(type, options.allowRange)) return null;
+	const parameters = {};
+	const result = { type };
+	for (const param of rawParams) {
+		const separatorIndex = param.indexOf("=");
+		if (separatorIndex <= 0) continue;
+		const key = param.slice(0, separatorIndex).trim().toLowerCase();
+		if (!key || !tokenPattern.test(key)) continue;
+		const paramValue = unquote(param.slice(separatorIndex + 1));
+		parameters[key] = paramValue;
+		if (key === "charset") result.charset = normalizeCharsetName(paramValue);
+		if (key === "boundary") result.boundary = paramValue;
+	}
+	const extraParameters = Object.fromEntries(Object.entries(parameters).filter(([key]) => key !== "charset" && key !== "boundary"));
+	if (Object.keys(extraParameters).length > 0) result.parameters = extraParameters;
+	return result;
+}
+function parseMediaRange(value) {
+	return parseParameterizedMediaType(value, { allowRange: true });
+}
+function normalizeQuality(value) {
+	if (value === void 0) return 1;
+	const q = typeof value === "number" ? value : Number.parseFloat(value);
+	return Number.isFinite(q) && q >= 0 && q <= 1 ? q : 1;
+}
+function formatContentType(value) {
+	const params = [];
+	if (value.charset) params.push(`charset=${value.charset}`);
+	if (value.boundary) params.push(`boundary=${value.boundary}`);
+	for (const [key, paramValue] of Object.entries(value.parameters ?? {})) {
+		if (key === "q") continue;
+		params.push(`${key}=${paramValue}`);
+	}
+	return [value.type, ...params].join("; ");
+}
+/**
+* Normalize a concrete media type.
+*
+* @param value - Media type to normalize.
+* @returns Normalized media type.
+*/
+function normalizeMediaType(value) {
+	const type = normalizeType(value.type);
+	const charset = value.charset ? normalizeCharsetName(value.charset) : void 0;
+	const boundary = value.boundary ? normalizeToken(value.boundary) : void 0;
+	const parameters = value.parameters ? Object.fromEntries(Object.entries(value.parameters).map(([key, paramValue]) => [key.trim().toLowerCase(), paramValue.trim()])) : void 0;
+	const result = { type };
+	if (charset) result.charset = charset;
+	if (boundary) result.boundary = boundary;
+	if (parameters && Object.keys(parameters).length > 0) result.parameters = parameters;
+	return result;
+}
+/**
+* Parse a single HTTP `Content-Type` header value.
+*
+* @param value - Header value to parse.
+* @returns Parsed content type, or `null` when the value is invalid or missing.
+*/
+function parseContentType(value) {
+	if (!value) return null;
+	return parseParameterizedMediaType(value, { allowRange: false });
+}
+/**
+* Parse a concrete media type value.
+*
+* @param value - Media type value to parse.
+* @returns Parsed media type, or `null` when the value is invalid.
+*/
+function parseMediaType(value) {
+	return parseContentType(value);
+}
+/**
+* Return the preference weight from an Accept-style media range.
+*
+* @param value - Media range value to inspect.
+* @returns The parsed `q` value, or `1` when none is provided.
+*/
+function mediaRangeQuality(value) {
+	if (typeof value !== "string") return normalizeQuality("q" in value ? value.q : value.parameters?.q);
+	return normalizeQuality(parseMediaRange(value)?.parameters?.q);
+}
+/**
+* Format an Accept-style media range as a concrete `Content-Type`.
+*
+* @param value - Media range value to format.
+* @returns The media type without any `q` preference parameter, or `null` when invalid.
+*/
+function mediaRangeToContentType(value) {
+	const parsed = typeof value === "string" ? parseMediaRange(value) : normalizeMediaType(value);
+	if (!parsed) return null;
+	return formatContentType(parsed);
+}
+/**
+* Parse an Accept header into quality-sorted media ranges.
+*
+* @param value - Accept header value to parse.
+* @returns Media ranges sorted by descending `q` values, preserving original order for ties.
+*/
+function parseAcceptHeader(value) {
+	const entries = [];
+	for (const [index, entry] of (value ?? "").split(",").entries()) {
+		const parsed = parseMediaRange(entry.trim());
+		if (!parsed) continue;
+		const qParameter = parsed.parameters?.q;
+		const parsedQ = qParameter === void 0 ? 1 : Number.parseFloat(qParameter);
+		const q = Number.isFinite(parsedQ) && parsedQ >= 0 && parsedQ <= 1 ? parsedQ : 1;
+		const parameters = { ...parsed.parameters ?? {} };
+		delete parameters.q;
+		const media = {
+			...parsed,
+			q
+		};
+		delete media.parameters;
+		if (Object.keys(parameters).length > 0) media.parameters = parameters;
+		entries.push({
+			media,
+			index
+		});
+	}
+	entries.sort((a, b) => {
+		if (b.media.q !== a.media.q) return b.media.q - a.media.q;
+		return a.index - b.index;
+	});
+	return entries.map((entry) => {
+		const { parameters, ...media } = entry.media;
+		return parameters && Object.keys(parameters).length > 0 ? {
+			...media,
+			parameters
+		} : media;
+	});
+}
+/**
+* Test whether a media type is a JSON document type.
+*
+* @param value - Content type or header value to inspect.
+* @returns Whether the media type is `application/json` or an `application/*+json` type.
+*/
+function isJsonContentType(value) {
+	const contentType = typeof value === "string" ? parseContentType(value) : value;
+	if (!contentType) return false;
+	const [type, subtype] = contentType.type.split("/", 2);
+	return type === "application" && (subtype === "json" || subtype.endsWith("+json"));
+}
+/**
+* Test whether an accepted concrete media type matches an incoming content type.
+*
+* @param accept - Media type accepted by a route.
+* @param contentType - Incoming request content type.
+* @returns Whether the accepted media type matches the content type.
+*/
+function mediaTypeMatches(accept, contentType) {
+	const normalizedAccept = normalizeMediaType(accept);
+	const normalizedContent = normalizeMediaType(contentType);
+	if (normalizedAccept.type !== normalizedContent.type) return false;
+	if (normalizedAccept.charset && normalizedContent.charset) {
+		if (normalizeCharsetName(normalizedAccept.charset) !== normalizeCharsetName(normalizedContent.charset)) return false;
+	}
+	if (normalizedAccept.boundary && normalizedContent.boundary) {
+		if (normalizedAccept.boundary !== normalizedContent.boundary) return false;
+	}
+	return true;
+}
+/**
+* Test whether an HTTP media range accepts a concrete media type.
+*
+* @param range - Accept-style media range.
+* @param mediaType - Concrete media type to test.
+* @returns Whether the range accepts the media type.
+*/
+function mediaRangeAccepts(range, mediaType) {
+	const parsedRange = typeof range === "string" ? parseMediaRange(range) : normalizeMediaType(range);
+	const produced = typeof mediaType === "string" ? parseContentType(mediaType) : mediaType;
+	if (!parsedRange || !produced) return false;
+	const normalizedRange = parsedRange.type.toLowerCase();
+	const normalizedProduced = produced.type.toLowerCase();
+	if (normalizedRange === "*/*") return true;
+	if (normalizedRange === normalizedProduced) return true;
+	const [rangeType, rangeSubtype] = normalizedRange.split("/", 2);
+	const [producedType, producedSubtype] = normalizedProduced.split("/", 2);
+	if (!rangeType || !rangeSubtype || !producedType || !producedSubtype) return false;
+	if (rangeSubtype === "*" && rangeType === producedType) return true;
+	if (rangeSubtype.startsWith("*+")) return rangeType === producedType && producedSubtype.endsWith(rangeSubtype.slice(1));
+	return false;
+}
+//#endregion
+//#region src/router/lib/schema-merge.ts
+function unionJsonSchemas(left, right) {
+	return { anyOf: [left, right] };
+}
+/**
+* Merge route schema contributions from routes and middleware.
+*
+* Response declarations at the same status are alternatives. Request declarations describe
+* parsed context fields and therefore may only be declared once within an executed chain.
+*
+* @param schemas - Schema contributions in middleware execution order followed by the route.
+* @returns The combined schema contribution, or `undefined` if none were supplied.
+*/
+function mergeRouteSchemas(...schemas) {
+	const request = {};
+	const responseBody = {};
+	let hasRequest = false;
+	let hasResponse = false;
+	for (const schema of schemas) {
+		if (!schema) continue;
+		if (schema.request) for (const component of [
+			"query",
+			"path",
+			"body"
+		]) {
+			const declaration = schema.request[component];
+			if (declaration === void 0) continue;
+			if (request[component] !== void 0) throw new Error(`Multiple middleware or route schemas declare request.${component}.`);
+			request[component] = declaration;
+			hasRequest = true;
+		}
+		for (const [status, declaration] of Object.entries(schema.response?.body ?? {})) {
+			if (declaration === void 0) continue;
+			const normalizedStatus = status === "default" ? status : Number(status);
+			const existing = responseBody[normalizedStatus];
+			responseBody[normalizedStatus] = existing === void 0 ? declaration : unionJsonSchemas(existing, declaration);
+			hasResponse = true;
+		}
+	}
+	if (!hasRequest && !hasResponse) return void 0;
+	return {
+		...hasRequest ? { request } : {},
+		...hasResponse ? { response: { body: responseBody } } : {}
+	};
+}
+//#endregion
+//#region src/router/response/directives.ts
+const routekitDirectiveBrand = Symbol("RoutekitDirective");
+/**
+* Test whether a value is a generator directive.
+*
+* @example
+* ```ts
+* if (isRoutekitDirective(value)) console.log(value.kind)
+* ```
+*
+* @param value - Value to inspect.
+* @returns Whether `value` is a Routekit generator directive.
+*/
+function isRoutekitDirective(value) {
+	return !!value && value[routekitDirectiveBrand] === true;
+}
+/**
+* Test whether a value is a status directive.
+*
+* @param value - Value to inspect.
+* @returns Whether `value` was created by [`status`]{@link status}.
+*/
+function isStatusDirective(value) {
+	return isRoutekitDirective(value) && value.kind === "status";
+}
+/**
+* Test whether a value is a headers directive.
+*
+* @param value - Value to inspect.
+* @returns Whether `value` was created by [`headers`]{@link headers}.
+*/
+function isHeadersDirective(value) {
+	return isRoutekitDirective(value) && value.kind === "headers";
+}
+/**
+* Test whether a value is a head directive.
+*
+* @param value - Value to inspect.
+* @returns Whether `value` was created by [`head`]{@link head}.
+*/
+function isHeadDirective(value) {
+	return isRoutekitDirective(value) && value.kind === "head";
+}
+/**
+* Test whether a value is a stream directive.
+*
+* @param value - Value to inspect.
+* @returns Whether `value` was created by [`stream`]{@link stream}.
+*/
+function isStreamDirective(value) {
+	return isRoutekitDirective(value) && value.kind === "stream";
+}
+/**
+* Test whether a value is a chunk directive.
+*
+* @param value - Value to inspect.
+* @returns Whether `value` was created by [`chunk`]{@link chunk}.
+*/
+function isChunkDirective(value) {
+	return isRoutekitDirective(value) && value.kind === "chunk";
+}
+function makeDirective(directive) {
+	return {
+		[routekitDirectiveBrand]: true,
+		...directive
+	};
+}
+/**
+* Create a generator directive that sets the response status.
+*
+* @example
+* ```ts
+* yield status(HttpStatus.ACCEPTED)
+* ```
+*
+* @param statusCode - HTTP status code to use.
+* @returns Status directive.
+*/
+function status(statusCode) {
+	return makeDirective({
+		kind: "status",
+		status: statusCode
+	});
+}
+/**
+* Create a generator directive that merges response headers.
+*
+* @example
+* ```ts
+* yield headers({'cache-control': 'no-store'})
+* ```
+*
+* @param init - Headers to merge into the response.
+* @returns Headers directive.
+*/
+function headers(init) {
+	return makeDirective({
+		kind: "headers",
+		headers: new Headers(init)
+	});
+}
+/**
+* Create a generator directive that sets response status and headers.
+*
+* @example
+* ```ts
+* yield head(HttpStatus.OK, {'cache-control': 'no-store'})
+* ```
+*
+* @param statusCode - HTTP status code to use.
+* @param init - Headers to merge into the response.
+* @returns Head directive.
+*/
+function head(statusCode, init = {}) {
+	return makeDirective({
+		kind: "head",
+		status: statusCode,
+		headers: new Headers(init)
+	});
+}
+/**
+* Create a generator directive that selects a structured stream framer.
+*
+* @example
+* ```ts
+* yield stream(sseFramer())
+* ```
+*
+* @param framer - Stream framer to use for subsequent chunks.
+* @param init - Additional stream headers.
+* @returns Stream directive.
+*/
+function stream(framer, init = {}) {
+	const streamHeaders = new Headers(framer.headers);
+	new Headers(init).forEach((value, key) => streamHeaders.set(key, value));
+	return makeDirective({
+		kind: "stream",
+		framer,
+		headers: streamHeaders
+	});
+}
+/**
+* Create a generator directive that emits one stream chunk.
+*
+* @example
+* ```ts
+* yield chunk({event: 'ready'})
+* ```
+*
+* @param value - Chunk value to stream.
+* @returns Chunk directive.
+*/
+function chunk(value) {
+	return makeDirective({
+		kind: "chunk",
+		value
+	});
+}
+//#endregion
+//#region src/router/response/framers.ts
+/**
+* Create an SSE stream framer.
+*
+* @example
+* ```ts
+* yield stream(sseFramer())
+* yield chunk({event: 'ready'})
+* ```
+*
+* @returns Stream framer for `text/event-stream`.
+*/
+function sseFramer() {
+	return {
+		contentType: "text/event-stream; charset=utf-8",
+		headers: {
+			[CommonHeaders.CACHE_CONTROL]: "no-cache",
+			[CommonHeaders.CONNECTION]: "keep-alive"
+		},
+		frame: (value) => `data: ${JSON.stringify(value) ?? "null"}\n\n`
+	};
+}
+/**
+* Create a JSON Lines stream framer.
+*
+* @example
+* ```ts
+* yield stream(jsonLinesFramer())
+* yield chunk({event: 'ready'})
+* ```
+*
+* @returns Stream framer for `application/jsonl`.
+*/
+function jsonLinesFramer() {
+	return {
+		contentType: "application/jsonl; charset=utf-8",
+		frame: (value) => `${JSON.stringify(value) ?? "null"}\n`
+	};
+}
+//#endregion
+//#region src/router/response/serializers.ts
+/**
+* Create the default JSON response body serializer.
+*
+* @example
+* ```ts
+* const router = new Router().setResponseBodySerializers([jsonResponseBodySerializer()])
+* ```
+*
+* @returns Serializer for `application/json`.
+*/
+function jsonResponseBodySerializer() {
+	return {
+		mediaTypes: [CommonContentTypes.JSON],
+		canSerialize: (_value) => true,
+		serialize: (value) => value === void 0 ? null : JSON.stringify(value)
+	};
+}
+/**
+* Create the default response body serializer list.
+*
+* @example
+* ```ts
+* const serializers = defaultResponseBodySerializers()
+* ```
+*
+* @returns Default response body serializers.
+*/
+function defaultResponseBodySerializers() {
+	return [jsonResponseBodySerializer()];
+}
+//#endregion
+//#region src/router/response/stream.ts
+function createStartStream(fn) {
+	return new ReadableStream({ start(controller) {
+		fn(controller);
+	} });
+}
+function createAsyncStream(fn) {
+	return new ReadableStream({ start(controller) {
+		const writer = { write: controller.enqueue.bind(controller) };
+		Promise.try(fn, writer).then(() => {
+			controller.close();
+		}, (err) => {
+			controller.error(err);
+		});
+	} });
+}
+//#endregion
+//#region src/router/middleware/define.ts
+const declaredMiddlewareBrand = Symbol("DeclaredMiddleware");
+const middlewareActionBrand = Symbol("MiddlewareAction");
+function declarationsSchema(declarations) {
+	if (!declarations) return void 0;
+	const body = Object.fromEntries(Object.entries(declarations).flatMap(([status, declaration]) => declaration ? [[status, declaration.schema]] : []));
+	return Object.keys(body).length > 0 ? { response: { body } } : void 0;
+}
+function middlewareAction(result) {
+	return {
+		[middlewareActionBrand]: true,
+		result
+	};
+}
+function defineMiddleware(options) {
+	const declarations = options.responses;
+	const schema = mergeRouteSchemas(options.schema, declarationsSchema(declarations));
+	const middleware = async (ctx, next) => {
+		const controls = {
+			next,
+			forward: middlewareAction,
+			respond(result) {
+				const declaration = declarations?.[result.status] ?? declarations?.default;
+				if (!declaration) throw new Error(`Middleware returned undeclared response status ${result.status}.`);
+				return middlewareAction(response(declaration.parse(result.body), {
+					status: result.status,
+					headers: result.headers
+				}));
+			}
+		};
+		const action = await options.run(ctx, controls);
+		if (action === void 0) return await next();
+		if (!action[middlewareActionBrand]) throw new TypeError("Declared middleware must return respond(...) or forward(...).");
+		return action.result;
+	};
+	Object.defineProperties(middleware, {
+		[declaredMiddlewareBrand]: { value: true },
+		schema: { value: schema },
+		schemaAppliesTo: { value: options.schemaAppliesTo }
+	});
+	return middleware;
+}
+/**
+* Test whether a middleware value carries schema declarations.
+*
+* @param value - Middleware value to inspect.
+* @returns Whether `value` was created by [`defineMiddleware`]{@link defineMiddleware}.
+* @internal
+*/
+function isDeclaredMiddleware(value) {
+	return typeof value === "function" && value[declaredMiddlewareBrand] === true;
+}
+//#endregion
+//#region src/router/request.ts
+/**
+* Error thrown when Routekit cannot read or parse a request body.
+*
+* @example
+* ```ts
+* throw new RequestBodyError('Unsupported body', HttpStatus.UNSUPPORTED_MEDIA_TYPE)
+* ```
+*/
+var RequestBodyError = class extends Error {
+	/**
+	* HTTP status code that should be returned for this request body failure.
+	*/
+	status;
+	/**
+	* Create a request body error.
+	*
+	* @param message - Error message.
+	* @param status - HTTP status code for the failure.
+	*/
+	constructor(message, status) {
+		super(message);
+		this.name = "RequestBodyError";
+		this.status = status;
+	}
+};
+/**
+* Error thrown when no registered parser accepts the request `Content-Type`.
+*
+* @example
+* ```ts
+* throw new UnsupportedRequestBodyMediaTypeError('image/png')
+* ```
+*/
+var UnsupportedRequestBodyMediaTypeError = class extends RequestBodyError {
+	/**
+	* Incoming `Content-Type` value that was rejected.
+	*/
+	contentType;
+	/**
+	* Create an unsupported media type error.
+	*
+	* @param contentType - Incoming content type, when present.
+	*/
+	constructor(contentType) {
+		super(contentType ? `Unsupported request body media type: ${contentType}` : "Request body is missing Content-Type.", HttpStatus.UNSUPPORTED_MEDIA_TYPE);
+		this.name = "UnsupportedRequestBodyMediaTypeError";
+		this.contentType = contentType;
+	}
+};
+/**
+* Error thrown when a request body exceeds a configured byte limit.
+*
+* @example
+* ```ts
+* throw new RequestBodyTooLargeError(1024, 2048)
+* ```
+*/
+var RequestBodyTooLargeError = class extends RequestBodyError {
+	/**
+	* Maximum allowed body size in bytes.
+	*/
+	maxSize;
+	/**
+	* Number of bytes received before the limit failed.
+	*/
+	received;
+	/**
+	* Create a body-too-large error.
+	*
+	* @param maxSize - Maximum allowed body size in bytes.
+	* @param received - Number of bytes received.
+	*/
+	constructor(maxSize, received) {
+		super(`Payload exceeded ${maxSize} bytes`, HttpStatus.PAYLOAD_TOO_LARGE);
+		this.name = "RequestBodyTooLargeError";
+		this.maxSize = maxSize;
+		this.received = received;
+	}
+};
+/**
+* Error thrown when `Content-Length` does not match the streamed body size.
+*
+* @example
+* ```ts
+* throw new RequestBodyLengthMismatchError(4, 3)
+* ```
+*/
+var RequestBodyLengthMismatchError = class extends RequestBodyError {
+	/**
+	* Expected byte count from `Content-Length`.
+	*/
+	expected;
+	/**
+	* Actual byte count read from the stream.
+	*/
+	received;
+	/**
+	* Create a content-length mismatch error.
+	*
+	* @param expected - Expected byte count.
+	* @param received - Actual byte count.
+	*/
+	constructor(expected, received) {
+		super(`Content-Length ${expected} bytes did not match ${received} bytes`, HttpStatus.BAD_REQUEST);
+		this.name = "RequestBodyLengthMismatchError";
+		this.expected = expected;
+		this.received = received;
+	}
+};
+var DefaultRoutekitRequestBody = class DefaultRoutekitRequestBody {
+	contentType;
+	#raw;
+	#headers;
+	#stream;
+	#parsers;
+	#arrayBufferPromise;
+	#textPromise;
+	#formDataPromise;
+	#parsePromise;
+	constructor(options) {
+		this.#raw = options.raw;
+		this.#headers = options.headers;
+		this.#stream = options.stream;
+		this.#parsers = options.parsers;
+		this.contentType = parseContentType(options.headers.get(CommonHeaders.CONTENT_TYPE));
+	}
+	get headers() {
+		return this.#headers;
+	}
+	stream() {
+		return this.#stream;
+	}
+	withStream(stream) {
+		return new DefaultRoutekitRequestBody({
+			raw: this.#raw,
+			headers: this.#headers,
+			stream,
+			parsers: this.#parsers
+		});
+	}
+	async parse() {
+		if (!this.#stream) return void 0;
+		this.#parsePromise ??= this.#parse();
+		return await this.#parsePromise;
+	}
+	async json() {
+		return JSON.parse(await this.text());
+	}
+	text() {
+		this.#textPromise ??= this.arrayBuffer().then((buffer) => new TextDecoder().decode(buffer));
+		return this.#textPromise;
+	}
+	arrayBuffer() {
+		this.#arrayBufferPromise ??= new Response(this.#stream).arrayBuffer();
+		return this.#arrayBufferPromise;
+	}
+	formData() {
+		return this.#formDataPromise ??= new Response(this.#stream, { headers: this.#headers }).formData();
+	}
+	async #parse() {
+		const parser = this.#selectParser();
+		if (!parser) throw new UnsupportedRequestBodyMediaTypeError(this.#headers.get(CommonHeaders.CONTENT_TYPE));
+		try {
+			return await parser.parse(this);
+		} catch (error) {
+			if (error instanceof RequestBodyError) throw error;
+			throw new RequestBodyError(error instanceof Error ? error.message : String(error), HttpStatus.BAD_REQUEST);
+		}
+	}
+	#parserQuality(parser) {
+		let bestQuality = parser.canParse?.(this.contentType) ? 1 : 0;
+		if (this.contentType) {
+			for (const mediaType of parser.mediaTypes) if (mediaRangeAccepts(mediaType, this.contentType)) bestQuality = Math.max(bestQuality, mediaRangeQuality(mediaType));
+		}
+		return bestQuality > 0 ? bestQuality : null;
+	}
+	#selectParser() {
+		let best = null;
+		for (const parser of this.#parsers) {
+			const quality = this.#parserQuality(parser);
+			if (quality == null) continue;
+			if (!best || quality > best.quality) best = {
+				parser,
+				quality
+			};
+		}
+		return best?.parser ?? null;
+	}
+};
+var DefaultRoutekitRequest = class DefaultRoutekitRequest {
+	raw;
+	url;
+	method;
+	headers;
+	signal;
+	body;
+	constructor(raw, url, body) {
+		this.raw = raw;
+		this.url = url;
+		this.method = raw.method;
+		this.headers = raw.headers;
+		this.signal = raw.signal;
+		this.body = body;
+	}
+	withBody(body) {
+		return new DefaultRoutekitRequest(this.raw, this.url, body);
+	}
+};
+function readParams(searchParams) {
+	const query = {};
+	for (const [key, value] of searchParams.entries()) {
+		const existing = query[key];
+		if (existing === void 0) {
+			query[key] = value;
+			continue;
+		}
+		if (Array.isArray(existing)) existing.push(value);
+		else query[key] = [existing, value];
+	}
+	return query;
+}
+/**
+* Create the default JSON request body parser.
+*
+* @example
+* ```ts
+* const router = new Router().setRequestBodyParsers([jsonRequestBodyParser()])
+* ```
+*
+* @returns Parser for `application/json` and `application/*+json` request bodies.
+*/
+function jsonRequestBodyParser() {
+	return {
+		mediaTypes: ["application/json", "application/*+json;q=0.5"],
+		parse: async (ctx) => JSON.parse(await ctx.text())
+	};
+}
+/**
+* Create the default text request body parser.
+*
+* @example
+* ```ts
+* const router = new Router().setRequestBodyParsers([textRequestBodyParser()])
+* ```
+*
+* @returns Parser for `text/*` request bodies.
+*/
+function textRequestBodyParser() {
+	return {
+		mediaTypes: ["text/*"],
+		parse: (ctx) => ctx.text()
+	};
+}
+/**
+* Create the default URL-encoded form request body parser.
+*
+* @example
+* ```ts
+* const router = new Router().setRequestBodyParsers([urlEncodedRequestBodyParser()])
+* ```
+*
+* @returns Parser for `application/x-www-form-urlencoded` request bodies.
+*/
+function urlEncodedRequestBodyParser() {
+	return {
+		mediaTypes: ["application/x-www-form-urlencoded"],
+		parse: async (ctx) => readParams(new URLSearchParams(await ctx.text()))
+	};
+}
+/**
+* Create the default multipart form request body parser.
+*
+* @example
+* ```ts
+* const router = new Router().setRequestBodyParsers([formDataRequestBodyParser()])
+* ```
+*
+* @returns Parser for `multipart/form-data` request bodies.
+*/
+function formDataRequestBodyParser() {
+	return {
+		mediaTypes: ["multipart/form-data"],
+		parse: (ctx) => ctx.formData()
+	};
+}
+/**
+* Create the default Routekit request body parser list.
+*
+* @example
+* ```ts
+* const parsers = defaultRequestBodyParsers()
+* ```
+*
+* @returns Default parser list.
+*/
+function defaultRequestBodyParsers() {
+	return [
+		jsonRequestBodyParser(),
+		textRequestBodyParser(),
+		urlEncodedRequestBodyParser(),
+		formDataRequestBodyParser()
+	];
+}
+/**
+* Create a Routekit request wrapper for a native Fetch request.
+*
+* @example
+* ```ts
+* const request = createRoutekitRequest(new Request('https://example.com'), new URL('https://example.com'), defaultRequestBodyParsers())
+* ```
+*
+* @param raw - Native Fetch request.
+* @param url - Parsed request URL.
+* @param parsers - Request body parsers.
+* @returns Routekit request wrapper.
+*/
+function createRoutekitRequest(raw, url, parsers) {
+	return new DefaultRoutekitRequest(raw, url, new DefaultRoutekitRequestBody({
+		raw,
+		headers: raw.headers,
+		stream: raw.body,
+		parsers
+	}));
+}
+/**
+* Create a plain response for a request body error.
+*
+* @example
+* ```ts
+* const response = responseFromRequestBodyError(error)
+* ```
+*
+* @param error - Request body error to convert.
+* @returns HTTP response for the body error.
+*/
+function responseFromRequestBodyError(error) {
+	return new Response(StatusText[error.status] ?? error.message, { status: error.status });
+}
+//#endregion
+export { stream as A, parseMediaType as B, isChunkDirective as C, isStatusDirective as D, isRoutekitDirective as E, mediaRangeToContentType as F, mediaTypeMatches as I, normalizeMediaType as L, isJsonContentType as M, mediaRangeAccepts as N, isStreamDirective as O, mediaRangeQuality as P, parseAcceptHeader as R, headers as S, isHeadersDirective as T, jsonResponseBodySerializer as _, createRoutekitRequest as a, chunk as b, jsonRequestBodyParser as c, urlEncodedRequestBodyParser as d, defineMiddleware as f, defaultResponseBodySerializers as g, createStartStream as h, UnsupportedRequestBodyMediaTypeError as i, mergeRouteSchemas as j, status as k, responseFromRequestBodyError as l, createAsyncStream as m, RequestBodyLengthMismatchError as n, defaultRequestBodyParsers as o, isDeclaredMiddleware as p, RequestBodyTooLargeError as r, formDataRequestBodyParser as s, RequestBodyError as t, textRequestBodyParser as u, jsonLinesFramer as v, isHeadDirective as w, head as x, sseFramer as y, parseContentType as z };