boss-css 0.0.1 → 0.0.2

package/dist/strategy/runtime-only/css.cjs

@@ -0,0 +1,183 @@
+
+//#region src/strategy/runtime-only/css.ts
+let baseStyleElement = null;
+let baseSheet = null;
+let atStyleElement = null;
+let atSheet = null;
+let atRuleIndex = 0;
+const atRules = [];
+const inserted = /* @__PURE__ */ new Set();
+const canUseDom = () => typeof document !== "undefined" && typeof document.createElement === "function";
+const ensureBaseSheet = () => {
+	if (baseSheet || !canUseDom()) return baseSheet;
+	baseStyleElement = document.querySelector("style[data-boss-runtime]");
+	if (!baseStyleElement) {
+		baseStyleElement = document.createElement("style");
+		baseStyleElement.setAttribute("data-boss-runtime", "");
+		document.head.appendChild(baseStyleElement);
+	}
+	baseSheet = baseStyleElement.sheet;
+	return baseSheet;
+};
+const ensureAtSheet = () => {
+	if (atSheet || !canUseDom()) return atSheet;
+	ensureBaseSheet();
+	atStyleElement = document.querySelector("style[data-boss-runtime-at]");
+	if (!atStyleElement) {
+		atStyleElement = document.createElement("style");
+		atStyleElement.setAttribute("data-boss-runtime-at", "");
+		const parent = baseStyleElement?.parentNode;
+		if (parent) parent.insertBefore(atStyleElement, baseStyleElement?.nextSibling ?? null);
+		else document.head.appendChild(atStyleElement);
+	}
+	atSheet = atStyleElement.sheet;
+	return atSheet;
+};
+const compareAtRuleOrder = (a, b) => {
+	if (a.group !== b.group) return a.group - b.group;
+	if (a.primary !== b.primary) return a.primary - b.primary;
+	if (a.secondary !== b.secondary) return a.secondary - b.secondary;
+	return a.index - b.index;
+};
+const getAtRuleOrder = (query, index) => {
+	const normalized = query.trim().toLowerCase();
+	if (!normalized.startsWith("@media")) return {
+		group: 4,
+		primary: 0,
+		secondary: 0,
+		index
+	};
+	const minMatch = normalized.match(/min-width\s*:\s*(\d+(?:\.\d+)?)px/);
+	const maxMatch = normalized.match(/max-width\s*:\s*(\d+(?:\.\d+)?)px/);
+	const min = minMatch ? Number(minMatch[1]) : null;
+	const max = maxMatch ? Number(maxMatch[1]) : null;
+	if (min !== null && max !== null) return {
+		group: 1,
+		primary: min,
+		secondary: max,
+		index
+	};
+	if (max !== null) return {
+		group: 0,
+		primary: -max,
+		secondary: 0,
+		index
+	};
+	if (min !== null) return {
+		group: 2,
+		primary: min,
+		secondary: 0,
+		index
+	};
+	return {
+		group: 3,
+		primary: 0,
+		secondary: 0,
+		index
+	};
+};
+const insertRule = (rule, key = rule, query = null) => {
+	if (inserted.has(key)) return;
+	inserted.add(key);
+	if (!query) {
+		const activeSheet$1 = ensureBaseSheet();
+		if (!activeSheet$1) return;
+		try {
+			activeSheet$1.insertRule(rule, activeSheet$1.cssRules.length);
+		} catch {
+			baseStyleElement?.appendChild(document.createTextNode(rule));
+		}
+		return;
+	}
+	const activeSheet = ensureAtSheet();
+	if (!activeSheet) return;
+	const order = getAtRuleOrder(query, atRuleIndex);
+	atRuleIndex += 1;
+	let insertIndex = atRules.length;
+	for (let i = 0; i < atRules.length; i += 1) if (compareAtRuleOrder(order, atRules[i].order) < 0) {
+		insertIndex = i;
+		break;
+	}
+	try {
+		activeSheet.insertRule(rule, insertIndex);
+		atRules.splice(insertIndex, 0, {
+			key,
+			order
+		});
+	} catch {
+		atStyleElement?.appendChild(document.createTextNode(rule));
+		atRules.push({
+			key,
+			order
+		});
+	}
+};
+var RuntimeCSS = class {
+	api;
+	current = null;
+	root = /* @__PURE__ */ new Set();
+	imports = /* @__PURE__ */ new Set();
+	constructor(api) {
+		this.api = api;
+	}
+	get text() {
+		return "";
+	}
+	addImport(_url) {}
+	addRoot(_value, _source) {}
+	removeSource(_source) {}
+	reset() {}
+	selector({ className, selector = null, pseudos = [], query = null }) {
+		if (!this.current) this.current = {
+			className: null,
+			selector: null,
+			pseudos: [],
+			values: /* @__PURE__ */ new Set(),
+			query: null
+		};
+		const current = this.current;
+		if (query && current.query && query !== current.query) throw new Error(`RuntimeCSS:selector Selector already has a query. Existing: ${current.query} Incoming: ${query}`);
+		const mergedPseudos = [];
+		for (const pseudo of [...current.pseudos, ...pseudos]) if (!mergedPseudos.includes(pseudo)) mergedPseudos.push(pseudo);
+		const next = {
+			pseudos: mergedPseudos,
+			query: query || current.query
+		};
+		if (selector) Object.assign(next, {
+			selector,
+			className: null
+		});
+		else if (className) Object.assign(next, { className });
+		Object.assign(current, next);
+	}
+	rule(property, value, options) {
+		if (!this.current) throw new Error("RuntimeCSS:rule No current selector");
+		const suffix = options?.important ? " !important" : "";
+		this.current.values.add(`${property}: ${this.api.dictionary.toValue(value, property)}${suffix}`);
+	}
+	addRule(rule, query = null, _source) {
+		const wrapped = query ? `${query} { ${rule} }` : rule;
+		insertRule(wrapped, wrapped, query);
+	}
+	write() {
+		if (!this.current) throw new Error("RuntimeCSS:write No current selector");
+		const current = this.current;
+		const baseSelector = current.selector || (current.className ? `.${current.className}` : null);
+		if (!baseSelector) throw new Error("RuntimeCSS:write No className or selector");
+		const selector = [baseSelector, ...current.pseudos].join(":");
+		const selectorScope = typeof this.api.selectorScope === "string" ? this.api.selectorScope : "";
+		const scopedSelector = selectorScope ? `${selectorScope}${selector}` : selector;
+		let rule = `${scopedSelector} { ${[...current.values].join(";")} }`;
+		if (current.query) rule = `${current.query} { ${rule} }`;
+		const key = `${current.query ?? ""}|${scopedSelector}|${[...current.values].join(";")}`;
+		insertRule(rule, key, current.query);
+		this.current = null;
+	}
+};
+const onInit = (api) => {
+	if (!api.css || !(api.css instanceof RuntimeCSS)) api.css = new RuntimeCSS(api);
+};
+
+//#endregion
+exports.RuntimeCSS = RuntimeCSS;
+exports.onInit = onInit;

package/dist/strategy/runtime-only/css.mjs

@@ -0,0 +1,181 @@
+//#region src/strategy/runtime-only/css.ts
+let baseStyleElement = null;
+let baseSheet = null;
+let atStyleElement = null;
+let atSheet = null;
+let atRuleIndex = 0;
+const atRules = [];
+const inserted = /* @__PURE__ */ new Set();
+const canUseDom = () => typeof document !== "undefined" && typeof document.createElement === "function";
+const ensureBaseSheet = () => {
+	if (baseSheet || !canUseDom()) return baseSheet;
+	baseStyleElement = document.querySelector("style[data-boss-runtime]");
+	if (!baseStyleElement) {
+		baseStyleElement = document.createElement("style");
+		baseStyleElement.setAttribute("data-boss-runtime", "");
+		document.head.appendChild(baseStyleElement);
+	}
+	baseSheet = baseStyleElement.sheet;
+	return baseSheet;
+};
+const ensureAtSheet = () => {
+	if (atSheet || !canUseDom()) return atSheet;
+	ensureBaseSheet();
+	atStyleElement = document.querySelector("style[data-boss-runtime-at]");
+	if (!atStyleElement) {
+		atStyleElement = document.createElement("style");
+		atStyleElement.setAttribute("data-boss-runtime-at", "");
+		const parent = baseStyleElement?.parentNode;
+		if (parent) parent.insertBefore(atStyleElement, baseStyleElement?.nextSibling ?? null);
+		else document.head.appendChild(atStyleElement);
+	}
+	atSheet = atStyleElement.sheet;
+	return atSheet;
+};
+const compareAtRuleOrder = (a, b) => {
+	if (a.group !== b.group) return a.group - b.group;
+	if (a.primary !== b.primary) return a.primary - b.primary;
+	if (a.secondary !== b.secondary) return a.secondary - b.secondary;
+	return a.index - b.index;
+};
+const getAtRuleOrder = (query, index) => {
+	const normalized = query.trim().toLowerCase();
+	if (!normalized.startsWith("@media")) return {
+		group: 4,
+		primary: 0,
+		secondary: 0,
+		index
+	};
+	const minMatch = normalized.match(/min-width\s*:\s*(\d+(?:\.\d+)?)px/);
+	const maxMatch = normalized.match(/max-width\s*:\s*(\d+(?:\.\d+)?)px/);
+	const min = minMatch ? Number(minMatch[1]) : null;
+	const max = maxMatch ? Number(maxMatch[1]) : null;
+	if (min !== null && max !== null) return {
+		group: 1,
+		primary: min,
+		secondary: max,
+		index
+	};
+	if (max !== null) return {
+		group: 0,
+		primary: -max,
+		secondary: 0,
+		index
+	};
+	if (min !== null) return {
+		group: 2,
+		primary: min,
+		secondary: 0,
+		index
+	};
+	return {
+		group: 3,
+		primary: 0,
+		secondary: 0,
+		index
+	};
+};
+const insertRule = (rule, key = rule, query = null) => {
+	if (inserted.has(key)) return;
+	inserted.add(key);
+	if (!query) {
+		const activeSheet$1 = ensureBaseSheet();
+		if (!activeSheet$1) return;
+		try {
+			activeSheet$1.insertRule(rule, activeSheet$1.cssRules.length);
+		} catch {
+			baseStyleElement?.appendChild(document.createTextNode(rule));
+		}
+		return;
+	}
+	const activeSheet = ensureAtSheet();
+	if (!activeSheet) return;
+	const order = getAtRuleOrder(query, atRuleIndex);
+	atRuleIndex += 1;
+	let insertIndex = atRules.length;
+	for (let i = 0; i < atRules.length; i += 1) if (compareAtRuleOrder(order, atRules[i].order) < 0) {
+		insertIndex = i;
+		break;
+	}
+	try {
+		activeSheet.insertRule(rule, insertIndex);
+		atRules.splice(insertIndex, 0, {
+			key,
+			order
+		});
+	} catch {
+		atStyleElement?.appendChild(document.createTextNode(rule));
+		atRules.push({
+			key,
+			order
+		});
+	}
+};
+var RuntimeCSS = class {
+	api;
+	current = null;
+	root = /* @__PURE__ */ new Set();
+	imports = /* @__PURE__ */ new Set();
+	constructor(api) {
+		this.api = api;
+	}
+	get text() {
+		return "";
+	}
+	addImport(_url) {}
+	addRoot(_value, _source) {}
+	removeSource(_source) {}
+	reset() {}
+	selector({ className, selector = null, pseudos = [], query = null }) {
+		if (!this.current) this.current = {
+			className: null,
+			selector: null,
+			pseudos: [],
+			values: /* @__PURE__ */ new Set(),
+			query: null
+		};
+		const current = this.current;
+		if (query && current.query && query !== current.query) throw new Error(`RuntimeCSS:selector Selector already has a query. Existing: ${current.query} Incoming: ${query}`);
+		const mergedPseudos = [];
+		for (const pseudo of [...current.pseudos, ...pseudos]) if (!mergedPseudos.includes(pseudo)) mergedPseudos.push(pseudo);
+		const next = {
+			pseudos: mergedPseudos,
+			query: query || current.query
+		};
+		if (selector) Object.assign(next, {
+			selector,
+			className: null
+		});
+		else if (className) Object.assign(next, { className });
+		Object.assign(current, next);
+	}
+	rule(property, value, options) {
+		if (!this.current) throw new Error("RuntimeCSS:rule No current selector");
+		const suffix = options?.important ? " !important" : "";
+		this.current.values.add(`${property}: ${this.api.dictionary.toValue(value, property)}${suffix}`);
+	}
+	addRule(rule, query = null, _source) {
+		const wrapped = query ? `${query} { ${rule} }` : rule;
+		insertRule(wrapped, wrapped, query);
+	}
+	write() {
+		if (!this.current) throw new Error("RuntimeCSS:write No current selector");
+		const current = this.current;
+		const baseSelector = current.selector || (current.className ? `.${current.className}` : null);
+		if (!baseSelector) throw new Error("RuntimeCSS:write No className or selector");
+		const selector = [baseSelector, ...current.pseudos].join(":");
+		const selectorScope = typeof this.api.selectorScope === "string" ? this.api.selectorScope : "";
+		const scopedSelector = selectorScope ? `${selectorScope}${selector}` : selector;
+		let rule = `${scopedSelector} { ${[...current.values].join(";")} }`;
+		if (current.query) rule = `${current.query} { ${rule} }`;
+		const key = `${current.query ?? ""}|${scopedSelector}|${[...current.values].join(";")}`;
+		insertRule(rule, key, current.query);
+		this.current = null;
+	}
+};
+const onInit = (api) => {
+	if (!api.css || !(api.css instanceof RuntimeCSS)) api.css = new RuntimeCSS(api);
+};
+
+//#endregion
+export { RuntimeCSS, onInit };

package/dist/tasks/build.cjs

@@ -0,0 +1,88 @@
+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('./session.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);
+
+//#region src/tasks/build.ts
+const resolveBuildConfig = (userConfig, baseDir = process.cwd()) => {
+	const configDir = userConfig.configDir ?? ".bo$$";
+	const folder = userConfig.folder ?? configDir;
+	const stylesheetPath = userConfig.stylesheetPath ?? node_path.default.join(baseDir, configDir, "styles.css");
+	return {
+		config: {
+			...userConfig,
+			folder,
+			stylesheetPath,
+			configDir
+		},
+		folderPath: node_path.default.resolve(baseDir, folder),
+		stylesheetPath: node_path.default.isAbsolute(stylesheetPath) ? stylesheetPath : node_path.default.resolve(baseDir, stylesheetPath),
+		runtimeOnly: userConfig.runtime?.only === true
+	};
+};
+const runBuild = async (userConfig, options = {}) => {
+	const baseDir = options.baseDir ?? process.cwd();
+	const start = process.hrtime.bigint();
+	const { config, folderPath, stylesheetPath, runtimeOnly } = resolveBuildConfig(userConfig, baseDir);
+	if (!config.content) throw new Error("boss build requires config.content in .bo$$/config.js or package.json.");
+	const api = await require_api_server.createApi(config, true);
+	api.baseDir = baseDir;
+	const sessionStart = await require_session.resolveSessionPayload(baseDir, config, "build", "start");
+	await require_session.emitSession(api, sessionStart);
+	await require_session.emitSession(api, {
+		...sessionStart,
+		phase: "run"
+	});
+	const inputPaths = await require_file.resolveContentPaths(config.content);
+	const parsedFiles = [];
+	await Promise.all(inputPaths.map(async (inputPath) => {
+		if (!(await node_fs_promises.default.stat(inputPath).catch(() => null))?.isFile()) return;
+		const content = await node_fs_promises.default.readFile(inputPath, "utf8");
+		parsedFiles.push(inputPath);
+		await api.trigger("onParse", {
+			content,
+			path: inputPath
+		});
+	}));
+	await node_fs_promises.default.mkdir(folderPath, { recursive: true });
+	if (api.strategy !== "classname-only") {
+		await api.file.js.write();
+		if (api.file.native?.hasContent) await api.file.native.write();
+	}
+	let cssPath = null;
+	let cssBytes = 0;
+	let boundaryPaths = [];
+	if (!runtimeOnly) {
+		const boundaryResult = await require_boundaries.resolveBoundaryOutputs(api, {
+			rootDir: baseDir,
+			stylesheetPath,
+			boundaries: config.css?.boundaries
+		});
+		boundaryPaths = boundaryResult.boundaryFiles;
+		for (const output of boundaryResult.outputs) {
+			await node_fs_promises.default.mkdir(node_path.default.dirname(output.path), { recursive: true });
+			await node_fs_promises.default.writeFile(output.path, output.text, "utf8");
+		}
+		const globalOutput = boundaryResult.outputs.find((output) => output.path === stylesheetPath);
+		cssPath = stylesheetPath;
+		cssBytes = Buffer.byteLength(globalOutput?.text ?? "");
+	}
+	const durationMs = Number(process.hrtime.bigint() - start) / 1e6;
+	await require_session.emitSession(api, await require_session.resolveSessionPayload(baseDir, config, "build", "stop"));
+	return {
+		filesParsed: parsedFiles.length,
+		cssPath,
+		cssBytes,
+		durationMs,
+		boundaryPaths
+	};
+};
+
+//#endregion
+exports.resolveBuildConfig = resolveBuildConfig;
+exports.runBuild = runBuild;

package/dist/tasks/build.mjs

@@ -0,0 +1,84 @@
+import { createApi } from "../api/server.mjs";
+import { resolveContentPaths } from "../shared/file.mjs";
+import { resolveBoundaryOutputs } from "../shared/boundaries.mjs";
+import { emitSession, resolveSessionPayload } from "./session.mjs";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+//#region src/tasks/build.ts
+const resolveBuildConfig = (userConfig, baseDir = process.cwd()) => {
+	const configDir = userConfig.configDir ?? ".bo$$";
+	const folder = userConfig.folder ?? configDir;
+	const stylesheetPath = userConfig.stylesheetPath ?? path.join(baseDir, configDir, "styles.css");
+	return {
+		config: {
+			...userConfig,
+			folder,
+			stylesheetPath,
+			configDir
+		},
+		folderPath: path.resolve(baseDir, folder),
+		stylesheetPath: path.isAbsolute(stylesheetPath) ? stylesheetPath : path.resolve(baseDir, stylesheetPath),
+		runtimeOnly: userConfig.runtime?.only === true
+	};
+};
+const runBuild = async (userConfig, options = {}) => {
+	const baseDir = options.baseDir ?? process.cwd();
+	const start = process.hrtime.bigint();
+	const { config, folderPath, stylesheetPath, runtimeOnly } = resolveBuildConfig(userConfig, baseDir);
+	if (!config.content) throw new Error("boss build requires config.content in .bo$$/config.js or package.json.");
+	const api = await createApi(config, true);
+	api.baseDir = baseDir;
+	const sessionStart = await resolveSessionPayload(baseDir, config, "build", "start");
+	await emitSession(api, sessionStart);
+	await emitSession(api, {
+		...sessionStart,
+		phase: "run"
+	});
+	const inputPaths = await resolveContentPaths(config.content);
+	const parsedFiles = [];
+	await Promise.all(inputPaths.map(async (inputPath) => {
+		if (!(await fs.stat(inputPath).catch(() => null))?.isFile()) return;
+		const content = await fs.readFile(inputPath, "utf8");
+		parsedFiles.push(inputPath);
+		await api.trigger("onParse", {
+			content,
+			path: inputPath
+		});
+	}));
+	await fs.mkdir(folderPath, { recursive: true });
+	if (api.strategy !== "classname-only") {
+		await api.file.js.write();
+		if (api.file.native?.hasContent) await api.file.native.write();
+	}
+	let cssPath = null;
+	let cssBytes = 0;
+	let boundaryPaths = [];
+	if (!runtimeOnly) {
+		const boundaryResult = await resolveBoundaryOutputs(api, {
+			rootDir: baseDir,
+			stylesheetPath,
+			boundaries: config.css?.boundaries
+		});
+		boundaryPaths = boundaryResult.boundaryFiles;
+		for (const output of boundaryResult.outputs) {
+			await fs.mkdir(path.dirname(output.path), { recursive: true });
+			await fs.writeFile(output.path, output.text, "utf8");
+		}
+		const globalOutput = boundaryResult.outputs.find((output) => output.path === stylesheetPath);
+		cssPath = stylesheetPath;
+		cssBytes = Buffer.byteLength(globalOutput?.text ?? "");
+	}
+	const durationMs = Number(process.hrtime.bigint() - start) / 1e6;
+	await emitSession(api, await resolveSessionPayload(baseDir, config, "build", "stop"));
+	return {
+		filesParsed: parsedFiles.length,
+		cssPath,
+		cssBytes,
+		durationMs,
+		boundaryPaths
+	};
+};
+
+//#endregion
+export { resolveBuildConfig, runBuild };

package/dist/tasks/compile.cjs

@@ -0,0 +1,12 @@
+const require_index = require('../compile/index.cjs');
+
+//#region src/tasks/compile.ts
+const runCompile = async ({ config, prod = false }) => {
+	return require_index.compileProject({
+		config,
+		prod
+	});
+};
+
+//#endregion
+exports.runCompile = runCompile;

package/dist/tasks/compile.mjs

@@ -0,0 +1,12 @@
+import { compileProject } from "../compile/index.mjs";
+
+//#region src/tasks/compile.ts
+const runCompile = async ({ config, prod = false }) => {
+	return compileProject({
+		config,
+		prod
+	});
+};
+
+//#endregion
+export { runCompile };

package/dist/tasks/postcss.cjs

@@ -0,0 +1,116 @@
+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('./session.cjs');
+const require_api_config = require('../api/config.cjs');
+const require_cache = require('../transform/cache.cjs');
+const require_processFile = require('../transform/processFile.cjs');
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+let postcss = require("postcss");
+postcss = require_rolldown_runtime.__toESM(postcss);
+
+//#region src/tasks/postcss.ts
+const configPromises = /* @__PURE__ */ new Map();
+const apiCache = /* @__PURE__ */ new Map();
+const knownFiles = /* @__PURE__ */ new Map();
+const runQueues = /* @__PURE__ */ new Map();
+const sessionStarted = /* @__PURE__ */ new Set();
+const isTruthyEnv = (value) => Boolean(value) && value !== "0" && value !== "false";
+const isTurbopackEnv = () => [
+	process.env.TURBOPACK,
+	process.env.__NEXT_TURBOPACK,
+	process.env.__NEXT_TURBOPACK__,
+	process.env.NEXT_TURBOPACK
+].some(isTruthyEnv);
+const resolveConfig = (baseDir) => {
+	const key = baseDir ?? "__default__";
+	if (!configPromises.has(key)) configPromises.set(key, require_api_config.loadConfig(baseDir));
+	return configPromises.get(key);
+};
+const resolveApi = async (baseDir) => {
+	const key = baseDir ?? "__default__";
+	if (!apiCache.has(key)) apiCache.set(key, (async () => {
+		const api = await require_api_server.createApi(await resolveConfig(baseDir), true);
+		api.baseDir = baseDir ?? process.cwd();
+		return { api };
+	})());
+	return apiCache.get(key);
+};
+const runPostcss = async (root, result, options = {}) => {
+	const dirDependencies = options.dirDependencies ?? !isTurbopackEnv();
+	const baseDir = options.baseDir;
+	const { messages } = result;
+	const config = await resolveConfig(baseDir);
+	const { api } = await resolveApi(baseDir);
+	const { content, stylesheetPath } = api;
+	const queueKey = baseDir ?? "__default__";
+	const run = (runQueues.get(queueKey) ?? Promise.resolve()).catch(() => {}).then(async () => {
+		const inputFile = root.source?.input?.file;
+		const fromFile = result.opts?.from;
+		const filePath = typeof inputFile === "string" ? inputFile : typeof fromFile === "string" ? fromFile : void 0;
+		const resolvedFile = filePath ? node_path.default.resolve(filePath) : null;
+		const resolvedStylesheet = node_path.default.resolve(stylesheetPath);
+		if (resolvedFile && resolvedFile !== resolvedStylesheet && !resolvedFile.endsWith(".boss.css")) return;
+		if (!sessionStarted.has(queueKey)) {
+			sessionStarted.add(queueKey);
+			await require_session.emitSession(api, await require_session.resolveSessionPayload(baseDir ?? process.cwd(), config, "postcss", "start"));
+		}
+		await require_session.emitSession(api, await require_session.resolveSessionPayload(baseDir ?? process.cwd(), config, "postcss", "run"));
+		const resolvedPaths = (await require_file.resolveContentPaths(content)).map((entry) => node_path.default.resolve(entry));
+		const previousFiles = knownFiles.get(queueKey) ?? /* @__PURE__ */ new Set();
+		const nextFiles = new Set(resolvedPaths);
+		for (const file of previousFiles) if (!nextFiles.has(file)) {
+			api.css?.removeSource?.(file);
+			require_cache.cache.delete(file);
+		}
+		knownFiles.set(queueKey, nextFiles);
+		const promises = [];
+		resolvedPaths.forEach((file) => {
+			if (require_cache.setCache(file, { isFile: true })) messages.push({
+				type: "dependency",
+				file
+			});
+			if (dirDependencies) {
+				const dir = node_path.default.dirname(file);
+				if (!require_cache.cache.has(dir)) {
+					messages.push({
+						type: "dir-dependency",
+						dir
+					});
+					require_cache.setCache(dir, { isFile: false });
+				}
+			}
+			promises.push(require_processFile.default(file));
+		});
+		const processedFiles = await Promise.allSettled(promises);
+		const onParsePromises = [];
+		for (const settled of processedFiles) {
+			if (settled.status !== "fulfilled") continue;
+			const processed = settled.value;
+			const value = processed?.value;
+			if (!value || !processed?.changed) continue;
+			const changedPath = value.path ? node_path.default.resolve(value.path) : null;
+			if (changedPath) api.css?.removeSource?.(changedPath);
+			onParsePromises.push(api.trigger("onParse", value));
+		}
+		await Promise.allSettled(onParsePromises);
+		const boundaryResult = await require_boundaries.resolveBoundaryOutputs(api, {
+			rootDir: baseDir ?? process.cwd(),
+			stylesheetPath,
+			boundaries: config.css?.boundaries
+		});
+		const outputText = new Map(boundaryResult.outputs.map((output) => [node_path.default.resolve(output.path), output.text])).get(resolvedFile ?? resolvedStylesheet);
+		if (outputText !== void 0) result.root = postcss.default.parse(outputText, result.opts);
+		if (api.strategy !== "classname-only") {
+			api.file.js.write();
+			if (api.file.native?.hasContent) api.file.native.write();
+		}
+	});
+	runQueues.set(queueKey, run);
+	await run;
+};
+
+//#endregion
+exports.runPostcss = runPostcss;