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

package/dist/_chunks/_deps/parseurl.mjs

@@ -1,168 +0,0 @@
-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/_chunks/_deps/path-parse.mjs

@@ -1,85 +0,0 @@
-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/_deps/pathe.mjs

@@ -1,251 +0,0 @@
-const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-function normalizeWindowsPath(input = "") {
-  if (!input) {
-    return input;
-  }
-  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
-}
-
-const _UNC_REGEX = /^[/\\]{2}/;
-const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
-const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
-const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
-const normalize = function(path) {
-  if (path.length === 0) {
-    return ".";
-  }
-  path = normalizeWindowsPath(path);
-  const isUNCPath = path.match(_UNC_REGEX);
-  const isPathAbsolute = isAbsolute(path);
-  const trailingSeparator = path[path.length - 1] === "/";
-  path = normalizeString(path, !isPathAbsolute);
-  if (path.length === 0) {
-    if (isPathAbsolute) {
-      return "/";
-    }
-    return trailingSeparator ? "./" : ".";
-  }
-  if (trailingSeparator) {
-    path += "/";
-  }
-  if (_DRIVE_LETTER_RE.test(path)) {
-    path += "/";
-  }
-  if (isUNCPath) {
-    if (!isPathAbsolute) {
-      return `//./${path}`;
-    }
-    return `//${path}`;
-  }
-  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
-};
-const join = function(...segments) {
-  let path = "";
-  for (const seg of segments) {
-    if (!seg) {
-      continue;
-    }
-    if (path.length > 0) {
-      const pathTrailing = path[path.length - 1] === "/";
-      const segLeading = seg[0] === "/";
-      const both = pathTrailing && segLeading;
-      if (both) {
-        path += seg.slice(1);
-      } else {
-        path += pathTrailing || segLeading ? seg : `/${seg}`;
-      }
-    } else {
-      path += seg;
-    }
-  }
-  return normalize(path);
-};
-function cwd() {
-  if (typeof process !== "undefined" && typeof process.cwd === "function") {
-    return process.cwd().replace(/\\/g, "/");
-  }
-  return "/";
-}
-const resolve = function(...arguments_) {
-  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-    const path = index >= 0 ? arguments_[index] : cwd();
-    if (!path || path.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path);
-  }
-  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
-    return `/${resolvedPath}`;
-  }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-function normalizeString(path, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let index = 0; index <= path.length; ++index) {
-    if (index < path.length) {
-      char = path[index];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = index;
-            dots = 0;
-            continue;
-          } else if (res.length > 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path.slice(lastSlash + 1, index)}`;
-        } else {
-          res = path.slice(lastSlash + 1, index);
-        }
-        lastSegmentLength = index - lastSlash - 1;
-      }
-      lastSlash = index;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
-    }
-  }
-  return res;
-}
-const isAbsolute = function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
-};
-const extname = function(p) {
-  if (p === "..") return "";
-  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
-  return match && match[1] || "";
-};
-const relative = function(from, to) {
-  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
-  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
-  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
-    return _to.join("/");
-  }
-  const _fromCopy = [..._from];
-  for (const segment of _fromCopy) {
-    if (_to[0] !== segment) {
-      break;
-    }
-    _from.shift();
-    _to.shift();
-  }
-  return [..._from.map(() => ".."), ..._to].join("/");
-};
-const dirname = function(p) {
-  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
-  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
-    segments[0] += "/";
-  }
-  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
-};
-const basename = function(p, extension) {
-  const segments = normalizeWindowsPath(p).split("/");
-  let lastSegment = "";
-  for (let i = segments.length - 1; i >= 0; i--) {
-    const val = segments[i];
-    if (val) {
-      lastSegment = val;
-      break;
-    }
-  }
-  return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
-};
-const parse = function(p) {
-  const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
-  const base = basename(p);
-  const extension = extname(base);
-  return {
-    root,
-    dir: dirname(p),
-    base,
-    ext: extension,
-    name: base.slice(0, base.length - extension.length)
-  };
-};
-
-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 { relative as a, basename as b, resolveAlias as c, dirname as d, extname as e, isAbsolute as i, join as j, normalize as n, parse as p, resolve as r };

package/dist/_chunks/_deps/perfect-debounce.mjs

@@ -1,88 +0,0 @@
-//#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 };