nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-121649-98b56dfe

package/dist/_libs/send.mjs

@@ -0,0 +1,857 @@
+import { i as __require, t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+import { t as require_encodeurl } from "./encodeurl.mjs";
+import { t as require_escape_html } from "./escape-html.mjs";
+import { t as require_http_errors } from "./http-errors.mjs";
+import { n as require_ms, t as require_src } from "./debug.mjs";
+import { t as require_etag } from "./etag.mjs";
+import { t as require_fresh } from "./fresh.mjs";
+import { t as require_mime_types } from "./mime-types.mjs";
+import { t as require_on_finished } from "./on-finished.mjs";
+import { t as require_range_parser } from "./range-parser.mjs";
+
+//#region node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/codes.json
+var require_codes = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/statuses@2.0.2/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.2/node_modules/statuses/index.js
+var require_statuses = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/statuses@2.0.2/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/send@1.2.0/node_modules/send/index.js
+var require_send = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/send@1.2.0/node_modules/send/index.js": ((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var createError = require_http_errors();
+	var debug = require_src()("send");
+	var encodeUrl = require_encodeurl();
+	var escapeHtml = require_escape_html();
+	var etag = require_etag();
+	var fresh = require_fresh();
+	var fs = __require("fs");
+	var mime = require_mime_types();
+	var ms = require_ms();
+	var onFinished = require_on_finished();
+	var parseRange = require_range_parser();
+	var path = __require("path");
+	var statuses = require_statuses();
+	var Stream = __require("stream");
+	var util = __require("util");
+	/**
+	* Path function references.
+	* @private
+	*/
+	var extname = path.extname;
+	var join = path.join;
+	var normalize = path.normalize;
+	var resolve = path.resolve;
+	var sep = path.sep;
+	/**
+	* Regular expression for identifying a bytes Range header.
+	* @private
+	*/
+	var BYTES_RANGE_REGEXP = /^ *bytes=/;
+	/**
+	* Maximum value allowed for the max age.
+	* @private
+	*/
+	var MAX_MAXAGE = 3600 * 24 * 365 * 1e3;
+	/**
+	* Regular expression to match a path with a directory up component.
+	* @private
+	*/
+	var UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = send;
+	/**
+	* Return a `SendStream` for `req` and `path`.
+	*
+	* @param {object} req
+	* @param {string} path
+	* @param {object} [options]
+	* @return {SendStream}
+	* @public
+	*/
+	function send(req, path$1, options) {
+		return new SendStream(req, path$1, options);
+	}
+	/**
+	* Initialize a `SendStream` with the given `path`.
+	*
+	* @param {Request} req
+	* @param {String} path
+	* @param {object} [options]
+	* @private
+	*/
+	function SendStream(req, path$1, options) {
+		Stream.call(this);
+		var opts = options || {};
+		this.options = opts;
+		this.path = path$1;
+		this.req = req;
+		this._acceptRanges = opts.acceptRanges !== void 0 ? Boolean(opts.acceptRanges) : true;
+		this._cacheControl = opts.cacheControl !== void 0 ? Boolean(opts.cacheControl) : true;
+		this._etag = opts.etag !== void 0 ? Boolean(opts.etag) : true;
+		this._dotfiles = opts.dotfiles !== void 0 ? opts.dotfiles : "ignore";
+		if (this._dotfiles !== "ignore" && this._dotfiles !== "allow" && this._dotfiles !== "deny") throw new TypeError("dotfiles option must be \"allow\", \"deny\", or \"ignore\"");
+		this._extensions = opts.extensions !== void 0 ? normalizeList(opts.extensions, "extensions option") : [];
+		this._immutable = opts.immutable !== void 0 ? Boolean(opts.immutable) : false;
+		this._index = opts.index !== void 0 ? normalizeList(opts.index, "index option") : ["index.html"];
+		this._lastModified = opts.lastModified !== void 0 ? Boolean(opts.lastModified) : true;
+		this._maxage = opts.maxAge || opts.maxage;
+		this._maxage = typeof this._maxage === "string" ? ms(this._maxage) : Number(this._maxage);
+		this._maxage = !isNaN(this._maxage) ? Math.min(Math.max(0, this._maxage), MAX_MAXAGE) : 0;
+		this._root = opts.root ? resolve(opts.root) : null;
+	}
+	/**
+	* Inherits from `Stream`.
+	*/
+	util.inherits(SendStream, Stream);
+	/**
+	* Emit error with `status`.
+	*
+	* @param {number} status
+	* @param {Error} [err]
+	* @private
+	*/
+	SendStream.prototype.error = function error(status$1, err) {
+		if (hasListeners(this, "error")) return this.emit("error", createHttpError(status$1, err));
+		var res = this.res;
+		var doc = createHtmlDocument("Error", escapeHtml(statuses.message[status$1] || String(status$1)));
+		clearHeaders(res);
+		if (err && err.headers) setHeaders(res, err.headers);
+		res.statusCode = status$1;
+		res.setHeader("Content-Type", "text/html; charset=UTF-8");
+		res.setHeader("Content-Length", Buffer.byteLength(doc));
+		res.setHeader("Content-Security-Policy", "default-src 'none'");
+		res.setHeader("X-Content-Type-Options", "nosniff");
+		res.end(doc);
+	};
+	/**
+	* Check if the pathname ends with "/".
+	*
+	* @return {boolean}
+	* @private
+	*/
+	SendStream.prototype.hasTrailingSlash = function hasTrailingSlash() {
+		return this.path[this.path.length - 1] === "/";
+	};
+	/**
+	* Check if this is a conditional GET request.
+	*
+	* @return {Boolean}
+	* @api private
+	*/
+	SendStream.prototype.isConditionalGET = function isConditionalGET() {
+		return this.req.headers["if-match"] || this.req.headers["if-unmodified-since"] || this.req.headers["if-none-match"] || this.req.headers["if-modified-since"];
+	};
+	/**
+	* Check if the request preconditions failed.
+	*
+	* @return {boolean}
+	* @private
+	*/
+	SendStream.prototype.isPreconditionFailure = function isPreconditionFailure() {
+		var req = this.req;
+		var res = this.res;
+		var match = req.headers["if-match"];
+		if (match) {
+			var etag$1 = res.getHeader("ETag");
+			return !etag$1 || match !== "*" && parseTokenList(match).every(function(match$1) {
+				return match$1 !== etag$1 && match$1 !== "W/" + etag$1 && "W/" + match$1 !== etag$1;
+			});
+		}
+		var unmodifiedSince = parseHttpDate(req.headers["if-unmodified-since"]);
+		if (!isNaN(unmodifiedSince)) {
+			var lastModified = parseHttpDate(res.getHeader("Last-Modified"));
+			return isNaN(lastModified) || lastModified > unmodifiedSince;
+		}
+		return false;
+	};
+	/**
+	* Strip various content header fields for a change in entity.
+	*
+	* @private
+	*/
+	SendStream.prototype.removeContentHeaderFields = function removeContentHeaderFields() {
+		var res = this.res;
+		res.removeHeader("Content-Encoding");
+		res.removeHeader("Content-Language");
+		res.removeHeader("Content-Length");
+		res.removeHeader("Content-Range");
+		res.removeHeader("Content-Type");
+	};
+	/**
+	* Respond with 304 not modified.
+	*
+	* @api private
+	*/
+	SendStream.prototype.notModified = function notModified() {
+		var res = this.res;
+		debug("not modified");
+		this.removeContentHeaderFields();
+		res.statusCode = 304;
+		res.end();
+	};
+	/**
+	* Raise error that headers already sent.
+	*
+	* @api private
+	*/
+	SendStream.prototype.headersAlreadySent = function headersAlreadySent() {
+		var err = /* @__PURE__ */ new Error("Can't set headers after they are sent.");
+		debug("headers already sent");
+		this.error(500, err);
+	};
+	/**
+	* Check if the request is cacheable, aka
+	* responded with 2xx or 304 (see RFC 2616 section 14.2{5,6}).
+	*
+	* @return {Boolean}
+	* @api private
+	*/
+	SendStream.prototype.isCachable = function isCachable() {
+		var statusCode = this.res.statusCode;
+		return statusCode >= 200 && statusCode < 300 || statusCode === 304;
+	};
+	/**
+	* Handle stat() error.
+	*
+	* @param {Error} error
+	* @private
+	*/
+	SendStream.prototype.onStatError = function onStatError(error) {
+		switch (error.code) {
+			case "ENAMETOOLONG":
+			case "ENOENT":
+			case "ENOTDIR":
+				this.error(404, error);
+				break;
+			default:
+				this.error(500, error);
+				break;
+		}
+	};
+	/**
+	* Check if the cache is fresh.
+	*
+	* @return {Boolean}
+	* @api private
+	*/
+	SendStream.prototype.isFresh = function isFresh() {
+		return fresh(this.req.headers, {
+			etag: this.res.getHeader("ETag"),
+			"last-modified": this.res.getHeader("Last-Modified")
+		});
+	};
+	/**
+	* Check if the range is fresh.
+	*
+	* @return {Boolean}
+	* @api private
+	*/
+	SendStream.prototype.isRangeFresh = function isRangeFresh() {
+		var ifRange = this.req.headers["if-range"];
+		if (!ifRange) return true;
+		if (ifRange.indexOf("\"") !== -1) {
+			var etag$1 = this.res.getHeader("ETag");
+			return Boolean(etag$1 && ifRange.indexOf(etag$1) !== -1);
+		}
+		return parseHttpDate(this.res.getHeader("Last-Modified")) <= parseHttpDate(ifRange);
+	};
+	/**
+	* Redirect to path.
+	*
+	* @param {string} path
+	* @private
+	*/
+	SendStream.prototype.redirect = function redirect(path$1) {
+		var res = this.res;
+		if (hasListeners(this, "directory")) {
+			this.emit("directory", res, path$1);
+			return;
+		}
+		if (this.hasTrailingSlash()) {
+			this.error(403);
+			return;
+		}
+		var loc = encodeUrl(collapseLeadingSlashes(this.path + "/"));
+		var doc = createHtmlDocument("Redirecting", "Redirecting to " + escapeHtml(loc));
+		res.statusCode = 301;
+		res.setHeader("Content-Type", "text/html; charset=UTF-8");
+		res.setHeader("Content-Length", Buffer.byteLength(doc));
+		res.setHeader("Content-Security-Policy", "default-src 'none'");
+		res.setHeader("X-Content-Type-Options", "nosniff");
+		res.setHeader("Location", loc);
+		res.end(doc);
+	};
+	/**
+	* Pipe to `res.
+	*
+	* @param {Stream} res
+	* @return {Stream} res
+	* @api public
+	*/
+	SendStream.prototype.pipe = function pipe(res) {
+		var root = this._root;
+		this.res = res;
+		var path$1 = decode(this.path);
+		if (path$1 === -1) {
+			this.error(400);
+			return res;
+		}
+		if (~path$1.indexOf("\0")) {
+			this.error(400);
+			return res;
+		}
+		var parts;
+		if (root !== null) {
+			if (path$1) path$1 = normalize("." + sep + path$1);
+			if (UP_PATH_REGEXP.test(path$1)) {
+				debug("malicious path \"%s\"", path$1);
+				this.error(403);
+				return res;
+			}
+			parts = path$1.split(sep);
+			path$1 = normalize(join(root, path$1));
+		} else {
+			if (UP_PATH_REGEXP.test(path$1)) {
+				debug("malicious path \"%s\"", path$1);
+				this.error(403);
+				return res;
+			}
+			parts = normalize(path$1).split(sep);
+			path$1 = resolve(path$1);
+		}
+		if (containsDotFile(parts)) {
+			debug("%s dotfile \"%s\"", this._dotfiles, path$1);
+			switch (this._dotfiles) {
+				case "allow": break;
+				case "deny":
+					this.error(403);
+					return res;
+				case "ignore":
+				default:
+					this.error(404);
+					return res;
+			}
+		}
+		if (this._index.length && this.hasTrailingSlash()) {
+			this.sendIndex(path$1);
+			return res;
+		}
+		this.sendFile(path$1);
+		return res;
+	};
+	/**
+	* Transfer `path`.
+	*
+	* @param {String} path
+	* @api public
+	*/
+	SendStream.prototype.send = function send$1(path$1, stat) {
+		var len = stat.size;
+		var options = this.options;
+		var opts = {};
+		var res = this.res;
+		var req = this.req;
+		var ranges = req.headers.range;
+		var offset = options.start || 0;
+		if (res.headersSent) {
+			this.headersAlreadySent();
+			return;
+		}
+		debug("pipe \"%s\"", path$1);
+		this.setHeader(path$1, stat);
+		this.type(path$1);
+		if (this.isConditionalGET()) {
+			if (this.isPreconditionFailure()) {
+				this.error(412);
+				return;
+			}
+			if (this.isCachable() && this.isFresh()) {
+				this.notModified();
+				return;
+			}
+		}
+		len = Math.max(0, len - offset);
+		if (options.end !== void 0) {
+			var bytes = options.end - offset + 1;
+			if (len > bytes) len = bytes;
+		}
+		if (this._acceptRanges && BYTES_RANGE_REGEXP.test(ranges)) {
+			ranges = parseRange(len, ranges, { combine: true });
+			if (!this.isRangeFresh()) {
+				debug("range stale");
+				ranges = -2;
+			}
+			if (ranges === -1) {
+				debug("range unsatisfiable");
+				res.setHeader("Content-Range", contentRange("bytes", len));
+				return this.error(416, { headers: { "Content-Range": res.getHeader("Content-Range") } });
+			}
+			if (ranges !== -2 && ranges.length === 1) {
+				debug("range %j", ranges);
+				res.statusCode = 206;
+				res.setHeader("Content-Range", contentRange("bytes", len, ranges[0]));
+				offset += ranges[0].start;
+				len = ranges[0].end - ranges[0].start + 1;
+			}
+		}
+		for (var prop in options) opts[prop] = options[prop];
+		opts.start = offset;
+		opts.end = Math.max(offset, offset + len - 1);
+		res.setHeader("Content-Length", len);
+		if (req.method === "HEAD") {
+			res.end();
+			return;
+		}
+		this.stream(path$1, opts);
+	};
+	/**
+	* Transfer file for `path`.
+	*
+	* @param {String} path
+	* @api private
+	*/
+	SendStream.prototype.sendFile = function sendFile(path$1) {
+		var i = 0;
+		var self = this;
+		debug("stat \"%s\"", path$1);
+		fs.stat(path$1, function onstat(err, stat) {
+			var pathEndsWithSep = path$1[path$1.length - 1] === sep;
+			if (err && err.code === "ENOENT" && !extname(path$1) && !pathEndsWithSep) return next(err);
+			if (err) return self.onStatError(err);
+			if (stat.isDirectory()) return self.redirect(path$1);
+			if (pathEndsWithSep) return self.error(404);
+			self.emit("file", path$1, stat);
+			self.send(path$1, stat);
+		});
+		function next(err) {
+			if (self._extensions.length <= i) return err ? self.onStatError(err) : self.error(404);
+			var p = path$1 + "." + self._extensions[i++];
+			debug("stat \"%s\"", p);
+			fs.stat(p, function(err$1, stat) {
+				if (err$1) return next(err$1);
+				if (stat.isDirectory()) return next();
+				self.emit("file", p, stat);
+				self.send(p, stat);
+			});
+		}
+	};
+	/**
+	* Transfer index for `path`.
+	*
+	* @param {String} path
+	* @api private
+	*/
+	SendStream.prototype.sendIndex = function sendIndex(path$1) {
+		var i = -1;
+		var self = this;
+		function next(err) {
+			if (++i >= self._index.length) {
+				if (err) return self.onStatError(err);
+				return self.error(404);
+			}
+			var p = join(path$1, self._index[i]);
+			debug("stat \"%s\"", p);
+			fs.stat(p, function(err$1, stat) {
+				if (err$1) return next(err$1);
+				if (stat.isDirectory()) return next();
+				self.emit("file", p, stat);
+				self.send(p, stat);
+			});
+		}
+		next();
+	};
+	/**
+	* Stream `path` to the response.
+	*
+	* @param {String} path
+	* @param {Object} options
+	* @api private
+	*/
+	SendStream.prototype.stream = function stream(path$1, options) {
+		var self = this;
+		var res = this.res;
+		var stream$1 = fs.createReadStream(path$1, options);
+		this.emit("stream", stream$1);
+		stream$1.pipe(res);
+		function cleanup() {
+			stream$1.destroy();
+		}
+		onFinished(res, cleanup);
+		stream$1.on("error", function onerror(err) {
+			cleanup();
+			self.onStatError(err);
+		});
+		stream$1.on("end", function onend() {
+			self.emit("end");
+		});
+	};
+	/**
+	* Set content-type based on `path`
+	* if it hasn't been explicitly set.
+	*
+	* @param {String} path
+	* @api private
+	*/
+	SendStream.prototype.type = function type(path$1) {
+		var res = this.res;
+		if (res.getHeader("Content-Type")) return;
+		var ext = extname(path$1);
+		var type$1 = mime.contentType(ext) || "application/octet-stream";
+		debug("content-type %s", type$1);
+		res.setHeader("Content-Type", type$1);
+	};
+	/**
+	* Set response header fields, most
+	* fields may be pre-defined.
+	*
+	* @param {String} path
+	* @param {Object} stat
+	* @api private
+	*/
+	SendStream.prototype.setHeader = function setHeader(path$1, stat) {
+		var res = this.res;
+		this.emit("headers", res, path$1, stat);
+		if (this._acceptRanges && !res.getHeader("Accept-Ranges")) {
+			debug("accept ranges");
+			res.setHeader("Accept-Ranges", "bytes");
+		}
+		if (this._cacheControl && !res.getHeader("Cache-Control")) {
+			var cacheControl = "public, max-age=" + Math.floor(this._maxage / 1e3);
+			if (this._immutable) cacheControl += ", immutable";
+			debug("cache-control %s", cacheControl);
+			res.setHeader("Cache-Control", cacheControl);
+		}
+		if (this._lastModified && !res.getHeader("Last-Modified")) {
+			var modified = stat.mtime.toUTCString();
+			debug("modified %s", modified);
+			res.setHeader("Last-Modified", modified);
+		}
+		if (this._etag && !res.getHeader("ETag")) {
+			var val = etag(stat);
+			debug("etag %s", val);
+			res.setHeader("ETag", val);
+		}
+	};
+	/**
+	* Clear all headers from a response.
+	*
+	* @param {object} res
+	* @private
+	*/
+	function clearHeaders(res) {
+		for (const header of res.getHeaderNames()) res.removeHeader(header);
+	}
+	/**
+	* Collapse all leading slashes into a single slash
+	*
+	* @param {string} str
+	* @private
+	*/
+	function collapseLeadingSlashes(str) {
+		for (var i = 0; i < str.length; i++) if (str[i] !== "/") break;
+		return i > 1 ? "/" + str.substr(i) : str;
+	}
+	/**
+	* Determine if path parts contain a dotfile.
+	*
+	* @api private
+	*/
+	function containsDotFile(parts) {
+		for (var i = 0; i < parts.length; i++) {
+			var part = parts[i];
+			if (part.length > 1 && part[0] === ".") return true;
+		}
+		return false;
+	}
+	/**
+	* Create a Content-Range header.
+	*
+	* @param {string} type
+	* @param {number} size
+	* @param {array} [range]
+	*/
+	function contentRange(type, size, range) {
+		return type + " " + (range ? range.start + "-" + range.end : "*") + "/" + size;
+	}
+	/**
+	* Create a minimal HTML document.
+	*
+	* @param {string} title
+	* @param {string} body
+	* @private
+	*/
+	function createHtmlDocument(title, body) {
+		return "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<title>" + title + "</title>\n</head>\n<body>\n<pre>" + body + "</pre>\n</body>\n</html>\n";
+	}
+	/**
+	* Create a HttpError object from simple arguments.
+	*
+	* @param {number} status
+	* @param {Error|object} err
+	* @private
+	*/
+	function createHttpError(status$1, err) {
+		if (!err) return createError(status$1);
+		return err instanceof Error ? createError(status$1, err, { expose: false }) : createError(status$1, err);
+	}
+	/**
+	* decodeURIComponent.
+	*
+	* Allows V8 to only deoptimize this fn instead of all
+	* of send().
+	*
+	* @param {String} path
+	* @api private
+	*/
+	function decode(path$1) {
+		try {
+			return decodeURIComponent(path$1);
+		} catch (err) {
+			return -1;
+		}
+	}
+	/**
+	* Determine if emitter has listeners of a given type.
+	*
+	* The way to do this check is done three different ways in Node.js >= 0.10
+	* so this consolidates them into a minimal set using instance methods.
+	*
+	* @param {EventEmitter} emitter
+	* @param {string} type
+	* @returns {boolean}
+	* @private
+	*/
+	function hasListeners(emitter, type) {
+		return (typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type)) > 0;
+	}
+	/**
+	* Normalize the index option into an array.
+	*
+	* @param {boolean|string|array} val
+	* @param {string} name
+	* @private
+	*/
+	function normalizeList(val, name) {
+		var list = [].concat(val || []);
+		for (var i = 0; i < list.length; i++) if (typeof list[i] !== "string") throw new TypeError(name + " must be array of strings or false");
+		return list;
+	}
+	/**
+	* Parse an HTTP Date into a number.
+	*
+	* @param {string} date
+	* @private
+	*/
+	function parseHttpDate(date) {
+		var timestamp = date && Date.parse(date);
+		return typeof timestamp === "number" ? timestamp : NaN;
+	}
+	/**
+	* Parse a HTTP token list.
+	*
+	* @param {string} str
+	* @private
+	*/
+	function parseTokenList(str) {
+		var end = 0;
+		var list = [];
+		var start = 0;
+		for (var i = 0, len = str.length; i < len; i++) switch (str.charCodeAt(i)) {
+			case 32:
+				if (start === end) start = end = i + 1;
+				break;
+			case 44:
+				if (start !== end) list.push(str.substring(start, end));
+				start = end = i + 1;
+				break;
+			default:
+				end = i + 1;
+				break;
+		}
+		if (start !== end) list.push(str.substring(start, end));
+		return list;
+	}
+	/**
+	* Set an object of headers on a response.
+	*
+	* @param {object} res
+	* @param {object} headers
+	* @private
+	*/
+	function setHeaders(res, headers) {
+		var keys = Object.keys(headers);
+		for (var i = 0; i < keys.length; i++) {
+			var key = keys[i];
+			res.setHeader(key, headers[key]);
+		}
+	}
+}) });
+
+//#endregion
+export { require_send as t };