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

package/dist/{_chunks/_deps → _libs}/fdir.mjs

@@ -1,44 +1,36 @@
-import { createRequire } from 'module';
-import { sep, basename, dirname, resolve, normalize, relative } from 'path';
-import * as V from 'fs';
+import * as nativeFs$1 from "fs";
+import { basename, dirname, normalize, relative, resolve, sep } from "path";
+import { createRequire } from "module";
 
-//#region rolldown:runtime
+//#region node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.3/node_modules/fdir/dist/index.mjs
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-//#endregion
-//#region src/utils.ts
-function cleanPath(path) {
-	let normalized = normalize(path);
+function cleanPath(path$1) {
+	let normalized = normalize(path$1);
 	if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1);
 	return normalized;
 }
 const SLASHES_REGEX = /[\\/]/g;
-function convertSlashes(path, separator) {
-	return path.replace(SLASHES_REGEX, separator);
+function convertSlashes(path$1, separator) {
+	return path$1.replace(SLASHES_REGEX, separator);
 }
 const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-function isRootDirectory(path) {
-	return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path);
+function isRootDirectory(path$1) {
+	return path$1 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$1);
 }
-function normalizePath(path, options) {
+function normalizePath(path$1, options) {
 	const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-	const pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith(".");
-	if (resolvePaths) path = resolve(path);
-	if (normalizePath$1 || pathNeedsCleaning) path = cleanPath(path);
-	if (path === ".") return "";
-	const needsSeperator = path[path.length - 1] !== pathSeparator;
-	return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+	const pathNeedsCleaning = process.platform === "win32" && path$1.includes("/") || path$1.startsWith(".");
+	if (resolvePaths) path$1 = resolve(path$1);
+	if (normalizePath$1 || pathNeedsCleaning) path$1 = cleanPath(path$1);
+	if (path$1 === ".") return "";
+	return convertSlashes(path$1[path$1.length - 1] !== pathSeparator ? path$1 + pathSeparator : path$1, pathSeparator);
 }
-
-//#endregion
-//#region src/api/functions/join-path.ts
 function joinPathWithBasePath(filename, directoryPath) {
 	return directoryPath + filename;
 }
 function joinPathWithRelativePath(root, options) {
 	return function(filename, directoryPath) {
-		const sameRoot = directoryPath.startsWith(root);
-		if (sameRoot) return directoryPath.slice(root.length) + filename;
+		if (directoryPath.startsWith(root)) return directoryPath.slice(root.length) + filename;
 		else return convertSlashes(relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
 	};
 }
@@ -52,9 +44,6 @@ function build$7(root, options) {
 	const { relativePaths, includeBasePath } = options;
 	return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
 }
-
-//#endregion
-//#region src/api/functions/push-directory.ts
 function pushDirectoryWithRelativePath(root) {
 	return function(directoryPath, paths) {
 		paths.push(directoryPath.substring(root.length) || ".");
@@ -70,8 +59,8 @@ const pushDirectory = (directoryPath, paths) => {
 	paths.push(directoryPath || ".");
 };
 const pushDirectoryFilter = (directoryPath, paths, filters) => {
-	const path = directoryPath || ".";
-	if (filters.every((filter) => filter(path, true))) paths.push(path);
+	const path$1 = directoryPath || ".";
+	if (filters.every((filter) => filter(path$1, true))) paths.push(path$1);
 };
 const empty$2 = () => {};
 function build$6(root, options) {
@@ -80,9 +69,6 @@ function build$6(root, options) {
 	if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
 	return filters && filters.length ? pushDirectoryFilter : pushDirectory;
 }
-
-//#endregion
-//#region src/api/functions/push-file.ts
 const pushFileFilterAndCount = (filename, _paths, counts, filters) => {
 	if (filters.every((filter) => filter(filename, false))) counts.files++;
 };
@@ -103,9 +89,6 @@ function build$5(options) {
 	else if (onlyCounts) return pushFileCount;
 	else return pushFile;
 }
-
-//#endregion
-//#region src/api/functions/get-array.ts
 const getArray = (paths) => {
 	return paths;
 };
@@ -115,9 +98,6 @@ const getArrayGroup = () => {
 function build$4(options) {
 	return options.group ? getArrayGroup : getArray;
 }
-
-//#endregion
-//#region src/api/functions/group-files.ts
 const groupFiles = (groups, directory, files) => {
 	groups.push({
 		directory,
@@ -129,30 +109,27 @@ const empty = () => {};
 function build$3(options) {
 	return options.group ? groupFiles : empty;
 }
-
-//#endregion
-//#region src/api/functions/resolve-symlink.ts
-const resolveSymlinksAsync = function(path, state, callback$1) {
+const resolveSymlinksAsync = function(path$1, state, callback$1) {
 	const { queue, fs, options: { suppressErrors } } = state;
 	queue.enqueue();
-	fs.realpath(path, (error, resolvedPath) => {
+	fs.realpath(path$1, (error, resolvedPath) => {
 		if (error) return queue.dequeue(suppressErrors ? null : error, state);
-		fs.stat(resolvedPath, (error$1, stat) => {
+		fs.stat(resolvedPath, (error$1, stat$1) => {
 			if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
-			if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
-			callback$1(stat, resolvedPath);
+			if (stat$1.isDirectory() && isRecursive(path$1, resolvedPath, state)) return queue.dequeue(null, state);
+			callback$1(stat$1, resolvedPath);
 			queue.dequeue(null, state);
 		});
 	});
 };
-const resolveSymlinks = function(path, state, callback$1) {
+const resolveSymlinks = function(path$1, state, callback$1) {
 	const { queue, fs, options: { suppressErrors } } = state;
 	queue.enqueue();
 	try {
-		const resolvedPath = fs.realpathSync(path);
-		const stat = fs.statSync(resolvedPath);
-		if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return;
-		callback$1(stat, resolvedPath);
+		const resolvedPath = fs.realpathSync(path$1);
+		const stat$1 = fs.statSync(resolvedPath);
+		if (stat$1.isDirectory() && isRecursive(path$1, resolvedPath, state)) return;
+		callback$1(stat$1, resolvedPath);
 	} catch (e) {
 		if (!suppressErrors) throw e;
 	}
@@ -161,25 +138,21 @@ function build$2(options, isSynchronous) {
 	if (!options.resolveSymlinks || options.excludeSymlinks) return null;
 	return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 }
-function isRecursive(path, resolved, state) {
+function isRecursive(path$1, resolved, state) {
 	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
-	let parent = dirname(path);
+	let parent = dirname(path$1);
 	let depth = 1;
 	while (parent !== state.root && depth < 2) {
 		const resolvedPath = state.symlinks.get(parent);
-		const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
-		if (isSameRoot) depth++;
+		if (!!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath))) depth++;
 		else parent = dirname(parent);
 	}
-	state.symlinks.set(path, resolved);
+	state.symlinks.set(path$1, resolved);
 	return depth > 1;
 }
 function isRecursiveUsingRealPaths(resolved, state) {
 	return state.visited.includes(resolved + state.options.pathSeparator);
 }
-
-//#endregion
-//#region src/api/functions/invoke-callback.ts
 const onlyCountsSync = (state) => {
 	return state.counts;
 };
@@ -219,9 +192,6 @@ function build$1(options, isSynchronous) {
 	else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
 	else return isSynchronous ? defaultSync : defaultAsync;
 }
-
-//#endregion
-//#region src/api/functions/walk-directory.ts
 const readdirOpts = { withFileTypes: true };
 const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
 	state.queue.enqueue();
@@ -250,9 +220,6 @@ const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) =>
 function build(isSynchronous) {
 	return isSynchronous ? walkSync : walkAsync;
 }
-
-//#endregion
-//#region src/api/queue.ts
 /**
 * This is a custom stateless queue to track concurrent async fs calls.
 * It increments a counter whenever a call is queued and decrements it
@@ -277,9 +244,6 @@ var Queue = class {
 		}
 	}
 };
-
-//#endregion
-//#region src/api/counter.ts
 var Counter = class {
 	_files = 0;
 	_directories = 0;
@@ -303,9 +267,6 @@ var Counter = class {
 		return this._directories;
 	}
 };
-
-//#endregion
-//#region src/api/aborter.ts
 /**
 * AbortController is not supported on Node 14 so we use this until we can drop
 * support for Node 14.
@@ -316,9 +277,6 @@ var Aborter = class {
 		this.aborted = true;
 	}
 };
-
-//#endregion
-//#region src/api/walker.ts
 var Walker = class {
 	root;
 	isSynchronous;
@@ -345,7 +303,7 @@ var Walker = class {
 			symlinks: /* @__PURE__ */ new Map(),
 			visited: [""].slice(0, 0),
 			controller: new Aborter(),
-			fs: options.fs || V
+			fs: options.fs || nativeFs$1
 		};
 		this.joinPath = build$7(this.root, options);
 		this.pushDirectory = build$6(this.root, options);
@@ -370,19 +328,19 @@ var Walker = class {
 				const filename = this.joinPath(entry.name, directoryPath);
 				this.pushFile(filename, files, this.state.counts, filters);
 			} else if (entry.isDirectory()) {
-				let path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-				if (exclude && exclude(entry.name, path)) continue;
-				this.pushDirectory(path, paths, filters);
-				this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+				let path$1 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+				if (exclude && exclude(entry.name, path$1)) continue;
+				this.pushDirectory(path$1, paths, filters);
+				this.walkDirectory(this.state, path$1, path$1, depth - 1, this.walk);
 			} else if (this.resolveSymlink && entry.isSymbolicLink()) {
-				let path = joinPathWithBasePath(entry.name, directoryPath);
-				this.resolveSymlink(path, this.state, (stat, resolvedPath) => {
-					if (stat.isDirectory()) {
+				let path$1 = joinPathWithBasePath(entry.name, directoryPath);
+				this.resolveSymlink(path$1, this.state, (stat$1, resolvedPath) => {
+					if (stat$1.isDirectory()) {
 						resolvedPath = normalizePath(resolvedPath, this.state.options);
-						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return;
-						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$1 + pathSeparator)) return;
+						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$1 + pathSeparator, depth - 1, this.walk);
 					} else {
-						resolvedPath = useRealPaths ? resolvedPath : path;
+						resolvedPath = useRealPaths ? resolvedPath : path$1;
 						const filename = basename(resolvedPath);
 						const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
 						resolvedPath = this.joinPath(filename, directoryPath$1);
@@ -394,9 +352,6 @@ var Walker = class {
 		this.groupFiles(this.state.groups, directoryPath, files);
 	};
 };
-
-//#endregion
-//#region src/api/async.ts
 function promise(root, options) {
 	return new Promise((resolve$1, reject) => {
 		callback(root, options, (err, output) => {
@@ -406,19 +361,11 @@ function promise(root, options) {
 	});
 }
 function callback(root, options, callback$1) {
-	let walker = new Walker(root, options, callback$1);
-	walker.start();
+	new Walker(root, options, callback$1).start();
 }
-
-//#endregion
-//#region src/api/sync.ts
 function sync(root, options) {
-	const walker = new Walker(root, options);
-	return walker.start();
+	return new Walker(root, options).start();
 }
-
-//#endregion
-//#region src/builder/api-builder.ts
 var APIBuilder = class {
 	constructor(root, options) {
 		this.root = root;
@@ -434,9 +381,6 @@ var APIBuilder = class {
 		return sync(this.root, this.options);
 	}
 };
-
-//#endregion
-//#region src/builder/index.ts
 let pm = null;
 /* c8 ignore next 6 */
 try {
@@ -561,9 +505,10 @@ var Builder = class {
 			isMatch = globFn(patterns, ...options);
 			this.globCache[patterns.join("\0")] = isMatch;
 		}
-		this.options.filters.push((path) => isMatch(path));
+		this.options.filters.push((path$1) => isMatch(path$1));
 		return this;
 	}
 };
 
-export { Builder as B };
+//#endregion
+export { Builder as t };

package/dist/_libs/fresh.mjs

@@ -0,0 +1,85 @@
+import { t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/fresh@2.0.0/node_modules/fresh/index.js
+var require_fresh = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/fresh@2.0.0/node_modules/fresh/index.js": ((exports, module) => {
+	/**
+	* RegExp to check for no-cache token in Cache-Control.
+	* @private
+	*/
+	var CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/;
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = fresh;
+	/**
+	* Check freshness of the response using request and response headers.
+	*
+	* @param {Object} reqHeaders
+	* @param {Object} resHeaders
+	* @return {Boolean}
+	* @public
+	*/
+	function fresh(reqHeaders, resHeaders) {
+		var modifiedSince = reqHeaders["if-modified-since"];
+		var noneMatch = reqHeaders["if-none-match"];
+		if (!modifiedSince && !noneMatch) return false;
+		var cacheControl = reqHeaders["cache-control"];
+		if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl)) return false;
+		if (noneMatch) {
+			if (noneMatch === "*") return true;
+			var etag = resHeaders.etag;
+			if (!etag) return false;
+			var matches = parseTokenList(noneMatch);
+			for (var i = 0; i < matches.length; i++) {
+				var match = matches[i];
+				if (match === etag || match === "W/" + etag || "W/" + match === etag) return true;
+			}
+			return false;
+		}
+		if (modifiedSince) {
+			var lastModified = resHeaders["last-modified"];
+			if (!lastModified || !(parseHttpDate(lastModified) <= parseHttpDate(modifiedSince))) return false;
+		}
+		return true;
+	}
+	/**
+	* Parse an HTTP Date into a number.
+	*
+	* @param {string} date
+	* @private
+	*/
+	function parseHttpDate(date) {
+		var timestamp = date && Date.parse(date);
+		// istanbul ignore next: guard against date.js Date.parse patching
+		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:
+				list.push(str.substring(start, end));
+				start = end = i + 1;
+				break;
+			default:
+				end = i + 1;
+				break;
+		}
+		list.push(str.substring(start, end));
+		return list;
+	}
+}) });
+
+//#endregion
+export { require_fresh as t };

package/dist/_libs/function-bind.mjs

@@ -0,0 +1,63 @@
+import { t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js
+var require_implementation = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js": ((exports, module) => {
+	var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+	var toStr = Object.prototype.toString;
+	var max = Math.max;
+	var funcType = "[object Function]";
+	var concatty = function concatty$1(a, b) {
+		var arr = [];
+		for (var i = 0; i < a.length; i += 1) arr[i] = a[i];
+		for (var j = 0; j < b.length; j += 1) arr[j + a.length] = b[j];
+		return arr;
+	};
+	var slicy = function slicy$1(arrLike, offset) {
+		var arr = [];
+		for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) arr[j] = arrLike[i];
+		return arr;
+	};
+	var joiny = function(arr, joiner) {
+		var str = "";
+		for (var i = 0; i < arr.length; i += 1) {
+			str += arr[i];
+			if (i + 1 < arr.length) str += joiner;
+		}
+		return str;
+	};
+	module.exports = function bind(that) {
+		var target = this;
+		if (typeof target !== "function" || toStr.apply(target) !== funcType) throw new TypeError(ERROR_MESSAGE + target);
+		var args = slicy(arguments, 1);
+		var bound;
+		var binder = function() {
+			if (this instanceof bound) {
+				var result = target.apply(this, concatty(args, arguments));
+				if (Object(result) === result) return result;
+				return this;
+			}
+			return target.apply(that, concatty(args, arguments));
+		};
+		var boundLength = max(0, target.length - args.length);
+		var boundArgs = [];
+		for (var i = 0; i < boundLength; i++) boundArgs[i] = "$" + i;
+		bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
+		if (target.prototype) {
+			var Empty = function Empty$1() {};
+			Empty.prototype = target.prototype;
+			bound.prototype = new Empty();
+			Empty.prototype = null;
+		}
+		return bound;
+	};
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js
+var require_function_bind = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js": ((exports, module) => {
+	var implementation = require_implementation();
+	module.exports = Function.prototype.bind || implementation;
+}) });
+
+//#endregion
+export { require_function_bind as t };