@codefast/cli 0.3.12 → 0.3.13-canary.0

package/dist/engine-CcWEHSCq.mjs

@@ -0,0 +1,287 @@
+import { t as messageFromCaughtUnknown } from "./caught-unknown-message-CRhkDWO7.mjs";
+import { i as indentOfLineContaining, n as applyEditsDescending } from "./ast-helpers-MDRYuIAk.mjs";
+import { n as walkTsxFiles } from "./walk-DjgQn66n.mjs";
+import "./arrange-BqP2DI3w.mjs";
+import { t as resolveTagTargetCandidates } from "./target-resolver-CR3FXMTy.mjs";
+import path from "node:path";
+import ts from "typescript";
+//#region src/lib/tag/application/engine.ts
+const PACKAGE_JSON = "package.json";
+const VERSION_TAG = "@since";
+function hasExportModifier(node) {
+	return (ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function isTaggableDeclaration(node) {
+	return ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isVariableStatement(node);
+}
+function addDeclarationName(registry, name, declaration) {
+	if (!registry.has(name)) {
+		registry.set(name, new Set([declaration]));
+		return;
+	}
+	registry.get(name).add(declaration);
+}
+function collectLocalNamedDeclarations(sf) {
+	const declarations = /* @__PURE__ */ new Map();
+	for (const statement of sf.statements) {
+		if (ts.isFunctionDeclaration(statement) && statement.name) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isClassDeclaration(statement) && statement.name) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isInterfaceDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isTypeAliasDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isEnumDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (!ts.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name)) addDeclarationName(declarations, declaration.name.text, statement);
+	}
+	return declarations;
+}
+function collectExportedDeclarations(sf) {
+	const exported = /* @__PURE__ */ new Set();
+	const localNamed = collectLocalNamedDeclarations(sf);
+	for (const statement of sf.statements) {
+		if (isTaggableDeclaration(statement) && hasExportModifier(statement)) {
+			exported.add(statement);
+			continue;
+		}
+		if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+			for (const element of statement.exportClause.elements) {
+				const localName = element.propertyName?.text ?? element.name.text;
+				const declarations = localNamed.get(localName);
+				if (!declarations) continue;
+				for (const declaration of declarations) exported.add(declaration);
+			}
+			continue;
+		}
+		if (!ts.isExportAssignment(statement) || !ts.isIdentifier(statement.expression)) continue;
+		const declarations = localNamed.get(statement.expression.text);
+		if (!declarations) continue;
+		for (const declaration of declarations) exported.add(declaration);
+	}
+	return exported;
+}
+function makeJSDocSinceLine(existingComment, sourceText, version) {
+	const commentText = sourceText.slice(existingComment.pos, existingComment.end);
+	const baseIndent = indentOfLineContaining(sourceText, existingComment.pos);
+	const normalizedBodyLines = commentText.replace(/^\/\*\*\s?/, "").replace(/\s*\*\/$/, "").split("\n").map((line) => line.replace(/^\s*\*\s?/, "").replace(/\s+$/, "")).filter((line, lineIndex, lines) => {
+		if (line.length > 0) return true;
+		const hasNonEmptyBefore = lines.slice(0, lineIndex).some((value) => value.length > 0);
+		const hasNonEmptyAfter = lines.slice(lineIndex + 1).some((value) => value.length > 0);
+		return hasNonEmptyBefore && hasNonEmptyAfter;
+	});
+	const replacement = `/**\n${normalizedBodyLines.length > 0 ? `${normalizedBodyLines.map((line) => `${baseIndent} * ${line}`).join("\n")}\n${baseIndent} *\n` : ""}${baseIndent} * ${VERSION_TAG} ${version}\n${baseIndent} */`;
+	return {
+		start: existingComment.pos,
+		end: existingComment.end,
+		replacement
+	};
+}
+function makeSinceOnlyJSDocBlock(declarationIndent, version) {
+	return `/**\n${declarationIndent} * ${VERSION_TAG} ${version}\n${declarationIndent} */`;
+}
+function makeDeclarationSinceLine(declaration, sf, sourceText, version) {
+	if (ts.getJSDocTags(declaration).some((tag) => tag.tagName.text === "since")) return void 0;
+	const lastJsDoc = ts.getJSDocCommentsAndTags(declaration).filter(ts.isJSDoc).at(-1);
+	if (lastJsDoc) return makeJSDocSinceLine(lastJsDoc, sourceText, version);
+	const start = declaration.getStart(sf);
+	const indent = indentOfLineContaining(sourceText, start);
+	return {
+		start,
+		end: start,
+		replacement: `${indent}${makeSinceOnlyJSDocBlock(indent, version)}\n${indent}`
+	};
+}
+function applySinceTagsToFile(filePath, version, fs, write) {
+	const sourceText = fs.readFileSync(filePath, "utf8");
+	const sf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+	const edits = [];
+	for (const declaration of collectExportedDeclarations(sf)) {
+		const edit = makeDeclarationSinceLine(declaration, sf, sourceText, version);
+		if (edit) edits.push(edit);
+	}
+	if (edits.length > 0 && write) {
+		const updated = applyEditsDescending(sourceText, edits);
+		fs.writeFileSync(filePath, updated, "utf8");
+	}
+	return {
+		filePath,
+		taggedDeclarations: edits.length,
+		changed: edits.length > 0
+	};
+}
+function resolveNearestPackageVersion(targetPath, fs) {
+	const resolved = path.resolve(targetPath);
+	let current = fs.statSync(resolved).isDirectory() ? resolved : path.dirname(resolved);
+	while (true) {
+		const packageJsonPath = path.join(current, PACKAGE_JSON);
+		if (fs.existsSync(packageJsonPath)) {
+			const raw = fs.readFileSync(packageJsonPath, "utf8");
+			const version = JSON.parse(raw).version;
+			if (typeof version === "string" && version.length > 0) return version;
+			throw new Error(`Missing or invalid version in ${packageJsonPath}`);
+		}
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	throw new Error(`Unable to locate ${PACKAGE_JSON} from target: ${targetPath}`);
+}
+function runTagOnTarget(targetPath, opts, fs) {
+	const resolvedTarget = path.resolve(targetPath);
+	const version = resolveNearestPackageVersion(resolvedTarget, fs);
+	const tsFiles = (fs.statSync(resolvedTarget).isDirectory() ? walkTsxFiles(resolvedTarget, fs) : [resolvedTarget]).filter((filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx"));
+	const fileResults = tsFiles.map((filePath) => applySinceTagsToFile(filePath, version, fs, opts.write));
+	const filesChanged = fileResults.filter((result) => result.changed).length;
+	const taggedDeclarations = fileResults.reduce((sum, result) => sum + result.taggedDeclarations, 0);
+	return {
+		version,
+		filesScanned: tsFiles.length,
+		filesChanged,
+		taggedDeclarations,
+		fileResults
+	};
+}
+async function runTagOnAfterWriteHook(hook, modifiedFiles) {
+	if (!hook || modifiedFiles.length === 0) return null;
+	try {
+		await hook({ files: modifiedFiles });
+		return null;
+	} catch (caughtHookError) {
+		return `[tag] onAfterWrite hook failed: ${messageFromCaughtUnknown(caughtHookError)}`;
+	}
+}
+function summarizeVersions(targetResults) {
+	const distinctVersions = extractDistinctVersions(targetResults);
+	if (distinctVersions.size === 0) return "none";
+	if (distinctVersions.size > 1) return "mixed";
+	return [...distinctVersions][0];
+}
+function extractDistinctVersions(targetResults) {
+	return new Set(targetResults.map((targetResult) => targetResult.result?.version).filter((version) => typeof version === "string" && version.length > 0));
+}
+function chooseWorkspacePackageTargetPath(candidate, fs) {
+	if (candidate.source !== "workspace-package") return {
+		targetPath: candidate.candidatePath,
+		source: candidate.source
+	};
+	const preferredSourceDir = path.join(candidate.candidatePath, "src");
+	if (fs.existsSync(preferredSourceDir) && fs.statSync(preferredSourceDir).isDirectory()) return {
+		targetPath: preferredSourceDir,
+		source: "workspace-package-selected-src"
+	};
+	return {
+		targetPath: candidate.candidatePath,
+		source: "workspace-package-selected-root"
+	};
+}
+function resolveTargetSelection(candidate, rootDir, fs) {
+	const selectedTarget = chooseWorkspacePackageTargetPath(candidate, fs);
+	const rootRelativeTargetPath = path.relative(rootDir, selectedTarget.targetPath).split(path.sep).join("/");
+	return {
+		targetPath: selectedTarget.targetPath,
+		rootRelativeTargetPath: rootRelativeTargetPath || ".",
+		source: selectedTarget.source,
+		packageDir: candidate.packageDir,
+		packageName: candidate.packageName
+	};
+}
+function filterSkippedCandidates(targetCandidates, skipPackages) {
+	if (!skipPackages || skipPackages.length === 0) return {
+		includedCandidates: targetCandidates,
+		skippedPackages: []
+	};
+	const skipPackageSet = new Set(skipPackages);
+	const includedCandidates = [];
+	const skippedPackages = [];
+	for (const candidate of targetCandidates) {
+		const packageName = candidate.packageName;
+		if (packageName && skipPackageSet.has(packageName)) {
+			skippedPackages.push(packageName);
+			continue;
+		}
+		includedCandidates.push(candidate);
+	}
+	return {
+		includedCandidates,
+		skippedPackages
+	};
+}
+async function runOnResolvedTarget(resolvedTarget, write, fs, listener) {
+	listener?.onTargetStarted(resolvedTarget);
+	const absoluteTargetPath = path.resolve(resolvedTarget.targetPath);
+	if (!fs.existsSync(absoluteTargetPath)) {
+		const missingTargetResult = {
+			target: resolvedTarget,
+			targetExists: false,
+			runError: `Not found: ${absoluteTargetPath}`,
+			result: null
+		};
+		listener?.onTargetCompleted(resolvedTarget, missingTargetResult);
+		return missingTargetResult;
+	}
+	try {
+		const targetRunResult = {
+			target: resolvedTarget,
+			targetExists: true,
+			runError: null,
+			result: runTagOnTarget(absoluteTargetPath, { write }, fs)
+		};
+		listener?.onTargetCompleted(resolvedTarget, targetRunResult);
+		return targetRunResult;
+	} catch (caughtRunError) {
+		const failedTargetRunResult = {
+			target: resolvedTarget,
+			targetExists: true,
+			runError: messageFromCaughtUnknown(caughtRunError),
+			result: null
+		};
+		listener?.onTargetCompleted(resolvedTarget, failedTargetRunResult);
+		return failedTargetRunResult;
+	}
+}
+/**
+* CLI entry: run tagging and optional `onAfterWrite` using config injected by the command layer.
+* Returns structured execution data; presentation/logging belongs to command layer.
+*/
+async function runTagSync(opts) {
+	const { fs } = opts;
+	const { includedCandidates, skippedPackages } = filterSkippedCandidates(await resolveTagTargetCandidates(opts.rootDir, opts.targetPath, fs), opts.skipPackages);
+	const selectedTargets = includedCandidates.map((candidate) => resolveTargetSelection(candidate, opts.rootDir, fs));
+	const targetResults = await Promise.all(selectedTargets.map((resolvedTarget) => runOnResolvedTarget(resolvedTarget, opts.write, fs, opts.listener)));
+	const allFileResults = targetResults.flatMap((targetResult) => targetResult.result?.fileResults ?? []);
+	const filesScanned = targetResults.reduce((sum, targetResult) => sum + (targetResult.result?.filesScanned ?? 0), 0);
+	const filesChanged = targetResults.reduce((sum, targetResult) => sum + (targetResult.result?.filesChanged ?? 0), 0);
+	const taggedDeclarations = targetResults.reduce((sum, targetResult) => sum + (targetResult.result?.taggedDeclarations ?? 0), 0);
+	const modifiedFiles = allFileResults.filter((entry) => entry.changed).map((entry) => entry.filePath);
+	const hookError = opts.write && modifiedFiles.length > 0 ? await runTagOnAfterWriteHook(opts.config?.onAfterWrite, modifiedFiles) : null;
+	const distinctVersions = [...extractDistinctVersions(targetResults)].sort((left, right) => left.localeCompare(right));
+	return {
+		mode: opts.write ? "applied" : "dry-run",
+		selectedTargets,
+		resolvedTargets: selectedTargets,
+		skippedPackages,
+		targetResults,
+		filesScanned,
+		filesChanged,
+		taggedDeclarations,
+		versionSummary: summarizeVersions(targetResults),
+		distinctVersions,
+		modifiedFiles,
+		hookError
+	};
+}
+//#endregion
+export { runTagOnTarget as n, runTagSync as r, resolveNearestPackageVersion as t };

package/dist/engine-DRTdkc5u.mjs

@@ -0,0 +1,236 @@
+import { a as VALID_JS_EXTENSIONS, i as PACKAGE_JSON_EXPORT, n as DTS_EXTENSION } from "./constants-Bq5wdyLC.mjs";
+import { t as isDirentList } from "./dirent-list-BSDeRG5i.mjs";
+import { t as normalizePath } from "./path-normalizer-D4ceBO3l.mjs";
+import path from "node:path";
+//#region src/lib/mirror/application/engine.ts
+function resolvePackageScopedConfig(configMap, pkgMeta) {
+	if (!configMap) return void 0;
+	return configMap[pkgMeta.packageName];
+}
+async function scanDirectoryFiles(fs, dir, baseDir = dir) {
+	try {
+		const raw = await fs.readdir(dir, {
+			recursive: true,
+			withFileTypes: true
+		});
+		if (!isDirentList(raw)) return [];
+		return raw.filter((dirent) => dirent.isFile()).map((dirent) => {
+			const fullPath = path.join(dirent.parentPath, dirent.name);
+			return normalizePath(path.relative(baseDir, fullPath));
+		});
+	} catch (caughtError) {
+		if (caughtError && typeof caughtError === "object" && "code" in caughtError) {
+			if (caughtError.code === "ENOENT" || caughtError.code === "EACCES") return [];
+		}
+		throw caughtError;
+	}
+}
+async function isDirectoryCssOnly(fs, distDir, dirPath) {
+	try {
+		const raw = await fs.readdir(path.join(distDir, dirPath), { withFileTypes: true });
+		if (!isDirentList(raw)) return false;
+		if (raw.length === 0) return true;
+		return raw.every((dirent) => dirent.isFile() && dirent.name.endsWith(".css"));
+	} catch {
+		return false;
+	}
+}
+function groupFilesByModule(files) {
+	const modules = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		let ext;
+		let modulePath;
+		if (file.endsWith(".d.ts")) {
+			ext = DTS_EXTENSION;
+			modulePath = file.slice(0, -DTS_EXTENSION.length);
+		} else {
+			ext = path.extname(file);
+			if (!VALID_JS_EXTENSIONS.has(ext)) continue;
+			modulePath = file.slice(0, -ext.length);
+		}
+		if (!path.basename(modulePath)) continue;
+		let distModule = modules.get(modulePath);
+		if (!distModule) {
+			distModule = {
+				path: modulePath,
+				files: {
+					js: null,
+					cjs: null,
+					dts: null
+				}
+			};
+			modules.set(modulePath, distModule);
+		}
+		if (ext === ".js") distModule.files.js = file;
+		else if (ext === ".cjs") distModule.files.cjs = file;
+		else if (ext === ".d.ts") distModule.files.dts = file;
+	}
+	return modules;
+}
+function toExportPath(distPath) {
+	if (distPath === "index") return ".";
+	if (distPath.endsWith("/index")) return `./${distPath.slice(0, -6)}`;
+	return `./${distPath}`;
+}
+const GROUP_ORDER = {
+	components: 100,
+	hooks: 200,
+	primitives: 300,
+	core: 400,
+	loaders: 500,
+	utils: 600,
+	adapters: 700,
+	script: 750,
+	css: 900
+};
+function getExportGroup(exportPath, pathTransform) {
+	if (exportPath === ".") return [
+		".",
+		"",
+		0,
+		0
+	];
+	const cleanPath = exportPath.startsWith("./") ? exportPath.slice(2) : exportPath;
+	if (cleanPath.endsWith("/*")) {
+		const dirName = cleanPath.slice(0, -2);
+		return [
+			dirName,
+			"",
+			dirName === "css" ? 900 : 100,
+			0
+		];
+	}
+	const parts = cleanPath.split("/");
+	if (parts.length === 1) {
+		const name = parts[0];
+		if (name in GROUP_ORDER) return [
+			name,
+			"",
+			GROUP_ORDER[name] ?? 0,
+			0
+		];
+		if (pathTransform) return [
+			"components",
+			name,
+			100,
+			1
+		];
+		return [
+			"",
+			name,
+			800,
+			1
+		];
+	}
+	const group = parts[0] ?? "";
+	return [
+		group,
+		parts.slice(1).join("/"),
+		GROUP_ORDER[group] ?? 700,
+		1
+	];
+}
+function createPathTransform(config, pkgMeta) {
+	const pathConfig = resolvePackageScopedConfig(config?.pathTransformations, pkgMeta);
+	if (!pathConfig) return null;
+	const { removePrefix } = pathConfig;
+	if (!removePrefix) return null;
+	return (exportPath) => {
+		if (!exportPath.startsWith(removePrefix)) return exportPath;
+		const result = exportPath.slice(removePrefix.length);
+		if (result && result !== "." && !result.startsWith("./")) return `./${result}`;
+		return result;
+	};
+}
+function getSortTuple(exportPath, pathTransform) {
+	const [group, subpath, order, isIndex] = getExportGroup(exportPath, pathTransform);
+	return [
+		order,
+		group,
+		isIndex,
+		subpath
+	];
+}
+function compareTuples(left, right) {
+	if (left[0] !== right[0]) return left[0] - right[0];
+	if (left[1] !== right[1]) return left[1] < right[1] ? -1 : 1;
+	if (left[2] !== right[2]) return left[2] - right[2];
+	if (left[3] !== right[3]) return left[3] < right[3] ? -1 : 1;
+	return 0;
+}
+async function generateCssExports(fs, distDir, cssConfig) {
+	if (cssConfig === false) return {};
+	if (cssConfig === true) cssConfig = { enabled: true };
+	if (!cssConfig || cssConfig.enabled === false) return {};
+	const cssFiles = (await scanDirectoryFiles(fs, distDir)).filter((relativeDistPath) => relativeDistPath.endsWith(".css"));
+	if (!cssFiles.length) return {};
+	const cssExports = { ...cssConfig.customExports };
+	const cssByDir = /* @__PURE__ */ new Map();
+	const rootCss = [];
+	for (const file of cssFiles) {
+		const dirName = normalizePath(path.dirname(file));
+		if (dirName === ".") rootCss.push(file);
+		else {
+			const arr = cssByDir.get(dirName) || [];
+			arr.push(file);
+			cssByDir.set(dirName, arr);
+		}
+	}
+	for (const file of rootCss) {
+		const exportPath = `./${file}`;
+		if (!(exportPath in cssExports)) cssExports[exportPath] = `./dist/${file}`;
+	}
+	for (const [dirName, dirFiles] of cssByDir.entries()) if (await isDirectoryCssOnly(fs, distDir, dirName) && !cssConfig.forceExportFiles) {
+		const wildcardExport = `./${dirName}/*`;
+		if (!(wildcardExport in cssExports)) cssExports[wildcardExport] = `./dist/${dirName}/*`;
+	} else for (const file of dirFiles) {
+		const exportPath = `./${file}`;
+		if (!(exportPath in cssExports)) cssExports[exportPath] = `./dist/${file}`;
+	}
+	return cssExports;
+}
+/**
+* Compute `package.json#exports` from a built `dist/` tree. No logging; no writes.
+*/
+async function generateExports(fs, distDir, pathTransform, cssConfig, customExports) {
+	const files = await scanDirectoryFiles(fs, distDir);
+	if (!files.length) return {
+		exports: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		jsCount: 0,
+		cssCount: 0
+	};
+	const modules = groupFilesByModule(files);
+	const validModules = Array.from(modules.values()).filter((mod) => mod.files.js && mod.files.dts);
+	if (!validModules.length) return {
+		exports: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		jsCount: 0,
+		cssCount: 0
+	};
+	const exportsObj = {};
+	for (const distModuleEntry of validModules) {
+		let exportPath = toExportPath(distModuleEntry.path);
+		if (pathTransform) exportPath = pathTransform(exportPath);
+		const distPath = `./dist/${distModuleEntry.path}`;
+		const entry = { types: `${distPath}.d.ts` };
+		if (distModuleEntry.files.js) entry.import = `${distPath}.js`;
+		if (distModuleEntry.files.cjs) entry.require = `${distPath}.cjs`;
+		exportsObj[exportPath] = entry;
+	}
+	let sortedKeys = Object.keys(exportsObj).sort((pathA, pathB) => compareTuples(getSortTuple(pathA, pathTransform), getSortTuple(pathB, pathTransform)));
+	const sortedExports = {};
+	for (const exportKey of sortedKeys) sortedExports[exportKey] = exportsObj[exportKey];
+	const cssExports = await generateCssExports(fs, distDir, cssConfig ?? { enabled: true });
+	Object.assign(sortedExports, cssExports);
+	for (const [specifier, mappedPath] of Object.entries(customExports || {})) if (specifier !== "./package.json") sortedExports[specifier] = mappedPath;
+	sortedKeys = Object.keys(sortedExports).filter((exportKey) => exportKey !== PACKAGE_JSON_EXPORT).sort((pathA, pathB) => compareTuples(getSortTuple(pathA, pathTransform), getSortTuple(pathB, pathTransform)));
+	const finalExports = {};
+	for (const exportKey of sortedKeys) finalExports[exportKey] = sortedExports[exportKey];
+	finalExports[PACKAGE_JSON_EXPORT] = PACKAGE_JSON_EXPORT;
+	return {
+		exports: finalExports,
+		jsCount: Object.keys(exportsObj).length,
+		cssCount: Object.keys(cssExports).length
+	};
+}
+//#endregion
+export { generateExports as n, createPathTransform as t };

package/dist/errors-CFH4w6ic.mjs

@@ -0,0 +1,15 @@
+//#region src/lib/mirror/domain/errors.ts
+const MirrorErrorCode = {
+	FATAL: "FATAL",
+	PACKAGE_WRITE: "PACKAGE_WRITE"
+};
+var MirrorError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "MirrorError";
+		this.code = code;
+	}
+};
+//#endregion
+export { MirrorErrorCode as n, MirrorError as t };

package/dist/errors-CpU1ogfA.mjs

@@ -0,0 +1,19 @@
+//#region src/lib/arrange/domain/errors.ts
+/**
+* Structured errors for the arrange CLI library (throw from lib; handle exit in commands).
+*/
+const ArrangeErrorCode = {
+	TARGET_NOT_FOUND: "TARGET_NOT_FOUND",
+	INVALID_INPUT: "INVALID_INPUT",
+	INTERNAL: "INTERNAL"
+};
+var ArrangeError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "ArrangeError";
+		this.code = code;
+	}
+};
+//#endregion
+export { ArrangeErrorCode as n, ArrangeError as t };

package/dist/formatters-DGE8jJ53.mjs

@@ -0,0 +1,52 @@
+import { i as indentOfLineContaining } from "./ast-helpers-MDRYuIAk.mjs";
+//#region src/lib/arrange/presentation/formatters.ts
+function escapeTsStringLiteralContent(group) {
+	return group.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
+}
+/**
+* Multiline fragment for use *inside* an existing `cn(...)` — replaces one
+* string argument with several, without producing `cn(cn(...))`.
+*/
+function formatCnArguments(groups, options) {
+	const indent = options?.indent ?? "  ";
+	const commaAfterLast = options?.commaAfterLastGroup ?? options?.trailingClassName ?? false;
+	const lines = [];
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i];
+		const comma = i < groups.length - 1 || commaAfterLast ? "," : "";
+		lines.push(`${indent}"${escapeTsStringLiteralContent(group)}"${comma}`);
+	}
+	if (options?.trailingClassName) lines.push(`${indent}className,`);
+	return lines.join("\n");
+}
+function formatCnCall(groups, options) {
+	const lines = ["cn("];
+	const commaOnEachStringLine = groups.length > 1 || Boolean(options?.trailingClassName);
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i];
+		const comma = commaOnEachStringLine ? "," : "";
+		lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
+	}
+	if (options?.trailingClassName) lines.push("  className,");
+	lines.push(")");
+	return lines.join("\n");
+}
+function formatArray(groups) {
+	const lines = ["["];
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i];
+		const comma = i < groups.length - 1 || groups.length > 1 ? "," : "";
+		lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
+	}
+	lines.push("]");
+	return lines.join("\n");
+}
+function formatJsxCnAttributeValue(groups, source, valueNodeStart) {
+	const baseIndent = indentOfLineContaining(source, valueNodeStart);
+	return `{cn(\n${formatCnArguments(groups, {
+		indent: `${baseIndent}  `,
+		commaAfterLastGroup: groups.length > 1
+	})}\n${baseIndent})}`;
+}
+//#endregion
+export { formatJsxCnAttributeValue as a, formatCnCall as i, formatArray as n, formatCnArguments as r, escapeTsStringLiteralContent as t };