@nuxt/cli-nightly 3.29.4-20251009-171833-0915ec9 → 3.29.4-20251021-190716-bbf70fc

package/dist/_shared-C3vB2YLc.mjs

@@ -0,0 +1,42 @@
+//#region ../nuxi/src/commands/_shared.ts
+const cwdArgs = { cwd: {
+	type: "string",
+	description: "Specify the working directory",
+	valueHint: "directory",
+	default: "."
+} };
+const logLevelArgs = { logLevel: {
+	type: "string",
+	description: "Specify build-time log level",
+	valueHint: "silent|info|verbose"
+} };
+const envNameArgs = { envName: {
+	type: "string",
+	description: "The environment to use when resolving configuration overrides (default is `production` when building, and `development` when running the dev server)"
+} };
+const dotEnvArgs = { dotenv: {
+	type: "string",
+	description: "Path to `.env` file to load, relative to the root directory"
+} };
+const extendsArgs = { extends: {
+	type: "string",
+	description: "Extend from a Nuxt layer",
+	valueHint: "layer-name",
+	alias: ["e"]
+} };
+const legacyRootDirArgs = {
+	cwd: {
+		...cwdArgs.cwd,
+		description: "Specify the working directory, this takes precedence over ROOTDIR (default: `.`)",
+		default: void 0
+	},
+	rootDir: {
+		type: "positional",
+		description: "Specifies the working directory (default: `.`)",
+		required: false,
+		default: "."
+	}
+};
+
+//#endregion
+export { legacyRootDirArgs as a, extendsArgs as i, dotEnvArgs as n, logLevelArgs as o, envNameArgs as r, cwdArgs as t };

package/dist/_utils-DTrPahho.mjs

@@ -0,0 +1,29 @@
+import { satisfies } from "semver";
+import { $fetch } from "ofetch";
+import { parseINI } from "confbox";
+
+//#region ../nuxi/src/commands/module/_utils.ts
+async function fetchModules() {
+	const { modules } = await $fetch(`https://api.nuxt.com/modules?version=all`);
+	return modules;
+}
+function checkNuxtCompatibility(module, nuxtVersion) {
+	if (!module.compatibility?.nuxt) return true;
+	return satisfies(nuxtVersion, module.compatibility.nuxt, { includePrerelease: true });
+}
+function getRegistryFromContent(content, scope) {
+	try {
+		const npmConfig = parseINI(content);
+		if (scope) {
+			const scopeKey = `${scope}:registry`;
+			if (npmConfig[scopeKey]) return npmConfig[scopeKey].trim();
+		}
+		if (npmConfig.registry) return npmConfig.registry.trim();
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+export { fetchModules as n, getRegistryFromContent as r, checkNuxtCompatibility as t };

package/dist/add-BGMHIn5L.mjs

@@ -0,0 +1,333 @@
+import { o as logLevelArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import { t as loadKit } from "./kit-xFxVGu6d.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { existsSync, promises } from "node:fs";
+import { dirname, extname, resolve } from "pathe";
+import { camelCase, pascalCase } from "scule";
+
+//#region ../nuxi/src/utils/templates/api.ts
+const httpMethods = [
+	"connect",
+	"delete",
+	"get",
+	"head",
+	"options",
+	"post",
+	"put",
+	"trace",
+	"patch"
+];
+const api = ({ name, args, nuxtOptions }) => {
+	return {
+		path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, `api/${name}${applySuffix(args, httpMethods, "method")}.ts`),
+		contents: `
+export default defineEventHandler(event => {
+  return 'Hello ${name}'
+})
+`
+	};
+};
+
+//#endregion
+//#region ../nuxi/src/utils/templates/app.ts
+const app = ({ args, nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, "app.vue"),
+	contents: args.pages ? `
+<script setup lang="ts"><\/script>
+
+<template>
+  <div>
+    <NuxtLayout>
+      <NuxtPage/>
+    </NuxtLayout>
+  </div>
+</template>
+
+<style scoped></style>
+` : `
+<script setup lang="ts"><\/script>
+
+<template>
+  <div>
+    <h1>Hello World!</h1>
+  </div>
+</template>
+
+<style scoped></style>
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/app-config.ts
+const appConfig = ({ nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, "app.config.ts"),
+	contents: `
+export default defineAppConfig({})
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/component.ts
+const component = ({ name, args, nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, `components/${name}${applySuffix(args, ["client", "server"], "mode")}.vue`),
+	contents: `
+<script setup lang="ts"><\/script>
+
+<template>
+  <div>
+    Component: ${name}
+  </div>
+</template>
+
+<style scoped></style>
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/composable.ts
+const composable = ({ name, nuxtOptions }) => {
+	const nameWithUsePrefix = `use${pascalCase(name.replace(/^use-?/, ""))}`;
+	return {
+		path: resolve(nuxtOptions.srcDir, `composables/${name}.ts`),
+		contents: `
+export const ${nameWithUsePrefix} = () => {
+  return ref()
+}
+    `
+	};
+};
+
+//#endregion
+//#region ../nuxi/src/utils/templates/error.ts
+const error = ({ nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, "error.vue"),
+	contents: `
+<script setup lang="ts">
+import type { NuxtError } from '#app'
+
+const props = defineProps({
+  error: Object as () => NuxtError
+})
+<\/script>
+
+<template>
+  <div>
+    <h1>{{ error.statusCode }}</h1>
+    <NuxtLink to="/">Go back home</NuxtLink>
+  </div>
+</template>
+
+<style scoped></style>
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/layer.ts
+const layer = ({ name, nuxtOptions }) => {
+	return {
+		path: resolve(nuxtOptions.rootDir, `layers/${name}/nuxt.config.ts`),
+		contents: `
+export default defineNuxtConfig({})
+`
+	};
+};
+
+//#endregion
+//#region ../nuxi/src/utils/templates/layout.ts
+const layout = ({ name, nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.layouts, `${name}.vue`),
+	contents: `
+<script setup lang="ts"><\/script>
+
+<template>
+  <div>
+    Layout: ${name}
+    <slot />
+  </div>
+</template>
+
+<style scoped></style>
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/middleware.ts
+const middleware = ({ name, args, nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.middleware, `${name}${applySuffix(args, ["global"])}.ts`),
+	contents: `
+export default defineNuxtRouteMiddleware((to, from) => {})
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/module.ts
+const module = ({ name, nuxtOptions }) => ({
+	path: resolve(nuxtOptions.rootDir, "modules", `${name}.ts`),
+	contents: `
+import { defineNuxtModule } from 'nuxt/kit'
+
+export default defineNuxtModule({
+  meta: {
+    name: '${name}'
+  },
+  setup () {}
+})
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/page.ts
+const page = ({ name, nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.pages, `${name}.vue`),
+	contents: `
+<script setup lang="ts"><\/script>
+
+<template>
+  <div>
+    Page: ${name}
+  </div>
+</template>
+
+<style scoped></style>
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/plugin.ts
+const plugin = ({ name, args, nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.plugins, `${name}${applySuffix(args, ["client", "server"], "mode")}.ts`),
+	contents: `
+export default defineNuxtPlugin(nuxtApp => {})
+  `
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/server-middleware.ts
+const serverMiddleware = ({ name, nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, "middleware", `${name}.ts`),
+	contents: `
+export default defineEventHandler(event => {})
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/server-plugin.ts
+const serverPlugin = ({ name, nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, "plugins", `${name}.ts`),
+	contents: `
+export default defineNitroPlugin(nitroApp => {})
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/server-route.ts
+const serverRoute = ({ name, args, nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, args.api ? "api" : "routes", `${name}.ts`),
+	contents: `
+export default defineEventHandler(event => {})
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/server-util.ts
+const serverUtil = ({ name, nuxtOptions }) => ({
+	path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, "utils", `${name}.ts`),
+	contents: `
+export function ${camelCase(name)}() {}
+`
+});
+
+//#endregion
+//#region ../nuxi/src/utils/templates/index.ts
+const templates = {
+	"api": api,
+	"app": app,
+	"app-config": appConfig,
+	"component": component,
+	"composable": composable,
+	"error": error,
+	"layer": layer,
+	"layout": layout,
+	"middleware": middleware,
+	"module": module,
+	"page": page,
+	"plugin": plugin,
+	"server-middleware": serverMiddleware,
+	"server-plugin": serverPlugin,
+	"server-route": serverRoute,
+	"server-util": serverUtil
+};
+function applySuffix(args, suffixes, unwrapFrom) {
+	let suffix = "";
+	for (const s of suffixes) if (args[s]) suffix += `.${s}`;
+	if (unwrapFrom && args[unwrapFrom] && suffixes.includes(args[unwrapFrom])) suffix += `.${args[unwrapFrom]}`;
+	return suffix;
+}
+
+//#endregion
+//#region ../nuxi/src/commands/add.ts
+const templateNames = Object.keys(templates);
+var add_default = defineCommand({
+	meta: {
+		name: "add",
+		description: "Create a new template file."
+	},
+	args: {
+		...cwdArgs,
+		...logLevelArgs,
+		force: {
+			type: "boolean",
+			description: "Force override file if it already exists",
+			default: false
+		},
+		template: {
+			type: "positional",
+			required: true,
+			valueHint: templateNames.join("|"),
+			description: `Specify which template to generate`
+		},
+		name: {
+			type: "positional",
+			required: true,
+			description: "Specify name of the generated file"
+		}
+	},
+	async run(ctx) {
+		const cwd = resolve(ctx.args.cwd);
+		const templateName = ctx.args.template;
+		if (!templateNames.includes(templateName)) {
+			logger.error(`Template ${templateName} is not supported. Possible values: ${Object.keys(templates).join(", ")}`);
+			process.exit(1);
+		}
+		const ext = extname(ctx.args.name);
+		const name = ext === ".vue" || ext === ".ts" ? ctx.args.name.replace(ext, "") : ctx.args.name;
+		if (!name) {
+			logger.error("name argument is missing!");
+			process.exit(1);
+		}
+		const config = await (await loadKit(cwd)).loadNuxtConfig({ cwd });
+		const template = templates[templateName];
+		const res = template({
+			name,
+			args: ctx.args,
+			nuxtOptions: config
+		});
+		if (!ctx.args.force && existsSync(res.path)) {
+			logger.error(`File exists: ${res.path} . Use --force to override or use a different name.`);
+			process.exit(1);
+		}
+		const parentDir = dirname(res.path);
+		if (!existsSync(parentDir)) {
+			logger.info("Creating directory", parentDir);
+			if (templateName === "page") logger.info("This enables vue-router functionality!");
+			await promises.mkdir(parentDir, { recursive: true });
+		}
+		await promises.writeFile(res.path, `${res.contents.trim()}\n`);
+		logger.info(`🪄 Generated a new ${templateName} in ${res.path}`);
+	}
+});
+
+//#endregion
+export { add_default as default };

package/dist/add-CRBwIlDF.mjs

@@ -0,0 +1,298 @@
+import { o as logLevelArgs, t as cwdArgs } from "./_shared-C3vB2YLc.mjs";
+import { t as logger } from "./logger-Dk0gkCkX.mjs";
+import { t as getNuxtVersion } from "./versions-CSy_3o_-.mjs";
+import { t as prepare_default } from "./prepare-xI978yFg.mjs";
+import { n as fetchModules, r as getRegistryFromContent, t as checkNuxtCompatibility } from "./_utils-DTrPahho.mjs";
+import { join } from "node:path";
+import process from "node:process";
+import { defineCommand, runCommand } from "citty";
+import { fileURLToPath } from "node:url";
+import * as fs from "node:fs";
+import { resolve as resolve$1 } from "pathe";
+import { joinURL } from "ufo";
+import { colors } from "consola/utils";
+import { satisfies } from "semver";
+import { homedir } from "node:os";
+import { addDependency } from "nypm";
+import { readPackageJSON } from "pkg-types";
+import { $fetch } from "ofetch";
+import { updateConfig } from "c12/update";
+
+//#region ../nuxi/src/commands/_utils.ts
+const nuxiCommands = [
+	"add",
+	"analyze",
+	"build",
+	"cleanup",
+	"_dev",
+	"dev",
+	"devtools",
+	"generate",
+	"info",
+	"init",
+	"module",
+	"prepare",
+	"preview",
+	"start",
+	"test",
+	"typecheck",
+	"upgrade"
+];
+function isNuxiCommand(command) {
+	return nuxiCommands.includes(command);
+}
+
+//#endregion
+//#region ../nuxi/src/run.ts
+globalThis.__nuxt_cli__ = globalThis.__nuxt_cli__ || {
+	startTime: Date.now(),
+	entry: fileURLToPath(new URL("../../bin/nuxi.mjs", import.meta.url)),
+	devEntry: fileURLToPath(new URL("../dev/index.mjs", import.meta.url))
+};
+async function runCommand$1(command, argv = process.argv.slice(2), data = {}) {
+	argv.push("--no-clear");
+	if (command.meta && "name" in command.meta && typeof command.meta.name === "string") {
+		const name = command.meta.name;
+		if (!isNuxiCommand(name)) throw new Error(`Invalid command ${name}`);
+	} else throw new Error(`Invalid command, must be named`);
+	return await runCommand(command, {
+		rawArgs: argv,
+		data: { overrides: data.overrides || {} }
+	});
+}
+
+//#endregion
+//#region ../nuxi/src/commands/module/add.ts
+var add_default = defineCommand({
+	meta: {
+		name: "add",
+		description: "Add Nuxt modules"
+	},
+	args: {
+		...cwdArgs,
+		...logLevelArgs,
+		moduleName: {
+			type: "positional",
+			description: "Specify one or more modules to install by name, separated by spaces"
+		},
+		skipInstall: {
+			type: "boolean",
+			description: "Skip npm install"
+		},
+		skipConfig: {
+			type: "boolean",
+			description: "Skip nuxt.config.ts update"
+		},
+		dev: {
+			type: "boolean",
+			description: "Install modules as dev dependencies"
+		}
+	},
+	async setup(ctx) {
+		const cwd = resolve$1(ctx.args.cwd);
+		const modules = ctx.args._.map((e) => e.trim()).filter(Boolean);
+		const projectPkg = await readPackageJSON(cwd).catch(() => ({}));
+		if (!projectPkg.dependencies?.nuxt && !projectPkg.devDependencies?.nuxt) {
+			logger.warn(`No \`nuxt\` dependency detected in \`${cwd}\`.`);
+			if (await logger.prompt(`Do you want to continue anyway?`, {
+				type: "confirm",
+				initial: false,
+				cancel: "default"
+			}) !== true) process.exit(1);
+		}
+		const resolvedModules = (await Promise.all(modules.map((moduleName) => resolveModule(moduleName, cwd)))).filter((x) => x != null);
+		logger.info(`Resolved \`${resolvedModules.map((x) => x.pkgName).join("`, `")}\`, adding module${resolvedModules.length > 1 ? "s" : ""}...`);
+		await addModules(resolvedModules, {
+			...ctx.args,
+			cwd
+		}, projectPkg);
+		if (!ctx.args.skipInstall) await runCommand$1(prepare_default, Object.entries(ctx.args).filter(([k]) => k in cwdArgs || k in logLevelArgs).map(([k, v]) => `--${k}=${v}`));
+	}
+});
+async function addModules(modules, { skipInstall, skipConfig, cwd, dev }, projectPkg) {
+	if (!skipInstall) {
+		const installedModules = [];
+		const notInstalledModules = [];
+		const dependencies = new Set([...Object.keys(projectPkg.dependencies || {}), ...Object.keys(projectPkg.devDependencies || {})]);
+		for (const module of modules) if (dependencies.has(module.pkgName)) installedModules.push(module);
+		else notInstalledModules.push(module);
+		if (installedModules.length > 0) {
+			const installedModulesList = installedModules.map((module) => module.pkgName).join("`, `");
+			const are = installedModules.length > 1 ? "are" : "is";
+			logger.info(`\`${installedModulesList}\` ${are} already installed`);
+		}
+		if (notInstalledModules.length > 0) {
+			const isDev = Boolean(projectPkg.devDependencies?.nuxt) || dev;
+			const notInstalledModulesList = notInstalledModules.map((module) => module.pkg).join("`, `");
+			const dependency = notInstalledModules.length > 1 ? "dependencies" : "dependency";
+			const a = notInstalledModules.length > 1 ? "" : " a";
+			logger.info(`Installing \`${notInstalledModulesList}\` as${a}${isDev ? " development" : ""} ${dependency}`);
+			if (await addDependency(notInstalledModules.map((module) => module.pkg), {
+				cwd,
+				dev: isDev,
+				installPeerDependencies: true
+			}).then(() => true).catch((error) => {
+				logger.error(error);
+				const failedModulesList = notInstalledModules.map((module) => colors.cyan(module.pkg)).join("`, `");
+				const s = notInstalledModules.length > 1 ? "s" : "";
+				return logger.prompt(`Install failed for \`${failedModulesList}\`. Do you want to continue adding the module${s} to ${colors.cyan("nuxt.config")}?`, {
+					type: "confirm",
+					initial: false,
+					cancel: "default"
+				});
+			}) !== true) return;
+		}
+	}
+	if (!skipConfig) await updateConfig({
+		cwd,
+		configFile: "nuxt.config",
+		async onCreate() {
+			logger.info(`Creating \`nuxt.config.ts\``);
+			return getDefaultNuxtConfig();
+		},
+		async onUpdate(config) {
+			if (!config.modules) config.modules = [];
+			for (const resolved of modules) {
+				if (config.modules.includes(resolved.pkgName)) {
+					logger.info(`\`${resolved.pkgName}\` is already in the \`modules\``);
+					continue;
+				}
+				logger.info(`Adding \`${resolved.pkgName}\` to the \`modules\``);
+				config.modules.push(resolved.pkgName);
+			}
+		}
+	}).catch((error) => {
+		logger.error(`Failed to update \`nuxt.config\`: ${error.message}`);
+		logger.error(`Please manually add \`${modules.map((module) => module.pkgName).join("`, `")}\` to the \`modules\` in \`nuxt.config.ts\``);
+		return null;
+	});
+}
+function getDefaultNuxtConfig() {
+	return `
+// https://nuxt.com/docs/api/configuration/nuxt-config
+export default defineNuxtConfig({
+  modules: []
+})`;
+}
+const packageRegex = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?([a-z0-9-~][a-z0-9-._~]*)(@[^@]+)?$/;
+async function resolveModule(moduleName, cwd) {
+	let pkgName = moduleName;
+	let pkgVersion;
+	const reMatch = moduleName.match(packageRegex);
+	if (reMatch) {
+		if (reMatch[3]) {
+			pkgName = `${reMatch[1] || ""}${reMatch[2] || ""}`;
+			pkgVersion = reMatch[3].slice(1);
+		}
+	} else {
+		logger.error(`Invalid package name \`${pkgName}\`.`);
+		return false;
+	}
+	const matchedModule = (await fetchModules().catch((err) => {
+		logger.warn(`Cannot search in the Nuxt Modules database: ${err}`);
+		return [];
+	})).find((module) => module.name === moduleName || pkgVersion && module.name === pkgName || module.npm === pkgName || module.aliases?.includes(pkgName));
+	if (matchedModule?.npm) pkgName = matchedModule.npm;
+	if (matchedModule && matchedModule.compatibility.nuxt) {
+		const nuxtVersion = await getNuxtVersion(cwd);
+		if (!checkNuxtCompatibility(matchedModule, nuxtVersion)) {
+			logger.warn(`The module \`${pkgName}\` is not compatible with Nuxt \`${nuxtVersion}\` (requires \`${matchedModule.compatibility.nuxt}\`)`);
+			if (!await logger.prompt("Do you want to continue installing incompatible version?", {
+				type: "confirm",
+				initial: false,
+				cancel: "default"
+			})) return false;
+		}
+		const versionMap = matchedModule.compatibility.versionMap;
+		if (versionMap) {
+			for (const [_nuxtVersion, _moduleVersion] of Object.entries(versionMap)) if (satisfies(nuxtVersion, _nuxtVersion)) {
+				if (!pkgVersion) pkgVersion = _moduleVersion;
+				else {
+					logger.warn(`Recommended version of \`${pkgName}\` for Nuxt \`${nuxtVersion}\` is \`${_moduleVersion}\` but you have requested \`${pkgVersion}\``);
+					pkgVersion = await logger.prompt("Choose a version:", {
+						type: "select",
+						options: [_moduleVersion, pkgVersion],
+						cancel: "undefined"
+					});
+					if (!pkgVersion) return false;
+				}
+				break;
+			}
+		}
+	}
+	let version = pkgVersion || "latest";
+	const meta = await detectNpmRegistry(pkgName.startsWith("@") ? pkgName.split("/")[0] : null);
+	const headers = {};
+	if (meta.authToken) headers.Authorization = `Bearer ${meta.authToken}`;
+	const pkgDetails = await $fetch(joinURL(meta.registry, `${pkgName}`), { headers });
+	if (pkgDetails["dist-tags"]?.[version]) version = pkgDetails["dist-tags"][version];
+	else version = Object.keys(pkgDetails.versions)?.findLast((v) => satisfies(v, version)) || version;
+	const pkg = pkgDetails.versions[version];
+	const pkgDependencies = Object.assign(pkg.dependencies || {}, pkg.devDependencies || {});
+	if (!pkgDependencies.nuxt && !pkgDependencies["nuxt-edge"] && !pkgDependencies["@nuxt/kit"]) {
+		logger.warn(`It seems that \`${pkgName}\` is not a Nuxt module.`);
+		if (!await logger.prompt(`Do you want to continue installing ${colors.cyan(pkgName)} anyway?`, {
+			type: "confirm",
+			initial: false,
+			cancel: "default"
+		})) return false;
+	}
+	return {
+		nuxtModule: matchedModule,
+		pkg: `${pkgName}@${version}`,
+		pkgName,
+		pkgVersion: version
+	};
+}
+function getNpmrcPaths() {
+	const userNpmrcPath = join(homedir(), ".npmrc");
+	return [join(process.cwd(), ".npmrc"), userNpmrcPath];
+}
+async function getAuthToken(registry) {
+	const paths = getNpmrcPaths();
+	const authTokenRegex = new RegExp(`^//${registry.replace(/^https?:\/\//, "").replace(/\/$/, "")}/:_authToken=(.+)$`, "m");
+	for (const npmrcPath of paths) {
+		let fd;
+		try {
+			fd = await fs.promises.open(npmrcPath, "r");
+			if (await fd.stat().then((r) => r.isFile())) {
+				const authTokenMatch = (await fd.readFile("utf-8")).match(authTokenRegex)?.[1];
+				if (authTokenMatch) return authTokenMatch.trim();
+			}
+		} catch {} finally {
+			await fd?.close();
+		}
+	}
+	return null;
+}
+async function detectNpmRegistry(scope) {
+	const registry = await getRegistry(scope);
+	return {
+		registry,
+		authToken: await getAuthToken(registry)
+	};
+}
+async function getRegistry(scope) {
+	if (process.env.COREPACK_NPM_REGISTRY) return process.env.COREPACK_NPM_REGISTRY;
+	const registry = await getRegistryFromFile(getNpmrcPaths(), scope);
+	if (registry) process.env.COREPACK_NPM_REGISTRY = registry;
+	return registry || "https://registry.npmjs.org";
+}
+async function getRegistryFromFile(paths, scope) {
+	for (const npmrcPath of paths) {
+		let fd;
+		try {
+			fd = await fs.promises.open(npmrcPath, "r");
+			if (await fd.stat().then((r) => r.isFile())) {
+				const registry = getRegistryFromContent(await fd.readFile("utf-8"), scope);
+				if (registry) return registry;
+			}
+		} catch {} finally {
+			await fd?.close();
+		}
+	}
+	return null;
+}
+
+//#endregion
+export { runCommand$1 as n, add_default as t };