@nodefony/http 10.0.0-alpha.1

package/dist/nodefony/src/context/http/Response.js

@@ -0,0 +1,368 @@
+import Cookie from "../../cookies/cookie.js";
+import { typeOf } from "nodefony";
+import http from "node:http";
+import mime from "mime-types";
+//#region nodefony/src/context/http/Response.ts
+const ANSI_REGEX = new RegExp(["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"].join("|"), "g");
+const stripAnsi = function(val) {
+	return typeof val === "string" ? val.replace(ANSI_REGEX, "") : val;
+};
+const REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+const NO_CONTENT_LENGTH_METHODS = /* @__PURE__ */ new Set([
+	"HEAD",
+	"OPTIONS",
+	"TRACE"
+]);
+const NO_CONTENT_LENGTH_STATUS = /* @__PURE__ */ new Set([204, 304]);
+var HttpResponse = class {
+	context;
+	response;
+	statusCode = 200;
+	statusMessage = "";
+	flushing = false;
+	encoding = "utf-8";
+	body = null;
+	contentType = "application/octet-stream";
+	headers = {};
+	timeout;
+	cookies = {};
+	constructor(response, context) {
+		this.context = context;
+		this.response = response;
+		this.timeout = this.context?.httpKernel?.responseTimeout[this.context.type];
+	}
+	/**
+	* Filet posé juste avant l'émission des en-têtes : si aucun `Content-Type`
+	* n'a été choisi (ni négociation, ni `render`, ni controller), émet le défaut
+	* `this.contentType` (application/octet-stream) — comportement identique à
+	* l'ancienne pose au constructeur, sans le ping-pong set/remove/re-set.
+	*/
+	ensureContentTypeHeader() {
+		if (this.response && !this.response.hasHeader("content-type")) this.response.setHeader("content-type", this.contentType);
+	}
+	clean() {
+		this.response = null;
+		this.body = null;
+		this.cookies = {};
+	}
+	isHeaderSent() {
+		if (this.response) return this.response.headersSent;
+		return false;
+	}
+	isHtml() {
+		let ct = this.getHeader("Content-Type");
+		return mime.extension(ct) === "html";
+	}
+	setTimeout(ms) {
+		this.timeout = ms;
+	}
+	addCookie(cookie) {
+		if (cookie instanceof Cookie) return this.cookies[cookie.name] = cookie;
+		throw new Error("Response addCookies not valid cookies");
+	}
+	deleteCookie(cookie) {
+		if (cookie instanceof Cookie) {
+			if (this.cookies[cookie.name]) {
+				delete this.cookies[cookie.name];
+				return true;
+			}
+			return false;
+		}
+		throw new Error("Response delCookie not valid cookies");
+	}
+	deleteCookieByName(name) {
+		if (this.cookies[name]) {
+			delete this.cookies[name];
+			return true;
+		}
+		return false;
+	}
+	setCookies() {
+		const names = Object.keys(this.cookies);
+		if (names.length === 0) return;
+		if (names.length === 1) return this.setCookie(this.cookies[names[0]]);
+		const serialized = [];
+		for (const name of names) {
+			const s = this.cookies[name].serialize();
+			this.log(`ADD COOKIE ==> ${s}`, "DEBUG");
+			serialized.push(s);
+		}
+		return this.setHeader("Set-Cookie", serialized);
+	}
+	setCookie(cookie) {
+		const serialize = cookie.serialize();
+		this.log(`ADD COOKIE ==> ${serialize}`, "DEBUG");
+		return this.setHeader("Set-Cookie", serialize);
+	}
+	setHeader(name, value) {
+		if (this.response) {
+			if (this.flushing) {
+				const obj = {};
+				obj[name] = value;
+				return this.addTrailers(obj);
+			}
+			if (!this.response.headersSent) {
+				const lower = name.toLowerCase();
+				if (lower === "vary") return this.response.setHeader(lower, this.#mergeVary(value));
+				return this.response.setHeader(lower, value);
+			}
+		}
+	}
+	/**
+	* Union des tokens `Vary` déjà posés et de ceux qu'on ajoute, sans doublon.
+	*
+	* `*` absorbe tout (RFC 9110 : « la réponse varie sur des paramètres non
+	* exprimables ») — le conserver seul évite une liste qui contredirait ce total.
+	* Comparaison insensible à la casse : les noms d'en-têtes le sont.
+	*
+	* Coût : ne s'exécute QUE sur `Vary`, jamais sur les autres en-têtes.
+	*/
+	#mergeVary(value) {
+		const incoming = (Array.isArray(value) ? value.join(",") : String(value)).split(",").map((t) => t.trim()).filter(Boolean);
+		const current = this.response?.getHeader?.("vary");
+		const all = [...(Array.isArray(current) ? current.join(",") : String(current ?? "")).split(",").map((t) => t.trim()).filter(Boolean), ...incoming];
+		if (all.some((t) => t === "*")) return "*";
+		const seen = /* @__PURE__ */ new Set();
+		const merged = [];
+		for (const token of all) {
+			const key = token.toLowerCase();
+			if (seen.has(key)) continue;
+			seen.add(key);
+			merged.push(token);
+		}
+		return merged.join(", ");
+	}
+	setHeaders(obj) {
+		if (!this.response?.headersSent) {
+			if (obj instanceof Object) for (const head in obj) {
+				const value = obj[head];
+				if (value !== void 0) this.setHeader(head, value);
+			}
+			return this.headers = this.response?.getHeaders();
+		}
+		this.log("headers already sended ", "WARNING");
+		return this.headers = this.response.getHeaders();
+	}
+	setContentType(type, encoding) {
+		if (type && encoding) {
+			let mytype = mime.contentType(type);
+			if (mytype) {
+				mytype = mytype.split(";")[0];
+				this.contentType = mytype;
+				this.encoding = encoding;
+				if (mytype === "application/json" || mytype.endsWith("+json")) return this.setHeader("Content-Type", mytype);
+				return this.setHeader("Content-Type", `${mytype}; charset=${encoding}`);
+			}
+		}
+		if (type && !encoding) {
+			const mytype = mime.contentType(type);
+			if (mytype) {
+				this.contentType = mytype;
+				let charset = mime.charset(this.contentType);
+				if (charset) this.encoding = charset;
+				return this.setHeader("Content-Type", mytype);
+			}
+		}
+		return this.setHeader("Content-Type", `${this.contentType}; charset=${this.encoding}`);
+	}
+	setFileMimeType(type, encoding) {
+		let myType = this.getMimeType(type);
+		if (!myType) {
+			this.log(`Content-Type not valid !!! : ${type}`, "WARNING");
+			myType = "application/octet-stream";
+		}
+		this.contentType = myType;
+		return this.setContentType(myType, encoding || this.encoding);
+	}
+	setContentTypeByExtension(extention) {
+		const ismime = mime.contentType(extention);
+		if (ismime) {
+			this.contentType = ismime;
+			let charset = mime.charset(this.contentType);
+			if (charset) this.encoding = charset;
+			return this.setHeader("Content-Type", ismime);
+		}
+		this.log(`setContentTypeByExtension: ${extention}  not found`, "WARNING");
+	}
+	getMimeType(filenameOrExt) {
+		return mime.lookup(filenameOrExt);
+	}
+	setEncoding(encoding) {
+		return this.encoding = encoding;
+	}
+	setStatusCode(status, message) {
+		if (status && typeof status !== "number") {
+			status = parseInt(status, 10);
+			if (isNaN(status)) status = 500;
+		}
+		this.statusCode = status || this.statusCode;
+		if (message) {
+			const ascii = stripAnsi(message).replace(/[^\x20-\x7E]/g, "").trim();
+			this.statusMessage = ascii || (http.STATUS_CODES[this.statusCode] ?? "Unknown Error");
+		} else if (!this.statusMessage) {
+			if (http.STATUS_CODES[this.statusCode]) this.statusMessage = http.STATUS_CODES[this.statusCode];
+			else this.statusMessage = http.STATUS_CODES[500];
+		}
+		return {
+			code: this.statusCode,
+			message: this.statusMessage
+		};
+	}
+	getStatus() {
+		return {
+			code: this.getStatusCode(),
+			message: this.getStatusMessage()
+		};
+	}
+	getStatusCode() {
+		return this.statusCode;
+	}
+	getStatusMessage(code) {
+		if (code) {
+			if (this.response) return http.STATUS_CODES[code] || this.statusMessage || this.response.statusMessage;
+		}
+		if (this.response) return this.statusMessage || this.response.statusMessage || http.STATUS_CODES[this.statusCode];
+		return this.statusMessage || http.STATUS_CODES[this.statusCode];
+	}
+	setBody(ele, encoding) {
+		if (typeof ele === "string") this.body = Buffer.from(ele, encoding || this.encoding);
+		else if (ele instanceof ArrayBuffer || ele instanceof SharedArrayBuffer) this.body = Buffer.from(ele);
+		else if (ArrayBuffer.isView(ele) && ele.buffer instanceof ArrayBuffer) this.body = Buffer.from(ele.buffer, ele.byteOffset, ele.byteLength);
+		else try {
+			this.body = Buffer.from(JSON.stringify(ele));
+		} catch (e) {
+			this.body = Buffer.from(String(ele));
+		}
+		return this.body;
+	}
+	setLength(body) {
+		if (this.response?.headersSent) throw new Error("Headers already sended");
+		const actualBody = body || this.body;
+		const isChunked = this.getHeader("Transfer-Encoding") === "chunked";
+		if (!NO_CONTENT_LENGTH_METHODS.has(this.context?.method) && !NO_CONTENT_LENGTH_STATUS.has(this.statusCode) && !isChunked) {
+			if (actualBody) {
+				const length = Buffer.byteLength(actualBody);
+				this.setHeader("Content-Length", String(length));
+				return length;
+			}
+			return 0;
+		}
+		if (!NO_CONTENT_LENGTH_STATUS.has(this.statusCode)) this.setHeader("Content-Length", "0");
+		return 0;
+	}
+	writeHead(statusCode, headers) {
+		if (statusCode) this.setStatusCode(statusCode);
+		if (this.response && !this.response.headersSent) {
+			if (this.statusCode) {
+				if (typeof this.statusCode === "string") this.statusCode = parseInt(this.statusCode, 10);
+				if (this.statusCode > 599) this.statusCode = 500;
+			}
+			this.statusMessage = this.getStatusMessage();
+			if (this.context.requestId && !this.response.headersSent) this.response.setHeader("x-request-id", this.context.requestId);
+			if (this.context.traceparent && !this.response.headersSent) this.response.setHeader("traceparent", this.context.traceparent);
+			this.setLength();
+			this.ensureContentTypeHeader();
+			const std = http.STATUS_CODES[this.statusCode];
+			if (this.statusMessage === std) this.response.writeHead(this.statusCode, headers);
+			else {
+				const safeMsg = this.statusMessage.replace(/[^\x20-\x7E]/g, "").trim() || (std ?? "Unknown Error");
+				this.response.writeHead(this.statusCode, safeMsg, headers);
+			}
+		} else {
+			this.log("Headers already sent !!", "WARNING");
+			throw new Error(`Headers already sent !!`);
+		}
+	}
+	addTrailers(headers) {
+		return this.response?.addTrailers(headers);
+	}
+	flush(chunk, encoding) {
+		this.flushing = true;
+		this.setHeader("Transfer-Encoding", "chunked");
+		return this.send(chunk, encoding, true);
+	}
+	async send(chunk, encoding, _flush = false) {
+		if (this.context.isRedirect) {
+			if (!this.response?.headersSent) this.writeHead();
+			await this.end();
+			return this;
+		}
+		if (chunk) this.setBody(chunk);
+		if (!this.response) throw new Error(`Http Response not found`);
+		if (this.body === null) this.body = Buffer.alloc(0);
+		const res = this.response;
+		return new Promise((resolve) => {
+			let settled = false;
+			const done = () => {
+				if (!settled) {
+					settled = true;
+					resolve(this);
+				}
+			};
+			const onDrain = () => done();
+			if (res.write(this.body, encoding || this.encoding, (error) => {
+				if (error) {
+					this.log(error, "ERROR");
+					res.removeListener("drain", onDrain);
+					done();
+				}
+			})) done();
+			else res.once("drain", onDrain);
+		});
+	}
+	async write(chunk, encoding) {
+		return await this.send(chunk, encoding || this.encoding);
+	}
+	writeContinue() {
+		return this.response?.writeContinue();
+	}
+	async end(chunk, encoding) {
+		return new Promise((resolve, reject) => {
+			if (this.response) return resolve(this.response.end(chunk, encoding || this.encoding));
+			return reject(/* @__PURE__ */ new Error(`response not found`));
+		});
+	}
+	getHeader(name) {
+		return this.response?.getHeader(name);
+	}
+	hasHeader(name) {
+		if (this.response) return this.response.hasHeader(name);
+		throw new Error(`Respose not foud`);
+	}
+	getHeaders() {
+		return this.response?.getHeaders();
+	}
+	redirect(url, status, headers) {
+		this.context.isRedirect = true;
+		if (typeof status === "string") status = parseInt(status, 10);
+		if (typeof status !== "number" || !REDIRECT_STATUS_CODES.has(status)) {
+			if (status !== void 0 && !Number.isNaN(status)) this.log(`Invalid redirect status ${status} → fallback 302 (RFC 9110 §15.4)`, "WARNING");
+			status = 302;
+		}
+		this.setStatusCode(status);
+		if (headers) switch (typeOf(headers)) {
+			case "object":
+				this.setHeaders(headers);
+				break;
+			case "boolean": this.setHeaders({
+				"Cache-Control": "no-store, no-cache, must-revalidate",
+				Expires: "Thu, 01 Jan 1970 00:00:00 GMT"
+			});
+		}
+		this.setHeader("Location", url);
+		this.log(`REDIRECT ${status} : ${url} `, "DEBUG");
+		return this;
+	}
+	log(pci, severity, msgid, msg) {
+		if (!msgid) msgid = `${this.context.type} RESPONSE `;
+		return this.context.log(pci, severity, msgid, msg);
+	}
+};
+//#endregion
+export { HttpResponse as default };

package/dist/nodefony/src/context/http/parser.js

@@ -0,0 +1,188 @@
+import HttpError from "../../errors/httpError.js";
+import { escapeRegExp, extend } from "nodefony";
+import QS from "qs";
+import xml2js from "xml2js";
+//#region nodefony/src/context/http/parser.ts
+var Parser = class {
+	request;
+	chunks;
+	received = 0;
+	aborted = false;
+	overflow = null;
+	onOverflow = null;
+	constructor(request) {
+		this.request = request;
+		this.chunks = [];
+		this.request.request.on("data", (data) => {
+			this.write(data);
+		});
+	}
+	write(buffer) {
+		if (this.aborted) return buffer;
+		const max = this.request.maxBodySize ?? 0;
+		this.received += buffer.length;
+		if (max > 0 && this.received > max) {
+			this.aborted = true;
+			this.chunks.length = 0;
+			this.overflow = new HttpError(`Request body exceeds maxBodySize (${max} bytes)`, 413, this.request.context);
+			this.request.request.pause?.();
+			if (this.onOverflow) this.onOverflow(this.overflow);
+			return buffer;
+		}
+		this.chunks.push(buffer);
+		return buffer;
+	}
+	/**
+	* Résout quand le flux requête est **entièrement reçu** (`end`). No-op si déjà
+	* terminé (corps vide / déjà drainé) → pas de hang d'un `once("end")` tardif.
+	* Indispensable avant de concaténer les chunks pour un corps à décoder
+	* (JSON…) : sinon on lit un buffer encore incomplet. (formidable drainait via
+	* son `await form.parse()` ; ses remplaçants doivent drainer explicitement.)
+	* Rejette en 413 si le corps dépasse `maxBodySize` (avant ou pendant l'attente).
+	*/
+	ended() {
+		if (this.overflow) return Promise.reject(this.overflow);
+		const req = this.request.request;
+		return new Promise((resolve, reject) => {
+			if (req.readableEnded || req.complete) return resolve();
+			const cleanup = () => {
+				req.removeListener("end", onEnd);
+				req.removeListener("error", onError);
+				this.onOverflow = null;
+			};
+			const onEnd = () => {
+				cleanup();
+				resolve();
+			};
+			const onError = (e) => {
+				cleanup();
+				reject(e instanceof Error ? e : new Error(String(e)));
+			};
+			this.onOverflow = (err) => {
+				cleanup();
+				reject(err);
+			};
+			req.once("end", onEnd);
+			req.once("error", onError);
+		});
+	}
+	async parse() {
+		await this.ended();
+		this.request.data = Buffer.concat(this.chunks);
+		this.request.context.requestEnded = true;
+		return this;
+	}
+};
+var ParserQs = class extends Parser {
+	parserOptions;
+	charset = "utf8";
+	constructor(request) {
+		super(request);
+		this.parserOptions = this.request.queryStringOptions || {};
+		this.charset = this.request.charset;
+	}
+	async parse() {
+		await super.parse();
+		this.request.queryPost = QS.parse(this.request.data.toString(this.charset), this.parserOptions);
+		this.request.query = extend({}, this.request.query, this.request.queryPost);
+		this.request.context.requestEnded = true;
+		return this;
+	}
+};
+var ParserXml = class extends Parser {
+	xmlParser;
+	charset = "utf8";
+	constructor(request, settingsXml) {
+		super(request);
+		this.xmlParser = new xml2js.Parser(settingsXml);
+		this.charset = this.request.charset;
+	}
+	async parse() {
+		await super.parse();
+		return new Promise((resolve, reject) => {
+			this.xmlParser.parseString(this.request.data.toString(this.charset), (err, result) => {
+				if (err) return reject(err);
+				this.request.queryPost = result;
+				this.request.context.requestEnded = true;
+				return resolve(this);
+			});
+		});
+	}
+};
+/**
+* Parse un corps `application/json` (ou `*+json`) en objet → `queryPost`
+* (source lue par le décorateur `@Body`). Reprend le rôle de l'ancien plugin
+* `json` de formidable, supprimé avec le passage à busboy (multipart seul).
+* Lenient : un corps JSON malformé est ignoré (pas de throw — `parse()` est
+* invoqué non-awaité par `initialize`, un rejet serait non géré) ; le brut
+* reste disponible dans `request.data`.
+*/
+var ParserJson = class extends Parser {
+	charset = "utf8";
+	constructor(request) {
+		super(request);
+		this.charset = this.request.charset;
+	}
+	async parse() {
+		await super.parse();
+		const text = this.request.data.toString(this.charset).trim();
+		if (text) try {
+			this.request.queryPost = JSON.parse(text);
+			this.request.query = extend({}, this.request.query, this.request.queryPost);
+		} catch {}
+		this.request.context.requestEnded = true;
+		return this;
+	}
+};
+const ACCEPT_ANY = [{
+	type: /.*/,
+	subtype: /.*/
+}];
+/**
+* Construit le matcher d'un composant de media-range `Accept` (`type` ou `subtype`).
+* Le wildcard `*` devient `.*` ; **tout autre token est ÉCHAPPÉ puis ancré** avant
+* `new RegExp` — jamais passé brut.
+*
+* ⚠️ Sécurité : le `Accept` est un en-tête CLIENT arbitraire. Le passer brut à
+* `new RegExp` (ancien code) faisait **throw** sur un métacaractère non balancé —
+* ex. un token à `*` en tête (`*x`) → `SyntaxError: Nothing to repeat` — throw NON
+* rattrapé remontant dans le constructeur de la requête = **crash / DoS trivial via
+* un simple en-tête**. L'échappement rend `new RegExp` infaillible ; l'ancrage
+* corrige aussi la négociation (match du token ENTIER, pas d'une sous-chaîne).
+*/
+const acceptMatcher = (token) => !token || token === "*" ? /.*/ : new RegExp(`^${escapeRegExp(token)}$`);
+const acceptParser = function(acc) {
+	if (!acc) return ACCEPT_ANY;
+	const arr = [];
+	try {
+		const types = acc.split(",");
+		for (let i = 0; i < types.length; i++) {
+			const type = types[i].split(";");
+			const mine = type.shift();
+			if (!mine) continue;
+			const dec = mine.trim().split("/");
+			const ele1 = dec.shift();
+			const ele2 = dec.shift();
+			const obj = {
+				type: acceptMatcher(ele1),
+				subtype: acceptMatcher(ele2)
+			};
+			for (let j = 0; j < type.length; j++) {
+				const params = type[j].split("=");
+				const name = params.shift();
+				const value = params.shift();
+				obj[name] = name === "q" ? parseFloat(value) : value;
+			}
+			arr.push(obj);
+		}
+		if (arr.length === 0) return ACCEPT_ANY;
+		return arr.sort((a, b) => {
+			const qA = a.q || 1;
+			return (b.q || 1) - qA;
+		});
+	} catch {
+		return ACCEPT_ANY;
+	}
+};
+//#endregion
+export { Parser, ParserJson, ParserQs, ParserXml, acceptParser };

package/dist/nodefony/src/context/http/urlFastPath.js

@@ -0,0 +1,103 @@
+//#region nodefony/src/context/http/urlFastPath.ts
+const PATH_SAFE = /* @__PURE__ */ new Uint8Array(128);
+const SEARCH_SAFE = /* @__PURE__ */ new Uint8Array(128);
+const HOST_SAFE = /* @__PURE__ */ new Uint8Array(128);
+for (let c = 0; c < 128; c++) {
+	const ch = String.fromCharCode(c);
+	if (/[A-Za-z0-9\-._~!$&'()*+,;=:@/]/.test(ch)) PATH_SAFE[c] = 1;
+	if (c > 32 && c < 127 && !"\"#<>'".includes(ch)) SEARCH_SAFE[c] = 1;
+	if (/[a-z0-9\-._]/.test(ch)) HOST_SAFE[c] = 1;
+}
+const SLASH = 47;
+const DOT = 46;
+const QMARK = 63;
+const COLON = 58;
+/**
+* Découpe un request-target origin-form (`/path[?query]`) en
+* pathname/search SI — et seulement si — le parse WHATWG serait l'identité.
+*
+* @param target - le request-target brut (`IncomingMessage.url` en HTTP/1,
+*   pseudo-header `:path` en HTTP/2).
+* @returns les composants découpés, ou `null` (bail-out → vrai `new URL`).
+*/
+function splitTarget(target) {
+	if (typeof target !== "string" || target.length === 0) return null;
+	if (target.charCodeAt(0) !== SLASH) return null;
+	let prev = 0;
+	for (let i = 0; i < target.length; i++) {
+		const c = target.charCodeAt(i);
+		if (c >= 128) return null;
+		if (c === QMARK) {
+			for (let j = i + 1; j < target.length; j++) {
+				const s = target.charCodeAt(j);
+				if (s >= 128 || SEARCH_SAFE[s] === 0) return null;
+			}
+			return {
+				pathname: target.slice(0, i),
+				search: i === target.length - 1 ? "" : target.slice(i)
+			};
+		}
+		if (PATH_SAFE[c] === 0) return null;
+		if (c === SLASH && prev === SLASH) return null;
+		if (c === DOT && prev === SLASH) return null;
+		prev = c;
+	}
+	return {
+		pathname: target,
+		search: ""
+	};
+}
+/**
+* L'autorité (`host[:port]` brut de l'en-tête `Host` / `:authority`) est-elle
+* déjà sous la forme exacte que le parseur WHATWG rendrait ?
+*
+* Refusé (→ bail-out) : majuscules (lowercase WHATWG), IPv6 (`[`), toute
+* forme « IPv4-like » ambiguë (`127.1`, `0x7f.1`, `2130706433` — WHATWG les
+* NORMALISE en dotted-quad, un matcher les lisant brut serait contournable),
+* label vide (`a..b`, `.a`, `a.`), port par défaut du scheme (élidé par
+* WHATWG) ou avec zéro de tête, percent-encoding, non-ASCII (punycode).
+*
+* @param host - autorité brute (peut contenir `:port`).
+* @param scheme - scheme effectif (`http` | `https`) — décide du port par défaut.
+*/
+function isCanonicalAuthority(host, scheme) {
+	if (typeof host !== "string" || host.length === 0) return false;
+	let colon = -1;
+	for (let i = 0; i < host.length; i++) {
+		const c = host.charCodeAt(i);
+		if (c === COLON) {
+			if (colon !== -1) return false;
+			colon = i;
+			continue;
+		}
+		if (c >= 128 || (colon === -1 ? HOST_SAFE[c] === 0 : c < 48 || c > 57)) return false;
+	}
+	const name = colon === -1 ? host : host.slice(0, colon);
+	if (name.length === 0) return false;
+	if (colon !== -1) {
+		const port = host.slice(colon + 1);
+		if (port.length === 0 || port.charCodeAt(0) === 48) return false;
+		if (scheme === "https" && port === "443" || scheme === "http" && port === "80") return false;
+	}
+	const labels = name.split(".");
+	for (const label of labels) if (label.length === 0) return false;
+	const last = labels[labels.length - 1];
+	if (isDigits(last)) {
+		if (labels.length !== 4) return false;
+		for (const label of labels) {
+			if (!isDigits(label) || label.length > 3) return false;
+			if (label.length > 1 && label.charCodeAt(0) === 48) return false;
+			if (Number(label) > 255) return false;
+		}
+	}
+	return true;
+}
+function isDigits(s) {
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if (c < 48 || c > 57) return false;
+	}
+	return true;
+}
+//#endregion
+export { isCanonicalAuthority, splitTarget };

package/dist/nodefony/src/context/http2/Request.js

@@ -0,0 +1,29 @@
+import HttpRequest from "../http/Request.js";
+//#region nodefony/src/context/http2/Request.ts
+var Http2Request = class extends HttpRequest {
+	request;
+	constructor(request, context) {
+		super(request, context);
+		this.context = context;
+		this.request = request;
+	}
+	getHost() {
+		return this.headers[":authority"];
+	}
+	getUserAgent() {
+		return this.headers["user-agent"];
+	}
+	getMethod() {
+		return this.headers[":method"];
+	}
+	getRawTarget() {
+		return this.headers[":path"];
+	}
+	resolveScheme() {
+		if (this.forwarded?.proto) return this.forwarded.proto;
+		if (this.headers[":scheme"] === "https") return "https";
+		return "http";
+	}
+};
+//#endregion
+export { Http2Request as default };