nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/_chunks/_deps/ms.mjs

@@ -0,0 +1,172 @@
+/**
+ * Helpers.
+ */
+
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms = function (val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
+
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
+
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
+
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
+
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms;
+}
+
+export { requireMs as r };

package/dist/_chunks/_deps/node-fetch-native.mjs

@@ -0,0 +1,3 @@
+var n=Object.defineProperty;var e=(t,r)=>n(t,"name",{value:r,configurable:true});var i=Object.defineProperty,c=e((t,r)=>i(t,"name",{value:r,configurable:true}),"e");function a(){return {agent:void 0,dispatcher:void 0}}e(a,"createProxy"),c(a,"createProxy");function o(){return globalThis.fetch}e(o,"createFetch"),c(o,"createFetch");const h=globalThis.fetch;
+
+export { h };

package/dist/_chunks/_deps/nypm.mjs

@@ -0,0 +1,219 @@
+import 'node:module';
+import { v as ve } from './tinyexec.mjs';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { r as resolve, j as join, n as normalize } from './pathe.mjs';
+
+async function findup(cwd, match, options = {}) {
+  const segments = normalize(cwd).split("/");
+  while (segments.length > 0) {
+    const path = segments.join("/") || "/";
+    const result = await match(path);
+    if (result || !options.includeParentDirs) {
+      return result;
+    }
+    segments.pop();
+  }
+}
+function cached(fn) {
+  let v;
+  return () => {
+    if (v === void 0) {
+      v = fn().then((r) => {
+        v = r;
+        return v;
+      });
+    }
+    return v;
+  };
+}
+const hasCorepack = cached(async () => {
+  if (globalThis.process?.versions?.webcontainer) {
+    return false;
+  }
+  try {
+    const { exitCode } = await ve("corepack", ["--version"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+});
+async function executeCommand(command, args, options = {}) {
+  const xArgs = command === "npm" || command === "bun" || command === "deno" || !await hasCorepack() ? [command, args] : ["corepack", [command, ...args]];
+  const { exitCode, stdout, stderr } = await ve(xArgs[0], xArgs[1], {
+    nodeOptions: {
+      cwd: resolve(options.cwd || process.cwd()),
+      env: options.env,
+      stdio: options.silent ? "pipe" : "inherit"
+    }
+  });
+  if (exitCode !== 0) {
+    throw new Error(
+      `\`${xArgs.flat().join(" ")}\` failed.${options.silent ? ["", stdout, stderr].join("\n") : ""}`
+    );
+  }
+}
+const NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG = "No package manager auto-detected.";
+async function resolveOperationOptions(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const env = { ...process.env, ...options.env };
+  const packageManager = (typeof options.packageManager === "string" ? packageManagers.find((pm) => pm.name === options.packageManager) : options.packageManager) || await detectPackageManager(options.cwd || process.cwd());
+  if (!packageManager) {
+    throw new Error(NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG);
+  }
+  return {
+    cwd,
+    env,
+    silent: options.silent ?? false,
+    packageManager,
+    dev: options.dev ?? false,
+    workspace: options.workspace,
+    global: options.global ?? false,
+    dry: options.dry ?? false
+  };
+}
+function parsePackageManagerField(packageManager) {
+  const [name, _version] = (packageManager || "").split("@");
+  const [version, buildMeta] = _version?.split("+") || [];
+  if (name && name !== "-" && /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(name)) {
+    return { name, version, buildMeta };
+  }
+  const sanitized = name.replace(/\W+/g, "");
+  const warnings = [
+    `Abnormal characters found in \`packageManager\` field, sanitizing from \`${name}\` to \`${sanitized}\``
+  ];
+  return {
+    name: sanitized,
+    version,
+    buildMeta,
+    warnings
+  };
+}
+
+const packageManagers = [
+  {
+    name: "npm",
+    command: "npm",
+    lockFile: "package-lock.json"
+  },
+  {
+    name: "pnpm",
+    command: "pnpm",
+    lockFile: "pnpm-lock.yaml",
+    files: ["pnpm-workspace.yaml"]
+  },
+  {
+    name: "bun",
+    command: "bun",
+    lockFile: ["bun.lockb", "bun.lock"]
+  },
+  {
+    name: "yarn",
+    command: "yarn",
+    lockFile: "yarn.lock",
+    files: [".yarnrc.yml"]
+  },
+  {
+    name: "deno",
+    command: "deno",
+    lockFile: "deno.lock",
+    files: ["deno.json"]
+  }
+];
+async function detectPackageManager(cwd, options = {}) {
+  const detected = await findup(
+    resolve(cwd || "."),
+    async (path) => {
+      if (!options.ignorePackageJSON) {
+        const packageJSONPath = join(path, "package.json");
+        if (existsSync(packageJSONPath)) {
+          const packageJSON = JSON.parse(
+            await readFile(packageJSONPath, "utf8")
+          );
+          if (packageJSON?.packageManager) {
+            const {
+              name,
+              version = "0.0.0",
+              buildMeta,
+              warnings
+            } = parsePackageManagerField(packageJSON.packageManager);
+            if (name) {
+              const majorVersion = version.split(".")[0];
+              const packageManager = packageManagers.find(
+                (pm) => pm.name === name && pm.majorVersion === majorVersion
+              ) || packageManagers.find((pm) => pm.name === name);
+              return {
+                name,
+                command: name,
+                version,
+                majorVersion,
+                buildMeta,
+                warnings,
+                files: packageManager?.files,
+                lockFile: packageManager?.lockFile
+              };
+            }
+          }
+        }
+        const denoJSONPath = join(path, "deno.json");
+        if (existsSync(denoJSONPath)) {
+          return packageManagers.find((pm) => pm.name === "deno");
+        }
+      }
+      if (!options.ignoreLockFile) {
+        for (const packageManager of packageManagers) {
+          const detectionsFiles = [
+            packageManager.lockFile,
+            packageManager.files
+          ].flat().filter(Boolean);
+          if (detectionsFiles.some((file) => existsSync(resolve(path, file)))) {
+            return {
+              ...packageManager
+            };
+          }
+        }
+      }
+    },
+    {
+      includeParentDirs: options.includeParentDirs ?? true
+    }
+  );
+  if (!detected && !options.ignoreArgv) {
+    const scriptArg = process.argv[1];
+    if (scriptArg) {
+      for (const packageManager of packageManagers) {
+        const re = new RegExp(`[/\\\\]\\.?${packageManager.command}`);
+        if (re.test(scriptArg)) {
+          return packageManager;
+        }
+      }
+    }
+  }
+  return detected;
+}
+
+async function installDependencies(options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const pmToFrozenLockfileInstallCommand = {
+    npm: ["ci"],
+    yarn: ["install", "--immutable"],
+    bun: ["install", "--frozen-lockfile"],
+    pnpm: ["install", "--frozen-lockfile"],
+    deno: ["install", "--frozen"]
+  };
+  const commandArgs = options.frozenLockFile ? pmToFrozenLockfileInstallCommand[resolvedOptions.packageManager.name] : ["install"];
+  if (!resolvedOptions.dry) {
+    await executeCommand(resolvedOptions.packageManager.command, commandArgs, {
+      cwd: resolvedOptions.cwd,
+      silent: resolvedOptions.silent
+    });
+  }
+  return {
+    exec: {
+      command: resolvedOptions.packageManager.command,
+      args: commandArgs
+    }
+  };
+}
+
+export { installDependencies as i };

package/dist/_chunks/_deps/on-finished.mjs

@@ -0,0 +1,246 @@
+import { r as requireEeFirst } from './ee-first.mjs';
+
+var onFinished = {exports: {}};
+
+/*!
+ * on-finished
+ * Copyright(c) 2013 Jonathan Ong
+ * Copyright(c) 2014 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredOnFinished;
+
+function requireOnFinished () {
+	if (hasRequiredOnFinished) return onFinished.exports;
+	hasRequiredOnFinished = 1;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	onFinished.exports = onFinished$1;
+	onFinished.exports.isFinished = isFinished;
+
+	/**
+	 * Module dependencies.
+	 * @private
+	 */
+
+	var asyncHooks = tryRequireAsyncHooks();
+	var first = requireEeFirst();
+
+	/**
+	 * Variables.
+	 * @private
+	 */
+
+	/* istanbul ignore next */
+	var defer = typeof setImmediate === 'function'
+	  ? setImmediate
+	  : function (fn) { process.nextTick(fn.bind.apply(fn, arguments)); };
+
+	/**
+	 * Invoke callback when the response has finished, useful for
+	 * cleaning up resources afterwards.
+	 *
+	 * @param {object} msg
+	 * @param {function} listener
+	 * @return {object}
+	 * @public
+	 */
+
+	function onFinished$1 (msg, listener) {
+	  if (isFinished(msg) !== false) {
+	    defer(listener, null, msg);
+	    return msg
+	  }
+
+	  // attach the listener to the message
+	  attachListener(msg, wrap(listener));
+
+	  return msg
+	}
+
+	/**
+	 * Determine if message is already finished.
+	 *
+	 * @param {object} msg
+	 * @return {boolean}
+	 * @public
+	 */
+
+	function isFinished (msg) {
+	  var socket = msg.socket;
+
+	  if (typeof msg.finished === 'boolean') {
+	    // OutgoingMessage
+	    return Boolean(msg.finished || (socket && !socket.writable))
+	  }
+
+	  if (typeof msg.complete === 'boolean') {
+	    // IncomingMessage
+	    return Boolean(msg.upgrade || !socket || !socket.readable || (msg.complete && !msg.readable))
+	  }
+
+	  // don't know
+	  return undefined
+	}
+
+	/**
+	 * Attach a finished listener to the message.
+	 *
+	 * @param {object} msg
+	 * @param {function} callback
+	 * @private
+	 */
+
+	function attachFinishedListener (msg, callback) {
+	  var eeMsg;
+	  var eeSocket;
+	  var finished = false;
+
+	  function onFinish (error) {
+	    eeMsg.cancel();
+	    eeSocket.cancel();
+
+	    finished = true;
+	    callback(error);
+	  }
+
+	  // finished on first message event
+	  eeMsg = eeSocket = first([[msg, 'end', 'finish']], onFinish);
+
+	  function onSocket (socket) {
+	    // remove listener
+	    msg.removeListener('socket', onSocket);
+
+	    if (finished) return
+	    if (eeMsg !== eeSocket) return
+
+	    // finished on first socket event
+	    eeSocket = first([[socket, 'error', 'close']], onFinish);
+	  }
+
+	  if (msg.socket) {
+	    // socket already assigned
+	    onSocket(msg.socket);
+	    return
+	  }
+
+	  // wait for socket to be assigned
+	  msg.on('socket', onSocket);
+
+	  if (msg.socket === undefined) {
+	    // istanbul ignore next: node.js 0.8 patch
+	    patchAssignSocket(msg, onSocket);
+	  }
+	}
+
+	/**
+	 * Attach the listener to the message.
+	 *
+	 * @param {object} msg
+	 * @return {function}
+	 * @private
+	 */
+
+	function attachListener (msg, listener) {
+	  var attached = msg.__onFinished;
+
+	  // create a private single listener with queue
+	  if (!attached || !attached.queue) {
+	    attached = msg.__onFinished = createListener(msg);
+	    attachFinishedListener(msg, attached);
+	  }
+
+	  attached.queue.push(listener);
+	}
+
+	/**
+	 * Create listener on message.
+	 *
+	 * @param {object} msg
+	 * @return {function}
+	 * @private
+	 */
+
+	function createListener (msg) {
+	  function listener (err) {
+	    if (msg.__onFinished === listener) msg.__onFinished = null;
+	    if (!listener.queue) return
+
+	    var queue = listener.queue;
+	    listener.queue = null;
+
+	    for (var i = 0; i < queue.length; i++) {
+	      queue[i](err, msg);
+	    }
+	  }
+
+	  listener.queue = [];
+
+	  return listener
+	}
+
+	/**
+	 * Patch ServerResponse.prototype.assignSocket for node.js 0.8.
+	 *
+	 * @param {ServerResponse} res
+	 * @param {function} callback
+	 * @private
+	 */
+
+	// istanbul ignore next: node.js 0.8 patch
+	function patchAssignSocket (res, callback) {
+	  var assignSocket = res.assignSocket;
+
+	  if (typeof assignSocket !== 'function') return
+
+	  // res.on('socket', callback) is broken in 0.8
+	  res.assignSocket = function _assignSocket (socket) {
+	    assignSocket.call(this, socket);
+	    callback(socket);
+	  };
+	}
+
+	/**
+	 * Try to require async_hooks
+	 * @private
+	 */
+
+	function tryRequireAsyncHooks () {
+	  try {
+	    return require('async_hooks')
+	  } catch (e) {
+	    return {}
+	  }
+	}
+
+	/**
+	 * Wrap function with async resource, if possible.
+	 * AsyncResource.bind static method backported.
+	 * @private
+	 */
+
+	function wrap (fn) {
+	  var res;
+
+	  // create anonymous resource
+	  if (asyncHooks.AsyncResource) {
+	    res = new asyncHooks.AsyncResource(fn.name || 'bound-anonymous-fn');
+	  }
+
+	  // incompatible node.js
+	  if (!res || !res.runInAsyncScope) {
+	    return fn
+	  }
+
+	  // return bound function
+	  return res.runInAsyncScope.bind(res, fn, null)
+	}
+	return onFinished.exports;
+}
+
+export { requireOnFinished as r };