@qzsy/vinext 0.1.7

package/dist/server/pages-i18n.d.ts

@@ -0,0 +1,106 @@
+import { NextI18nConfig } from "../config/next-config.js";
+import { DomainLocale, detectDomainLocale } from "../utils/domain-locale.js";
+
+//#region src/server/pages-i18n.d.ts
+type HeaderValue = string | string[] | undefined;
+type HeaderBag = Headers | Record<string, HeaderValue> | undefined;
+type LocaleRedirectOptions = {
+  headers?: HeaderBag;
+  nextConfig: {
+    basePath?: string;
+    i18n?: NextI18nConfig | null;
+    trailingSlash?: boolean;
+  };
+  pathLocale?: string;
+  urlParsed: {
+    hostname?: string | null;
+    pathname: string;
+    search?: string;
+  };
+};
+type PagesI18nRequestInfo = {
+  locale: string;
+  url: string;
+  hadPrefix: boolean;
+  domainLocale?: DomainLocale;
+  redirectUrl?: string;
+};
+/**
+ * Prepend the default locale prefix to a pathname when i18n is configured and
+ * the path does not already carry a locale prefix. Mirrors Next.js's
+ * server-side path normalisation in `resolve-routes.ts` (lines ~250-263):
+ *
+ *   if (!initialLocaleResult.detectedLocale && !pathname.startsWith('/_next/')) {
+ *     parsedUrl.pathname = `/${defaultLocale}${pathname === '/' ? '' : pathname}`
+ *   }
+ *
+ * Run this **before** matching against `next.config.js` redirects/rewrites
+ * (which are emitted by `applyLocaleToRoutes` in locale-prefixed forms) so
+ * that requests arriving without a locale prefix still match those rules.
+ *
+ * Skips internal paths that Next.js leaves alone:
+ *   - `/_next/*` (build assets, prerender manifests, image optimisation)
+ *   - `/__vinext/*` (vinext-internal endpoints)
+ *
+ * Returns the input unchanged when i18n is not configured or when the path
+ * already starts with one of the configured locales. The host-based default
+ * locale (i18n.domains[].defaultLocale) is preferred over the global default
+ * when supplied, matching Next.js's `domainLocale.defaultLocale` branch.
+ *
+ * Item 4 of issue #1336: without this normalisation, requests like
+ * `/to-sv` (default locale = en) against a rule `source: '/:locale/to-sv'`
+ * with `locale: false` do not match because there is no segment for
+ * `:locale`. After normalisation the request looks like `/en/to-sv` and
+ * the rule matches with `:locale=en`.
+ *
+ * Ported from Next.js: packages/next/src/server/lib/router-utils/resolve-routes.ts
+ * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/resolve-routes.ts
+ */
+declare function normalizeDefaultLocalePathname(pathname: string, i18n: NextI18nConfig | null | undefined, options?: {
+  hostname?: string | null;
+}): string;
+/**
+ * Extract locale prefix from a URL path.
+ * e.g. /fr/about -> { locale: "fr", url: "/about", hadPrefix: true }
+ *      /about    -> { locale: defaultLocale, url: "/about", hadPrefix: false }
+ */
+declare function extractLocaleFromUrl(url: string, i18nConfig: NextI18nConfig, defaultLocale?: string): {
+  locale: string;
+  url: string;
+  hadPrefix: boolean;
+};
+/**
+ * Strip a leading i18n locale segment from a URL so the result can be used for
+ * API route matching. Mirrors Next.js's base-server behaviour for Pages
+ * Router API routes: `normalizeLocalePath(pathname, i18n.locales).pathname`
+ * runs before the `/api/*` check so `/fr/api/ok` resolves to the
+ * `pages/api/ok` handler instead of 404'ing.
+ *
+ * Returns the original URL untouched when:
+ * - `i18nConfig` is null/undefined (no i18n configured)
+ * - the URL does not start with a configured locale
+ *
+ * The query string is preserved verbatim — only the path segment is stripped.
+ *
+ * Reference: packages/next/src/shared/lib/i18n/normalize-locale-path.ts.
+ */
+declare function stripI18nLocaleForApiRoute(url: string, i18nConfig: NextI18nConfig | null | undefined): string;
+/**
+ * Detect the preferred locale from the Accept-Language header.
+ * Returns the best matching locale or null.
+ */
+declare function detectLocaleFromAcceptLanguage(acceptLang: string | null | undefined, i18nConfig: NextI18nConfig): string | null;
+/**
+ * Parse the NEXT_LOCALE cookie.
+ * Returns the cookie value if it matches a configured locale, otherwise null.
+ */
+declare function parseCookieLocaleFromHeader(cookieHeader: string | null | undefined, i18nConfig: NextI18nConfig): string | null;
+declare function getLocaleRedirect({
+  headers,
+  nextConfig,
+  pathLocale,
+  urlParsed
+}: LocaleRedirectOptions): string | undefined;
+declare function resolvePagesI18nRequest(url: string, i18nConfig: NextI18nConfig, headers?: HeaderBag, hostname?: string | null, basePath?: string, trailingSlash?: boolean): PagesI18nRequestInfo;
+//#endregion
+export { detectDomainLocale, detectLocaleFromAcceptLanguage, extractLocaleFromUrl, getLocaleRedirect, normalizeDefaultLocalePathname, parseCookieLocaleFromHeader, resolvePagesI18nRequest, stripI18nLocaleForApiRoute };

package/dist/server/pages-i18n.js

@@ -0,0 +1,183 @@
+import { detectDomainLocale, normalizeDomainHostname } from "../utils/domain-locale.js";
+//#region src/server/pages-i18n.ts
+function readHeader(headers, name) {
+	if (!headers) return void 0;
+	if (headers instanceof Headers) return headers.get(name) ?? void 0;
+	const direct = headers[name];
+	if (Array.isArray(direct)) return direct.join(", ");
+	return direct;
+}
+const normalizeHostname = normalizeDomainHostname;
+/**
+* Prepend the default locale prefix to a pathname when i18n is configured and
+* the path does not already carry a locale prefix. Mirrors Next.js's
+* server-side path normalisation in `resolve-routes.ts` (lines ~250-263):
+*
+*   if (!initialLocaleResult.detectedLocale && !pathname.startsWith('/_next/')) {
+*     parsedUrl.pathname = `/${defaultLocale}${pathname === '/' ? '' : pathname}`
+*   }
+*
+* Run this **before** matching against `next.config.js` redirects/rewrites
+* (which are emitted by `applyLocaleToRoutes` in locale-prefixed forms) so
+* that requests arriving without a locale prefix still match those rules.
+*
+* Skips internal paths that Next.js leaves alone:
+*   - `/_next/*` (build assets, prerender manifests, image optimisation)
+*   - `/__vinext/*` (vinext-internal endpoints)
+*
+* Returns the input unchanged when i18n is not configured or when the path
+* already starts with one of the configured locales. The host-based default
+* locale (i18n.domains[].defaultLocale) is preferred over the global default
+* when supplied, matching Next.js's `domainLocale.defaultLocale` branch.
+*
+* Item 4 of issue #1336: without this normalisation, requests like
+* `/to-sv` (default locale = en) against a rule `source: '/:locale/to-sv'`
+* with `locale: false` do not match because there is no segment for
+* `:locale`. After normalisation the request looks like `/en/to-sv` and
+* the rule matches with `:locale=en`.
+*
+* Ported from Next.js: packages/next/src/server/lib/router-utils/resolve-routes.ts
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/resolve-routes.ts
+*/
+function normalizeDefaultLocalePathname(pathname, i18n, options = {}) {
+	if (!i18n) return pathname;
+	if (pathname.startsWith("/_next/") || pathname.startsWith("/__vinext/")) return pathname;
+	const parts = pathname.split("/", 3);
+	if (parts[1] && i18n.locales.includes(parts[1])) return pathname;
+	const defaultLocale = detectDomainLocale(i18n.domains, options.hostname ?? void 0)?.defaultLocale ?? i18n.defaultLocale;
+	if (pathname === "/") return `/${defaultLocale}`;
+	return `/${defaultLocale}${pathname}`;
+}
+/**
+* Extract locale prefix from a URL path.
+* e.g. /fr/about -> { locale: "fr", url: "/about", hadPrefix: true }
+*      /about    -> { locale: defaultLocale, url: "/about", hadPrefix: false }
+*/
+function extractLocaleFromUrl(url, i18nConfig, defaultLocale = i18nConfig.defaultLocale) {
+	const parts = url.split("?")[0].split("/").filter(Boolean);
+	const query = url.includes("?") ? url.slice(url.indexOf("?")) : "";
+	if (parts.length > 0 && i18nConfig.locales.includes(parts[0])) return {
+		locale: parts[0],
+		url: ("/" + parts.slice(1).join("/") || "/") + query,
+		hadPrefix: true
+	};
+	return {
+		locale: defaultLocale,
+		url,
+		hadPrefix: false
+	};
+}
+/**
+* Strip a leading i18n locale segment from a URL so the result can be used for
+* API route matching. Mirrors Next.js's base-server behaviour for Pages
+* Router API routes: `normalizeLocalePath(pathname, i18n.locales).pathname`
+* runs before the `/api/*` check so `/fr/api/ok` resolves to the
+* `pages/api/ok` handler instead of 404'ing.
+*
+* Returns the original URL untouched when:
+* - `i18nConfig` is null/undefined (no i18n configured)
+* - the URL does not start with a configured locale
+*
+* The query string is preserved verbatim — only the path segment is stripped.
+*
+* Reference: packages/next/src/shared/lib/i18n/normalize-locale-path.ts.
+*/
+function stripI18nLocaleForApiRoute(url, i18nConfig) {
+	if (!i18nConfig) return url;
+	const { url: stripped, hadPrefix } = extractLocaleFromUrl(url, i18nConfig);
+	return hadPrefix ? stripped : url;
+}
+/**
+* Detect the preferred locale from the Accept-Language header.
+* Returns the best matching locale or null.
+*/
+function detectLocaleFromAcceptLanguage(acceptLang, i18nConfig) {
+	if (!acceptLang) return null;
+	const langs = acceptLang.split(",").map((part) => {
+		const [lang, qPart] = part.trim().split(";");
+		const q = qPart ? parseFloat(qPart.replace("q=", "")) : 1;
+		return {
+			lang: lang.trim().toLowerCase(),
+			q
+		};
+	}).sort((a, b) => b.q - a.q);
+	for (const { lang } of langs) {
+		const exactMatch = i18nConfig.locales.find((locale) => locale.toLowerCase() === lang);
+		if (exactMatch) return exactMatch;
+		const prefix = lang.split("-")[0];
+		const prefixMatch = i18nConfig.locales.find((locale) => {
+			const lowered = locale.toLowerCase();
+			return lowered === prefix || lowered.startsWith(prefix + "-");
+		});
+		if (prefixMatch) return prefixMatch;
+	}
+	return null;
+}
+/**
+* Parse the NEXT_LOCALE cookie.
+* Returns the cookie value if it matches a configured locale, otherwise null.
+*/
+function parseCookieLocaleFromHeader(cookieHeader, i18nConfig) {
+	if (!cookieHeader) return null;
+	const match = cookieHeader.match(/(?:^|;\s*)NEXT_LOCALE=([^;]*)/);
+	if (!match) return null;
+	let value;
+	try {
+		value = decodeURIComponent(match[1].trim());
+	} catch {
+		return null;
+	}
+	const lowerValue = value.toLowerCase();
+	return i18nConfig.locales.find((locale) => locale.toLowerCase() === lowerValue) ?? null;
+}
+function formatLocalizedRootPath(locale, defaultLocale, basePath = "", trailingSlash = false, search = "") {
+	if (locale.toLowerCase() === defaultLocale.toLowerCase()) return void 0;
+	return `${`${basePath}/${locale}${trailingSlash ? "/" : ""}`.replace(/\/{2,}/g, "/")}${search}`;
+}
+function getLocaleRedirect({ headers, nextConfig, pathLocale, urlParsed }) {
+	const i18n = nextConfig.i18n;
+	if (!i18n || i18n.localeDetection === false || urlParsed.pathname !== "/") return void 0;
+	const domainLocale = detectDomainLocale(i18n.domains, urlParsed.hostname ?? void 0);
+	const defaultLocale = domainLocale?.defaultLocale || i18n.defaultLocale;
+	const preferredLocale = detectLocaleFromAcceptLanguage(readHeader(headers, "accept-language"), i18n) ?? void 0;
+	const detectedLocale = pathLocale || domainLocale?.defaultLocale || (parseCookieLocaleFromHeader(readHeader(headers, "cookie"), i18n) ?? void 0) || preferredLocale || i18n.defaultLocale;
+	const search = urlParsed.search ?? "";
+	const preferredDomain = detectDomainLocale(i18n.domains, void 0, preferredLocale);
+	if (domainLocale && preferredDomain) {
+		const sameDomain = normalizeHostname(domainLocale.domain) === normalizeHostname(preferredDomain.domain);
+		const sameLocale = preferredLocale !== void 0 && preferredDomain.defaultLocale.toLowerCase() === preferredLocale.toLowerCase();
+		if (!sameDomain || !sameLocale) {
+			const scheme = `http${preferredDomain.http ? "" : "s"}`;
+			const localePath = sameLocale || preferredLocale === void 0 ? "" : `/${preferredLocale}`;
+			const rootPath = `${nextConfig.basePath ?? ""}${localePath}${nextConfig.trailingSlash ? "/" : ""}` || "/";
+			const normalizedPath = rootPath.startsWith("/") ? rootPath : `/${rootPath}`;
+			return `${scheme}://${preferredDomain.domain}${normalizedPath}${search}`;
+		}
+	}
+	return formatLocalizedRootPath(detectedLocale, defaultLocale, nextConfig.basePath, nextConfig.trailingSlash, search);
+}
+function resolvePagesI18nRequest(url, i18nConfig, headers, hostname, basePath = "", trailingSlash = false) {
+	const domainLocale = detectDomainLocale(i18nConfig.domains, hostname ?? void 0);
+	const localeInfo = extractLocaleFromUrl(url, i18nConfig, domainLocale?.defaultLocale || i18nConfig.defaultLocale);
+	let redirectUrl;
+	if (!localeInfo.hadPrefix) redirectUrl = getLocaleRedirect({
+		headers,
+		nextConfig: {
+			basePath,
+			i18n: i18nConfig,
+			trailingSlash
+		},
+		urlParsed: {
+			hostname,
+			pathname: localeInfo.url.split("?")[0] || "/",
+			search: localeInfo.url.includes("?") ? localeInfo.url.slice(localeInfo.url.indexOf("?")) : ""
+		}
+	});
+	return {
+		...localeInfo,
+		domainLocale,
+		redirectUrl
+	};
+}
+//#endregion
+export { detectDomainLocale, detectLocaleFromAcceptLanguage, extractLocaleFromUrl, getLocaleRedirect, normalizeDefaultLocalePathname, parseCookieLocaleFromHeader, resolvePagesI18nRequest, stripI18nLocaleForApiRoute };

package/dist/server/pages-media-type.d.ts

@@ -0,0 +1,15 @@
+//#region src/server/pages-media-type.d.ts
+/**
+ * Shared media-type helpers and body-parse error for Pages API routes.
+ *
+ * Used by both api-handler.ts (Pages Router dev/prod with Node.js req/res) and
+ * pages-node-compat.ts (Pages Router fetch-based facade for Cloudflare Workers).
+ */
+declare class PagesBodyParseError extends Error {
+  readonly statusCode: number;
+  constructor(message: string, statusCode: number);
+}
+declare function getMediaType(contentType: string | null | undefined): string;
+declare function isJsonMediaType(mediaType: string): boolean;
+//#endregion
+export { PagesBodyParseError, getMediaType, isJsonMediaType };

package/dist/server/pages-media-type.js

@@ -0,0 +1,24 @@
+//#region src/server/pages-media-type.ts
+/**
+* Shared media-type helpers and body-parse error for Pages API routes.
+*
+* Used by both api-handler.ts (Pages Router dev/prod with Node.js req/res) and
+* pages-node-compat.ts (Pages Router fetch-based facade for Cloudflare Workers).
+*/
+var PagesBodyParseError = class extends Error {
+	statusCode;
+	constructor(message, statusCode) {
+		super(message);
+		this.statusCode = statusCode;
+		this.name = "PagesBodyParseError";
+	}
+};
+function getMediaType(contentType) {
+	const [type] = (contentType ?? "text/plain").split(";");
+	return type?.trim().toLowerCase() || "text/plain";
+}
+function isJsonMediaType(mediaType) {
+	return mediaType === "application/json" || mediaType === "application/ld+json";
+}
+//#endregion
+export { PagesBodyParseError, getMediaType, isJsonMediaType };

package/dist/server/pages-node-compat.d.ts

@@ -0,0 +1,55 @@
+import { PagesBodyParseError } from "./pages-media-type.js";
+import { RevalidateOptions } from "./pages-revalidate.js";
+import { Readable, Writable } from "node:stream";
+
+//#region src/server/pages-node-compat.d.ts
+type PagesRequestQuery = Record<string, string | string[]>;
+type PagesReqResRequest = Readable & {
+  method: string;
+  url: string;
+  headers: Record<string, string>;
+  query: PagesRequestQuery;
+  body: unknown;
+  cookies: Record<string, string>;
+};
+type PagesReqResHeaders = {
+  [key: string]: string | number | boolean | string[];
+};
+type PagesReqResResponse = Writable & {
+  statusCode: number;
+  readonly headersSent: boolean;
+  writeHead: (code: number, headers?: PagesReqResHeaders) => PagesReqResResponse;
+  setHeader: (name: string, value: string | number | boolean | string[]) => PagesReqResResponse;
+  getHeader: (name: string) => string | number | boolean | string[] | undefined;
+  status: (code: number) => PagesReqResResponse;
+  json: (data: unknown) => void;
+  send: (data: unknown) => void;
+  redirect: (statusOrUrl: number | string, url?: string) => void;
+  getHeaders: () => PagesReqResHeaders;
+  revalidate: (urlPath: string, opts?: RevalidateOptions) => Promise<void>;
+};
+type CreatePagesReqResOptions = {
+  body: unknown;
+  query: PagesRequestQuery;
+  request: Request;
+  url: string;
+};
+type CreatePagesReqResResult = {
+  req: PagesReqResRequest;
+  res: PagesReqResResponse;
+  responsePromise: Promise<Response>;
+};
+/**
+ * Read and parse a Pages Router API request body for the Workers/prod path.
+ *
+ * `maxBytes` defaults to the 1 MB Next.js default but may be overridden by
+ * `export const config = { api: { bodyParser: { sizeLimit: '4mb' } } }` on
+ * the route module. Handlers that opt out entirely (`bodyParser: false`)
+ * MUST skip this function so the body stream stays intact for user code.
+ *
+ * @see https://nextjs.org/docs/pages/building-your-application/routing/api-routes#custom-config
+ */
+declare function parsePagesApiBody(request: Request, maxBytes?: number): Promise<unknown>;
+declare function createPagesReqRes(options: CreatePagesReqResOptions): CreatePagesReqResResult;
+//#endregion
+export { PagesBodyParseError as PagesApiBodyParseError, PagesReqResRequest, PagesReqResResponse, PagesRequestQuery, createPagesReqRes, parsePagesApiBody };

package/dist/server/pages-node-compat.js

@@ -0,0 +1,235 @@
+import { parseCookieHeader } from "../utils/parse-cookie.js";
+import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
+import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
+import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT } from "./pages-body-parser-config.js";
+import { performOnDemandRevalidate } from "./pages-revalidate.js";
+import { decode } from "node:querystring";
+import { Readable, Writable } from "node:stream";
+//#region src/server/pages-node-compat.ts
+const MAX_PAGES_API_BODY_SIZE = DEFAULT_PAGES_API_BODY_SIZE_LIMIT;
+async function readPagesRequestBodyWithLimit(request, maxBytes) {
+	if (!request.body) return "";
+	return readStreamAsTextWithLimit(request.body, maxBytes, () => {
+		throw new PagesBodyParseError("Request body too large", 413);
+	});
+}
+/**
+* Read and parse a Pages Router API request body for the Workers/prod path.
+*
+* `maxBytes` defaults to the 1 MB Next.js default but may be overridden by
+* `export const config = { api: { bodyParser: { sizeLimit: '4mb' } } }` on
+* the route module. Handlers that opt out entirely (`bodyParser: false`)
+* MUST skip this function so the body stream stays intact for user code.
+*
+* @see https://nextjs.org/docs/pages/building-your-application/routing/api-routes#custom-config
+*/
+async function parsePagesApiBody(request, maxBytes = MAX_PAGES_API_BODY_SIZE) {
+	if (Number.parseInt(request.headers.get("content-length") || "0", 10) > maxBytes) throw new PagesBodyParseError("Request body too large", 413);
+	let rawBody = "";
+	try {
+		rawBody = await readPagesRequestBodyWithLimit(request, maxBytes);
+	} catch (err) {
+		if (err instanceof PagesBodyParseError) throw err;
+		throw new PagesBodyParseError("Request body too large", 413);
+	}
+	const mediaType = getMediaType(request.headers.get("content-type"));
+	if (!rawBody) return isJsonMediaType(mediaType) ? {} : mediaType === "application/x-www-form-urlencoded" ? decode(rawBody) : void 0;
+	if (isJsonMediaType(mediaType)) try {
+		return JSON.parse(rawBody);
+	} catch {
+		throw new PagesBodyParseError("Invalid JSON", 400);
+	}
+	if (mediaType === "application/x-www-form-urlencoded") return decode(rawBody);
+	return rawBody;
+}
+async function* requestBodyChunks(request) {
+	if (!request.body || request.bodyUsed) return;
+	const reader = request.body.getReader();
+	try {
+		for (;;) {
+			const { value, done } = await reader.read();
+			if (done) return;
+			yield Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+		}
+	} finally {
+		try {
+			await reader.cancel();
+		} catch {}
+		reader.releaseLock();
+	}
+}
+function createRequestReadable(request) {
+	return Readable.from(requestBodyChunks(request), { objectMode: false });
+}
+var PagesResponseStream = class extends Writable {
+	resolveResponse;
+	rejectResponse;
+	requestHeaders;
+	resStatusCode = 200;
+	resHeaders = {};
+	setCookieHeaders = [];
+	resolved = false;
+	controller = null;
+	bufferedChunks = [];
+	streamEnded = false;
+	constructor(resolveResponse, rejectResponse, requestHeaders) {
+		super();
+		this.resolveResponse = resolveResponse;
+		this.rejectResponse = rejectResponse;
+		this.requestHeaders = requestHeaders;
+		this.once("error", (err) => {
+			if (!this.resolved) {
+				this.resolved = true;
+				this.rejectResponse(err);
+			}
+		});
+	}
+	get statusCode() {
+		return this.resStatusCode;
+	}
+	set statusCode(code) {
+		this.resStatusCode = code;
+	}
+	get headersSent() {
+		return this.writableEnded || this.resolved;
+	}
+	writeHead(code, headers) {
+		this.resStatusCode = code;
+		if (headers) for (const [key, value] of Object.entries(headers)) this.setHeaderValue(key, value, { replaceSetCookie: false });
+		return this;
+	}
+	setHeader(name, value) {
+		this.setHeaderValue(name, value, { replaceSetCookie: true });
+		return this;
+	}
+	getHeader(name) {
+		if (name.toLowerCase() === "set-cookie") return this.setCookieHeaders.length > 0 ? this.setCookieHeaders : void 0;
+		return this.resHeaders[name.toLowerCase()];
+	}
+	status(code) {
+		this.resStatusCode = code;
+		return this;
+	}
+	json(data) {
+		this.resHeaders["content-type"] = "application/json";
+		this.end(JSON.stringify(data));
+	}
+	send(data) {
+		if (Buffer.isBuffer(data)) {
+			if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "application/octet-stream";
+			this.resHeaders["content-length"] = String(data.length);
+			this.end(data);
+			return;
+		}
+		if (typeof data === "object" && data !== null) {
+			this.resHeaders["content-type"] = "application/json";
+			this.end(JSON.stringify(data));
+			return;
+		}
+		if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "text/plain";
+		this.end(String(data));
+	}
+	redirect(statusOrUrl, url) {
+		if (typeof statusOrUrl === "string") this.writeHead(307, { Location: statusOrUrl });
+		else this.writeHead(statusOrUrl, { Location: url ?? "" });
+		this.end();
+	}
+	getHeaders() {
+		const headers = { ...this.resHeaders };
+		if (this.setCookieHeaders.length > 0) headers["set-cookie"] = this.setCookieHeaders;
+		return headers;
+	}
+	async revalidate(urlPath, opts) {
+		await performOnDemandRevalidate(this.requestHeaders, urlPath, opts);
+	}
+	_write(chunk, encoding, callback) {
+		const buffer = typeof chunk === "string" ? Buffer.from(chunk, encoding) : Buffer.from(chunk);
+		if (this.controller && !this.streamEnded) try {
+			this.controller.enqueue(buffer);
+		} catch {}
+		else this.bufferedChunks.push(buffer);
+		this.resolveOnce();
+		callback();
+	}
+	_final(callback) {
+		this.streamEnded = true;
+		if (this.controller) try {
+			this.controller.close();
+		} catch {}
+		this.resolveOnce();
+		callback();
+	}
+	_destroy(error, callback) {
+		this.streamEnded = true;
+		if (!this.resolved) if (error) {
+			this.resolved = true;
+			this.rejectResponse(error);
+		} else this.resolveOnce();
+		if (this.controller) try {
+			if (error) this.controller.error(error);
+			else this.controller.close();
+		} catch {}
+		callback(error);
+	}
+	setHeaderValue(name, value, options) {
+		if (name.toLowerCase() === "set-cookie") {
+			if (options.replaceSetCookie) this.setCookieHeaders.length = 0;
+			if (Array.isArray(value)) this.setCookieHeaders.push(...value.map(String));
+			else this.setCookieHeaders.push(String(value));
+			return;
+		}
+		this.resHeaders[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+	}
+	resolveOnce() {
+		if (this.resolved) return;
+		this.resolved = true;
+		const headers = new Headers();
+		for (const [key, value] of Object.entries(this.resHeaders)) headers.set(key, String(value));
+		for (const cookie of this.setCookieHeaders) headers.append("set-cookie", cookie);
+		const stream = new ReadableStream({
+			start: (controller) => {
+				this.controller = controller;
+				for (const buffer of this.bufferedChunks) try {
+					controller.enqueue(buffer);
+				} catch {}
+				this.bufferedChunks.length = 0;
+				if (this.streamEnded) try {
+					controller.close();
+				} catch {}
+			},
+			cancel: (reason) => {
+				this.bufferedChunks.length = 0;
+				this.destroy(reason instanceof Error ? reason : /* @__PURE__ */ new Error("Response body cancelled"));
+			}
+		});
+		this.resolveResponse(new Response(stream, {
+			status: this.resStatusCode,
+			headers
+		}));
+	}
+};
+function createPagesReqRes(options) {
+	const headersObj = {};
+	for (const [key, value] of options.request.headers) headersObj[key.toLowerCase()] = value;
+	const req = Object.assign(createRequestReadable(options.request), {
+		method: options.request.method,
+		url: options.url,
+		headers: headersObj,
+		query: options.query,
+		body: options.body,
+		cookies: parseCookieHeader(options.request.headers.get("cookie"))
+	});
+	let resolveResponse;
+	let rejectResponse;
+	const responsePromise = new Promise((resolve, reject) => {
+		resolveResponse = resolve;
+		rejectResponse = reject;
+	});
+	return {
+		req,
+		res: new PagesResponseStream(resolveResponse, rejectResponse, options.request.headers),
+		responsePromise
+	};
+}
+//#endregion
+export { PagesBodyParseError as PagesApiBodyParseError, createPagesReqRes, parsePagesApiBody };