nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-122334-09c1a7a8

package/dist/_libs/gzip-size.mjs

@@ -0,0 +1,21 @@
+import { s as __toESM } from "../_chunks/DXMHy5ca.mjs";
+import { t as require_duplexer } from "./duplexer.mjs";
+import fs from "node:fs";
+import { promisify } from "node:util";
+import zlib from "node:zlib";
+import "node:stream";
+
+//#region node_modules/.pnpm/gzip-size@7.0.0/node_modules/gzip-size/index.js
+var import_duplexer = /* @__PURE__ */ __toESM(require_duplexer(), 1);
+const getOptions = (options) => ({
+	level: 9,
+	...options
+});
+const gzip = promisify(zlib.gzip);
+async function gzipSize(input, options) {
+	if (!input) return 0;
+	return (await gzip(input, getOptions(options))).length;
+}
+
+//#endregion
+export { gzipSize as t };

package/dist/_libs/hasown.mjs

@@ -0,0 +1,14 @@
+import { t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+import { t as require_function_bind } from "./function-bind.mjs";
+
+//#region node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js
+var require_hasown = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js": ((exports, module) => {
+	var call = Function.prototype.call;
+	var $hasOwn = Object.prototype.hasOwnProperty;
+	var bind = require_function_bind();
+	/** @type {import('.')} */
+	module.exports = bind.call(call, $hasOwn);
+}) });
+
+//#endregion
+export { require_hasown as t };

package/dist/_libs/http-errors.mjs

@@ -0,0 +1,436 @@
+import { i as __require, t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+import { t as require_depd } from "./depd.mjs";
+
+//#region node_modules/.pnpm/setprototypeof@1.2.0/node_modules/setprototypeof/index.js
+var require_setprototypeof = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/setprototypeof@1.2.0/node_modules/setprototypeof/index.js": ((exports, module) => {
+	module.exports = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);
+	function setProtoOf(obj, proto) {
+		obj.__proto__ = proto;
+		return obj;
+	}
+	function mixinProperties(obj, proto) {
+		for (var prop in proto) if (!Object.prototype.hasOwnProperty.call(obj, prop)) obj[prop] = proto[prop];
+		return obj;
+	}
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/codes.json
+var require_codes = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/codes.json": ((exports, module) => {
+	module.exports = {
+		"100": "Continue",
+		"101": "Switching Protocols",
+		"102": "Processing",
+		"103": "Early Hints",
+		"200": "OK",
+		"201": "Created",
+		"202": "Accepted",
+		"203": "Non-Authoritative Information",
+		"204": "No Content",
+		"205": "Reset Content",
+		"206": "Partial Content",
+		"207": "Multi-Status",
+		"208": "Already Reported",
+		"226": "IM Used",
+		"300": "Multiple Choices",
+		"301": "Moved Permanently",
+		"302": "Found",
+		"303": "See Other",
+		"304": "Not Modified",
+		"305": "Use Proxy",
+		"307": "Temporary Redirect",
+		"308": "Permanent Redirect",
+		"400": "Bad Request",
+		"401": "Unauthorized",
+		"402": "Payment Required",
+		"403": "Forbidden",
+		"404": "Not Found",
+		"405": "Method Not Allowed",
+		"406": "Not Acceptable",
+		"407": "Proxy Authentication Required",
+		"408": "Request Timeout",
+		"409": "Conflict",
+		"410": "Gone",
+		"411": "Length Required",
+		"412": "Precondition Failed",
+		"413": "Payload Too Large",
+		"414": "URI Too Long",
+		"415": "Unsupported Media Type",
+		"416": "Range Not Satisfiable",
+		"417": "Expectation Failed",
+		"418": "I'm a Teapot",
+		"421": "Misdirected Request",
+		"422": "Unprocessable Entity",
+		"423": "Locked",
+		"424": "Failed Dependency",
+		"425": "Too Early",
+		"426": "Upgrade Required",
+		"428": "Precondition Required",
+		"429": "Too Many Requests",
+		"431": "Request Header Fields Too Large",
+		"451": "Unavailable For Legal Reasons",
+		"500": "Internal Server Error",
+		"501": "Not Implemented",
+		"502": "Bad Gateway",
+		"503": "Service Unavailable",
+		"504": "Gateway Timeout",
+		"505": "HTTP Version Not Supported",
+		"506": "Variant Also Negotiates",
+		"507": "Insufficient Storage",
+		"508": "Loop Detected",
+		"509": "Bandwidth Limit Exceeded",
+		"510": "Not Extended",
+		"511": "Network Authentication Required"
+	};
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/index.js
+var require_statuses = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/index.js": ((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var codes = require_codes();
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = status;
+	status.message = codes;
+	status.code = createMessageToStatusCodeMap(codes);
+	status.codes = createStatusCodeList(codes);
+	status.redirect = {
+		300: true,
+		301: true,
+		302: true,
+		303: true,
+		305: true,
+		307: true,
+		308: true
+	};
+	status.empty = {
+		204: true,
+		205: true,
+		304: true
+	};
+	status.retry = {
+		502: true,
+		503: true,
+		504: true
+	};
+	/**
+	* Create a map of message to status code.
+	* @private
+	*/
+	function createMessageToStatusCodeMap(codes$1) {
+		var map = {};
+		Object.keys(codes$1).forEach(function forEachCode(code) {
+			var message = codes$1[code];
+			var status$1 = Number(code);
+			map[message.toLowerCase()] = status$1;
+		});
+		return map;
+	}
+	/**
+	* Create a list of all status codes.
+	* @private
+	*/
+	function createStatusCodeList(codes$1) {
+		return Object.keys(codes$1).map(function mapCode(code) {
+			return Number(code);
+		});
+	}
+	/**
+	* Get the status code for given message.
+	* @private
+	*/
+	function getStatusCode(message) {
+		var msg = message.toLowerCase();
+		if (!Object.prototype.hasOwnProperty.call(status.code, msg)) throw new Error("invalid status message: \"" + message + "\"");
+		return status.code[msg];
+	}
+	/**
+	* Get the status message for given code.
+	* @private
+	*/
+	function getStatusMessage(code) {
+		if (!Object.prototype.hasOwnProperty.call(status.message, code)) throw new Error("invalid status code: " + code);
+		return status.message[code];
+	}
+	/**
+	* Get the status code.
+	*
+	* Given a number, this will throw if it is not a known status
+	* code, otherwise the code will be returned. Given a string,
+	* the string will be parsed for a number and return the code
+	* if valid, otherwise will lookup the code assuming this is
+	* the status message.
+	*
+	* @param {string|number} code
+	* @returns {number}
+	* @public
+	*/
+	function status(code) {
+		if (typeof code === "number") return getStatusMessage(code);
+		if (typeof code !== "string") throw new TypeError("code must be a number or string");
+		var n = parseInt(code, 10);
+		if (!isNaN(n)) return getStatusMessage(n);
+		return getStatusCode(code);
+	}
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js
+var require_inherits_browser = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js": ((exports, module) => {
+	if (typeof Object.create === "function") module.exports = function inherits$1(ctor, superCtor) {
+		if (superCtor) {
+			ctor.super_ = superCtor;
+			ctor.prototype = Object.create(superCtor.prototype, { constructor: {
+				value: ctor,
+				enumerable: false,
+				writable: true,
+				configurable: true
+			} });
+		}
+	};
+	else module.exports = function inherits$1(ctor, superCtor) {
+		if (superCtor) {
+			ctor.super_ = superCtor;
+			var TempCtor = function() {};
+			TempCtor.prototype = superCtor.prototype;
+			ctor.prototype = new TempCtor();
+			ctor.prototype.constructor = ctor;
+		}
+	};
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js
+var require_inherits = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js": ((exports, module) => {
+	try {
+		var util = __require("util");
+		/* istanbul ignore next */
+		if (typeof util.inherits !== "function") throw "";
+		module.exports = util.inherits;
+	} catch (e) {
+		/* istanbul ignore next */
+		module.exports = require_inherits_browser();
+	}
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/toidentifier@1.0.1/node_modules/toidentifier/index.js
+var require_toidentifier = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/toidentifier@1.0.1/node_modules/toidentifier/index.js": ((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = toIdentifier$1;
+	/**
+	* Trasform the given string into a JavaScript identifier
+	*
+	* @param {string} str
+	* @returns {string}
+	* @public
+	*/
+	function toIdentifier$1(str) {
+		return str.split(" ").map(function(token) {
+			return token.slice(0, 1).toUpperCase() + token.slice(1);
+		}).join("").replace(/[^ _0-9a-z]/gi, "");
+	}
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/http-errors@2.0.0/node_modules/http-errors/index.js
+var require_http_errors = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/http-errors@2.0.0/node_modules/http-errors/index.js": ((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var deprecate = require_depd()("http-errors");
+	var setPrototypeOf = require_setprototypeof();
+	var statuses = require_statuses();
+	var inherits = require_inherits();
+	var toIdentifier = require_toidentifier();
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = createError;
+	module.exports.HttpError = createHttpErrorConstructor();
+	module.exports.isHttpError = createIsHttpErrorFunction(module.exports.HttpError);
+	populateConstructorExports(module.exports, statuses.codes, module.exports.HttpError);
+	/**
+	* Get the code class of a status code.
+	* @private
+	*/
+	function codeClass(status$1) {
+		return Number(String(status$1).charAt(0) + "00");
+	}
+	/**
+	* Create a new HTTP Error.
+	*
+	* @returns {Error}
+	* @public
+	*/
+	function createError() {
+		var err;
+		var msg;
+		var status$1 = 500;
+		var props = {};
+		for (var i = 0; i < arguments.length; i++) {
+			var arg = arguments[i];
+			var type = typeof arg;
+			if (type === "object" && arg instanceof Error) {
+				err = arg;
+				status$1 = err.status || err.statusCode || status$1;
+			} else if (type === "number" && i === 0) status$1 = arg;
+			else if (type === "string") msg = arg;
+			else if (type === "object") props = arg;
+			else throw new TypeError("argument #" + (i + 1) + " unsupported type " + type);
+		}
+		if (typeof status$1 === "number" && (status$1 < 400 || status$1 >= 600)) deprecate("non-error status code; use only 4xx or 5xx status codes");
+		if (typeof status$1 !== "number" || !statuses.message[status$1] && (status$1 < 400 || status$1 >= 600)) status$1 = 500;
+		var HttpError = createError[status$1] || createError[codeClass(status$1)];
+		if (!err) {
+			err = HttpError ? new HttpError(msg) : new Error(msg || statuses.message[status$1]);
+			Error.captureStackTrace(err, createError);
+		}
+		if (!HttpError || !(err instanceof HttpError) || err.status !== status$1) {
+			err.expose = status$1 < 500;
+			err.status = err.statusCode = status$1;
+		}
+		for (var key in props) if (key !== "status" && key !== "statusCode") err[key] = props[key];
+		return err;
+	}
+	/**
+	* Create HTTP error abstract base class.
+	* @private
+	*/
+	function createHttpErrorConstructor() {
+		function HttpError() {
+			throw new TypeError("cannot construct abstract class");
+		}
+		inherits(HttpError, Error);
+		return HttpError;
+	}
+	/**
+	* Create a constructor for a client error.
+	* @private
+	*/
+	function createClientErrorConstructor(HttpError, name, code) {
+		var className = toClassName(name);
+		function ClientError(message) {
+			var msg = message != null ? message : statuses.message[code];
+			var err = new Error(msg);
+			Error.captureStackTrace(err, ClientError);
+			setPrototypeOf(err, ClientError.prototype);
+			Object.defineProperty(err, "message", {
+				enumerable: true,
+				configurable: true,
+				value: msg,
+				writable: true
+			});
+			Object.defineProperty(err, "name", {
+				enumerable: false,
+				configurable: true,
+				value: className,
+				writable: true
+			});
+			return err;
+		}
+		inherits(ClientError, HttpError);
+		nameFunc(ClientError, className);
+		ClientError.prototype.status = code;
+		ClientError.prototype.statusCode = code;
+		ClientError.prototype.expose = true;
+		return ClientError;
+	}
+	/**
+	* Create function to test is a value is a HttpError.
+	* @private
+	*/
+	function createIsHttpErrorFunction(HttpError) {
+		return function isHttpError(val) {
+			if (!val || typeof val !== "object") return false;
+			if (val instanceof HttpError) return true;
+			return val instanceof Error && typeof val.expose === "boolean" && typeof val.statusCode === "number" && val.status === val.statusCode;
+		};
+	}
+	/**
+	* Create a constructor for a server error.
+	* @private
+	*/
+	function createServerErrorConstructor(HttpError, name, code) {
+		var className = toClassName(name);
+		function ServerError(message) {
+			var msg = message != null ? message : statuses.message[code];
+			var err = new Error(msg);
+			Error.captureStackTrace(err, ServerError);
+			setPrototypeOf(err, ServerError.prototype);
+			Object.defineProperty(err, "message", {
+				enumerable: true,
+				configurable: true,
+				value: msg,
+				writable: true
+			});
+			Object.defineProperty(err, "name", {
+				enumerable: false,
+				configurable: true,
+				value: className,
+				writable: true
+			});
+			return err;
+		}
+		inherits(ServerError, HttpError);
+		nameFunc(ServerError, className);
+		ServerError.prototype.status = code;
+		ServerError.prototype.statusCode = code;
+		ServerError.prototype.expose = false;
+		return ServerError;
+	}
+	/**
+	* Set the name of a function, if possible.
+	* @private
+	*/
+	function nameFunc(func, name) {
+		var desc = Object.getOwnPropertyDescriptor(func, "name");
+		if (desc && desc.configurable) {
+			desc.value = name;
+			Object.defineProperty(func, "name", desc);
+		}
+	}
+	/**
+	* Populate the exports object with constructors for every error class.
+	* @private
+	*/
+	function populateConstructorExports(exports, codes$1, HttpError) {
+		codes$1.forEach(function forEachCode(code) {
+			var CodeError;
+			var name = toIdentifier(statuses.message[code]);
+			switch (codeClass(code)) {
+				case 400:
+					CodeError = createClientErrorConstructor(HttpError, name, code);
+					break;
+				case 500:
+					CodeError = createServerErrorConstructor(HttpError, name, code);
+					break;
+			}
+			if (CodeError) {
+				exports[code] = CodeError;
+				exports[name] = CodeError;
+			}
+		});
+	}
+	/**
+	* Get a class name from a name identifier.
+	* @private
+	*/
+	function toClassName(name) {
+		return name.substr(-5) !== "Error" ? name + "Error" : name;
+	}
+}) });
+
+//#endregion
+export { require_http_errors as t };