boss-css 0.0.1 → 0.0.2

package/dist/compile/classname.mjs

@@ -0,0 +1,360 @@
+import { parseSync, printSync } from "@swc/core";
+
+//#region src/compile/classname.ts
+const tokenPrefix = "$$.token.";
+const rewriteClassNameTokens = (input) => {
+	if (!input.includes(tokenPrefix) && !input.includes("{")) return input;
+	return splitSelectors(input).flatMap((selector) => rewriteSelector(selector, { expandSingleGroup: false })).join(" ");
+};
+const rewriteClassNameTokensInText = (source, options = {}) => {
+	return rewriteQuotedSegments(source, ({ value, hasTemplateExpression }) => {
+		if (hasTemplateExpression) return null;
+		return rewriteClassNameTokensWithMap(value, options.mapToken);
+	});
+};
+const rewriteClassNameTokensInSource = (source, options) => {
+	const ext = options.filename.split(".").pop() ?? "";
+	const isTs = ext === "ts" || ext === "tsx";
+	const isJsx = [
+		"jsx",
+		"tsx",
+		"js",
+		"mjs",
+		"cjs"
+	].includes(ext);
+	const classNameProp = options.classNameProp ?? "className";
+	const mapToken = options.mapToken;
+	const parsed = parseSync(source, {
+		syntax: isTs ? "typescript" : "ecmascript",
+		tsx: isTs && isJsx,
+		jsx: !isTs && isJsx
+	});
+	const visit = (node, context = {}) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			node.forEach((child) => visit(child, context));
+			return;
+		}
+		const current = node;
+		if (current.type === "JSXElement") rewriteClassNameTokensInElement(current, classNameProp, mapToken);
+		if (current.type === "CallExpression") rewriteClassNameTokensInCall(current, mapToken);
+		if (!context.inModuleSpecifier) {
+			if (current.type === "StringLiteral") {
+				const literal = current;
+				updateStringLiteral(literal, rewriteClassNameTokensWithMap(literal.value, mapToken));
+			}
+			if (current.type === "TemplateLiteral" && Array.isArray(current.expressions) && current.expressions.length === 0 && Array.isArray(current.quasis) && current.quasis.length) {
+				const firstQuasi = current.quasis[0];
+				if (firstQuasi) {
+					const rewritten = rewriteClassNameTokensWithMap(firstQuasi.cooked ?? "", mapToken);
+					firstQuasi.cooked = rewritten;
+					firstQuasi.raw = rewritten;
+				}
+			}
+		}
+		for (const key of Object.keys(current)) {
+			const nextContext = (current.type === "ImportDeclaration" || current.type === "ExportAllDeclaration" || current.type === "ExportNamedDeclaration") && key === "source" ? {
+				...context,
+				inModuleSpecifier: true
+			} : context;
+			visit(current[key], nextContext);
+		}
+	};
+	visit(parsed);
+	return printSync(parsed).code;
+};
+const rewriteClassNameTokensInCall = (expr, mapToken) => {
+	const callee = expr.callee;
+	if (callee.type !== "Identifier" || callee.value !== "$$") return;
+	if (expr.arguments.length !== 1) return;
+	const arg = expr.arguments[0].expression;
+	rewriteStringExpression(arg, mapToken);
+};
+const rewriteStringExpression = (expression, mapToken) => {
+	if (!expression) return;
+	if (expression.type === "StringLiteral") {
+		updateStringLiteral(expression, rewriteClassNameTokensWithMap(expression.value, mapToken));
+		return;
+	}
+	if (expression.type === "TemplateLiteral" && expression.expressions.length === 0 && expression.quasis.length) {
+		const firstQuasi = expression.quasis[0];
+		if (!firstQuasi) return;
+		const rewritten = rewriteClassNameTokensWithMap(firstQuasi.cooked ?? "", mapToken);
+		firstQuasi.cooked = rewritten;
+		firstQuasi.raw = rewritten;
+	}
+};
+const rewriteClassNameTokensInElement = (element, classNameProp = "className", mapToken) => {
+	const attributes = element.opening.attributes;
+	for (const attr of attributes) {
+		if (attr.type !== "JSXAttribute") continue;
+		if (!isClassAttribute(attr, classNameProp)) continue;
+		if (!attr.value) continue;
+		if (attr.value.type === "StringLiteral") {
+			updateStringLiteral(attr.value, rewriteClassNameTokensWithMap(attr.value.value, mapToken));
+			continue;
+		}
+		if (attr.value.type === "JSXExpressionContainer") {
+			const expression = attr.value.expression;
+			rewriteStringExpression(expression, mapToken);
+		}
+	}
+};
+const isClassAttribute = (attr, classNameProp) => {
+	return attr.name.type === "Identifier" && attr.name.value === classNameProp;
+};
+const rewriteSelector = (selector, options) => {
+	const grouped = parseGroupedSelector(selector);
+	if (grouped) {
+		const nextEntries = grouped.entries.map((entry$1) => ({
+			name: entry$1.name,
+			rawValue: rewriteTokenValue(entry$1.rawValue)
+		}));
+		if (nextEntries.length > 1 || options.expandSingleGroup) return [...nextEntries].sort((a, b) => a.name.localeCompare(b.name)).map((entry$1) => `${grouped.prefix}:${entry$1.name}:${entry$1.rawValue}`);
+		const [entry] = nextEntries;
+		return [`${grouped.prefix}:{${entry.name}:${entry.rawValue}}`];
+	}
+	const fragments = splitFragments(selector);
+	if (fragments.length < 2) return [selector];
+	const rawValue = fragments.at(-1) ?? "";
+	const nextValue = rewriteTokenValue(rawValue);
+	if (nextValue === rawValue) return [selector];
+	return [`${fragments.slice(0, -1).join(":")}:${nextValue}`];
+};
+const rewriteClassNameTokensWithMap = (input, mapToken) => {
+	if (!mapToken) return rewriteClassNameTokens(input);
+	const selectors = splitSelectors(input).flatMap((selector) => rewriteSelector(selector, { expandSingleGroup: true }));
+	let didChange = selectors.join(" ") !== input;
+	const mapped = selectors.map((selector) => {
+		if (!mapToken) return selector;
+		const next = mapToken(selector);
+		if (next && next !== selector) {
+			didChange = true;
+			return next;
+		}
+		return selector;
+	});
+	if (!didChange) return input;
+	return mapped.join(" ");
+};
+const rewriteTokenValue = (rawValue) => {
+	if (!rawValue.startsWith(tokenPrefix)) return rawValue;
+	const fragments = rawValue.slice(9).split(".").filter(Boolean);
+	if (fragments.length < 2) return rawValue;
+	return fragments.slice(1).join(".");
+};
+const updateStringLiteral = (literal, nextValue) => {
+	literal.value = nextValue;
+	literal.raw = JSON.stringify(nextValue);
+};
+const splitSelectors = (input) => splitOutside(input, " ");
+const splitFragments = (selector) => splitOutside(selector, ":");
+const splitGroupedEntries = (body) => splitOutside(body, ";");
+const splitGroupedEntry = (entry) => splitOnceOutside(entry, ":");
+const parseGroupedSelector = (selector) => {
+	if (!selector.endsWith("}")) return null;
+	const groupStart = findGroupStart(selector);
+	if (groupStart === -1) return null;
+	const prefix = selector.slice(0, groupStart);
+	const entries = splitGroupedEntries(selector.slice(groupStart + 2, -1)).map((entry) => entry.trim()).filter((entry) => Boolean(entry)).map((entry) => {
+		const parts = splitGroupedEntry(entry);
+		if (!parts) return null;
+		const [name, rawValue] = parts;
+		return {
+			name: name.trim(),
+			rawValue: rawValue.trim()
+		};
+	}).filter((entry) => Boolean(entry));
+	if (!entries.length) return null;
+	return {
+		prefix,
+		entries
+	};
+};
+const splitOutside = (input, delimiter) => {
+	const results = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (const char of input) {
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) {
+			if (current) results.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current) results.push(current);
+	return results;
+};
+const splitOnceOutside = (input, delimiter) => {
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (let i = 0; i < input.length; i += 1) {
+		const char = input[i];
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) return [input.slice(0, i), input.slice(i + 1)];
+	}
+	return null;
+};
+const findGroupStart = (selector) => {
+	let bracketDepth = 0;
+	for (let i = 0; i < selector.length - 1; i += 1) {
+		const char = selector[i];
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (bracketDepth === 0 && selector[i] === ":" && selector[i + 1] === "{") return i;
+	}
+	return -1;
+};
+const stripImportantSuffix = (fragment) => {
+	return fragment && fragment.endsWith("!") ? fragment.slice(0, -1) : fragment;
+};
+const getChildSelector = (fragment) => {
+	if (!fragment || !fragment.startsWith("[") || !fragment.endsWith("]")) return null;
+	return fragment.slice(1, -1);
+};
+const isSingleWordToken = (token) => /^[a-zA-Z]+$/.test(token);
+const isBossSelectorToken = (selector, api) => {
+	if (isSingleWordToken(selector)) return false;
+	if (parseGroupedSelector(selector)) return true;
+	const rawFragments = splitFragments(selector);
+	if (!rawFragments.length) return false;
+	const resolveDescriptor = (fragment) => {
+		if (getChildSelector(fragment)) return api.dictionary.resolve("child");
+		return api.dictionary.resolve(fragment);
+	};
+	const firstDescriptor = resolveDescriptor(stripImportantSuffix(rawFragments[0])).descriptor;
+	if (!firstDescriptor) return false;
+	if (rawFragments.length === 1) return firstDescriptor.single === true;
+	const path = [];
+	for (const [index, fragment] of Object.entries(rawFragments)) {
+		const isLast = rawFragments.length === +index + 1;
+		if (path.length && isLast) continue;
+		const cleanedFragment = stripImportantSuffix(fragment);
+		const childSelector = getChildSelector(cleanedFragment);
+		if (childSelector) path.push("child", childSelector);
+		else path.push(cleanedFragment);
+	}
+	if (!path.length) return false;
+	const lastProp = path.at(-1);
+	const lastDescriptor = lastProp ? resolveDescriptor(lastProp).descriptor : null;
+	return Boolean(lastDescriptor?.isCSSProp);
+};
+const collectBossClassTokensInSource = (source, options) => {
+	const ext = options.filename.split(".").pop() ?? "";
+	const isTs = ext === "ts" || ext === "tsx";
+	const isJsx = [
+		"jsx",
+		"tsx",
+		"js",
+		"mjs",
+		"cjs"
+	].includes(ext);
+	const parsed = parseSync(source, {
+		syntax: isTs ? "typescript" : "ecmascript",
+		tsx: isTs && isJsx,
+		jsx: !isTs && isJsx
+	});
+	const tokens = /* @__PURE__ */ new Set();
+	const visit = (node, context = {}) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			node.forEach((child) => visit(child, context));
+			return;
+		}
+		const current = node;
+		if (!context.inModuleSpecifier) {
+			if (current.type === "StringLiteral") splitSelectors(current.value).flatMap((selector) => rewriteSelector(selector, { expandSingleGroup: true })).forEach((selector) => {
+				if (isBossSelectorToken(selector, options.api)) tokens.add(selector);
+			});
+			if (current.type === "TemplateLiteral" && Array.isArray(current.expressions) && current.expressions.length === 0 && Array.isArray(current.quasis) && current.quasis.length) {
+				const firstQuasi = current.quasis[0];
+				if (firstQuasi?.cooked != null) splitSelectors(firstQuasi.cooked).flatMap((selector) => rewriteSelector(selector, { expandSingleGroup: true })).forEach((selector) => {
+					if (isBossSelectorToken(selector, options.api)) tokens.add(selector);
+				});
+			}
+		}
+		for (const key of Object.keys(current)) {
+			const nextContext = (current.type === "ImportDeclaration" || current.type === "ExportAllDeclaration" || current.type === "ExportNamedDeclaration") && key === "source" ? {
+				...context,
+				inModuleSpecifier: true
+			} : context;
+			visit(current[key], nextContext);
+		}
+	};
+	visit(parsed);
+	return tokens;
+};
+const collectBossClassTokensInText = (source, options) => {
+	const tokens = /* @__PURE__ */ new Set();
+	rewriteQuotedSegments(source, ({ value, hasTemplateExpression }) => {
+		if (hasTemplateExpression) return null;
+		splitSelectors(value).flatMap((selector) => rewriteSelector(selector, { expandSingleGroup: true })).forEach((selector) => {
+			if (isBossSelectorToken(selector, options.api)) tokens.add(selector);
+		});
+		return null;
+	});
+	return tokens;
+};
+const rewriteQuotedSegments = (input, rewrite) => {
+	let output = "";
+	let index = 0;
+	const length = input.length;
+	while (index < length) {
+		const char = input[index];
+		if (char !== "\"" && char !== "'" && char !== "`") {
+			output += char;
+			index += 1;
+			continue;
+		}
+		const quote = char;
+		const start = index;
+		index += 1;
+		let value = "";
+		let escaped = false;
+		let hasTemplateExpression = false;
+		while (index < length) {
+			const current = input[index];
+			if (escaped) {
+				value += current;
+				escaped = false;
+				index += 1;
+				continue;
+			}
+			if (current === "\\") {
+				value += current;
+				escaped = true;
+				index += 1;
+				continue;
+			}
+			if (quote === "`" && current === "$" && input[index + 1] === "{") hasTemplateExpression = true;
+			if (current === quote) break;
+			value += current;
+			index += 1;
+		}
+		if (index >= length) {
+			output += input.slice(start);
+			break;
+		}
+		const replacement = rewrite({
+			value,
+			quote,
+			hasTemplateExpression
+		});
+		if (replacement === null) output += quote + value + quote;
+		else output += quote + replacement + quote;
+		index += 1;
+	}
+	return output;
+};
+
+//#endregion
+export { collectBossClassTokensInSource, collectBossClassTokensInText, rewriteClassNameTokensInElement, rewriteClassNameTokensInSource, rewriteClassNameTokensInText, rewriteClassNameTokensWithMap };

package/dist/compile/index.cjs

@@ -0,0 +1,238 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_api_server = require('../api/server.cjs');
+const require_file = require('../shared/file.cjs');
+const require_boundaries = require('../shared/boundaries.cjs');
+const require_session = require('../tasks/session.cjs');
+const require_framework = require('../shared/framework.cjs');
+const require_classname = require('./classname.cjs');
+const require_classname_strategy = require('./classname-strategy.cjs');
+const require_prepared = require('./prepared.cjs');
+const require_transform = require('./transform.cjs');
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+let lightningcss = require("lightningcss");
+
+//#region src/compile/index.ts
+const supportedExtensions = new Set([
+	".js",
+	".jsx",
+	".ts",
+	".tsx",
+	".mjs",
+	".cjs"
+]);
+async function compileProject(options) {
+	const { config, prod } = options;
+	const compileConfig = {
+		stats: "quick",
+		...config.compile ?? {}
+	};
+	const content = config.content;
+	const baseDir = process.cwd();
+	if (!content) throw new Error("compile: config.content is required");
+	const root = baseDir;
+	const tempOutDir = compileConfig.tempOutDir;
+	if (!prod && !tempOutDir) throw new Error("compile.tempOutDir is required when not running in prod mode.");
+	const outputRoot = prod ? root : node_path.default.resolve(root, tempOutDir);
+	const inputPaths = (await require_file.resolveContentPaths(content)).sort();
+	const sourceCache = /* @__PURE__ */ new Map();
+	const preparedByFile = /* @__PURE__ */ new Map();
+	const preparedRegistry = /* @__PURE__ */ new Map();
+	const preparedUsages = [];
+	const api = await require_api_server.createApi(config, true);
+	api.baseDir = baseDir;
+	const classNameStrategy = compileConfig.classNameStrategy ?? false;
+	const classNameMapper = classNameStrategy ? require_classname_strategy.createClassNameMapper({
+		strategy: classNameStrategy,
+		prefix: api.selectorPrefix ?? ""
+	}) : null;
+	if (classNameMapper) {
+		const baseContextToClassName = api.contextToClassName;
+		api.contextToClassName = (name, value, contexts, escape = true, _prefix = "") => {
+			const raw = baseContextToClassName(name, value, contexts, false, "");
+			const mapped = classNameMapper.getOrCreate(raw);
+			if (!escape) return mapped;
+			return api.camelCaseToDash(api.escapeClassName(mapped));
+		};
+		const baseClassTokenToSelector = api.classTokenToSelector;
+		api.classTokenToSelector = (token) => baseClassTokenToSelector(classNameMapper.getOrCreate(token));
+	}
+	const sessionStart = await require_session.resolveSessionPayload(baseDir, config, "compile", "start");
+	await require_session.emitSession(api, sessionStart);
+	await require_session.emitSession(api, {
+		...sessionStart,
+		phase: "run"
+	});
+	const statsMode = compileConfig.stats ?? "quick";
+	const start = process.hrtime.bigint();
+	const fileResults = [];
+	for (const inputPath of inputPaths) {
+		if (!(await node_fs_promises.default.stat(inputPath).catch(() => null))?.isFile()) continue;
+		const ext = node_path.default.extname(inputPath);
+		const source = await node_fs_promises.default.readFile(inputPath, "utf8");
+		sourceCache.set(inputPath, source);
+		if (classNameMapper) (supportedExtensions.has(ext) ? require_classname.collectBossClassTokensInSource(source, {
+			filename: inputPath,
+			api
+		}) : require_classname.collectBossClassTokensInText(source, { api })).forEach((token) => classNameMapper.getOrCreate(token));
+		if (!supportedExtensions.has(ext)) continue;
+		const scan = require_prepared.scanPrepared(source, {
+			isTs: ext === ".ts" || ext === ".tsx",
+			isJsx: ext === ".jsx" || ext === ".tsx" || ext === ".js" || ext === ".mjs" || ext === ".cjs"
+		});
+		if (scan.definitions.length) {
+			const local = /* @__PURE__ */ new Map();
+			for (const definition of scan.definitions) {
+				local.set(definition.name, {
+					definition: definition.definition,
+					inlineable: definition.inlineable
+				});
+				preparedRegistry.set(definition.name, {
+					definition: definition.definition,
+					inlineable: definition.inlineable
+				});
+			}
+			preparedByFile.set(inputPath, local);
+		}
+		if (scan.usages.length) for (const usage of scan.usages) preparedUsages.push({
+			...usage,
+			file: inputPath
+		});
+	}
+	const preparedGlobal = /* @__PURE__ */ new Map();
+	for (const [name, entry] of preparedRegistry.entries()) if (entry.inlineable) preparedGlobal.set(name, entry.definition);
+	const preparedRuntime = /* @__PURE__ */ new Set();
+	for (const usage of preparedUsages) {
+		if (!compileConfig.spread && usage.hasSpread) {
+			preparedRuntime.add(usage.name);
+			continue;
+		}
+		if (preparedByFile.get(usage.file)?.get(usage.name)) continue;
+		if (preparedRegistry.get(usage.name)?.inlineable) continue;
+		preparedRuntime.add(usage.name);
+	}
+	const processFile = async (inputPath) => {
+		if (!(await node_fs_promises.default.stat(inputPath).catch(() => null))?.isFile()) return;
+		const ext = node_path.default.extname(inputPath);
+		const relativePath = node_path.default.relative(root, inputPath);
+		const outputPath = prod ? inputPath : node_path.default.join(outputRoot, relativePath);
+		await node_fs_promises.default.mkdir(node_path.default.dirname(outputPath), { recursive: true });
+		const source = sourceCache.get(inputPath) ?? await node_fs_promises.default.readFile(inputPath, "utf8");
+		if (!supportedExtensions.has(ext)) {
+			const parseContent = require_classname.rewriteClassNameTokensInText(source, { mapToken: classNameMapper ? () => void 0 : void 0 });
+			await api.trigger("onParse", {
+				content: parseContent,
+				path: inputPath
+			}, (plugin) => plugin.name === "classname");
+			if (!prod) if (classNameMapper) {
+				const rewritten = require_classname.rewriteClassNameTokensInText(source, { mapToken: (token) => classNameMapper.get(token) });
+				await node_fs_promises.default.writeFile(outputPath, rewritten, "utf8");
+			} else await node_fs_promises.default.copyFile(inputPath, outputPath);
+			fileResults.push({
+				file: inputPath,
+				processed: false,
+				copied: !prod,
+				needsRuntime: false,
+				needsValueHelper: false,
+				replacedElements: 0
+			});
+			return;
+		}
+		const classNameSource = require_classname.rewriteClassNameTokensInSource(source, {
+			filename: inputPath,
+			classNameProp: require_framework.getClassNameProp(api.framework),
+			mapToken: classNameMapper ? () => void 0 : void 0
+		});
+		await api.trigger("onParse", {
+			content: classNameSource,
+			path: inputPath
+		}, (plugin) => plugin.name === "classname");
+		const transformed = await require_transform.transformSource(source, {
+			api,
+			compile: compileConfig,
+			filename: inputPath,
+			preparedGlobal,
+			preparedLocal: new Map(Array.from(preparedByFile.get(inputPath)?.entries() ?? []).map(([key, value]) => [key, value.definition])),
+			preparedRuntime,
+			classNameMapper
+		});
+		fileResults.push({
+			file: inputPath,
+			processed: true,
+			copied: false,
+			needsRuntime: transformed.needsRuntime,
+			needsValueHelper: transformed.needsValueHelper,
+			replacedElements: transformed.replacedElements
+		});
+		await node_fs_promises.default.writeFile(outputPath, transformed.code, "utf8");
+	};
+	if (classNameStrategy === "shortest" || classNameStrategy === "unicode") for (const inputPath of inputPaths) await processFile(inputPath);
+	else await Promise.all(inputPaths.map(processFile));
+	let cssBytes = 0;
+	let cssWritten = false;
+	let stylesheetPath = null;
+	if (!prod && api.css.text.trim()) {
+		const resolvedStylesheetPath = config.stylesheetPath ?? node_path.default.join(root, config.configDir ?? ".bo$$", "styles.css");
+		const outputs = (await require_boundaries.resolveBoundaryOutputs(api, {
+			rootDir: root,
+			stylesheetPath: resolvedStylesheetPath,
+			boundaries: config.css?.boundaries
+		})).outputs.map((output) => {
+			const relative = node_path.default.relative(root, output.path);
+			return {
+				path: node_path.default.join(outputRoot, relative),
+				text: output.text
+			};
+		});
+		const globalOutputPath = node_path.default.resolve(node_path.default.join(outputRoot, node_path.default.relative(root, resolvedStylesheetPath)));
+		const outputSizes = /* @__PURE__ */ new Map();
+		for (const output of outputs) {
+			const minified = (0, lightningcss.transform)({
+				code: Buffer.from(output.text),
+				filename: output.path,
+				minify: true
+			});
+			await node_fs_promises.default.mkdir(node_path.default.dirname(output.path), { recursive: true });
+			await node_fs_promises.default.writeFile(output.path, minified.code.toString(), "utf8");
+			outputSizes.set(node_path.default.resolve(output.path), minified.code.length);
+		}
+		const globalOutput = outputs.find((output) => node_path.default.resolve(output.path) === globalOutputPath);
+		cssBytes = globalOutput ? outputSizes.get(node_path.default.resolve(globalOutput.path)) ?? 0 : 0;
+		cssWritten = true;
+		stylesheetPath = globalOutput?.path ?? globalOutputPath;
+	}
+	const durationMs = Number(process.hrtime.bigint() - start) / 1e6;
+	const runtimeFiles = fileResults.filter((result$1) => result$1.needsRuntime).map((result$1) => result$1.file);
+	const valueHelperFiles = fileResults.filter((result$1) => result$1.needsValueHelper).map((result$1) => result$1.file);
+	const filesProcessed = fileResults.filter((result$1) => result$1.processed).length;
+	const filesCopied = fileResults.filter((result$1) => result$1.copied).length;
+	const filesTotal = fileResults.length;
+	const filesSkipped = filesTotal - filesProcessed - filesCopied;
+	const elementsReplaced = fileResults.reduce((total, result$1) => total + result$1.replacedElements, 0);
+	const result = {
+		statsMode,
+		stats: {
+			outputMode: prod ? "prod" : "temp",
+			outputDir: outputRoot,
+			runtimeFree: runtimeFiles.length === 0,
+			runtimeFiles: runtimeFiles.map((file) => node_path.default.relative(root, file)),
+			valueHelperFiles: valueHelperFiles.map((file) => node_path.default.relative(root, file)),
+			filesProcessed,
+			filesCopied,
+			filesSkipped,
+			filesTotal,
+			elementsReplaced,
+			durationMs,
+			cssBytes,
+			cssWritten,
+			stylesheetPath
+		}
+	};
+	await require_session.emitSession(api, await require_session.resolveSessionPayload(baseDir, config, "compile", "stop"));
+	return result;
+}
+
+//#endregion
+exports.compileProject = compileProject;