nitro-nightly 3.1.0-20251028-004953-57503e42 → 3.1.0-20251028-110430-e607b753

package/dist/_deps/parseurl.mjs

@@ -0,0 +1,168 @@
+import require$$0 from 'url';
+
+var parseurl = {exports: {}};
+
+/*!
+ * parseurl
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredParseurl;
+
+function requireParseurl () {
+	if (hasRequiredParseurl) return parseurl.exports;
+	hasRequiredParseurl = 1;
+
+	/**
+	 * Module dependencies.
+	 * @private
+	 */
+
+	var url = require$$0;
+	var parse = url.parse;
+	var Url = url.Url;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	parseurl.exports = parseurl$1;
+	parseurl.exports.original = originalurl;
+
+	/**
+	 * Parse the `req` url with memoization.
+	 *
+	 * @param {ServerRequest} req
+	 * @return {Object}
+	 * @public
+	 */
+
+	function parseurl$1 (req) {
+	  var url = req.url;
+
+	  if (url === undefined) {
+	    // URL is undefined
+	    return undefined
+	  }
+
+	  var parsed = req._parsedUrl;
+
+	  if (fresh(url, parsed)) {
+	    // Return cached URL parse
+	    return parsed
+	  }
+
+	  // Parse the URL
+	  parsed = fastparse(url);
+	  parsed._raw = url;
+
+	  return (req._parsedUrl = parsed)
+	}
+	/**
+	 * Parse the `req` original url with fallback and memoization.
+	 *
+	 * @param {ServerRequest} req
+	 * @return {Object}
+	 * @public
+	 */
+
+	function originalurl (req) {
+	  var url = req.originalUrl;
+
+	  if (typeof url !== 'string') {
+	    // Fallback
+	    return parseurl$1(req)
+	  }
+
+	  var parsed = req._parsedOriginalUrl;
+
+	  if (fresh(url, parsed)) {
+	    // Return cached URL parse
+	    return parsed
+	  }
+
+	  // Parse the URL
+	  parsed = fastparse(url);
+	  parsed._raw = url;
+
+	  return (req._parsedOriginalUrl = parsed)
+	}
+	/**
+	 * Parse the `str` url with fast-path short-cut.
+	 *
+	 * @param {string} str
+	 * @return {Object}
+	 * @private
+	 */
+
+	function fastparse (str) {
+	  if (typeof str !== 'string' || str.charCodeAt(0) !== 0x2f /* / */) {
+	    return parse(str)
+	  }
+
+	  var pathname = str;
+	  var query = null;
+	  var search = null;
+
+	  // This takes the regexp from https://github.com/joyent/node/pull/7878
+	  // Which is /^(\/[^?#\s]*)(\?[^#\s]*)?$/
+	  // And unrolls it into a for loop
+	  for (var i = 1; i < str.length; i++) {
+	    switch (str.charCodeAt(i)) {
+	      case 0x3f: /* ?  */
+	        if (search === null) {
+	          pathname = str.substring(0, i);
+	          query = str.substring(i + 1);
+	          search = str.substring(i);
+	        }
+	        break
+	      case 0x09: /* \t */
+	      case 0x0a: /* \n */
+	      case 0x0c: /* \f */
+	      case 0x0d: /* \r */
+	      case 0x20: /*    */
+	      case 0x23: /* #  */
+	      case 0xa0:
+	      case 0xfeff:
+	        return parse(str)
+	    }
+	  }
+
+	  var url = Url !== undefined
+	    ? new Url()
+	    : {};
+
+	  url.path = str;
+	  url.href = str;
+	  url.pathname = pathname;
+
+	  if (search !== null) {
+	    url.query = query;
+	    url.search = search;
+	  }
+
+	  return url
+	}
+
+	/**
+	 * Determine if parsed is still fresh for url.
+	 *
+	 * @param {string} url
+	 * @param {object} parsedUrl
+	 * @return {boolean}
+	 * @private
+	 */
+
+	function fresh (url, parsedUrl) {
+	  return typeof parsedUrl === 'object' &&
+	    parsedUrl !== null &&
+	    (Url === undefined || parsedUrl instanceof Url) &&
+	    parsedUrl._raw === url
+	}
+	return parseurl.exports;
+}
+
+export { requireParseurl as r };

package/dist/_deps/path-parse.mjs

@@ -0,0 +1,85 @@
+var pathParse = {exports: {}};
+
+var hasRequiredPathParse;
+
+function requirePathParse () {
+	if (hasRequiredPathParse) return pathParse.exports;
+	hasRequiredPathParse = 1;
+
+	var isWindows = process.platform === 'win32';
+
+	// Regex to split a windows path into into [dir, root, basename, name, ext]
+	var splitWindowsRe =
+	    /^(((?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?[\\\/]?)(?:[^\\\/]*[\\\/])*)((\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))[\\\/]*$/;
+
+	var win32 = {};
+
+	function win32SplitPath(filename) {
+	  return splitWindowsRe.exec(filename).slice(1);
+	}
+
+	win32.parse = function(pathString) {
+	  if (typeof pathString !== 'string') {
+	    throw new TypeError(
+	        "Parameter 'pathString' must be a string, not " + typeof pathString
+	    );
+	  }
+	  var allParts = win32SplitPath(pathString);
+	  if (!allParts || allParts.length !== 5) {
+	    throw new TypeError("Invalid path '" + pathString + "'");
+	  }
+	  return {
+	    root: allParts[1],
+	    dir: allParts[0] === allParts[1] ? allParts[0] : allParts[0].slice(0, -1),
+	    base: allParts[2],
+	    ext: allParts[4],
+	    name: allParts[3]
+	  };
+	};
+
+
+
+	// Split a filename into [dir, root, basename, name, ext], unix version
+	// 'root' is just a slash, or nothing.
+	var splitPathRe =
+	    /^((\/?)(?:[^\/]*\/)*)((\.{1,2}|[^\/]+?|)(\.[^.\/]*|))[\/]*$/;
+	var posix = {};
+
+
+	function posixSplitPath(filename) {
+	  return splitPathRe.exec(filename).slice(1);
+	}
+
+
+	posix.parse = function(pathString) {
+	  if (typeof pathString !== 'string') {
+	    throw new TypeError(
+	        "Parameter 'pathString' must be a string, not " + typeof pathString
+	    );
+	  }
+	  var allParts = posixSplitPath(pathString);
+	  if (!allParts || allParts.length !== 5) {
+	    throw new TypeError("Invalid path '" + pathString + "'");
+	  }
+	  
+	  return {
+	    root: allParts[1],
+	    dir: allParts[0].slice(0, -1),
+	    base: allParts[2],
+	    ext: allParts[4],
+	    name: allParts[3],
+	  };
+	};
+
+
+	if (isWindows)
+	  pathParse.exports = win32.parse;
+	else /* posix */
+	  pathParse.exports = posix.parse;
+
+	pathParse.exports.posix = posix.parse;
+	pathParse.exports.win32 = win32.parse;
+	return pathParse.exports;
+}
+
+export { requirePathParse as r };

package/dist/{_chunks/pathe.M-eThtNZ.mjs → _deps/pathe.mjs}

@@ -201,4 +201,51 @@ const parse = function(p) {
   };
 };
 
-export { relative as a, basename as b, normalizeWindowsPath as c, dirname as d, extname as e, isAbsolute as i, join as j, normalize as n, parse as p, resolve as r };
+const pathSeparators = /* @__PURE__ */ new Set(["/", "\\", void 0]);
+const normalizedAliasSymbol = Symbol.for("pathe:normalizedAlias");
+function normalizeAliases(_aliases) {
+  if (_aliases[normalizedAliasSymbol]) {
+    return _aliases;
+  }
+  const aliases = Object.fromEntries(
+    Object.entries(_aliases).sort(([a], [b]) => _compareAliases(a, b))
+  );
+  for (const key in aliases) {
+    for (const alias in aliases) {
+      if (alias === key || key.startsWith(alias)) {
+        continue;
+      }
+      if (aliases[key]?.startsWith(alias) && pathSeparators.has(aliases[key][alias.length])) {
+        aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
+      }
+    }
+  }
+  Object.defineProperty(aliases, normalizedAliasSymbol, {
+    value: true,
+    enumerable: false
+  });
+  return aliases;
+}
+function resolveAlias(path, aliases) {
+  const _path = normalizeWindowsPath(path);
+  aliases = normalizeAliases(aliases);
+  for (const [alias, to] of Object.entries(aliases)) {
+    if (!_path.startsWith(alias)) {
+      continue;
+    }
+    const _alias = hasTrailingSlash(alias) ? alias.slice(0, -1) : alias;
+    if (hasTrailingSlash(_path[_alias.length])) {
+      return join(to, _path.slice(alias.length));
+    }
+  }
+  return _path;
+}
+function _compareAliases(a, b) {
+  return b.split("/").length - a.split("/").length;
+}
+function hasTrailingSlash(path = "/") {
+  const lastChar = path[path.length - 1];
+  return lastChar === "/" || lastChar === "\\";
+}
+
+export { resolve as a, resolveAlias as b, basename as c, dirname as d, extname as e, isAbsolute as i, join as j, normalize as n, parse as p, relative as r };

package/dist/_deps/perfect-debounce.mjs

@@ -0,0 +1,88 @@
+//#region src/index.ts
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+
+export { debounce as d };