cluaupp 0.1.4 → 0.2.0

package/src/utils/project.ts

@@ -0,0 +1,506 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { BuildOptions, BuildResult, ProjectConfig } from "../types.js";
+import { pkg } from "../package-info.js";
+import { isSourceFile, toLuauPath } from "../preprocess.js";
+import { installEditorSupport, syncEditorSupport } from "../intellisense.js";
+import { ProcessOrchestrator } from "./process-orchestrator.js";
+import { RojoMapper } from "./rojo-mapper.js";
+import { transpileSource } from "../transpile.js";
+import { assertInitDest, assertInside, isInside, safeProjectSubdir, safeRelPath } from "./safe-paths.js";
+
+function readProjectConfig(file: string): Partial<ProjectConfig> {
+	const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+		return {};
+	}
+	const data = raw as Record<string, unknown>;
+	const parsed: Partial<ProjectConfig> = {};
+	if (typeof data.rootDir === "string") {
+		parsed.rootDir = data.rootDir;
+	}
+	if (typeof data.outDir === "string") {
+		parsed.outDir = data.outDir;
+	}
+	if (typeof data.strict === "boolean") {
+		parsed.strict = data.strict;
+	}
+	if (typeof data.architecture === "boolean") {
+		parsed.architecture = data.architecture;
+	}
+	return parsed;
+}
+
+export function loadConfig(root: string): ProjectConfig {
+	const defaults: ProjectConfig = { rootDir: "src", outDir: "out", strict: false, architecture: false };
+	const configNames = ["cluaupp.config.json", "cluau.config.json"];
+	let parsed: Partial<ProjectConfig> = {};
+	for (const name of configNames) {
+		const file = path.join(root, name);
+		if (fs.existsSync(file)) {
+			parsed = readProjectConfig(file);
+			break;
+		}
+	}
+	const config: ProjectConfig = {
+		...defaults,
+		...parsed,
+		rootDir: safeProjectSubdir(parsed.rootDir || defaults.rootDir, defaults.rootDir, "rootDir"),
+		outDir: safeProjectSubdir(parsed.outDir || defaults.outDir, defaults.outDir, "outDir"),
+	};
+	if (config.rootDir === config.outDir) {
+		throw new Error("cluaupp: rootDir and outDir must be different");
+	}
+	const absRoot = path.resolve(root);
+	assertInside(absRoot, path.join(absRoot, config.rootDir), "rootDir");
+	assertInside(absRoot, path.join(absRoot, config.outDir), "outDir");
+	return config;
+}
+
+function copyDir(from: string, to: string): void {
+	fs.mkdirSync(to, { recursive: true });
+	for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+		const src = path.join(from, entry.name);
+		const dest = path.join(to, entry.name);
+		if (entry.isDirectory()) {
+			copyDir(src, dest);
+		} else {
+			fs.copyFileSync(src, dest);
+		}
+	}
+}
+
+function tryRm(target: string, root?: string): boolean {
+	if (root && !isInside(root, target)) {
+		console.error("cluaupp: skip remove outside project", target);
+		return false;
+	}
+	try {
+		fs.rmSync(target, { recursive: true, force: true });
+		return true;
+	} catch (err) {
+		const error = err as NodeJS.ErrnoException;
+		if (error.code === "EPERM" || error.code === "EBUSY" || error.code === "ENOTEMPTY") {
+			console.error("cluaupp: skip remove", target, `(${error.code})`);
+			return false;
+		}
+		throw err;
+	}
+}
+
+function copyFileIfChanged(src: string, dest: string, mode = "fill"): void {
+	if (mode === "fill" && fs.existsSync(dest)) {
+		return;
+	}
+	if (mode === "update" && fs.existsSync(dest)) {
+		const from = fs.statSync(src);
+		const to = fs.statSync(dest);
+		if (from.size === to.size && from.mtimeMs <= to.mtimeMs) {
+			return;
+		}
+	}
+	fs.mkdirSync(path.dirname(dest), { recursive: true });
+	try {
+		fs.copyFileSync(src, dest);
+	} catch (err) {
+		const error = err as NodeJS.ErrnoException;
+		if (error.code === "EPERM" || error.code === "EBUSY") {
+			console.error("cluaupp: skip copy", dest, `(${error.code})`);
+			return;
+		}
+		throw err;
+	}
+}
+
+function syncDir(from: string, to: string, mode = "fill"): void {
+	if (!fs.existsSync(from)) {
+		return;
+	}
+	fs.mkdirSync(to, { recursive: true });
+	for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+		const src = path.join(from, entry.name);
+		const dest = path.join(to, entry.name);
+		if (entry.isDirectory()) {
+			syncDir(src, dest, mode);
+		} else {
+			copyFileIfChanged(src, dest, mode);
+		}
+	}
+}
+
+function copyRuntime(dest: string): void {
+	const runtime = path.join(__dirname, "..", "..", "runtime");
+	if (!fs.existsSync(runtime)) {
+		return;
+	}
+	syncDir(runtime, path.join(dest, "libs"));
+}
+
+function copyHeaders(dest: string): void {
+	const from = path.join(__dirname, "..", "..", "include", "cluaupp");
+	if (!fs.existsSync(from)) {
+		return;
+	}
+	syncDir(from, path.join(dest, "include", "cluaupp"));
+}
+
+export function collectCpp(dir: string, files: string[] = []): string[] {
+	if (!fs.existsSync(dir)) {
+		return files;
+	}
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			collectCpp(full, files);
+		} else if (isSourceFile(entry.name)) {
+			files.push(full);
+		}
+	}
+	return files;
+}
+
+function collectFiles(dir: string, files: string[] = []): string[] {
+	if (!fs.existsSync(dir)) {
+		return files;
+	}
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			collectFiles(full, files);
+		} else {
+			files.push(full);
+		}
+	}
+	return files;
+}
+
+function resolveKey(file: string): string {
+	const resolved = path.resolve(file);
+	return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+
+function posixRel(from: string, file: string): string {
+	return path.relative(from, file).replace(/\\/g, "/");
+}
+
+function sourcePrefixes(rel: string): string[] {
+	const noExt = rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, "");
+	const noTag = noExt.replace(/\.(server|client)$/i, "");
+	return [...new Set([noExt, noTag, toLuauPath(rel).replace(/\\/g, "/")])];
+}
+
+function matchesPrefix(relOut: string, prefixes: string[]): boolean {
+	const n = relOut.replace(/\\/g, "/").toLowerCase();
+	return prefixes.some((prefix) => {
+		const key = prefix.replace(/\\/g, "/").toLowerCase();
+		return n === key || n === `${key}.luau` || n.startsWith(`${key}/`) || n.startsWith(`${key}.`);
+	});
+}
+
+function removeEmptyOutDirs(outDir: string, projectRootDir: string): void {
+	if (!fs.existsSync(outDir)) {
+		return;
+	}
+	const walk = (dir: string) => {
+		if (resolveKey(dir) === resolveKey(outDir)) {
+			for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+				if (entry.isDirectory()) {
+					walk(path.join(dir, entry.name));
+				}
+			}
+			return;
+		}
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			if (entry.isDirectory()) {
+				walk(path.join(dir, entry.name));
+			}
+		}
+		if (fs.existsSync(dir) && fs.readdirSync(dir).length === 0) {
+			if (tryRm(dir, projectRootDir)) {
+				console.log("cluaupp: removed", path.relative(projectRootDir, dir));
+			}
+		}
+	};
+	walk(outDir);
+}
+
+function pruneOut(root: string, config: ProjectConfig, written: Set<string>, failedPrefixes: string[]): void {
+	const outDir = path.resolve(root, config.outDir);
+	if (!fs.existsSync(outDir) || !isInside(root, outDir)) {
+		return;
+	}
+	for (const file of collectFiles(outDir)) {
+		if (written.has(resolveKey(file))) {
+			continue;
+		}
+		if (!isInside(outDir, file)) {
+			continue;
+		}
+		const rel = posixRel(outDir, file);
+		if (matchesPrefix(rel, failedPrefixes)) {
+			continue;
+		}
+		if (tryRm(file, outDir)) {
+			console.log("cluaupp: removed", path.relative(root, file));
+		}
+	}
+	removeEmptyOutDirs(outDir, root);
+}
+
+function createMapper(root: string, config: ProjectConfig, rojoPath?: string): RojoMapper {
+	const projectJson = path.resolve(root, rojoPath || "default.project.json");
+	const mapper = new RojoMapper(projectJson, path.join(root, config.rootDir), config.outDir);
+	mapper.loadSync();
+	return mapper;
+}
+
+function compileProject(root: string, config: ProjectConfig, mapper: RojoMapper) {
+	const srcDir = path.join(root, config.rootDir);
+	const files = collectCpp(srcDir);
+	const jobs: Array<{ rel: string; files: Array<{ name: string; contents: string }>; stale: string[] }> = [];
+	const errors: Array<{ rel: string; prefixes: string[]; message: string }> = [];
+
+	for (const file of files) {
+		const source = fs.readFileSync(file, "utf8");
+		const rel = posixRel(srcDir, file);
+		try {
+			const result = transpileSource(source, rel, {
+				...config,
+				filePath: file,
+				relativeName: rel,
+				outName: toLuauPath(rel),
+				architecture: config.architecture === true,
+				includeDirs: [path.dirname(file), srcDir, path.join(root, "include")],
+				srcDir,
+				outDir: config.outDir,
+			}, mapper);
+			jobs.push({ rel, files: result.files, stale: result.stale || [] });
+		} catch (err) {
+			errors.push({ rel, prefixes: sourcePrefixes(rel), message: (err as Error).message });
+		}
+	}
+
+	return { files, jobs, errors };
+}
+
+function writeTextIfChanged(dest: string, contents: string): boolean {
+	if (fs.existsSync(dest) && fs.readFileSync(dest, "utf8") === contents) {
+		return false;
+	}
+	fs.mkdirSync(path.dirname(dest), { recursive: true });
+	fs.writeFileSync(dest, contents, "utf8");
+	return true;
+}
+
+function outDest(root: string, config: ProjectConfig, rel: string): string | null {
+	const safe = safeRelPath(rel);
+	if (!safe) {
+		console.error("cluaupp: skip unsafe out path", rel);
+		return null;
+	}
+	const outRoot = path.resolve(root, config.outDir);
+	const dest = path.join(outRoot, safe);
+	if (!isInside(outRoot, dest) || !isInside(root, dest)) {
+		console.error("cluaupp: skip unsafe out path", rel);
+		return null;
+	}
+	return dest;
+}
+
+function writeJobs(root: string, config: ProjectConfig, jobs: Array<{ rel: string; files: Array<{ name: string; contents: string }>; stale: string[] }>, format: boolean): Set<string> {
+	const written = new Set<string>();
+	for (const job of jobs) {
+		for (const artifact of job.files) {
+			const dest = outDest(root, config, artifact.name);
+			if (!dest) {
+				continue;
+			}
+			const changed = writeTextIfChanged(dest, artifact.contents);
+			written.add(resolveKey(dest));
+			if (changed) {
+				console.log("cluaupp:", job.rel, "→", path.relative(root, dest));
+			}
+			if (format && /\.luau$/i.test(dest)) {
+				ProcessOrchestrator.formatWithStyLuaSync(dest);
+			}
+		}
+		for (const stale of job.stale || []) {
+			const dest = outDest(root, config, stale);
+			if (dest && fs.existsSync(dest) && !written.has(resolveKey(dest))) {
+				if (tryRm(dest, path.resolve(root, config.outDir))) {
+					console.log("cluaupp: removed", path.relative(root, dest));
+				}
+			}
+		}
+	}
+	return written;
+}
+
+function ensureVendor(root: string): void {
+	copyRuntime(root);
+	copyHeaders(root);
+}
+
+export function build(root: string, options: BuildOptions = {}): BuildResult {
+	const exitOnError = options.exitOnError !== false;
+	const holdOnError = options.holdOnError === true;
+	const format = options.format === true;
+	const config = loadConfig(root);
+	if (options.syncVendor !== false) {
+		ensureVendor(root);
+	}
+	const srcDir = path.join(root, config.rootDir);
+	if (!fs.existsSync(srcDir) || collectCpp(srcDir).length === 0) {
+		console.error("no .cpp/.h/.hpp files in", config.rootDir);
+		if (!holdOnError) {
+			pruneOut(root, config, new Set(), []);
+		}
+		if (exitOnError) {
+			process.exit(1);
+		}
+		return { failed: 0, written: new Set() };
+	}
+
+	const mapper = createMapper(root, config, options.rojo);
+	const compiled = compileProject(root, config, mapper);
+	if (compiled.errors.length > 0) {
+		for (const err of compiled.errors) {
+			console.error(err.message);
+		}
+		if (holdOnError) {
+			console.error(`cluaupp: out not updated (${compiled.errors.length} compile error${compiled.errors.length === 1 ? "" : "s"})`);
+			try {
+				syncEditorSupport(root, config);
+			} catch (err) {
+				console.error("cluaupp: intellisense sync failed", (err as Error).message);
+			}
+			return { failed: compiled.errors.length, written: new Set() };
+		}
+	}
+
+	const written = writeJobs(root, config, compiled.jobs, format);
+	const failedPrefixes = compiled.errors.flatMap((err) => err.prefixes);
+	pruneOut(root, config, written, failedPrefixes);
+	try {
+		syncEditorSupport(root, config);
+	} catch (err) {
+		console.error("cluaupp: intellisense sync failed", (err as Error).message);
+	}
+
+	if (options.analyze) {
+		for (const file of written) {
+			if (/\.luau$/i.test(file)) {
+				const report = ProcessOrchestrator.analyzeWithLuauSync(file);
+				if (report) {
+					console.log("\n📊 Relatório de Análise Estática do Luau:\n", report);
+				}
+			}
+		}
+	}
+
+	if (compiled.errors.length > 0 && exitOnError) {
+		process.exit(1);
+	}
+	return { failed: compiled.errors.length, written };
+}
+
+export async function init(dest: string): Promise<void> {
+	const target = assertInitDest(dest);
+	const template = path.join(__dirname, "..", "..", "templates", "game");
+	const include = path.join(__dirname, "..", "..", "include");
+	copyDir(template, target);
+	copyDir(include, path.join(target, "include"));
+	copyRuntime(target);
+	syncEditorSupport(target);
+	const installed = await installEditorSupport();
+	console.log("Cluaupp ready in", target);
+	console.log("  rokit install");
+	console.log("  cluaupp build");
+	console.log("  rojo serve");
+	if (
+		installed.local.length ||
+		(installed.clangd && (installed.clangd.status === "installed" || installed.clangd.status === "already")) ||
+		(installed.llvm && (installed.llvm.status === "installed" || installed.llvm.status === "already"))
+	) {
+		console.log("  reload Cursor (Ctrl+Shift+P → Developer: Reload Window)");
+	}
+}
+
+function pidAlive(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function acquireWatchLock(root: string): void {
+	const file = path.join(root, ".cluaupp-watch.lock");
+	if (fs.existsSync(file)) {
+		const pid = Number(fs.readFileSync(file, "utf8").trim());
+		if (Number.isFinite(pid) && pid !== process.pid && pidAlive(pid)) {
+			console.error(`cluaupp: watch already running (pid ${pid}). Stop it first — two watchers make Rojo crash on libs/.`);
+			process.exit(1);
+		}
+	}
+	fs.writeFileSync(file, String(process.pid), "utf8");
+	const release = () => {
+		try {
+			if (fs.existsSync(file) && fs.readFileSync(file, "utf8").trim() === String(process.pid)) {
+				fs.unlinkSync(file);
+			}
+		} catch {
+			// ignore
+		}
+	};
+	process.on("exit", release);
+	process.on("SIGINT", () => {
+		release();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		release();
+		process.exit(0);
+	});
+}
+
+export function watch(root: string, options: BuildOptions = {}): void {
+	acquireWatchLock(root);
+	build(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo });
+	const config = loadConfig(root);
+	const dir = path.join(root, config.rootDir);
+	let timer: NodeJS.Timeout | null = null;
+	let running = false;
+	let queued = false;
+
+	const run = () => {
+		if (running) {
+			queued = true;
+			return;
+		}
+		running = true;
+		try {
+			build(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo });
+		} catch (err) {
+			console.error((err as Error).message);
+		} finally {
+			running = false;
+			if (queued) {
+				queued = false;
+				run();
+			}
+		}
+	};
+
+	console.log("cluaupp", pkg.version, "watching", dir, "(libs untouched)");
+	if (!fs.existsSync(dir)) {
+		fs.mkdirSync(dir, { recursive: true });
+	}
+	fs.watch(dir, { recursive: true }, () => {
+		if (timer) {
+			clearTimeout(timer);
+		}
+		timer = setTimeout(run, 400);
+	});
+}

package/src/utils/rojo-mapper.ts

@@ -0,0 +1,190 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse } from "comment-json";
+import type { RequireBinding, RojoConfig, RojoPathBinding } from "../types.js";
+import { INCLUDE_TO_MODULE, MODULES } from "../libs.js";
+import { isEngineStub } from "../preprocess.js";
+
+const SYSTEM_INCLUDES = new Set([
+	"iostream",
+	"string",
+	"string_view",
+	"vector",
+	"array",
+	"map",
+	"unordered_map",
+	"set",
+	"unordered_set",
+	"optional",
+	"memory",
+	"cstdint",
+	"cstddef",
+	"cmath",
+	"algorithm",
+	"utility",
+	"functional",
+	"span",
+	"tuple",
+	"type_traits",
+]);
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return null;
+	}
+	return value as Record<string, unknown>;
+}
+
+function posix(filePath: string): string {
+	return filePath.replace(/\\/g, "/");
+}
+
+export class RojoMapper {
+	private config: RojoConfig | null = null;
+	private bindings: RojoPathBinding[] = [];
+
+	constructor(
+		private projectJsonPath: string,
+		private srcDir?: string,
+		private outDir?: string,
+	) {}
+
+	public async load(): Promise<void> {
+		this.loadSync();
+	}
+
+	public loadSync(): void {
+		this.config = null;
+		this.bindings = [];
+		if (!fs.existsSync(this.projectJsonPath)) {
+			return;
+		}
+		const content = fs.readFileSync(this.projectJsonPath, "utf8");
+		this.config = parse(content) as unknown as RojoConfig;
+		this.bindings = this.walkTree(this.config.tree, []);
+	}
+
+	public resolveIncludeToRequire(includePath: string): RequireBinding | null {
+		const raw = includePath.replace(/[<>'"]/g, "").trim();
+		if (!raw) {
+			return null;
+		}
+		const cleanPath = posix(raw).replace(/\.h(pp|h)?$/i, "");
+		const baseName = path.posix.basename(cleanPath);
+		const key = baseName.toLowerCase();
+
+		if (isEngineStub(raw) || SYSTEM_INCLUDES.has(key) || SYSTEM_INCLUDES.has(cleanPath.toLowerCase())) {
+			return null;
+		}
+
+		const library = this.resolveLibrary(cleanPath, key);
+		if (library) {
+			return library;
+		}
+
+		const fromTree = this.resolveFromRojoTree(cleanPath, baseName);
+		if (fromTree) {
+			return fromTree;
+		}
+
+		const segments = cleanPath.split("/").filter(Boolean);
+		if (segments[0] === "src") {
+			segments.shift();
+		}
+		const alias = this.safeAlias(baseName);
+		if (segments[0] === "shared") {
+			return { alias, path: `ReplicatedStorage.Cluaupp.${segments.slice(1).join(".")}` };
+		}
+		if (segments[0] === "server") {
+			return { alias, path: `ServerScriptService.Cluaupp.${segments.slice(1).join(".")}` };
+		}
+		if (segments[0] === "client") {
+			return { alias, path: `StarterPlayer.StarterPlayerScripts.Cluaupp.${segments.slice(1).join(".")}` };
+		}
+		return { alias, path: `ReplicatedStorage.${segments.join(".")}` };
+	}
+
+	private resolveLibrary(cleanPath: string, key: string): RequireBinding | null {
+		const mapped = (INCLUDE_TO_MODULE as Record<string, string | null>)[key]
+			?? (INCLUDE_TO_MODULE as Record<string, string | null>)[path.posix.basename(cleanPath).toLowerCase()];
+		if (!mapped) {
+			return null;
+		}
+		const spec = (MODULES as Record<string, { file: string; bind: string }>)[mapped];
+		const bind = spec?.bind || mapped;
+		const file = spec?.file || mapped;
+		const libsRoot = this.findBinding((binding) => binding.robloxPath.endsWith(".CluauppLibs") || binding.robloxPath === "ReplicatedStorage.CluauppLibs");
+		const packagesRoot = this.findBinding((binding) => binding.robloxPath.endsWith(".Packages") || binding.robloxPath === "ReplicatedStorage.Packages");
+		if (libsRoot) {
+			return { alias: bind, path: `${libsRoot.robloxPath}.${file}` };
+		}
+		if (packagesRoot) {
+			return { alias: bind, path: `${packagesRoot.robloxPath}.${file}` };
+		}
+		return { alias: bind, path: `ReplicatedStorage.CluauppLibs.${file}` };
+	}
+
+	private resolveFromRojoTree(cleanPath: string, baseName: string): RequireBinding | null {
+		const outRel = this.guessOutRel(cleanPath);
+		if (!outRel || this.bindings.length === 0) {
+			return null;
+		}
+		let best: { binding: RojoPathBinding; rest: string[] } | null = null;
+		for (const binding of this.bindings) {
+			const prefix = posix(binding.fsPath).replace(/\/$/, "");
+			if (outRel === prefix || outRel.startsWith(`${prefix}/`)) {
+				const rest = outRel === prefix ? [] : outRel.slice(prefix.length + 1).split("/");
+				if (!best || prefix.length > posix(best.binding.fsPath).length) {
+					best = { binding, rest };
+				}
+			}
+		}
+		if (!best) {
+			return null;
+		}
+		const tail = best.rest.join(".");
+		return {
+			alias: this.safeAlias(baseName),
+			path: tail ? `${best.binding.robloxPath}.${tail}` : best.binding.robloxPath,
+		};
+	}
+
+	private guessOutRel(cleanPath: string): string | null {
+		const relative = posix(cleanPath).replace(/^src\//, "");
+		const outName = relative.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, "");
+		if (this.outDir) {
+			return posix(path.join(this.outDir, outName));
+		}
+		return posix(path.join("out", outName));
+	}
+
+	private walkTree(node: unknown, robloxPath: string[]): RojoPathBinding[] {
+		const record = asRecord(node);
+		if (!record) {
+			return [];
+		}
+		const found: RojoPathBinding[] = [];
+		if (typeof record.$path === "string" && robloxPath.length > 0) {
+			found.push({
+				robloxPath: robloxPath.join("."),
+				fsPath: posix(record.$path),
+			});
+		}
+		for (const [key, child] of Object.entries(record)) {
+			if (key.startsWith("$")) {
+				continue;
+			}
+			found.push(...this.walkTree(child, [...robloxPath, key]));
+		}
+		return found;
+	}
+
+	private findBinding(predicate: (binding: RojoPathBinding) => boolean): RojoPathBinding | undefined {
+		return this.bindings.find(predicate);
+	}
+
+	private safeAlias(name: string): string {
+		const cleaned = name.replace(/[^A-Za-z0-9_]/g, "_");
+		return /^[A-Za-z_]/.test(cleaned) ? cleaned : `_${cleaned}`;
+	}
+}