nitro 3.0.1-alpha.2 → 3.0.260415-beta

package/dist/_libs/{c12+giget+readdirp+chokidar.d.mts → c12+readdirp+chokidar.d.mts}

@@ -1,10 +1,35 @@
 import { Stats } from "node:fs";
-import { Jiti, JitiOptions } from "jiti";
 import { EventEmitter } from "node:events";
 import { Readable } from "node:stream";
-import { diff } from "ohash/utils";
-
-//#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.d.ts
+import { DownloadTemplateOptions } from "giget";
+//#region node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/utils/index.d.mts
+/**
+ * Calculates the difference between two objects and returns a list of differences.
+ *
+ * @param {any} obj1 - The first object to compare.
+ * @param {any} obj2 - The second object to compare.
+ * @param {HashOptions} [opts={}] - Configuration options for hashing the objects. See {@link HashOptions}.
+ * @returns {DiffEntry[]} An array with the differences between the two objects.
+ */
+declare function diff(obj1: any, obj2: any): DiffEntry[];
+declare class DiffEntry {
+  key: string;
+  type: "changed" | "added" | "removed";
+  newValue: DiffHashedObject;
+  oldValue?: DiffHashedObject | undefined;
+  constructor(key: string, type: "changed" | "added" | "removed", newValue: DiffHashedObject, oldValue?: DiffHashedObject | undefined);
+  toString(): string;
+  toJSON(): string;
+}
+declare class DiffHashedObject {
+  key: string;
+  value: any;
+  hash?: string | undefined;
+  props?: Record<string, DiffHashedObject> | undefined;
+  constructor(key: string, value: any, hash?: string | undefined, props?: Record<string, DiffHashedObject> | undefined);
+  toString(): string;
+  toJSON(): string;
+} //#endregion
 type AWF = {
   stabilityThreshold: number;
   pollInterval: number;
@@ -32,39 +57,6 @@ interface MatcherObject {
   recursive?: boolean;
 }
 type Matcher = string | RegExp | MatchFunction | MatcherObject;
-//#endregion
-//#region node_modules/.pnpm/giget@2.0.0/node_modules/giget/dist/index.d.mts
-interface TemplateInfo {
-  name: string;
-  tar: string;
-  version?: string;
-  subdir?: string;
-  url?: string;
-  defaultDir?: string;
-  headers?: Record<string, string | undefined>;
-  source?: never;
-  dir?: never;
-  [key: string]: any;
-}
-type TemplateProvider = (input: string, options: {
-  auth?: string;
-}) => TemplateInfo | Promise<TemplateInfo> | null;
-interface DownloadTemplateOptions {
-  provider?: string;
-  force?: boolean;
-  forceClean?: boolean;
-  offline?: boolean;
-  preferOffline?: boolean;
-  providers?: Record<string, TemplateProvider>;
-  dir?: string;
-  registry?: false | string;
-  cwd?: string;
-  auth?: string;
-  install?: boolean;
-  silent?: boolean;
-}
-//#endregion
-//#region node_modules/.pnpm/c12@3.3.3_magicast@0.5.1/node_modules/c12/dist/index.d.mts
 //#region src/dotenv.d.ts
 interface DotenvOptions {
   /**
@@ -94,6 +86,22 @@ interface DotenvOptions {
    * An object describing environment variables (key, value pairs).
    */
   env?: NodeJS.ProcessEnv;
+  /**
+   * Resolve `_FILE` suffixed environment variables by reading the file at the
+   * specified path and assigning its trimmed content to the base key.
+   *
+   * This is useful for container secrets (e.g. Docker, Kubernetes) where
+   * sensitive values are mounted as files.
+   *
+   * @default false
+   *
+   * @example
+   * ```env
+   * DATABASE_PASSWORD_FILE="/run/secrets/db_password"
+   * # resolves to DATABASE_PASSWORD=<contents of /run/secrets/db_password>
+   * ```
+   */
+  expandFileReferences?: boolean;
 }
 declare global {
   var __c12_dotenv_vars__: Map<Record<string, any>, Set<string>>;
@@ -176,8 +184,10 @@ interface LoadConfigOptions<T extends UserInputConfig = UserInputConfig, MT exte
   /** Context passed to config functions */
   context?: ConfigFunctionContext;
   resolve?: (id: string, options: LoadConfigOptions<T, MT>) => null | undefined | ResolvedConfig<T, MT> | Promise<ResolvedConfig<T, MT> | undefined | null>;
-  jiti?: Jiti;
-  jitiOptions?: JitiOptions;
+  /** Custom import function used to load configuration files */
+  import?: (id: string) => Promise<unknown>;
+  /** Custom resolver for picking which export to use from the loaded module. Default: `(mod) => mod.default || mod` */
+  resolveModule?: (mod: any) => any;
   giget?: false | DownloadTemplateOptions;
   merger?: (...sources: Array<T | null | undefined>) => T;
   extend?: false | {
@@ -210,5 +220,4 @@ interface WatchConfigOptions<T extends UserInputConfig = UserInputConfig, MT ext
     oldConfig: ResolvedConfig<T, MT>;
   }) => void | Promise<void>;
 }
-//#endregion
 export { WatchConfigOptions as a, ResolvedConfig as i, ConfigWatcher as n, ChokidarOptions as o, DotenvOptions as r, C12InputConfig as t };

package/dist/_libs/citty.mjs

@@ -1,6 +1,4 @@
 import { parseArgs } from "node:util";
-
-//#region node_modules/.pnpm/citty@0.2.0/node_modules/citty/dist/_chunks/libs/scule.mjs
 const NUMBER_CHAR_RE = /\d/;
 const STR_SPLITTERS = [
 	"-",
@@ -65,9 +63,9 @@ function camelCase(str, opts) {
 function kebabCase(str, joiner) {
 	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
 }
-
-//#endregion
-//#region node_modules/.pnpm/citty@0.2.0/node_modules/citty/dist/index.mjs
+function snakeCase(str) {
+	return kebabCase(str || "", "_");
+}
 function toArray(val) {
 	if (Array.isArray(val)) return val;
 	return val === void 0 ? [] : [val];
@@ -113,6 +111,12 @@ function parseRawArgs(args = [], opts = {}) {
 		for (const alias of aliases) if (booleans.has(alias)) return "boolean";
 		return "string";
 	}
+	function isStringType(name) {
+		if (strings.has(name)) return true;
+		const aliases = mainToAliases.get(name) || [];
+		for (const alias of aliases) if (strings.has(alias)) return true;
+		return false;
+	}
 	const allOptions = new Set([
 		...booleans,
 		...strings,
@@ -156,11 +160,23 @@ function parseRawArgs(args = [], opts = {}) {
 	}
 	const out = { _: [] };
 	out._ = parsed.positionals;
-	for (const [key, value] of Object.entries(parsed.values)) out[key] = value;
-	for (const [name] of Object.entries(negatedFlags)) out[name] = false;
+	for (const [key, value] of Object.entries(parsed.values)) {
+		let coerced = value;
+		if (getType(key) === "boolean" && typeof value === "string") coerced = value !== "false";
+		else if (isStringType(key) && typeof value === "boolean") coerced = "";
+		out[key] = coerced;
+	}
+	for (const [name] of Object.entries(negatedFlags)) {
+		out[name] = false;
+		const mainName = aliasToMain.get(name);
+		if (mainName) out[mainName] = false;
+		const aliases = mainToAliases.get(name);
+		if (aliases) for (const alias of aliases) out[alias] = false;
+	}
 	for (const [alias, main] of aliasToMain.entries()) {
 		if (out[alias] !== void 0 && out[main] === void 0) out[main] = out[alias];
 		if (out[main] !== void 0 && out[alias] === void 0) out[alias] = out[main];
+		if (out[alias] !== out[main] && defaults[main] === out[main]) out[main] = out[alias];
 	}
 	return out;
 }
@@ -222,6 +238,9 @@ function resolveArgs(argsDef) {
 	});
 	return args;
 }
+async function resolvePlugins(plugins) {
+	return Promise.all(plugins.map((p) => resolveValue(p)));
+}
 function defineCommand(def) {
 	return def;
 }
@@ -234,35 +253,92 @@ async function runCommand(cmd, opts) {
 		data: opts.data,
 		cmd
 	};
-	if (typeof cmd.setup === "function") await cmd.setup(context);
+	const plugins = await resolvePlugins(cmd.plugins ?? []);
 	let result;
+	let runError;
 	try {
+		for (const plugin of plugins) await plugin.setup?.(context);
+		if (typeof cmd.setup === "function") await cmd.setup(context);
 		const subCommands = await resolveValue(cmd.subCommands);
 		if (subCommands && Object.keys(subCommands).length > 0) {
-			const subCommandArgIndex = opts.rawArgs.findIndex((arg) => !arg.startsWith("-"));
-			const subCommandName = opts.rawArgs[subCommandArgIndex];
-			if (subCommandName) {
-				if (!subCommands[subCommandName]) throw new CLIError(`Unknown command ${cyan(subCommandName)}`, "E_UNKNOWN_COMMAND");
-				const subCommand = await resolveValue(subCommands[subCommandName]);
-				if (subCommand) await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
-			} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+			const subCommandArgIndex = findSubCommandIndex(opts.rawArgs, cmdArgs);
+			const explicitName = opts.rawArgs[subCommandArgIndex];
+			if (explicitName) {
+				const subCommand = await _findSubCommand(subCommands, explicitName);
+				if (!subCommand) throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
+				await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+			} else {
+				const defaultSubCommand = await resolveValue(cmd.default);
+				if (defaultSubCommand) {
+					if (cmd.run) throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
+					const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
+					if (!subCommand) throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
+					await runCommand(subCommand, { rawArgs: opts.rawArgs });
+				} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+			}
 		}
 		if (typeof cmd.run === "function") result = await cmd.run(context);
-	} finally {
-		if (typeof cmd.cleanup === "function") await cmd.cleanup(context);
+	} catch (error) {
+		runError = error;
+	}
+	const cleanupErrors = [];
+	if (typeof cmd.cleanup === "function") try {
+		await cmd.cleanup(context);
+	} catch (error) {
+		cleanupErrors.push(error);
 	}
+	for (const plugin of [...plugins].reverse()) try {
+		await plugin.cleanup?.(context);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	if (runError) throw runError;
+	if (cleanupErrors.length === 1) throw cleanupErrors[0];
+	if (cleanupErrors.length > 1) throw new Error("Multiple cleanup errors", { cause: cleanupErrors });
 	return { result };
 }
 async function resolveSubCommand(cmd, rawArgs, parent) {
 	const subCommands = await resolveValue(cmd.subCommands);
 	if (subCommands && Object.keys(subCommands).length > 0) {
-		const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
+		const subCommandArgIndex = findSubCommandIndex(rawArgs, await resolveValue(cmd.args || {}));
 		const subCommandName = rawArgs[subCommandArgIndex];
-		const subCommand = await resolveValue(subCommands[subCommandName]);
+		const subCommand = await _findSubCommand(subCommands, subCommandName);
 		if (subCommand) return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
 	}
 	return [cmd, parent];
 }
+async function _findSubCommand(subCommands, name) {
+	if (name in subCommands) return resolveValue(subCommands[name]);
+	for (const sub of Object.values(subCommands)) {
+		const resolved = await resolveValue(sub);
+		const meta = await resolveValue(resolved?.meta);
+		if (meta?.alias) {
+			if (toArray(meta.alias).includes(name)) return resolved;
+		}
+	}
+}
+function findSubCommandIndex(rawArgs, argsDef) {
+	for (let i = 0; i < rawArgs.length; i++) {
+		const arg = rawArgs[i];
+		if (arg === "--") return -1;
+		if (arg.startsWith("-")) {
+			if (!arg.includes("=") && _isValueFlag(arg, argsDef)) i++;
+			continue;
+		}
+		return i;
+	}
+	return -1;
+}
+function _isValueFlag(flag, argsDef) {
+	const name = flag.replace(/^-{1,2}/, "");
+	const normalized = camelCase(name);
+	for (const [key, def] of Object.entries(argsDef)) {
+		if (def.type !== "string" && def.type !== "enum") continue;
+		if (normalized === camelCase(key)) return true;
+		if ((Array.isArray(def.alias) ? def.alias : def.alias ? [def.alias] : []).includes(name)) return true;
+	}
+	return false;
+}
 async function showUsage(cmd, parent) {
 	try {
 		console.log(await renderUsage(cmd, parent) + "\n");
@@ -283,27 +359,17 @@ async function renderUsage(cmd, parent) {
 	for (const arg of cmdArgs) if (arg.type === "positional") {
 		const name = arg.name.toUpperCase();
 		const isRequired = arg.required !== false && arg.default === void 0;
-		const defaultHint = arg.default ? `="${arg.default}"` : "";
-		posLines.push([
-			cyan(name + defaultHint),
-			arg.description || "",
-			arg.valueHint ? `<${arg.valueHint}>` : ""
-		]);
+		posLines.push([cyan(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
 		usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
 	} else {
 		const isRequired = arg.required === true && arg.default === void 0;
-		const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "") + (arg.type === "enum" && arg.options ? `=<${arg.options.join("|")}>` : "");
-		argLines.push([cyan(argStr + (isRequired ? " (required)" : "")), arg.description || ""]);
-		/**
-		* print negative boolean arg variant usage when
-		* - enabled by default or has `negativeDescription`
-		* - not prefixed with `no-` or `no[A-Z]`
-		*/
+		const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + renderValueHint(arg);
+		argLines.push([cyan(argStr), renderDescription(arg, isRequired)]);
 		if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
 			const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
-			argLines.push([cyan(negativeArgStr + (isRequired ? " (required)" : "")), arg.negativeDescription || ""]);
+			argLines.push([cyan(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
 		}
-		if (isRequired) usageLine.push(argStr);
+		if (isRequired) usageLine.push(`--${arg.name}` + renderValueHint(arg));
 	}
 	if (cmd.subCommands) {
 		const commandNames = [];
@@ -311,8 +377,10 @@ async function renderUsage(cmd, parent) {
 		for (const [name, sub] of Object.entries(subCommands)) {
 			const meta = await resolveValue((await resolveValue(sub))?.meta);
 			if (meta?.hidden) continue;
-			commandsLines.push([cyan(name), meta?.description || ""]);
-			commandNames.push(name);
+			const aliases = toArray(meta?.alias);
+			const label = [name, ...aliases].join(", ");
+			commandsLines.push([cyan(label), meta?.description || ""]);
+			commandNames.push(name, ...aliases);
 		}
 		usageLine.push(commandNames.join("|"));
 	}
@@ -338,14 +406,31 @@ async function renderUsage(cmd, parent) {
 	}
 	return usageLines.filter((l) => typeof l === "string").join("\n");
 }
+function renderValueHint(arg) {
+	const valueHint = arg.valueHint ? `=<${arg.valueHint}>` : "";
+	const fallbackValueHint = valueHint || `=<${snakeCase(arg.name)}>`;
+	if (!arg.type || arg.type === "positional" || arg.type === "boolean") return valueHint;
+	if (arg.type === "enum" && arg.options?.length) return `=<${arg.options.join("|")}>`;
+	return fallbackValueHint;
+}
+function renderDescription(arg, required) {
+	const requiredHint = required ? gray("(Required)") : "";
+	const defaultHint = arg.default === void 0 ? "" : gray(`(Default: ${arg.default})`);
+	return [
+		arg.description,
+		requiredHint,
+		defaultHint
+	].filter(Boolean).join(" ");
+}
 async function runMain(cmd, opts = {}) {
 	const rawArgs = opts.rawArgs || process.argv.slice(2);
 	const showUsage$1 = opts.showUsage || showUsage;
 	try {
-		if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+		const builtinFlags = await _resolveBuiltinFlags(cmd);
+		if (builtinFlags.help.length > 0 && rawArgs.some((arg) => builtinFlags.help.includes(arg))) {
 			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
 			process.exit(0);
-		} else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
+		} else if (rawArgs.length === 1 && builtinFlags.version.includes(rawArgs[0])) {
 			const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
 			if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
 			console.log(meta.version);
@@ -358,6 +443,22 @@ async function runMain(cmd, opts = {}) {
 		process.exit(1);
 	}
 }
-
-//#endregion
-export { runMain as n, defineCommand as t };
+async function _resolveBuiltinFlags(cmd) {
+	const argsDef = await resolveValue(cmd.args || {});
+	const userNames = /* @__PURE__ */ new Set();
+	const userAliases = /* @__PURE__ */ new Set();
+	for (const [name, def] of Object.entries(argsDef)) {
+		userNames.add(name);
+		for (const alias of toArray(def.alias)) userAliases.add(alias);
+	}
+	return {
+		help: _getBuiltinFlags("help", "h", userNames, userAliases),
+		version: _getBuiltinFlags("version", "v", userNames, userAliases)
+	};
+}
+function _getBuiltinFlags(long, short, userNames, userAliases) {
+	if (userNames.has(long) || userAliases.has(long)) return [];
+	if (userNames.has(short) || userAliases.has(short)) return [`--${long}`];
+	return [`--${long}`, `-${short}`];
+}
+export { runMain as n, defineCommand as t };

package/dist/_libs/commondir+is-reference.mjs

@@ -1,10 +1,8 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "../_common.mjs";
-import { F as Builder, S as MagicString, c as walk, i as createFilter, o as extractAssignedNames, r as attachScopes, s as makeLegalIdentifier } from "../_build/common.mjs";
+import { P as Builder, S as MagicString, c as walk, i as createFilter, o as extractAssignedNames, r as attachScopes, s as makeLegalIdentifier } from "../_build/common.mjs";
 import { existsSync, readFileSync, statSync } from "fs";
 import { basename, dirname, extname, join, relative, resolve, sep } from "path";
-
-//#region node_modules/.pnpm/commondir@1.0.1/node_modules/commondir/index.js
-var require_commondir = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var import_commondir = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var path$1 = __require("path");
 	module.exports = function(basedir, relfiles) {
 		if (relfiles) var files = relfiles.map(function(r) {
@@ -19,43 +17,27 @@ var require_commondir = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}, files[0].split(/\/+|\\+/));
 		return res.length > 1 ? res.join("/") : "/";
 	};
-}));
-
-//#endregion
-//#region node_modules/.pnpm/is-reference@1.2.1/node_modules/is-reference/dist/is-reference.js
-var require_is_reference = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	(function(global, factory) {
-		typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = global || self, global.isReference = factory());
-	})(exports, (function() {
-		"use strict";
-		function isReference$1(node, parent) {
-			if (node.type === "MemberExpression") return !node.computed && isReference$1(node.object, node);
-			if (node.type === "Identifier") {
-				if (!parent) return true;
-				switch (parent.type) {
-					case "MemberExpression": return parent.computed || node === parent.object;
-					case "MethodDefinition": return parent.computed;
-					case "FieldDefinition": return parent.computed || node === parent.value;
-					case "Property": return parent.computed || node === parent.value;
-					case "ExportSpecifier":
-					case "ImportSpecifier": return node === parent.local;
-					case "LabeledStatement":
-					case "BreakStatement":
-					case "ContinueStatement": return false;
-					default: return true;
-				}
-			}
-			return false;
+})))(), 1);
+function isReference(node, parent) {
+	if (node.type === "MemberExpression") return !node.computed && isReference(node.object, node);
+	if (node.type === "Identifier") {
+		if (!parent) return true;
+		switch (parent.type) {
+			case "MemberExpression": return parent.computed || node === parent.object;
+			case "MethodDefinition": return parent.computed;
+			case "FieldDefinition": return parent.computed || node === parent.value;
+			case "Property": return parent.computed || node === parent.value;
+			case "ExportSpecifier":
+			case "ImportSpecifier": return node === parent.local;
+			case "LabeledStatement":
+			case "BreakStatement":
+			case "ContinueStatement": return false;
+			default: return true;
 		}
-		return isReference$1;
-	}));
-}));
-
-//#endregion
-//#region node_modules/.pnpm/@rollup+plugin-commonjs@29.0.0_rollup@4.55.3/node_modules/@rollup/plugin-commonjs/dist/es/index.js
-var import_commondir = /* @__PURE__ */ __toESM(require_commondir(), 1);
-var import_is_reference = /* @__PURE__ */ __toESM(require_is_reference(), 1);
-var version = "29.0.0";
+	}
+	return false;
+}
+var version = "29.0.1";
 var peerDependencies = { rollup: "^2.68.0||^3.0.0||^4.0.0" };
 function tryParse(parse, code, id) {
 	try {
@@ -118,10 +100,10 @@ function getName(id) {
 	if (name !== "index") return name;
 	return makeLegalIdentifier(basename(dirname(id)));
 }
-function normalizePathSlashes(path$2) {
-	return path$2.replace(/\\/g, "/");
+function normalizePathSlashes(path) {
+	return path.replace(/\\/g, "/");
 }
-const getVirtualPathForDynamicRequirePath = (path$2, commonDir) => `/${normalizePathSlashes(relative(commonDir, path$2))}`;
+const getVirtualPathForDynamicRequirePath = (path, commonDir) => `/${normalizePathSlashes(relative(commonDir, path))}`;
 function capitalize(name) {
 	return name[0].toUpperCase() + name.slice(1);
 }
@@ -157,9 +139,9 @@ function getPackageEntryPoint(dirPath) {
 	} catch (ignored) {}
 	return entryPoint;
 }
-function isDirectory(path$2) {
+function isDirectory(path) {
 	try {
-		if (statSync(path$2).isDirectory()) return true;
+		if (statSync(path).isDirectory()) return true;
 	} catch (ignored) {}
 	return false;
 }
@@ -169,12 +151,12 @@ function getDynamicRequireModules(patterns, dynamicRequireRoot) {
 	for (const pattern of !patterns || Array.isArray(patterns) ? patterns || [] : [patterns]) {
 		const isNegated = pattern.startsWith("!");
 		const modifyMap = (targetPath, resolvedPath) => isNegated ? dynamicRequireModules.delete(targetPath) : dynamicRequireModules.set(targetPath, resolvedPath);
-		for (const path$2 of new Builder().withBasePath().withDirs().glob(isNegated ? pattern.substr(1) : pattern).crawl(relative(".", dynamicRequireRoot)).sync().sort((a, b) => a.localeCompare(b, "en"))) {
-			const resolvedPath = resolve(path$2);
+		for (const path of new Builder().withBasePath().withDirs().glob(isNegated ? pattern.substr(1) : pattern).crawl(relative(".", dynamicRequireRoot)).sync().sort((a, b) => a.localeCompare(b, "en"))) {
+			const resolvedPath = resolve(path);
 			const requirePath = normalizePathSlashes(resolvedPath);
 			if (isDirectory(resolvedPath)) {
 				dirNames.add(resolvedPath);
-				const modulePath = resolve(join(resolvedPath, getPackageEntryPoint(path$2)));
+				const modulePath = resolve(join(resolvedPath, getPackageEntryPoint(path)));
 				modifyMap(requirePath, modulePath);
 				modifyMap(normalizePathSlashes(modulePath), modulePath);
 			} else {
@@ -606,14 +588,26 @@ function validateVersion(actualVersion, peerDependencyVersion, name) {
 	const [major, minor, patch] = actualVersion.split(".").map(Number);
 	if (major < minMajor || major === minMajor && (minor < minMinor || minor === minMinor && patch < minPatch)) throw new Error(`Insufficient ${name} version: "@rollup/plugin-commonjs" requires at least ${name}@${minMajor}.${minMinor}.${minPatch} but found ${name}@${actualVersion}.`);
 }
+function triStateAnd(a, b) {
+	if (a === false) return false;
+	if (b === false) return false;
+	if (a === true && b === true) return true;
+	return null;
+}
+function triStateOr(a, b) {
+	if (a === true) return true;
+	if (b === true) return true;
+	if (a === false && b === false) return false;
+	return null;
+}
 const operators = {
 	"==": (x) => equals(x.left, x.right, false),
 	"!=": (x) => not(operators["=="](x)),
 	"===": (x) => equals(x.left, x.right, true),
 	"!==": (x) => not(operators["==="](x)),
 	"!": (x) => isFalsy(x.argument),
-	"&&": (x) => isTruthy(x.left) && isTruthy(x.right),
-	"||": (x) => isTruthy(x.left) || isTruthy(x.right)
+	"&&": (x) => triStateAnd(isTruthy(x.left), isTruthy(x.right)),
+	"||": (x) => triStateOr(isTruthy(x.left), isTruthy(x.right))
 };
 function not(value) {
 	return value === null ? value : !value;
@@ -679,6 +673,9 @@ function getDefinePropertyCallName(node, targetName) {
 function isShorthandProperty(parent) {
 	return parent && parent.type === "Property" && parent.shorthand;
 }
+function isPropertyDefinitionKey(parent, node) {
+	return parent && parent.type === "PropertyDefinition" && parent.key === node;
+}
 function wrapCode(magicString, uses, moduleName, exportsName, indentExclusionRanges) {
 	const args = [];
 	const passedArgs = [];
@@ -1018,7 +1015,7 @@ async function transformCommonjs(parse, code, id, isEsModule, ignoreGlobal, igno
 					return;
 				case "Identifier": {
 					const { name } = node;
-					if (!(0, import_is_reference.default)(node, parent) || scope.contains(name) || parent.type === "PropertyDefinition" && parent.key === node) return;
+					if (!isReference(node, parent) || scope.contains(name) || isPropertyDefinitionKey(parent, node)) return;
 					switch (name) {
 						case "require":
 							uses.require = true;
@@ -1038,7 +1035,13 @@ async function transformCommonjs(parse, code, id, isEsModule, ignoreGlobal, igno
 							return;
 						case "global":
 							uses.global = true;
-							if (!ignoreGlobal) replacedGlobal.push(node);
+							if (!ignoreGlobal) {
+								if (isShorthandProperty(parent)) {
+									skippedNodes.add(parent.value);
+									magicString.prependRight(node.start, "global: ");
+								}
+								replacedGlobal.push(node);
+							}
 							return;
 						case "define":
 							magicString.overwrite(node.start, node.end, "undefined", { storeName: true });
@@ -1108,7 +1111,10 @@ async function transformCommonjs(parse, code, id, isEsModule, ignoreGlobal, igno
 	const dynamicRequireName = replacedDynamicRequires.length > 0 && deconflict([scope], globals, isDynamicRequireModulesEnabled ? CREATE_COMMONJS_REQUIRE_EXPORT : COMMONJS_REQUIRE_EXPORT);
 	const deconflictedExportNames = Object.create(null);
 	for (const [exportName, { scopes }] of exportsAssignmentsByName) deconflictedExportNames[exportName] = deconflict([...scopes], globals, exportName);
-	for (const node of replacedGlobal) magicString.overwrite(node.start, node.end, `${helpersName}.commonjsGlobal`, { storeName: true });
+	for (const node of replacedGlobal) magicString.overwrite(node.start, node.end, `${helpersName}.commonjsGlobal`, {
+		contentOnly: true,
+		storeName: true
+	});
 	for (const node of replacedThis) magicString.overwrite(node.start, node.end, exportsName, { storeName: true });
 	for (const node of replacedDynamicRequires) magicString.overwrite(node.start, node.end, isDynamicRequireModulesEnabled ? `${dynamicRequireName}(${JSON.stringify(virtualDynamicRequirePath)})` : dynamicRequireName, {
 		contentOnly: true,
@@ -1295,6 +1301,4 @@ function commonjs(options = {}) {
 		}
 	};
 }
-
-//#endregion
-export { commonjs as t };
+export { commonjs as t };

package/dist/_libs/compatx.d.mts

@@ -1,4 +1,3 @@
-//#region node_modules/.pnpm/compatx@0.2.0/node_modules/compatx/dist/index.d.mts
 /**
  * Known platform names
  */
@@ -43,5 +42,4 @@ type CompatibilityDateSpec = DateString | Partial<CompatibilityDates>;
 /**
  * Get compatibility updates applicable for the user given platform and date range.
  */
-//#endregion
 export { CompatibilityDates as n, DateString as r, CompatibilityDateSpec as t };

package/dist/_libs/compatx.mjs

@@ -1,4 +1,3 @@
-//#region node_modules/.pnpm/compatx@0.2.0/node_modules/compatx/dist/index.mjs
 const platforms = [
 	"aws",
 	"azure",
@@ -41,6 +40,4 @@ function normalizeDate(date) {
 	if (date === "latest") return /* @__PURE__ */ new Date();
 	return new Date(date);
 }
-
-//#endregion
-export { resolveCompatibilityDates as n, resolveCompatibilityDatesFromEnv as r, formatCompatibilityDate as t };
+export { resolveCompatibilityDates as n, resolveCompatibilityDatesFromEnv as r, formatCompatibilityDate as t };

package/dist/_libs/esbuild.d.mts

@@ -1,4 +1,3 @@
-//#region node_modules/.pnpm/esbuild@0.27.2/node_modules/esbuild/lib/main.d.ts
 // Note: These declarations exist to avoid type errors when you omit "dom" from
 // "lib" in your "tsconfig.json" file. TypeScript confusingly declares the
 // global "WebAssembly" type in "lib.dom.d.ts" even though it has nothing to do

package/dist/_libs/escape-string-regexp.mjs

@@ -1,8 +1,5 @@
-//#region node_modules/.pnpm/escape-string-regexp@5.0.0/node_modules/escape-string-regexp/index.js
 function escapeStringRegexp(string) {
 	if (typeof string !== "string") throw new TypeError("Expected a string");
 	return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
 }
-
-//#endregion
-export { escapeStringRegexp as t };
+export { escapeStringRegexp as t };

package/dist/_libs/{pluginutils+plugin-commonjs.d.mts → estree+pluginutils.d.mts}

@@ -1,12 +1,8 @@
 import { Plugin } from "rollup";
-
-//#region node_modules/.pnpm/@rollup+pluginutils@5.3.0_rollup@4.55.3/node_modules/@rollup/pluginutils/types/index.d.ts
 /**
  * A valid `picomatch` glob pattern, or array of patterns.
  */
 type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | null;
-//#endregion
-//#region node_modules/.pnpm/@rollup+plugin-commonjs@29.0.0_rollup@4.55.3/node_modules/@rollup/plugin-commonjs/types/index.d.ts
 type RequireReturnsDefaultOption = boolean | 'auto' | 'preferred' | 'namespace';
 type DefaultIsModuleExportsOption = boolean | 'auto';
 interface RollupCommonJSOptions {
@@ -237,5 +233,4 @@ interface RollupCommonJSOptions {
  * Convert CommonJS modules to ES6, so they can be included in a Rollup bundle
  */
 declare function commonjs(options?: RollupCommonJSOptions): Plugin;
-//#endregion
 export { commonjs as t };