@znight/http 0.0.0-stage → 0.1.0

package/dist/path.mjs

@@ -0,0 +1,245 @@
+// src/path.ts
+/** Name of the parameter holding the value matched by a trailing wildcard (`ctx.params['*']`). */
+const WILDCARD_PARAM = "*";
+/** Characters allowed in static segments. */
+const STATIC_SEGMENT = /^[A-Za-z0-9\-._~!$&'+,;=@]+$/;
+const PARAM_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const EDGE_SLASHES = /^\/+|\/+$/g;
+/** Error thrown by {@link parseRoutePath}. */
+var RoutePathError = class extends TypeError {
+	path;
+	issue;
+	constructor(path, issue) {
+		super(`Invalid route path "${path}": ${issue.message}`);
+		this.name = "RoutePathError";
+		this.path = path;
+		this.issue = issue;
+	}
+};
+/**
+* Normalises a path: exactly one leading slash, no trailing slash (except the root `/`). Inner
+* content is left untouched (`//` stays and is rejected by {@link parseRoutePath}).
+*
+* `normalizePath('users/')` → `/users`, `normalizePath('')` → `/`.
+*/
+function normalizePath(path) {
+	const trimmed = path.replace(EDGE_SLASHES, "");
+	return trimmed === "" ? "/" : `/${trimmed}`;
+}
+/**
+* Joins path parts (global prefix, controller base path, route path) with single slashes and
+* normalises the result. Empty parts and `/` are ignored.
+*
+* `joinPaths('/api', '/users/', ':id')` → `/api/users/:id`, `joinPaths('/', '')` → `/`.
+*/
+function joinPaths(...parts) {
+	let result = "";
+	for (const part of parts) {
+		const trimmed = part.replace(EDGE_SLASHES, "");
+		if (trimmed !== "") result += `/${trimmed}`;
+	}
+	return result === "" ? "/" : result;
+}
+/** Validates `path` (normalised first). Returns the first issue, or `undefined` when it is valid. */
+function checkRoutePath(path) {
+	const result = analyse(path);
+	return "message" in result ? result : void 0;
+}
+/**
+* Parses and validates a route path (normalised first).
+*
+* @throws RoutePathError when the path violates the grammar.
+*/
+function parseRoutePath(path) {
+	const result = analyse(path);
+	if ("message" in result) throw new RoutePathError(path, result);
+	return result;
+}
+function analyse(input) {
+	if (typeof input !== "string") return { message: "a route path must be a string" };
+	if (input.includes("?") || input.includes("#")) return { message: "a route path cannot contain \"?\" or \"#\" (query strings are not part of routes)" };
+	const path = normalizePath(input);
+	if (path === "/") return {
+		path,
+		segments: [],
+		params: [],
+		wildcard: false,
+		shape: "/"
+	};
+	const raw = path.slice(1).split("/");
+	const segments = [];
+	const params = [];
+	for (let index = 0; index < raw.length; index++) {
+		const segment = raw[index];
+		if (segment === "") return { message: "empty segment (\"//\")" };
+		if (segment === "*") {
+			if (index !== raw.length - 1) return {
+				message: "the wildcard \"*\" must be the last segment",
+				segment
+			};
+			segments.push({ kind: "wildcard" });
+			params.push("*");
+			continue;
+		}
+		if (segment.includes("*")) return {
+			message: `"*" must be a whole segment (found "${segment}")`,
+			segment
+		};
+		if (segment.startsWith(":")) {
+			const name = segment.slice(1);
+			if (!PARAM_NAME.test(name)) return {
+				message: `invalid parameter name "${name}" (expected letters, digits and "_", not starting with a digit)`,
+				segment
+			};
+			if (params.includes(name)) return {
+				message: `duplicate parameter ":${name}"`,
+				segment
+			};
+			segments.push({
+				kind: "param",
+				name
+			});
+			params.push(name);
+			continue;
+		}
+		if (segment.includes(":")) return {
+			message: `":" is only allowed at the start of a segment (found "${segment}")`,
+			segment
+		};
+		if (segment === "." || segment === "..") return {
+			message: "dot segments (\".\" and \"..\") are not allowed",
+			segment
+		};
+		if (!STATIC_SEGMENT.test(segment)) {
+			const bad = [...segment].find((char) => !STATIC_SEGMENT.test(char)) ?? segment;
+			return {
+				message: `invalid character ${JSON.stringify(bad)} in "${segment}" (allowed: letters, digits and - . _ ~ ! $ & ' + , ; = @)`,
+				segment
+			};
+		}
+		segments.push({
+			kind: "static",
+			value: segment
+		});
+	}
+	return {
+		path,
+		segments,
+		params,
+		wildcard: params.at(-1) === "*",
+		shape: shapeOf(segments)
+	};
+}
+function shapeOf(segments) {
+	let shape = "";
+	for (const segment of segments) if (segment.kind === "static") shape += `/${segment.value}`;
+	else if (segment.kind === "param") shape += "/:";
+	else shape += "/*";
+	return shape === "" ? "/" : shape;
+}
+/**
+* Matches a raw request path (no query string) against a route. Returns the **raw**
+* (percent-encoded) parameter values, or `undefined` when the path does not match.
+*/
+function matchRoutePath(route, path) {
+	if (path.charCodeAt(0) !== 47) return void 0;
+	const segments = route.segments;
+	if (segments.length === 0) return path === "/" ? {} : void 0;
+	const params = {};
+	let position = 1;
+	for (let index = 0; index < segments.length; index++) {
+		const segment = segments[index];
+		if (segment.kind === "wildcard") {
+			params["*"] = path.slice(position);
+			return params;
+		}
+		const slash = path.indexOf("/", position);
+		const end = slash === -1 ? path.length : slash;
+		const value = path.slice(position, end);
+		if (segment.kind === "static") {
+			if (value !== segment.value) return void 0;
+		} else {
+			if (value === "") return void 0;
+			params[segment.name] = value;
+		}
+		if (index === segments.length - 1) return end === path.length ? params : void 0;
+		if (slash === -1) return void 0;
+		position = slash + 1;
+	}
+	return params;
+}
+/** Decodes a raw parameter value. Returns `undefined` when it is not valid percent-encoding. */
+function decodePathValue(value) {
+	if (!value.includes("%")) return value;
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return;
+	}
+}
+const RANK = {
+	static: 0,
+	param: 1,
+	wildcard: 2
+};
+/**
+* Orders routes from the most to the least specific (static segments before parameters before the
+* wildcard, compared segment by segment), then by path. Registering routes in this order makes
+* first-match routers (Express, Hono) behave like specificity-based ones (Fastify, the built-in
+* router).
+*/
+function compareRoutePaths(a, b) {
+	const length = Math.min(a.segments.length, b.segments.length);
+	for (let index = 0; index < length; index++) {
+		const left = a.segments[index];
+		const right = b.segments[index];
+		const rank = RANK[left.kind] - RANK[right.kind];
+		if (rank !== 0) return rank;
+		if (left.kind === "static" && right.kind === "static" && left.value !== right.value) return left.value < right.value ? -1 : 1;
+	}
+	if (a.segments.length !== b.segments.length) return a.segments.length - b.segments.length;
+	return compareStrings(a.path, b.path);
+}
+/** Ordinal string comparison (locale-independent, deterministic). */
+function compareStrings(a, b) {
+	if (a === b) return 0;
+	return a < b ? -1 : 1;
+}
+/** Fastify / find-my-way pattern (`/users/:id`, `/files/*`). */
+function toFastifyPath(route) {
+	return toColonPath(route, "*");
+}
+/**
+* Hono pattern. The wildcard becomes a regexp parameter so that `/files/*` does not match `/files`
+* (Hono's own `*` does).
+*/
+function toHonoPath(route) {
+	return toColonPath(route, ":__znight_wildcard{.*}");
+}
+function toColonPath(route, wildcard) {
+	if (route.segments.length === 0) return "/";
+	let result = "";
+	for (const segment of route.segments) if (segment.kind === "static") result += `/${segment.value}`;
+	else if (segment.kind === "param") result += `/:${segment.name}`;
+	else result += `/${wildcard}`;
+	return result;
+}
+/**
+* Anchored regular expression source matching the raw path of a route, without capturing groups
+* (`^\/users\/[^/]+$`). Used by the Express adapter, which matches regular expressions against the
+* raw path.
+*/
+function toRegExpSource(route) {
+	if (route.segments.length === 0) return "^\\/$";
+	let source = "^";
+	for (const segment of route.segments) if (segment.kind === "static") source += `\\/${escapeRegExp(segment.value)}`;
+	else if (segment.kind === "param") source += "\\/[^/]+";
+	else source += "\\/.*";
+	return `${source}$`;
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export { RoutePathError, WILDCARD_PARAM, checkRoutePath, compareRoutePaths, compareStrings, decodePathValue, joinPaths, matchRoutePath, normalizePath, parseRoutePath, toFastifyPath, toHonoPath, toRegExpSource };
+
+//# sourceMappingURL=path.mjs.map

package/dist/path.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.mjs","names":[],"sources":["../src/path.ts"],"sourcesContent":["/**\n * Route path grammar of `@znight/http`, shared by the runtime (adapters, router) and the compiler\n * extension (ZNIGHT007 diagnostics, `fullPath`). This module is **pure**: no imports, no I/O, no\n * global state, so the compiler can load it without loading the HTTP runtime.\n *\n * Grammar (after normalisation, see {@link normalizePath}):\n *\n * ```\n * path     = \"/\" | ( \"/\" segment )+\n * segment  = static | param | wildcard            ; wildcard only as the last segment\n * static   = 1*( ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\" / \"!\" / \"$\" / \"&\" / \"'\" / \"+\" / \",\" / \";\" / \"=\" / \"@\" )\n * param    = \":\" name                              ; name = [A-Za-z_][A-Za-z0-9_]*, unique in the path\n * wildcard = \"*\"                                   ; matches the rest of the path (may be empty)\n * ```\n *\n * Matching is case-sensitive and works on the raw (percent-encoded) request path. A `:param`\n * matches one non-empty segment; `/files/*` matches `/files/` and `/files/a/b` (not `/files`).\n */\n\n/** A segment of a parsed route path. */\nexport type RouteSegment =\n  | { readonly kind: 'static'; readonly value: string }\n  | { readonly kind: 'param'; readonly name: string }\n  | { readonly kind: 'wildcard' }\n\n/** A validated, normalised route path. */\nexport interface RoutePath {\n  /** Normalised path (`/users/:id`, `/` for the root). */\n  readonly path: string\n  readonly segments: readonly RouteSegment[]\n  /** Parameter names, in order. The wildcard, when present, is last and named {@link WILDCARD_PARAM}. */\n  readonly params: readonly string[]\n  readonly wildcard: boolean\n  /**\n   * Matching shape: param names are erased (`/users/:` for `/users/:id`). Two routes with the same\n   * method and shape conflict.\n   */\n  readonly shape: string\n}\n\n/** A grammar violation. */\nexport interface RoutePathIssue {\n  readonly message: string\n  /** The offending segment, when the issue concerns one. */\n  readonly segment?: string\n}\n\n/** Name of the parameter holding the value matched by a trailing wildcard (`ctx.params['*']`). */\nexport const WILDCARD_PARAM = '*'\n\n/** Characters allowed in static segments. */\nconst STATIC_SEGMENT = /^[A-Za-z0-9\\-._~!$&'+,;=@]+$/\nconst PARAM_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/\nconst EDGE_SLASHES = /^\\/+|\\/+$/g\n\n/** Error thrown by {@link parseRoutePath}. */\nexport class RoutePathError extends TypeError {\n  readonly path: string\n  readonly issue: RoutePathIssue\n\n  constructor(path: string, issue: RoutePathIssue) {\n    super(`Invalid route path \"${path}\": ${issue.message}`)\n    this.name = 'RoutePathError'\n    this.path = path\n    this.issue = issue\n  }\n}\n\n/**\n * Normalises a path: exactly one leading slash, no trailing slash (except the root `/`). Inner\n * content is left untouched (`//` stays and is rejected by {@link parseRoutePath}).\n *\n * `normalizePath('users/')` → `/users`, `normalizePath('')` → `/`.\n */\nexport function normalizePath(path: string): string {\n  const trimmed = path.replace(EDGE_SLASHES, '')\n  return trimmed === '' ? '/' : `/${trimmed}`\n}\n\n/**\n * Joins path parts (global prefix, controller base path, route path) with single slashes and\n * normalises the result. Empty parts and `/` are ignored.\n *\n * `joinPaths('/api', '/users/', ':id')` → `/api/users/:id`, `joinPaths('/', '')` → `/`.\n */\nexport function joinPaths(...parts: readonly string[]): string {\n  let result = ''\n  for (const part of parts) {\n    const trimmed = part.replace(EDGE_SLASHES, '')\n    if (trimmed !== '') result += `/${trimmed}`\n  }\n  return result === '' ? '/' : result\n}\n\n/** Validates `path` (normalised first). Returns the first issue, or `undefined` when it is valid. */\nexport function checkRoutePath(path: string): RoutePathIssue | undefined {\n  const result = analyse(path)\n  return 'message' in result ? result : undefined\n}\n\n/**\n * Parses and validates a route path (normalised first).\n *\n * @throws RoutePathError when the path violates the grammar.\n */\nexport function parseRoutePath(path: string): RoutePath {\n  const result = analyse(path)\n  if ('message' in result) throw new RoutePathError(path, result)\n  return result\n}\n\nfunction analyse(input: string): RoutePath | RoutePathIssue {\n  if (typeof input !== 'string') return { message: 'a route path must be a string' }\n  if (input.includes('?') || input.includes('#')) {\n    return { message: 'a route path cannot contain \"?\" or \"#\" (query strings are not part of routes)' }\n  }\n  const path = normalizePath(input)\n  if (path === '/') return { path, segments: [], params: [], wildcard: false, shape: '/' }\n  const raw = path.slice(1).split('/')\n  const segments: RouteSegment[] = []\n  const params: string[] = []\n  for (let index = 0; index < raw.length; index++) {\n    const segment = raw[index] as string\n    if (segment === '') return { message: 'empty segment (\"//\")' }\n    if (segment === '*') {\n      if (index !== raw.length - 1) {\n        return { message: 'the wildcard \"*\" must be the last segment', segment }\n      }\n      segments.push({ kind: 'wildcard' })\n      params.push(WILDCARD_PARAM)\n      continue\n    }\n    if (segment.includes('*')) {\n      return { message: `\"*\" must be a whole segment (found \"${segment}\")`, segment }\n    }\n    if (segment.startsWith(':')) {\n      const name = segment.slice(1)\n      if (!PARAM_NAME.test(name)) {\n        return {\n          message: `invalid parameter name \"${name}\" (expected letters, digits and \"_\", not starting with a digit)`,\n          segment,\n        }\n      }\n      if (params.includes(name)) return { message: `duplicate parameter \":${name}\"`, segment }\n      segments.push({ kind: 'param', name })\n      params.push(name)\n      continue\n    }\n    if (segment.includes(':')) {\n      return { message: `\":\" is only allowed at the start of a segment (found \"${segment}\")`, segment }\n    }\n    if (segment === '.' || segment === '..') return { message: 'dot segments (\".\" and \"..\") are not allowed', segment }\n    if (!STATIC_SEGMENT.test(segment)) {\n      const bad = [...segment].find(char => !STATIC_SEGMENT.test(char)) ?? segment\n      return {\n        message: `invalid character ${JSON.stringify(bad)} in \"${segment}\" (allowed: letters, digits and - . _ ~ ! $ & ' + , ; = @)`,\n        segment,\n      }\n    }\n    segments.push({ kind: 'static', value: segment })\n  }\n  return { path, segments, params, wildcard: params.at(-1) === WILDCARD_PARAM, shape: shapeOf(segments) }\n}\n\nfunction shapeOf(segments: readonly RouteSegment[]): string {\n  let shape = ''\n  for (const segment of segments) {\n    if (segment.kind === 'static') shape += `/${segment.value}`\n    else if (segment.kind === 'param') shape += '/:'\n    else shape += '/*'\n  }\n  return shape === '' ? '/' : shape\n}\n\n/**\n * Matches a raw request path (no query string) against a route. Returns the **raw**\n * (percent-encoded) parameter values, or `undefined` when the path does not match.\n */\nexport function matchRoutePath(route: RoutePath, path: string): Record<string, string> | undefined {\n  if (path.charCodeAt(0) !== 47 /* / */) return undefined\n  const segments = route.segments\n  if (segments.length === 0) return path === '/' ? {} : undefined\n  const params: Record<string, string> = {}\n  let position = 1\n  for (let index = 0; index < segments.length; index++) {\n    const segment = segments[index] as RouteSegment\n    if (segment.kind === 'wildcard') {\n      params[WILDCARD_PARAM] = path.slice(position)\n      return params\n    }\n    const slash = path.indexOf('/', position)\n    const end = slash === -1 ? path.length : slash\n    const value = path.slice(position, end)\n    if (segment.kind === 'static') {\n      if (value !== segment.value) return undefined\n    } else {\n      if (value === '') return undefined\n      params[segment.name] = value\n    }\n    if (index === segments.length - 1) return end === path.length ? params : undefined\n    if (slash === -1) return undefined\n    position = slash + 1\n  }\n  return params\n}\n\n/** Decodes a raw parameter value. Returns `undefined` when it is not valid percent-encoding. */\nexport function decodePathValue(value: string): string | undefined {\n  if (!value.includes('%')) return value\n  try {\n    return decodeURIComponent(value)\n  } catch {\n    return undefined\n  }\n}\n\nconst RANK = { static: 0, param: 1, wildcard: 2 } as const\n\n/**\n * Orders routes from the most to the least specific (static segments before parameters before the\n * wildcard, compared segment by segment), then by path. Registering routes in this order makes\n * first-match routers (Express, Hono) behave like specificity-based ones (Fastify, the built-in\n * router).\n */\nexport function compareRoutePaths(a: RoutePath, b: RoutePath): number {\n  const length = Math.min(a.segments.length, b.segments.length)\n  for (let index = 0; index < length; index++) {\n    const left = a.segments[index] as RouteSegment\n    const right = b.segments[index] as RouteSegment\n    const rank = RANK[left.kind] - RANK[right.kind]\n    if (rank !== 0) return rank\n    if (left.kind === 'static' && right.kind === 'static' && left.value !== right.value) {\n      return left.value < right.value ? -1 : 1\n    }\n  }\n  if (a.segments.length !== b.segments.length) return a.segments.length - b.segments.length\n  return compareStrings(a.path, b.path)\n}\n\n/** Ordinal string comparison (locale-independent, deterministic). */\nexport function compareStrings(a: string, b: string): number {\n  if (a === b) return 0\n  return a < b ? -1 : 1\n}\n\n/** Fastify / find-my-way pattern (`/users/:id`, `/files/*`). */\nexport function toFastifyPath(route: RoutePath): string {\n  return toColonPath(route, '*')\n}\n\n/**\n * Hono pattern. The wildcard becomes a regexp parameter so that `/files/*` does not match `/files`\n * (Hono's own `*` does).\n */\nexport function toHonoPath(route: RoutePath): string {\n  return toColonPath(route, ':__znight_wildcard{.*}')\n}\n\nfunction toColonPath(route: RoutePath, wildcard: string): string {\n  if (route.segments.length === 0) return '/'\n  let result = ''\n  for (const segment of route.segments) {\n    if (segment.kind === 'static') result += `/${segment.value}`\n    else if (segment.kind === 'param') result += `/:${segment.name}`\n    else result += `/${wildcard}`\n  }\n  return result\n}\n\n/**\n * Anchored regular expression source matching the raw path of a route, without capturing groups\n * (`^\\/users\\/[^/]+$`). Used by the Express adapter, which matches regular expressions against the\n * raw path.\n */\nexport function toRegExpSource(route: RoutePath): string {\n  if (route.segments.length === 0) return '^\\\\/$'\n  let source = '^'\n  for (const segment of route.segments) {\n    if (segment.kind === 'static') source += `\\\\/${escapeRegExp(segment.value)}`\n    else if (segment.kind === 'param') source += '\\\\/[^/]+'\n    else source += '\\\\/.*'\n  }\n  return `${source}$`\n}\n\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n"],"mappings":"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"}

package/dist/size-D8rsQcV0.mjs

@@ -0,0 +1,184 @@
+// src/mime.ts
+/**
+* Media types of files: a small extension table for downloads and `type/*` patterns for upload
+* filters. This module is **pure** (no imports, no I/O): the compiler extension validates the
+* `mimeTypes` option of `@UploadedFile` with it.
+*/
+/** Common extensions → media type (text types get `charset=utf-8` in {@link contentTypeFor}). */
+const TYPES = {
+	txt: "text/plain",
+	text: "text/plain",
+	log: "text/plain",
+	md: "text/markdown",
+	markdown: "text/markdown",
+	csv: "text/csv",
+	tsv: "text/tab-separated-values",
+	htm: "text/html",
+	html: "text/html",
+	css: "text/css",
+	xml: "application/xml",
+	js: "text/javascript",
+	mjs: "text/javascript",
+	cjs: "text/javascript",
+	json: "application/json",
+	map: "application/json",
+	jsonld: "application/ld+json",
+	webmanifest: "application/manifest+json",
+	yaml: "application/yaml",
+	yml: "application/yaml",
+	ics: "text/calendar",
+	vtt: "text/vtt",
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	avif: "image/avif",
+	svg: "image/svg+xml",
+	ico: "image/x-icon",
+	bmp: "image/bmp",
+	tif: "image/tiff",
+	tiff: "image/tiff",
+	heic: "image/heic",
+	mp3: "audio/mpeg",
+	wav: "audio/wav",
+	ogg: "audio/ogg",
+	oga: "audio/ogg",
+	flac: "audio/flac",
+	aac: "audio/aac",
+	m4a: "audio/mp4",
+	opus: "audio/opus",
+	mp4: "video/mp4",
+	m4v: "video/mp4",
+	webm: "video/webm",
+	ogv: "video/ogg",
+	mov: "video/quicktime",
+	avi: "video/x-msvideo",
+	mkv: "video/x-matroska",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	ttf: "font/ttf",
+	otf: "font/otf",
+	pdf: "application/pdf",
+	rtf: "application/rtf",
+	doc: "application/msword",
+	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	xls: "application/vnd.ms-excel",
+	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	ppt: "application/vnd.ms-powerpoint",
+	pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	odt: "application/vnd.oasis.opendocument.text",
+	ods: "application/vnd.oasis.opendocument.spreadsheet",
+	odp: "application/vnd.oasis.opendocument.presentation",
+	epub: "application/epub+zip",
+	zip: "application/zip",
+	gz: "application/gzip",
+	tgz: "application/gzip",
+	tar: "application/x-tar",
+	bz2: "application/x-bzip2",
+	xz: "application/x-xz",
+	"7z": "application/x-7z-compressed",
+	rar: "application/vnd.rar",
+	wasm: "application/wasm",
+	bin: "application/octet-stream"
+};
+/** Default media type of files without a known extension. */
+const OCTET_STREAM = "application/octet-stream";
+/**
+* Media type of a file name from its extension (`report.pdf` → `application/pdf`, text types with
+* `; charset=utf-8`), `undefined` when the extension is unknown.
+*/
+function contentTypeFor(filename) {
+	const dot = filename.lastIndexOf(".");
+	if (dot === -1 || dot === filename.length - 1) return void 0;
+	if (dot < Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"))) return void 0;
+	const extension = filename.slice(dot + 1).toLowerCase();
+	if (!Object.hasOwn(TYPES, extension)) return void 0;
+	const type = TYPES[extension];
+	return isTextual(type) ? `${type}; charset=utf-8` : type;
+}
+function isTextual(type) {
+	return type.startsWith("text/") || type === "application/json" || type === "application/ld+json" || type === "application/manifest+json" || type === "application/xml" || type === "application/yaml" || type === "image/svg+xml";
+}
+/** `type/subtype` token characters (RFC 9110). */
+const TOKEN = "[!#$%&'*+\\-.^_`|~0-9A-Za-z]+";
+const MEDIA_TYPE = new RegExp(`^${TOKEN}/${TOKEN}$`);
+/**
+* Whether `pattern` is a valid media type filter: `type/subtype`, `type/*` or `*\/*`
+* (case-insensitive, without parameters).
+*/
+function isMediaTypePattern(pattern) {
+	if (!MEDIA_TYPE.test(pattern)) return false;
+	const [type, subtype] = pattern.split("/");
+	if (type.includes("*") && type !== "*") return false;
+	if (subtype.includes("*") && subtype !== "*") return false;
+	return type !== "*" || subtype === "*";
+}
+/** The essence of a media type: lower-case `type/subtype` without parameters (`Text/Plain; charset=x` → `text/plain`). */
+function mediaTypeEssence(type) {
+	const separator = type.indexOf(";");
+	return (separator === -1 ? type : type.slice(0, separator)).trim().toLowerCase();
+}
+/** Whether the media type `type` (parameters ignored) matches one of `patterns` (`image/png`, `image/*`, `*\/*`). */
+function matchesMediaType(type, patterns) {
+	const essence = mediaTypeEssence(type);
+	const slash = essence.indexOf("/");
+	if (slash <= 0 || slash === essence.length - 1) return false;
+	const major = essence.slice(0, slash);
+	for (const raw of patterns) {
+		const pattern = raw.toLowerCase();
+		if (pattern === "*/*" || pattern === essence) return true;
+		if (pattern.endsWith("/*") && pattern.slice(0, -2) === major) return true;
+	}
+	return false;
+}
+// src/size.ts
+const UNITS = {
+	b: 1,
+	k: 1024,
+	kb: 1024,
+	kib: 1024,
+	m: 1024 ** 2,
+	mb: 1024 ** 2,
+	mib: 1024 ** 2,
+	g: 1024 ** 3,
+	gb: 1024 ** 3,
+	gib: 1024 ** 3,
+	t: 1024 ** 4,
+	tb: 1024 ** 4,
+	tib: 1024 ** 4
+};
+const SIZE = /^(\d+(?:\.\d+)?|\.\d+)\s*([a-z]*)$/i;
+/**
+* Parses a {@link ByteSize}: `1024` → `1024`, `'10mb'` → `10485760`, `'1.5kb'` → `1536` (fractions
+* are rounded down). Returns `undefined` for anything else (negative or fractional numbers,
+* unknown units, `NaN`).
+*/
+function parseByteSize(value) {
+	if (typeof value === "number") {
+		if (value === Number.POSITIVE_INFINITY) return value;
+		return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+	}
+	if (typeof value !== "string") return void 0;
+	const match = SIZE.exec(value.trim());
+	if (match === null) return void 0;
+	const unit = match[2].toLowerCase();
+	const multiplier = unit === "" ? 1 : UNITS[unit];
+	if (multiplier === void 0) return void 0;
+	const bytes = Math.floor(Number(match[1]) * multiplier);
+	return Number.isSafeInteger(bytes) ? bytes : void 0;
+}
+/** Human-readable size for messages: `5 MiB`, `1.5 KiB`, `512 bytes`, `unlimited`. */
+function formatByteSize(bytes) {
+	if (bytes === Number.POSITIVE_INFINITY) return "unlimited";
+	for (const [unit, size] of [
+		["TiB", 1024 ** 4],
+		["GiB", 1024 ** 3],
+		["MiB", 1024 ** 2],
+		["KiB", 1024]
+	]) if (bytes >= size) return `${Number((bytes / size).toFixed(2))} ${unit}`;
+	return bytes === 1 ? "1 byte" : `${bytes} bytes`;
+}
+export { isMediaTypePattern as a, contentTypeFor as i, parseByteSize as n, matchesMediaType as o, OCTET_STREAM as r, mediaTypeEssence as s, formatByteSize as t };
+
+//# sourceMappingURL=size-D8rsQcV0.mjs.map

package/dist/size-D8rsQcV0.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"size-D8rsQcV0.mjs","names":[],"sources":["../src/mime.ts","../src/size.ts"],"sourcesContent":["/**\n * Media types of files: a small extension table for downloads and `type/*` patterns for upload\n * filters. This module is **pure** (no imports, no I/O): the compiler extension validates the\n * `mimeTypes` option of `@UploadedFile` with it.\n */\n\n/** Common extensions → media type (text types get `charset=utf-8` in {@link contentTypeFor}). */\nconst TYPES: Readonly<Record<string, string>> = {\n  // text\n  txt: 'text/plain',\n  text: 'text/plain',\n  log: 'text/plain',\n  md: 'text/markdown',\n  markdown: 'text/markdown',\n  csv: 'text/csv',\n  tsv: 'text/tab-separated-values',\n  htm: 'text/html',\n  html: 'text/html',\n  css: 'text/css',\n  xml: 'application/xml',\n  js: 'text/javascript',\n  mjs: 'text/javascript',\n  cjs: 'text/javascript',\n  json: 'application/json',\n  map: 'application/json',\n  jsonld: 'application/ld+json',\n  webmanifest: 'application/manifest+json',\n  yaml: 'application/yaml',\n  yml: 'application/yaml',\n  ics: 'text/calendar',\n  vtt: 'text/vtt',\n  // images\n  png: 'image/png',\n  jpg: 'image/jpeg',\n  jpeg: 'image/jpeg',\n  gif: 'image/gif',\n  webp: 'image/webp',\n  avif: 'image/avif',\n  svg: 'image/svg+xml',\n  ico: 'image/x-icon',\n  bmp: 'image/bmp',\n  tif: 'image/tiff',\n  tiff: 'image/tiff',\n  heic: 'image/heic',\n  // audio / video\n  mp3: 'audio/mpeg',\n  wav: 'audio/wav',\n  ogg: 'audio/ogg',\n  oga: 'audio/ogg',\n  flac: 'audio/flac',\n  aac: 'audio/aac',\n  m4a: 'audio/mp4',\n  opus: 'audio/opus',\n  mp4: 'video/mp4',\n  m4v: 'video/mp4',\n  webm: 'video/webm',\n  ogv: 'video/ogg',\n  mov: 'video/quicktime',\n  avi: 'video/x-msvideo',\n  mkv: 'video/x-matroska',\n  // fonts\n  woff: 'font/woff',\n  woff2: 'font/woff2',\n  ttf: 'font/ttf',\n  otf: 'font/otf',\n  // documents and archives\n  pdf: 'application/pdf',\n  rtf: 'application/rtf',\n  doc: 'application/msword',\n  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\n  xls: 'application/vnd.ms-excel',\n  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n  ppt: 'application/vnd.ms-powerpoint',\n  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',\n  odt: 'application/vnd.oasis.opendocument.text',\n  ods: 'application/vnd.oasis.opendocument.spreadsheet',\n  odp: 'application/vnd.oasis.opendocument.presentation',\n  epub: 'application/epub+zip',\n  zip: 'application/zip',\n  gz: 'application/gzip',\n  tgz: 'application/gzip',\n  tar: 'application/x-tar',\n  bz2: 'application/x-bzip2',\n  xz: 'application/x-xz',\n  '7z': 'application/x-7z-compressed',\n  rar: 'application/vnd.rar',\n  wasm: 'application/wasm',\n  bin: 'application/octet-stream',\n}\n\n/** Default media type of files without a known extension. */\nexport const OCTET_STREAM = 'application/octet-stream'\n\n/**\n * Media type of a file name from its extension (`report.pdf` → `application/pdf`, text types with\n * `; charset=utf-8`), `undefined` when the extension is unknown.\n */\nexport function contentTypeFor(filename: string): string | undefined {\n  const dot = filename.lastIndexOf('.')\n  if (dot === -1 || dot === filename.length - 1) return undefined\n  const separator = Math.max(filename.lastIndexOf('/'), filename.lastIndexOf('\\\\'))\n  if (dot < separator) return undefined\n  const extension = filename.slice(dot + 1).toLowerCase()\n  // own keys only: `.constructor` / `.__proto__` must not resolve to `Object.prototype` members\n  if (!Object.hasOwn(TYPES, extension)) return undefined\n  const type = TYPES[extension] as string\n  return isTextual(type) ? `${type}; charset=utf-8` : type\n}\n\nfunction isTextual(type: string): boolean {\n  return (\n    type.startsWith('text/') ||\n    type === 'application/json' ||\n    type === 'application/ld+json' ||\n    type === 'application/manifest+json' ||\n    type === 'application/xml' ||\n    type === 'application/yaml' ||\n    type === 'image/svg+xml'\n  )\n}\n\n/** `type/subtype` token characters (RFC 9110). */\nconst TOKEN = \"[!#$%&'*+\\\\-.^_`|~0-9A-Za-z]+\"\nconst MEDIA_TYPE = new RegExp(`^${TOKEN}/${TOKEN}$`)\n\n/**\n * Whether `pattern` is a valid media type filter: `type/subtype`, `type/*` or `*\\/*`\n * (case-insensitive, without parameters).\n */\nexport function isMediaTypePattern(pattern: string): boolean {\n  if (!MEDIA_TYPE.test(pattern)) return false\n  const [type, subtype] = pattern.split('/') as [string, string]\n  // `*` is only a wildcard on its own: `image/*`, `*/*` (`*/png` and `image/png*` are rejected)\n  if (type.includes('*') && type !== '*') return false\n  if (subtype.includes('*') && subtype !== '*') return false\n  return type !== '*' || subtype === '*'\n}\n\n/** The essence of a media type: lower-case `type/subtype` without parameters (`Text/Plain; charset=x` → `text/plain`). */\nexport function mediaTypeEssence(type: string): string {\n  const separator = type.indexOf(';')\n  return (separator === -1 ? type : type.slice(0, separator)).trim().toLowerCase()\n}\n\n/** Whether the media type `type` (parameters ignored) matches one of `patterns` (`image/png`, `image/*`, `*\\/*`). */\nexport function matchesMediaType(type: string, patterns: readonly string[]): boolean {\n  const essence = mediaTypeEssence(type)\n  const slash = essence.indexOf('/')\n  if (slash <= 0 || slash === essence.length - 1) return false\n  const major = essence.slice(0, slash)\n  for (const raw of patterns) {\n    const pattern = raw.toLowerCase()\n    if (pattern === '*/*' || pattern === essence) return true\n    if (pattern.endsWith('/*') && pattern.slice(0, -2) === major) return true\n  }\n  return false\n}\n","/**\n * Byte sizes (`1048576`, `'512kb'`, `'10 MiB'`, `'1.5gb'`) used by body and upload limits. This\n * module is **pure** (no imports, no I/O): the compiler extension evaluates `@BodyLimit('10mb')` and\n * `maxSize` options with it at build time.\n *\n * Units are case-insensitive and binary, like the `bytes` package used by Express:\n * `b`, `kb`/`kib`/`k` = 1024, `mb`/`mib`/`m` = 1024², `gb`/`gib`/`g` = 1024³, `tb`/`tib`/`t` = 1024⁴.\n */\n\n/**\n * A size in bytes: a non-negative integer (`Infinity` disables the limit) or a string with a unit\n * (`'512kb'`, `'10mb'`, `'1.5 GiB'`; `kb` = 1024 bytes).\n */\nexport type ByteSize = number | string\n\nconst UNITS: Readonly<Record<string, number>> = {\n  b: 1,\n  k: 1024,\n  kb: 1024,\n  kib: 1024,\n  m: 1024 ** 2,\n  mb: 1024 ** 2,\n  mib: 1024 ** 2,\n  g: 1024 ** 3,\n  gb: 1024 ** 3,\n  gib: 1024 ** 3,\n  t: 1024 ** 4,\n  tb: 1024 ** 4,\n  tib: 1024 ** 4,\n}\n\nconst SIZE = /^(\\d+(?:\\.\\d+)?|\\.\\d+)\\s*([a-z]*)$/i\n\n/**\n * Parses a {@link ByteSize}: `1024` → `1024`, `'10mb'` → `10485760`, `'1.5kb'` → `1536` (fractions\n * are rounded down). Returns `undefined` for anything else (negative or fractional numbers,\n * unknown units, `NaN`).\n */\nexport function parseByteSize(value: unknown): number | undefined {\n  if (typeof value === 'number') {\n    if (value === Number.POSITIVE_INFINITY) return value\n    return Number.isSafeInteger(value) && value >= 0 ? value : undefined\n  }\n  if (typeof value !== 'string') return undefined\n  const match = SIZE.exec(value.trim())\n  if (match === null) return undefined\n  const unit = (match[2] as string).toLowerCase()\n  const multiplier = unit === '' ? 1 : UNITS[unit]\n  if (multiplier === undefined) return undefined\n  const bytes = Math.floor(Number(match[1]) * multiplier)\n  return Number.isSafeInteger(bytes) ? bytes : undefined\n}\n\n/** Human-readable size for messages: `5 MiB`, `1.5 KiB`, `512 bytes`, `unlimited`. */\nexport function formatByteSize(bytes: number): string {\n  if (bytes === Number.POSITIVE_INFINITY) return 'unlimited'\n  for (const [unit, size] of [\n    ['TiB', 1024 ** 4],\n    ['GiB', 1024 ** 3],\n    ['MiB', 1024 ** 2],\n    ['KiB', 1024],\n  ] as const) {\n    if (bytes >= size) return `${Number((bytes / size).toFixed(2))} ${unit}`\n  }\n  return bytes === 1 ? '1 byte' : `${bytes} bytes`\n}\n"],"mappings":";;;;;;;AAOA,MAAM,QAA0C;CAE9C,KAAK;CACL,MAAM;CACN,KAAK;CACL,IAAI;CACJ,UAAU;CACV,KAAK;CACL,KAAK;CACL,KAAK;CACL,MAAM;CACN,KAAK;CACL,KAAK;CACL,IAAI;CACJ,KAAK;CACL,KAAK;CACL,MAAM;CACN,KAAK;CACL,QAAQ;CACR,aAAa;CACb,MAAM;CACN,KAAK;CACL,KAAK;CACL,KAAK;CAEL,KAAK;CACL,KAAK;CACL,MAAM;CACN,KAAK;CACL,MAAM;CACN,MAAM;CACN,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,MAAM;CACN,MAAM;CAEN,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,MAAM;CACN,KAAK;CACL,KAAK;CACL,MAAM;CACN,KAAK;CACL,KAAK;CACL,MAAM;CACN,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CAEL,MAAM;CACN,OAAO;CACP,KAAK;CACL,KAAK;CAEL,KAAK;CACL,KAAK;CACL,KAAK;CACL,MAAM;CACN,KAAK;CACL,MAAM;CACN,KAAK;CACL,MAAM;CACN,KAAK;CACL,KAAK;CACL,KAAK;CACL,MAAM;CACN,KAAK;CACL,IAAI;CACJ,KAAK;CACL,KAAK;CACL,KAAK;CACL,IAAI;CACJ,MAAM;CACN,KAAK;CACL,MAAM;CACN,KAAK;AACP;;AAGA,MAAa,eAAe;;;;;AAM5B,SAAgB,eAAe,UAAsC;CACnE,MAAM,MAAM,SAAS,YAAY,GAAG;CACpC,IAAI,QAAQ,MAAM,QAAQ,SAAS,SAAS,GAAG,OAAO,KAAA;CAEtD,IAAI,MADc,KAAK,IAAI,SAAS,YAAY,GAAG,GAAG,SAAS,YAAY,IAAI,CAC7D,GAAG,OAAO,KAAA;CAC5B,MAAM,YAAY,SAAS,MAAM,MAAM,CAAC,CAAC,CAAC,YAAY;CAEtD,IAAI,CAAC,OAAO,OAAO,OAAO,SAAS,GAAG,OAAO,KAAA;CAC7C,MAAM,OAAO,MAAM;CACnB,OAAO,UAAU,IAAI,IAAI,GAAG,KAAK,mBAAmB;AACtD;AAEA,SAAS,UAAU,MAAuB;CACxC,OACE,KAAK,WAAW,OAAO,KACvB,SAAS,sBACT,SAAS,yBACT,SAAS,+BACT,SAAS,qBACT,SAAS,sBACT,SAAS;AAEb;;AAGA,MAAM,QAAQ;AACd,MAAM,aAAa,IAAI,OAAO,IAAI,MAAM,GAAG,MAAM,EAAE;;;;;AAMnD,SAAgB,mBAAmB,SAA0B;CAC3D,IAAI,CAAC,WAAW,KAAK,OAAO,GAAG,OAAO;CACtC,MAAM,CAAC,MAAM,WAAW,QAAQ,MAAM,GAAG;CAEzC,IAAI,KAAK,SAAS,GAAG,KAAK,SAAS,KAAK,OAAO;CAC/C,IAAI,QAAQ,SAAS,GAAG,KAAK,YAAY,KAAK,OAAO;CACrD,OAAO,SAAS,OAAO,YAAY;AACrC;;AAGA,SAAgB,iBAAiB,MAAsB;CACrD,MAAM,YAAY,KAAK,QAAQ,GAAG;CAClC,QAAQ,cAAc,KAAK,OAAO,KAAK,MAAM,GAAG,SAAS,EAAA,CAAG,KAAK,CAAC,CAAC,YAAY;AACjF;;AAGA,SAAgB,iBAAiB,MAAc,UAAsC;CACnF,MAAM,UAAU,iBAAiB,IAAI;CACrC,MAAM,QAAQ,QAAQ,QAAQ,GAAG;CACjC,IAAI,SAAS,KAAK,UAAU,QAAQ,SAAS,GAAG,OAAO;CACvD,MAAM,QAAQ,QAAQ,MAAM,GAAG,KAAK;CACpC,KAAK,MAAM,OAAO,UAAU;EAC1B,MAAM,UAAU,IAAI,YAAY;EAChC,IAAI,YAAY,SAAS,YAAY,SAAS,OAAO;EACrD,IAAI,QAAQ,SAAS,IAAI,KAAK,QAAQ,MAAM,GAAG,EAAE,MAAM,OAAO,OAAO;CACvE;CACA,OAAO;AACT;;AC7IA,MAAM,QAA0C;CAC9C,GAAG;CACH,GAAG;CACH,IAAI;CACJ,KAAK;CACL,GAAG,QAAQ;CACX,IAAI,QAAQ;CACZ,KAAK,QAAQ;CACb,GAAG,QAAQ;CACX,IAAI,QAAQ;CACZ,KAAK,QAAQ;CACb,GAAG,QAAQ;CACX,IAAI,QAAQ;CACZ,KAAK,QAAQ;AACf;AAEA,MAAM,OAAO;;;;;;AAOb,SAAgB,cAAc,OAAoC;CAChE,IAAI,OAAO,UAAU,UAAU;EAC7B,IAAI,UAAU,OAAO,mBAAmB,OAAO;EAC/C,OAAO,OAAO,cAAc,KAAK,KAAK,SAAS,IAAI,QAAQ,KAAA;CAC7D;CACA,IAAI,OAAO,UAAU,UAAU,OAAO,KAAA;CACtC,MAAM,QAAQ,KAAK,KAAK,MAAM,KAAK,CAAC;CACpC,IAAI,UAAU,MAAM,OAAO,KAAA;CAC3B,MAAM,OAAQ,MAAM,EAAE,CAAY,YAAY;CAC9C,MAAM,aAAa,SAAS,KAAK,IAAI,MAAM;CAC3C,IAAI,eAAe,KAAA,GAAW,OAAO,KAAA;CACrC,MAAM,QAAQ,KAAK,MAAM,OAAO,MAAM,EAAE,IAAI,UAAU;CACtD,OAAO,OAAO,cAAc,KAAK,IAAI,QAAQ,KAAA;AAC/C;;AAGA,SAAgB,eAAe,OAAuB;CACpD,IAAI,UAAU,OAAO,mBAAmB,OAAO;CAC/C,KAAK,MAAM,CAAC,MAAM,SAAS;EACzB,CAAC,OAAO,QAAQ,CAAC;EACjB,CAAC,OAAO,QAAQ,CAAC;EACjB,CAAC,OAAO,QAAQ,CAAC;EACjB,CAAC,OAAO,IAAI;CACd,GACE,IAAI,SAAS,MAAM,OAAO,GAAG,QAAQ,QAAQ,KAAA,CAAM,QAAQ,CAAC,CAAC,EAAE,GAAG;CAEpE,OAAO,UAAU,IAAI,WAAW,GAAG,MAAM;AAC3C"}

package/dist/utils-DCbu3a4w.mjs

@@ -0,0 +1,27 @@
+// src/utils.ts
+/** Internal helpers (not part of the public API). */
+/** Whether `value` is a promise-like object (has a callable `then`). */
+function isThenable(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+/** Message of any thrown value. */
+function errorMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	try {
+		return String(error);
+	} catch {
+		return Object.prototype.toString.call(error);
+	}
+}
+/** A `Record` without prototype (safe for user-controlled keys such as `__proto__`). */
+function emptyRecord() {
+	return Object.create(null);
+}
+/** Whether the code runs on Bun. */
+function isBun() {
+	return typeof globalThis.Bun !== "undefined";
+}
+export { isThenable as i, errorMessage as n, isBun as r, emptyRecord as t };
+
+//# sourceMappingURL=utils-DCbu3a4w.mjs.map

package/dist/utils-DCbu3a4w.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-DCbu3a4w.mjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["/** Internal helpers (not part of the public API). */\n\n/** Whether `value` is a promise-like object (has a callable `then`). */\nexport function isThenable(value: unknown): value is PromiseLike<unknown> {\n  return (\n    value !== null &&\n    (typeof value === 'object' || typeof value === 'function') &&\n    typeof (value as { then?: unknown }).then === 'function'\n  )\n}\n\n/** Message of any thrown value. */\nexport function errorMessage(error: unknown): string {\n  if (error instanceof Error) return error.message\n  if (typeof error === 'string') return error\n  try {\n    return String(error)\n  } catch {\n    return Object.prototype.toString.call(error)\n  }\n}\n\n/** A `Record` without prototype (safe for user-controlled keys such as `__proto__`). */\nexport function emptyRecord<V>(): Record<string, V> {\n  return Object.create(null) as Record<string, V>\n}\n\n/** Whether the code runs on Bun. */\nexport function isBun(): boolean {\n  return typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined'\n}\n"],"mappings":";;;AAGA,SAAgB,WAAW,OAA+C;CACxE,OACE,UAAU,SACT,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,OAAQ,MAA6B,SAAS;AAElD;;AAGA,SAAgB,aAAa,OAAwB;CACnD,IAAI,iBAAiB,OAAO,OAAO,MAAM;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI;EACF,OAAO,OAAO,KAAK;CACrB,QAAQ;EACN,OAAO,OAAO,UAAU,SAAS,KAAK,KAAK;CAC7C;AACF;;AAGA,SAAgB,cAAoC;CAClD,OAAO,OAAO,OAAO,IAAI;AAC3B;;AAGA,SAAgB,QAAiB;CAC/B,OAAO,OAAQ,WAAiC,QAAQ;AAC1D"}