vite-plus 0.1.2 → 0.1.3

package/dist/global/migrate.js

@@ -1,22 +1,80 @@
-import { i as __toESM } from "./chunk-CtfvYSle.js";
-import { C as log, E as outro, S as intro, c as upgradeYarn, f as selectAgentTargetPaths, i as promptGitHooks, k as Ct, n as defaultInteractive, o as runViteInstall, p as writeAgentInstructions, r as downloadPackageManager$1, s as selectPackageManager, t as cancelAndExit, x as confirm, y as PackageManager } from "./prompts-CAIahN1u.js";
-import { t as lib_default } from "./lib-CibYHP32.js";
-import { a as selectEditor, c as checkVitestVersion, d as rewriteMonorepo, l as installGitHooks, m as require_semver, o as writeEditorConfigs, p as rewriteStandaloneProject, s as checkViteVersion, t as detectWorkspace$1, u as preflightGitHooksSetup } from "./workspace-MTwAF3M9.js";
-import "./browser-CY4NBwxR.js";
-import "./json-Bfvtp2rL.js";
-import { i as readNearestPackageJson, r as hasVitePlusDependency } from "./package-Pq2biU7_.js";
-import { a as renderCliDoc, n as log$1, r as muted, t as accent } from "./terminal-Cb-NuRkb.js";
+import { i as __toESM } from "./chunk-CgnkrU7a.js";
+import { A as select, E as log, M as Ct, S as PackageManager, T as intro, a as selectAgentTargetPaths, c as defaultInteractive, d as promptGitHooks, h as upgradeYarn, k as outro, l as downloadPackageManager$1, m as selectPackageManager, o as writeAgentInstructions, p as runViteInstall, s as cancelAndExit, t as detectAgentConflicts, w as confirm } from "./agent-BE4Xze8Q.js";
+import { t as lib_default } from "./lib-DxappLRQ.js";
+import { _ as preflightGitHooksSetup, a as detectEditorConflicts, b as rewriteStandaloneProject, c as writeEditorConfigs, d as detectEslintProject, f as detectPrettierProject, g as migratePrettierToOxfmt, h as migrateEslintToOxlint, i as EDITORS, l as checkViteVersion, m as mergeViteConfigFiles, p as installGitHooks, s as selectEditor, t as detectWorkspace$1, u as checkVitestVersion, v as rewriteMonorepo, x as require_semver } from "./workspace-lRm8huz4.js";
+import "./browser-CBapUTD0.js";
+import "./json-BRdVJ52a.js";
+import { i as readNearestPackageJson, r as hasVitePlusDependency } from "./package-YAMvX5PJ.js";
+import { i as muted, n as accent, r as log$1, t as renderCliDoc } from "./help-BAGHa8fD.js";
 import path from "node:path";
 import { styleText } from "node:util";
 import colors from "picocolors";
 import { vitePlusHeader } from "../../binding/index.js";
-
 //#region src/migration/bin.ts
 var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
 const { green } = colors;
+function warnPackageLevelEslint() {
+	log.warn("ESLint detected in workspace packages but no root config found. Package-level ESLint must be migrated manually.");
+}
+function warnLegacyEslintConfig(legacyConfigFile) {
+	log.warn(`Legacy ESLint configuration detected (${legacyConfigFile}). Automatic migration to Oxlint requires ESLint v9+ with flat config format (eslint.config.*). Please upgrade to ESLint v9 first: https://eslint.org/docs/latest/use/migrate-to-9.0.0`);
+}
+async function confirmEslintMigration(interactive) {
+	if (interactive) {
+		const confirmed = await confirm({
+			message: "Migrate ESLint rules to Oxlint using @oxlint/migrate?",
+			initialValue: true
+		});
+		if (Ct(confirmed)) cancelAndExit();
+		return !!confirmed;
+	}
+	log.info("ESLint configuration detected. Auto-migrating to Oxlint...");
+	return true;
+}
+async function promptEslintMigration(projectPath, interactive, packages) {
+	const eslintProject = detectEslintProject(projectPath, packages);
+	if (eslintProject.hasDependency && !eslintProject.configFile && eslintProject.legacyConfigFile) {
+		warnLegacyEslintConfig(eslintProject.legacyConfigFile);
+		return false;
+	}
+	if (!eslintProject.hasDependency) return false;
+	if (!eslintProject.configFile) {
+		warnPackageLevelEslint();
+		return false;
+	}
+	if (!await confirmEslintMigration(interactive)) return false;
+	if (!await migrateEslintToOxlint(projectPath, interactive, eslintProject.configFile, packages)) cancelAndExit("ESLint migration failed. Fix the issue and re-run `vp migrate`.", 1);
+	return true;
+}
+function warnPackageLevelPrettier() {
+	log.warn("Prettier detected in workspace packages but no root config found. Package-level Prettier must be migrated manually.");
+}
+async function confirmPrettierMigration(interactive) {
+	if (interactive) {
+		const confirmed = await confirm({
+			message: "Migrate Prettier to Oxfmt?",
+			initialValue: true
+		});
+		if (Ct(confirmed)) cancelAndExit();
+		return !!confirmed;
+	}
+	log.info("Prettier configuration detected. Auto-migrating to Oxfmt...");
+	return true;
+}
+async function promptPrettierMigration(projectPath, interactive, packages) {
+	const prettierProject = detectPrettierProject(projectPath, packages);
+	if (!prettierProject.hasDependency) return false;
+	if (!prettierProject.configFile) {
+		warnPackageLevelPrettier();
+		return false;
+	}
+	if (!await confirmPrettierMigration(interactive)) return false;
+	if (!await migratePrettierToOxfmt(projectPath, interactive, prettierProject.configFile, packages)) cancelAndExit("Prettier migration failed. Fix the issue and re-run `vp migrate`.", 1);
+	return true;
+}
 const helpMessage = renderCliDoc({
 	usage: "vp migrate [PATH] [OPTIONS]",
-	summary: "Migrate standalone Vite, Vitest, Oxlint, and Oxfmt projects to unified Vite+.",
+	summary: "Migrate standalone Vite, Vitest, Oxlint, Oxfmt, and Prettier projects to unified Vite+.",
 	sections: [
 		{
 			title: "Arguments",
@@ -78,8 +136,7 @@ const helpMessage = renderCliDoc({
 	]
 });
 function parseArgs() {
-	const args = process.argv.slice(3);
-	const parsed = lib_default(args, {
+	const parsed = lib_default(process.argv.slice(3), {
 		alias: { h: "help" },
 		boolean: [
 			"help",
@@ -90,11 +147,8 @@ function parseArgs() {
 	});
 	const interactive = parsed.interactive;
 	let projectPath = parsed._[0];
-	if (projectPath) {
-		projectPath = path.resolve(process.cwd(), projectPath);
-	} else {
-		projectPath = process.cwd();
-	}
+	if (projectPath) projectPath = path.resolve(process.cwd(), projectPath);
+	else projectPath = process.cwd();
 	return {
 		projectPath,
 		options: {
@@ -106,112 +160,198 @@ function parseArgs() {
 		}
 	};
 }
-async function main() {
-	const { projectPath, options } = parseArgs();
-	if (options.help) {
-		log$1(vitePlusHeader() + "\n");
-		log$1(helpMessage);
-		return;
-	}
-	intro(vitePlusHeader());
-	const workspaceInfoOptional = await detectWorkspace$1(projectPath);
-	const rootPkg = readNearestPackageJson(workspaceInfoOptional.rootDir);
-	if (hasVitePlusDependency(rootPkg)) {
-		const hasHooksToMigrate = rootPkg?.devDependencies?.husky || rootPkg?.dependencies?.husky || rootPkg?.devDependencies?.["lint-staged"] || rootPkg?.dependencies?.["lint-staged"];
-		if (!hasHooksToMigrate) {
-			outro(`This project is already using Vite+! ${accent(`Happy coding!`)}`);
-			return;
-		}
-		const shouldSetupHooks = await promptGitHooks(options);
-		if (shouldSetupHooks && installGitHooks(workspaceInfoOptional.rootDir)) {
-			outro(green("✔ Migration completed!"));
-		} else {
-			outro(`This project is already using Vite+! ${accent(`Happy coding!`)}`);
-		}
-		return;
-	}
+async function collectMigrationPlan(rootDir, detectedPackageManager, options, packages) {
 	if (options.interactive) {
-		log.info([
-			styleText("bold", "Migration plan:"),
-			"- Inspect workspace and package manager",
-			`- Run ${accent("vp install")} to prepare dependencies`,
-			"- Rewrite configs and dependencies for Vite+"
-		].join("\n") + "\n");
 		const approved = await confirm({
 			message: "Migrate this project to Vite+?",
 			initialValue: true
 		});
-		if (Ct(approved) || !approved) {
-			cancelAndExit("Migration cancelled");
-		}
+		if (Ct(approved) || !approved) cancelAndExit("Migration cancelled");
 	}
-	const packageManager = workspaceInfoOptional.packageManager ?? await selectPackageManager(options.interactive);
+	const packageManager = detectedPackageManager ?? await selectPackageManager(options.interactive);
 	let shouldSetupHooks = await promptGitHooks(options);
+	if (shouldSetupHooks) {
+		const reason = preflightGitHooksSetup(rootDir);
+		if (reason) {
+			log.warn(`⚠ ${reason}`);
+			shouldSetupHooks = false;
+		}
+	}
 	const selectedAgentTargetPaths = await selectAgentTargetPaths({
 		interactive: options.interactive,
 		agent: options.agent,
 		onCancel: () => cancelAndExit()
 	});
+	const agentConflicts = await detectAgentConflicts({
+		projectRoot: rootDir,
+		targetPaths: selectedAgentTargetPaths
+	});
+	const agentConflictDecisions = /* @__PURE__ */ new Map();
+	for (const conflict of agentConflicts) if (options.interactive) {
+		const action = await select({
+			message: `Agent instructions already exist at ${conflict.targetPath}.`,
+			options: [{
+				label: "Append",
+				value: "append",
+				hint: "Add template content to the end"
+			}, {
+				label: "Skip",
+				value: "skip",
+				hint: "Leave existing file unchanged"
+			}],
+			initialValue: "skip"
+		});
+		if (Ct(action)) cancelAndExit();
+		agentConflictDecisions.set(conflict.targetPath, action);
+	} else agentConflictDecisions.set(conflict.targetPath, "skip");
 	const selectedEditor = await selectEditor({
 		interactive: options.interactive,
 		editor: options.editor,
 		onCancel: () => cancelAndExit()
 	});
-	const downloadResult = await downloadPackageManager$1(packageManager, workspaceInfoOptional.packageManagerVersion, options.interactive);
+	const editorConflicts = detectEditorConflicts({
+		projectRoot: rootDir,
+		editorId: selectedEditor
+	});
+	const editorConflictDecisions = /* @__PURE__ */ new Map();
+	for (const conflict of editorConflicts) if (options.interactive) {
+		const action = await select({
+			message: `${conflict.displayPath} already exists.`,
+			options: [{
+				label: "Merge",
+				value: "merge",
+				hint: "Merge new settings into existing file"
+			}, {
+				label: "Skip",
+				value: "skip",
+				hint: "Leave existing file unchanged"
+			}],
+			initialValue: "skip"
+		});
+		if (Ct(action)) cancelAndExit();
+		editorConflictDecisions.set(conflict.fileName, action);
+	} else editorConflictDecisions.set(conflict.fileName, "merge");
+	const eslintProject = detectEslintProject(rootDir, packages);
+	let migrateEslint = false;
+	if (eslintProject.hasDependency && !eslintProject.configFile && eslintProject.legacyConfigFile) warnLegacyEslintConfig(eslintProject.legacyConfigFile);
+	else if (eslintProject.hasDependency && eslintProject.configFile) migrateEslint = await confirmEslintMigration(options.interactive);
+	else if (eslintProject.hasDependency) warnPackageLevelEslint();
+	const prettierProject = detectPrettierProject(rootDir, packages);
+	let migratePrettier = false;
+	if (prettierProject.hasDependency && prettierProject.configFile) migratePrettier = await confirmPrettierMigration(options.interactive);
+	else if (prettierProject.hasDependency) warnPackageLevelPrettier();
+	const plan = {
+		packageManager,
+		shouldSetupHooks,
+		selectedAgentTargetPaths,
+		agentConflictDecisions,
+		selectedEditor,
+		editorConflictDecisions,
+		migrateEslint,
+		eslintConfigFile: eslintProject.configFile,
+		migratePrettier,
+		prettierConfigFile: prettierProject.configFile
+	};
+	if (options.interactive) displayMigrationSummary(plan);
+	return plan;
+}
+function displayMigrationSummary(plan) {
+	const lines = [`- Install ${plan.packageManager} and dependencies`, "- Rewrite configs and dependencies for Vite+"];
+	if (plan.migrateEslint) lines.push("- Migrate ESLint rules to Oxlint");
+	if (plan.migratePrettier) lines.push("- Migrate Prettier to Oxfmt");
+	if (plan.shouldSetupHooks) lines.push("- Set up pre-commit hooks");
+	if (plan.selectedAgentTargetPaths && plan.selectedAgentTargetPaths.length > 0) {
+		const parts = plan.selectedAgentTargetPaths.map((tp) => {
+			const action = plan.agentConflictDecisions.get(tp);
+			return action ? `${tp}, ${action}` : tp;
+		});
+		lines.push(`- Write agent instructions (${parts.join("; ")})`);
+	}
+	if (plan.selectedEditor) {
+		const targetDir = EDITORS.find((e) => e.id === plan.selectedEditor)?.targetDir ?? plan.selectedEditor;
+		const decisions = [...plan.editorConflictDecisions.values()];
+		const uniqueActions = [...new Set(decisions)];
+		const actionStr = uniqueActions.length > 0 ? `, ${uniqueActions.join("/")}` : "";
+		lines.push(`- Write editor config (${targetDir}/${actionStr})`);
+	}
+	log.info([styleText("bold", "Migration plan:"), ...lines].join("\n") + "\n");
+}
+async function executeMigrationPlan(workspaceInfoOptional, plan, interactive) {
+	const downloadResult = await downloadPackageManager$1(plan.packageManager, workspaceInfoOptional.packageManagerVersion, interactive);
 	const workspaceInfo = {
 		...workspaceInfoOptional,
-		packageManager,
+		packageManager: plan.packageManager,
 		downloadPackageManager: downloadResult
 	};
-	if (packageManager === PackageManager.yarn && import_semver.default.satisfies(downloadResult.version, ">=4.0.0 <4.10.0")) {
-		await upgradeYarn(workspaceInfo.rootDir, options.interactive);
-	} else if (packageManager === PackageManager.pnpm && import_semver.default.satisfies(downloadResult.version, "< 9.5.0")) {
+	if (plan.packageManager === PackageManager.yarn && import_semver.default.satisfies(downloadResult.version, ">=4.0.0 <4.10.0")) await upgradeYarn(workspaceInfo.rootDir, interactive);
+	else if (plan.packageManager === PackageManager.pnpm && import_semver.default.satisfies(downloadResult.version, "< 9.5.0")) {
 		log.error(`✘ pnpm@${downloadResult.version} is not supported by auto migration, please upgrade pnpm to >=9.5.0 first`);
 		cancelAndExit("Vite+ cannot automatically migrate this project yet.", 1);
-	} else if (packageManager === PackageManager.npm && import_semver.default.satisfies(downloadResult.version, "< 8.3.0")) {
+	} else if (plan.packageManager === PackageManager.npm && import_semver.default.satisfies(downloadResult.version, "< 8.3.0")) {
 		log.error(`✘ npm@${downloadResult.version} is not supported by auto migration, please upgrade npm to >=8.3.0 first`);
 		cancelAndExit("Vite+ cannot automatically migrate this project yet.", 1);
 	}
-	await runViteInstall(workspaceInfo.rootDir, options.interactive);
+	await runViteInstall(workspaceInfo.rootDir, interactive);
 	const isViteSupported = checkViteVersion(workspaceInfo.rootDir);
 	const isVitestSupported = checkVitestVersion(workspaceInfo.rootDir);
-	if (!isViteSupported || !isVitestSupported) {
-		cancelAndExit("Vite+ cannot automatically migrate this project yet.", 1);
-	}
-	if (shouldSetupHooks) {
-		const reason = preflightGitHooksSetup(workspaceInfo.rootDir);
-		if (reason) {
-			log.warn(`⚠ ${reason}`);
-			shouldSetupHooks = false;
-		}
-	}
-	const skipStagedMigration = !shouldSetupHooks;
-	if (workspaceInfo.isMonorepo) {
-		rewriteMonorepo(workspaceInfo, skipStagedMigration);
-	} else {
-		rewriteStandaloneProject(workspaceInfo.rootDir, workspaceInfo, skipStagedMigration);
+	if (!isViteSupported || !isVitestSupported) cancelAndExit("Vite+ cannot automatically migrate this project yet.", 1);
+	if (plan.migrateEslint) {
+		if (!await migrateEslintToOxlint(workspaceInfo.rootDir, interactive, plan.eslintConfigFile, workspaceInfo.packages)) cancelAndExit("ESLint migration failed. Fix the issue and re-run `vp migrate`.", 1);
 	}
-	if (shouldSetupHooks) {
-		installGitHooks(workspaceInfo.rootDir);
+	if (plan.migratePrettier) {
+		if (!await migratePrettierToOxfmt(workspaceInfo.rootDir, interactive, plan.prettierConfigFile, workspaceInfo.packages)) cancelAndExit("Prettier migration failed. Fix the issue and re-run `vp migrate`.", 1);
 	}
+	const skipStagedMigration = !plan.shouldSetupHooks;
+	if (workspaceInfo.isMonorepo) rewriteMonorepo(workspaceInfo, skipStagedMigration);
+	else rewriteStandaloneProject(workspaceInfo.rootDir, workspaceInfo, skipStagedMigration);
+	if (plan.shouldSetupHooks) installGitHooks(workspaceInfo.rootDir);
 	await writeAgentInstructions({
 		projectRoot: workspaceInfo.rootDir,
-		targetPaths: selectedAgentTargetPaths,
-		interactive: options.interactive
+		targetPaths: plan.selectedAgentTargetPaths,
+		interactive,
+		conflictDecisions: plan.agentConflictDecisions
 	});
 	await writeEditorConfigs({
 		projectRoot: workspaceInfo.rootDir,
-		editorId: selectedEditor,
-		interactive: options.interactive
+		editorId: plan.selectedEditor,
+		interactive,
+		conflictDecisions: plan.editorConflictDecisions
 	});
-	const installArgs = packageManager === PackageManager.npm ? ["--force"] : undefined;
-	await runViteInstall(workspaceInfo.rootDir, options.interactive, installArgs);
+	const installArgs = plan.packageManager === PackageManager.npm ? ["--force"] : void 0;
+	await runViteInstall(workspaceInfo.rootDir, interactive, installArgs);
 	outro(green("✔ Migration completed!"));
 }
+async function main() {
+	const { projectPath, options } = parseArgs();
+	if (options.help) {
+		log$1(vitePlusHeader() + "\n");
+		log$1(helpMessage);
+		return;
+	}
+	intro(vitePlusHeader());
+	const workspaceInfoOptional = await detectWorkspace$1(projectPath);
+	const rootPkg = readNearestPackageJson(workspaceInfoOptional.rootDir);
+	if (hasVitePlusDependency(rootPkg)) {
+		let didMigrate = false;
+		const eslintMigrated = await promptEslintMigration(workspaceInfoOptional.rootDir, options.interactive, workspaceInfoOptional.packages);
+		const prettierMigrated = await promptPrettierMigration(workspaceInfoOptional.rootDir, options.interactive, workspaceInfoOptional.packages);
+		if (eslintMigrated || prettierMigrated) {
+			mergeViteConfigFiles(workspaceInfoOptional.rootDir);
+			await runViteInstall(workspaceInfoOptional.rootDir, options.interactive);
+			didMigrate = true;
+		}
+		if (rootPkg?.devDependencies?.husky || rootPkg?.dependencies?.husky || rootPkg?.devDependencies?.["lint-staged"] || rootPkg?.dependencies?.["lint-staged"]) {
+			if (await promptGitHooks(options) && installGitHooks(workspaceInfoOptional.rootDir)) didMigrate = true;
+		}
+		if (didMigrate) outro(green("✔ Migration completed!"));
+		else outro(`This project is already using Vite+! ${accent(`Happy coding!`)}`);
+		return;
+	}
+	await executeMigrationPlan(workspaceInfoOptional, await collectMigrationPlan(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager, options, workspaceInfoOptional.packages), options.interactive);
+}
 main().catch((err) => {
 	log.error(err.message);
 	console.error(err);
 	process.exit(1);
 });
-
-//#endregion
+//#endregion

package/dist/global/{package-Pq2biU7_.js → package-YAMvX5PJ.js}

@@ -1,19 +1,15 @@
-import { o as VITE_PLUS_NAME, r as readJsonFile } from "./json-Bfvtp2rL.js";
+import { r as readJsonFile } from "./json-BRdVJ52a.js";
 import path from "node:path";
 import fs from "node:fs";
 import { createRequire } from "node:module";
-
 //#region src/utils/package.ts
 function getScopeFromPackageName(packageName) {
-	if (packageName.startsWith("@")) {
-		return packageName.split("/")[0];
-	}
+	if (packageName.startsWith("@")) return packageName.split("/")[0];
 	return "";
 }
 function detectPackageMetadata(projectPath, packageName) {
 	try {
-		const require = createRequire(path.join(projectPath, "noop.js"));
-		const pkgFilePath = require.resolve(`${packageName}/package.json`);
+		const pkgFilePath = createRequire(path.join(projectPath, "noop.js")).resolve(`${packageName}/package.json`);
 		const pkg = JSON.parse(fs.readFileSync(pkgFilePath, "utf8"));
 		return {
 			name: pkg.name,
@@ -32,16 +28,13 @@ function detectPackageMetadata(projectPath, packageName) {
 function readNearestPackageJson(currentDir) {
 	do {
 		const packageJsonPath = path.join(currentDir, "package.json");
-		if (fs.existsSync(packageJsonPath)) {
-			return readJsonFile(packageJsonPath);
-		}
+		if (fs.existsSync(packageJsonPath)) return readJsonFile(packageJsonPath);
 		currentDir = path.dirname(currentDir);
 	} while (currentDir !== path.dirname(currentDir));
 	return null;
 }
 function hasVitePlusDependency(pkg) {
-	return Boolean(pkg?.dependencies?.[VITE_PLUS_NAME] || pkg?.devDependencies?.[VITE_PLUS_NAME]);
+	return Boolean(pkg?.dependencies?.["vite-plus"] || pkg?.devDependencies?.["vite-plus"]);
 }
-
 //#endregion
-export { readNearestPackageJson as i, getScopeFromPackageName as n, hasVitePlusDependency as r, detectPackageMetadata as t };
+export { readNearestPackageJson as i, getScopeFromPackageName as n, hasVitePlusDependency as r, detectPackageMetadata as t };

package/dist/global/{slice-ansi-BhwAwMdF.js → slice-ansi-Fap0ehe9.js}

@@ -1,48 +1,34 @@
-import { a as ansiStyles, i as isWide, r as isFullWidth } from "./strip-ansi-BL-dgd7n.js";
-
+import { a as ansiStyles, i as isWide, r as isFullWidth } from "./strip-ansi-CE-VDMdw.js";
 //#region ../../node_modules/.pnpm/is-fullwidth-code-point@5.1.0/node_modules/is-fullwidth-code-point/index.js
 function isFullwidthCodePoint(codePoint) {
-	if (!Number.isInteger(codePoint)) {
-		return false;
-	}
+	if (!Number.isInteger(codePoint)) return false;
 	return isFullWidth(codePoint) || isWide(codePoint);
 }
-
 //#endregion
 //#region ../../node_modules/.pnpm/slice-ansi@7.1.2/node_modules/slice-ansi/index.js
 const ESCAPES = new Set([27, 155]);
 const CODE_POINT_0 = "0".codePointAt(0);
 const CODE_POINT_9 = "9".codePointAt(0);
 const MAX_ANSI_SEQUENCE_LENGTH = 19;
-const endCodesSet = new Set();
-const endCodesMap = new Map();
+const endCodesSet = /* @__PURE__ */ new Set();
+const endCodesMap = /* @__PURE__ */ new Map();
 for (const [start, end] of ansiStyles.codes) {
 	endCodesSet.add(ansiStyles.color.ansi(end));
 	endCodesMap.set(ansiStyles.color.ansi(start), ansiStyles.color.ansi(end));
 }
 function getEndCode(code) {
-	if (endCodesSet.has(code)) {
-		return code;
-	}
-	if (endCodesMap.has(code)) {
-		return endCodesMap.get(code);
-	}
+	if (endCodesSet.has(code)) return code;
+	if (endCodesMap.has(code)) return endCodesMap.get(code);
 	code = code.slice(2);
-	if (code.includes(";")) {
-		code = code[0] + "0";
-	}
+	if (code.includes(";")) code = code[0] + "0";
 	const returnValue = ansiStyles.codes.get(Number.parseInt(code, 10));
-	if (returnValue) {
-		return ansiStyles.color.ansi(returnValue);
-	}
+	if (returnValue) return ansiStyles.color.ansi(returnValue);
 	return ansiStyles.reset.open;
 }
 function findNumberIndex(string) {
 	for (let index = 0; index < string.length; index++) {
 		const codePoint = string.codePointAt(index);
-		if (codePoint >= CODE_POINT_0 && codePoint <= CODE_POINT_9) {
-			return index;
-		}
+		if (codePoint >= CODE_POINT_0 && codePoint <= CODE_POINT_9) return index;
 	}
 	return -1;
 }
@@ -51,9 +37,7 @@ function parseAnsiCode(string, offset) {
 	const startIndex = findNumberIndex(string);
 	if (startIndex !== -1) {
 		let endIndex = string.indexOf("m", startIndex);
-		if (endIndex === -1) {
-			endIndex = string.length;
-		}
+		if (endIndex === -1) endIndex = string.length;
 		return string.slice(0, endIndex + 1);
 	}
 }
@@ -84,30 +68,22 @@ function tokenize(string, endCharacter = Number.POSITIVE_INFINITY) {
 		});
 		index += character.length;
 		visibleCount += isFullWidth ? 2 : character.length;
-		if (visibleCount >= endCharacter) {
-			break;
-		}
+		if (visibleCount >= endCharacter) break;
 	}
 	return returnValue;
 }
 function reduceAnsiCodes(codes) {
 	let returnValue = [];
-	for (const code of codes) {
-		if (code.code === ansiStyles.reset.open) {
-			returnValue = [];
-		} else if (endCodesSet.has(code.code)) {
-			returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.code);
-		} else {
-			returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.endCode);
-			returnValue.push(code);
-		}
+	for (const code of codes) if (code.code === ansiStyles.reset.open) returnValue = [];
+	else if (endCodesSet.has(code.code)) returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.code);
+	else {
+		returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.endCode);
+		returnValue.push(code);
 	}
 	return returnValue;
 }
 function undoAnsiCodes(codes) {
-	const reduced = reduceAnsiCodes(codes);
-	const endCodes = reduced.map(({ endCode }) => endCode);
-	return endCodes.reverse().join("");
+	return reduceAnsiCodes(codes).map(({ endCode }) => endCode).reverse().join("");
 }
 function sliceAnsi(string, start, end) {
 	const tokens = tokenize(string, end);
@@ -116,29 +92,22 @@ function sliceAnsi(string, start, end) {
 	let returnValue = "";
 	let include = false;
 	for (const token of tokens) {
-		if (end !== undefined && position >= end) {
-			break;
-		}
+		if (end !== void 0 && position >= end) break;
 		if (token.type === "ansi") {
 			activeCodes.push(token);
-			if (include) {
-				returnValue += token.code;
-			}
+			if (include) returnValue += token.code;
 		} else {
 			if (!include && position >= start) {
 				include = true;
 				activeCodes = reduceAnsiCodes(activeCodes);
 				returnValue = activeCodes.map(({ code }) => code).join("");
 			}
-			if (include) {
-				returnValue += token.value;
-			}
+			if (include) returnValue += token.value;
 			position += token.isFullWidth ? 2 : token.value.length;
 		}
 	}
 	returnValue += undoAnsiCodes(activeCodes);
 	return returnValue;
 }
-
 //#endregion
-export { sliceAnsi as t };
+export { sliceAnsi as t };