@master/css-compiler 0.0.0-site.1793659883.g69c9aebcf628

package/dist/stylesheet/delivery.js

@@ -0,0 +1,367 @@
+import { stylesheetOutputMap } from "./output-map.js";
+import { normalizeStylesheetGraphID, prepareCSSImportGraph, prepareCSSImportGraphWithResolver } from "../node-imports.js";
+import { compilePreparedGraph } from "../prepared-graph-cache.js";
+import { analyzeCSSDependencies, compileCSS, inspectCSS, mergeCSSDirectiveExtractionPolicy, resolveCSSReferenceFile } from "../node-compiler.js";
+import { collectStylesheetDirectives, hasLocalStyleDirectives, hasStylesheetSourceDirectives, mergeStylesheetDirectives, mergeStylesheetSourceOptions, resolveStylesheetSourcePaths } from "./directives.js";
+import { hasStylesheetResourceReferences, renderCompiledManifestCSS } from "./render.js";
+import { resolveReferenceOrigins } from "./reference-origins.js";
+import { referenceFileInputs } from "./reference-files.js";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { isAbsolute, resolve } from "node:path";
+import { MasterCSSError } from "@master/css-schema";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { createCompilerBindingSessionSync } from "@master/css-binding/compiler/node";
+// src/stylesheet/delivery.ts
+/** @internal Filesystem preparation and standalone stylesheet asset composition. */
+function prepareDelivery(graph, delivery, owners, metadataOnly = false) {
+	const urls = {};
+	const resourceURLs = {};
+	const resources = /* @__PURE__ */ new Map();
+	for (const [file, source] of Object.entries(graph.files)) {
+		const owner = owners[file] ?? file;
+		if (!owner.startsWith("\0")) delivery.onDependency?.(owner);
+		urls[file] = delivery.stylesheetURL(owner, owners[file] ? file : void 0);
+		resourceURLs[file] = {};
+		for (const { url } of analyzeCSSDependencies(source).resources) {
+			if (url.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(url)) continue;
+			const baseFile = graph.baseFiles?.[file] ?? (isAbsolute(owner) ? owner : void 0);
+			if (!baseFile) throw new TypeError(`Relative resource URL requires a source baseFile: ${owner}`);
+			const original = new URL(url, pathToFileURL(baseFile));
+			const resourceFile = fileURLToPath(original);
+			if (!metadataOnly) {
+				delivery.onDependency?.(resourceFile);
+				readFileSync(resourceFile);
+			}
+			const href = delivery.resourceURL(resourceFile);
+			if (!metadataOnly) resources.set(resourceFile, {
+				file: resourceFile,
+				href
+			});
+			resourceURLs[file][url] = `${href}${original.search}${original.hash}`;
+		}
+	}
+	return {
+		urls,
+		resourceURLs,
+		resources: [...resources.values()]
+	};
+}
+function prepareGraphReferences(graph, options, referenceStack = [], owners = {}, metadataOnly = false) {
+	const delivery = options.delivery;
+	const references = [...referenceFileInputs(options.referenceFiles), ...Object.entries(graph.files).flatMap(([file, source]) => {
+		const parsed = compileCSS(source, {
+			from: owners[file] ?? file,
+			preserveNativeCSS: false
+		});
+		if (file === graph.entry && options.references) return options.references;
+		const references = parsed.references || [];
+		const owner = graph.baseFiles?.[file] ?? owners[file] ?? file;
+		return resolveReferenceOrigins(source, references.map((reference) => ({
+			...reference,
+			file: owner
+		})), owner, graph.sourceMaps?.[file]);
+	})];
+	const entryFile = graph.baseFiles?.[graph.entry] ?? owners[graph.entry] ?? graph.entry;
+	const stack = [...referenceStack, ...entryFile.startsWith("\0") ? [] : [existsSync(entryFile) ? realpathSync(entryFile) : resolve(entryFile)]];
+	const reference = {
+		dependencies: [],
+		warnings: [],
+		resources: []
+	};
+	for (const item of references) {
+		const file = resolveCSSReferenceFile(item, { root: options.projectDir });
+		delivery.onDependency?.(file);
+		const chain = [...stack, ...item.file && !item.file.startsWith("\0") ? [existsSync(item.file) ? realpathSync(item.file) : resolve(item.file)] : []];
+		if (chain.includes(realpathSync(file))) throw new Error(`Circular CSS reference: ${[...stack, file].join(" -> ")}`);
+		const compiled = compileGraph(prepareCSSImportGraph(file, void 0, {
+			projectDir: options.projectDir,
+			onDependency: delivery.onDependency,
+			resolveNodePackageImports: delivery.resolveNodePackageImports
+		}, analyzeCSSDependencies), {
+			...options,
+			referenceFiles: void 0,
+			references: void 0,
+			baseManifest: reference.manifest ?? options.baseManifest
+		}, void 0, chain, {}, {}, [], metadataOnly);
+		reference.manifest = compiled.manifest;
+		reference.dependencies.push(...compiled.directives.dependencies);
+		reference.warnings.push(...compiled.directives.warnings);
+		reference.resources.push(...compiled.resources);
+	}
+	return reference;
+}
+function compileGraph(graph, options, classes, referenceStack = [], owners = {}, classesByStylesheet = {}, nativeStylesheets, metadataOnly = false, inlineImports = false, hostImports = {}, preparedReference) {
+	const delivery = options.delivery;
+	const prepared = prepareDelivery(graph, delivery, owners, metadataOnly);
+	if (new Set(Object.values(prepared.urls)).size !== Object.keys(prepared.urls).length) throw new TypeError("Each stylesheet variant requires a distinct delivery URL.");
+	const reference = preparedReference ?? prepareGraphReferences(graph, options, referenceStack, owners, metadataOnly);
+	prepared.resources.push(...reference.resources);
+	const binding = createCompilerBindingSessionSync();
+	try {
+		const result = compilePreparedGraph(binding, {
+			graph,
+			pruneNativeStylesheets: Object.keys(graph.files).filter((file) => {
+				const policy = collectStylesheetDirectives(graph.files[file], owners[file] ?? file, options.projectDir);
+				return !policy.preserveNative && (policy.pruneNative || options.pruneNativeCSS === true && !graph.packageFiles?.includes(file));
+			}),
+			urls: prepared.urls,
+			resourceURLs: inlineImports ? void 0 : prepared.resourceURLs,
+			inlineImports,
+			hostImports,
+			relativeResourceURLs: delivery.relativeResourceURLs,
+			classesByStylesheet,
+			nativeStylesheets,
+			baseManifest: options.baseManifest,
+			resolutionManifest: reference.manifest,
+			options: {
+				preserveNativeCSS: options.preserveNativeCSS ?? true,
+				...options.preserveNativeSource === void 0 ? {} : { preserveNativeSource: options.preserveNativeSource },
+				...classes ? { classes: [...classes] } : {}
+			}
+		});
+		const directives = result.directives;
+		directives.extractionPolicy = mergeCSSDirectiveExtractionPolicy(directives.extractionPolicy);
+		directives.dependencies = [.../* @__PURE__ */ new Set([
+			...directives.dependencies.map((file) => owners[file] ?? file),
+			...reference.dependencies,
+			...prepared.resources.map(({ file }) => file)
+		])];
+		directives.warnings = [.../* @__PURE__ */ new Set([...directives.warnings, ...reference.warnings])];
+		return {
+			...result,
+			manifest: result.manifest,
+			directives,
+			resources: [...new Map(prepared.resources.map((asset) => [asset.file, asset])).values()]
+		};
+	} catch (error) {
+		if (error instanceof MasterCSSError && error.diagnostics.some((diagnostic) => diagnostic.source && owners[diagnostic.source])) throw new MasterCSSError({
+			...error.payload,
+			diagnostics: error.diagnostics.map((diagnostic) => ({
+				...diagnostic,
+				...diagnostic.source ? { source: owners[diagnostic.source] ?? diagnostic.source } : {}
+			}))
+		}, { cause: error });
+		throw error;
+	} finally {
+		binding.dispose();
+	}
+}
+/** Compile native resource usage without flattening imports or reading host-owned assets. */
+function compileStylesheetMetadata(file, source, options) {
+	const graph = prepareCSSImportGraph(file, source, { projectDir: options.projectDir }, analyzeCSSDependencies);
+	if (!Object.values(graph.files).some((text) => inspectCSS(text).hasMasterEntry)) return;
+	return compileGraph(graph, {
+		...options,
+		delivery: {
+			entryURL: pathToFileURL(file).href,
+			stylesheetURL: (id) => pathToFileURL(id).href,
+			resourceURL: (id) => pathToFileURL(id).href
+		}
+	}, void 0, [], {}, {}, void 0, true);
+}
+/** Compile one file and its dependencies for a host that publishes every asset. */
+function compileDeliveredFile(file, options) {
+	const filename = resolve(options.projectDir ?? "", file);
+	const delivery = options.delivery;
+	if (delivery.resolveImport) throw new TypeError("Custom import resolution requires asynchronous stylesheet registration.");
+	const graph = prepareCSSImportGraph(filename, void 0, {
+		projectDir: options.projectDir,
+		onDependency: delivery.onDependency,
+		resolveNodePackageImports: delivery.resolveNodePackageImports
+	}, analyzeCSSDependencies);
+	return {
+		...compileGraph(graph, {
+			...options,
+			delivery: {
+				...delivery,
+				stylesheetURL: (id, variant) => id === filename ? delivery.entryURL : delivery.stylesheetURL(id, variant)
+			}
+		}, options.classes),
+		entry: graph.entry
+	};
+}
+/** Compile supplied local CSS and its imports without flattening their boundaries. */
+async function compileDeliveredSource(id, source, options, nativeClasses) {
+	const filename = normalizeStylesheetGraphID(id), delivery = options.delivery;
+	const graphOptions = {
+		baseFile: delivery.baseFile ?? options.baseFile,
+		sourceMap: delivery.sourceMap ?? options.sourceMap,
+		projectDir: options.projectDir,
+		onDependency: delivery.onDependency,
+		resolveNodePackageImports: delivery.resolveNodePackageImports
+	};
+	const graph = delivery.resolveImport || graphOptions.baseFile || graphOptions.sourceMap ? await prepareCSSImportGraphWithResolver(filename, source, graphOptions, analyzeCSSDependencies, delivery.resolveImport ?? (() => void 0)) : prepareCSSImportGraph(filename, source, graphOptions, analyzeCSSDependencies);
+	const nativeGraph = (!options.transformNativeStylesheets || options.preserveUnchangedNativeCSS) && !Object.entries(graph.files).some(([file, source]) => hasLocalStyleDirectives(source, file));
+	let reference;
+	if (nativeGraph) {
+		if (!options.transformNativeStylesheets) return;
+		reference = prepareGraphReferences(graph, options);
+		if (!hasStylesheetResourceReferences(reference.manifest ?? options.baseManifest, graph.files[graph.entry])) return;
+	}
+	const result = compileGraph(graph, {
+		...options,
+		delivery: {
+			...delivery,
+			stylesheetURL: (file, variant) => file === graph.entry ? delivery.entryURL : delivery.stylesheetURL(file, variant)
+		}
+	}, nativeClasses, [], {}, {}, void 0, false, false, {}, reference);
+	const stylesheets = result.stylesheets.map((asset) => ({
+		...asset,
+		sourceMap: stylesheetOutputMap(asset.css, asset.outputMappings, {
+			file: asset.id,
+			compilationFile: asset.id,
+			source: graph.files[asset.id],
+			sourceMap: graph.sourceMaps?.[asset.id],
+			graph: { sources: graph.files }
+		})
+	}));
+	return {
+		...result,
+		stylesheets,
+		entry: graph.entry,
+		outputMap: (css, mappings, file = graph.entry) => stylesheetOutputMap(css, mappings, {
+			file,
+			compilationFile: file,
+			source: graph.files[file],
+			sourceMap: graph.sourceMaps?.[file],
+			graph: { sources: graph.files }
+		})
+	};
+}
+async function registerDeliveredStylesheet(scanner, sources, id, source, options, inlineImports = false) {
+	const filename = normalizeStylesheetGraphID(id);
+	const graphOptions = {
+		baseFile: options.delivery?.baseFile,
+		sourceMap: options.delivery?.sourceMap,
+		projectDir: options.projectDir ?? scanner.cwd,
+		onDependency: options.delivery?.onDependency,
+		resolveNodePackageImports: options.delivery?.resolveNodePackageImports
+	};
+	const graph = options.delivery?.resolveImport || options.delivery?.baseFile || options.delivery?.sourceMap ? await prepareCSSImportGraphWithResolver(filename, source, graphOptions, analyzeCSSDependencies, options.delivery.resolveImport ?? (() => void 0)) : prepareCSSImportGraph(filename, source, graphOptions, analyzeCSSDependencies);
+	const directives = mergeStylesheetDirectives(...Object.entries(graph.files).map(([file, text]) => collectStylesheetDirectives(text, graph.baseFiles?.[file] ?? file, scanner.cwd)));
+	const result = compileGraph(graph, options, void 0, [], {}, {}, void 0, inlineImports, inlineImports, inlineImports ? collectionHostImports(graph) : {});
+	const scoped = mergeStylesheetSourceOptions({
+		...scanner.options,
+		exclude: scanner.customOptions ? scanner.customOptions.exclude : scanner.options.exclude
+	}, directives);
+	const sourceDependencies = hasStylesheetSourceDirectives(directives) ? resolveStylesheetSourcePaths(scoped, scanner.cwd).map((file) => resolve(scanner.cwd, file)) : [];
+	const dependencies = [.../* @__PURE__ */ new Set([...result.directives.dependencies, ...sourceDependencies])];
+	const rootPolicy = collectStylesheetDirectives(graph.files[graph.entry]);
+	const pruneNativeCSS = !rootPolicy.preserveNative && (options.pruneNativeCSS === true || rootPolicy.pruneNative);
+	const hasPruning = pruneNativeCSS || Object.values(graph.files).some((text) => {
+		const policy = collectStylesheetDirectives(text);
+		return !policy.preserveNative && policy.pruneNative;
+	});
+	if (inlineImports && hasPruning && result.directives.nativeClassNames.length && !scanner.registerNativeClasses) throw new TypeError("Stylesheet scanner integrations require registerNativeClasses().");
+	const masterCSS = inlineImports && Object.values(graph.files).some((text) => inspectCSS(text).hasMasterCSSImport);
+	sources.set(filename, {
+		source,
+		graph,
+		pruneNativeCSS,
+		masterCSS,
+		directives,
+		dependencies,
+		sourceDependencies,
+		classIndependent: !hasPruning && !hasStylesheetSourceDirectives(directives)
+	});
+	scanner.registerNativeClasses?.(filename, result.directives.nativeClassNames);
+	return {
+		...result.directives,
+		dependencies
+	};
+}
+function composeDeliveredStylesheets(sources, options, classes, styleClasses, inlineImports = false) {
+	const entry = "\0master-css-output";
+	const graph = {
+		entry,
+		files: { [entry]: "" },
+		edges: []
+	};
+	const generatedClasses = new Set(classes);
+	const owners = {};
+	const classesByStylesheet = {};
+	const nativeStylesheets = [];
+	const hostImports = {};
+	for (const [id, source] of sources) {
+		if (!source.graph) throw new TypeError("Standalone delivery requires graph registration for every stylesheet.");
+		const specifier = `sheet-${graph.edges.length}`;
+		graph.files[entry] += `@import "${specifier}";\n`;
+		const masterFiles = /* @__PURE__ */ new Set();
+		const pending = source.graph.edges.filter((edge) => edge.specifier === "@master/css" || edge.specifier === "@master/css-preset").map((edge) => edge.resolved);
+		while (pending.length) {
+			const file = pending.pop();
+			if (masterFiles.has(file)) continue;
+			masterFiles.add(file);
+			pending.push(...source.graph.edges.filter((edge) => edge.from === file).map((edge) => edge.resolved));
+		}
+		const scopedClasses = [...styleClasses(source)];
+		const variant = (file) => `${file}\0${specifier}`;
+		for (const [file, text] of Object.entries(source.graph.files)) {
+			const key = variant(file);
+			graph.files[key] = text;
+			(graph.resourceOwners ??= {})[key] = source.graph.resourceOwners?.[file] ?? file;
+			if (source.graph.baseFiles?.[file]) (graph.baseFiles ??= {})[key] = source.graph.baseFiles[file];
+			if (source.graph.sourceMaps?.[file]) (graph.sourceMaps ??= {})[key] = source.graph.sourceMaps[file];
+			owners[key] = file;
+			const filePolicy = collectStylesheetDirectives(text, file, options.projectDir);
+			classesByStylesheet[key] = !filePolicy.preserveNative && (filePolicy.pruneNative || options.pruneNativeCSS === true && !source.graph.packageFiles?.includes(file)) ? scopedClasses : null;
+			if (masterFiles.has(file) ? options.includeMasterBaseCSS !== false : options.includeNativeCSS !== false) nativeStylesheets.push(key);
+		}
+		if (inlineImports) hostImports[variant(id)] = collectionHostImports(source.graph)[id];
+		graph.edges.push({
+			from: entry,
+			specifier,
+			resolved: variant(id)
+		}, ...source.graph.edges.map((edge) => ({
+			...edge,
+			from: variant(edge.from),
+			resolved: variant(edge.resolved)
+		})));
+		for (const className of scopedClasses) generatedClasses.add(className);
+	}
+	const delivery = options.delivery;
+	const result = compileGraph(graph, {
+		...options,
+		baseManifest: options.manifest ?? options.baseManifest,
+		delivery: {
+			...delivery,
+			stylesheetURL: (file, variant) => file === entry ? delivery.entryURL : delivery.stylesheetURL(file, variant)
+		}
+	}, [...generatedClasses], [], owners, classesByStylesheet, nativeStylesheets, inlineImports, inlineImports, hostImports);
+	if (inlineImports && result.stylesheets.length > 1) throw new MasterCSSError({
+		code: "CSS_IMPORT_ERROR",
+		domain: "compiler",
+		message: "This stylesheet retains import or resource boundaries and requires stylesheet asset delivery."
+	});
+	const rendered = renderCompiledManifestCSS({
+		manifest: result.manifest,
+		nativeCSS: result.stylesheets.map((asset) => asset.css),
+		classNames: generatedClasses,
+		includeGeneratedCSS: options.includeGeneratedCSS
+	});
+	const referenced = renderCompiledManifestCSS({
+		manifest: result.resolutionManifest,
+		nativeCSS: result.stylesheets.map((asset) => asset.css),
+		includeGeneratedCSS: false,
+		emittedGlobals: rendered.emittedGlobals
+	});
+	return {
+		css: [
+			result.stylesheets.find((asset) => asset.id === entry)?.css,
+			rendered.generatedCSS,
+			referenced.generatedCSS
+		].filter(Boolean).join("\n"),
+		emittedGlobals: referenced.emittedGlobals,
+		stylesheets: result.stylesheets.filter((asset) => asset.id !== entry),
+		resources: result.resources,
+		dependencies: result.directives.dependencies.filter((file) => file !== entry)
+	};
+}
+/** Only the registered entry's unresolved imports are emitted by its host source.
+* Imported children's external boundaries still require explicit asset delivery.
+*/
+function collectionHostImports(graph) {
+	const local = new Set(graph.edges.filter((edge) => edge.from === graph.entry).map((edge) => edge.specifier));
+	return { [graph.entry]: analyzeCSSDependencies(graph.files[graph.entry]).imports.map((imported) => imported.source).filter((specifier) => !local.has(specifier)) };
+}
+export { compileDeliveredFile, compileDeliveredSource, compileStylesheetMetadata, composeDeliveredStylesheets, registerDeliveredStylesheet };

package/dist/stylesheet/directives.d.ts

@@ -0,0 +1,31 @@
+import { CSSDirectiveExtractionPolicy } from "@master/css-schema/css-directives";
+import { PrepareCSSImportGraphOptions } from "../node-imports.js";
+import { StandaloneCSSDirectiveStatement } from "../node-compiler.js";
+type StylesheetDirectives = CSSDirectiveExtractionPolicy;
+type StylesheetDirectiveStatement = StandaloneCSSDirectiveStatement;
+declare function hasLocalStyleDirectives(source: string, from?: string): boolean;
+interface StylesheetSourceOptions {
+  outputDirectories?: readonly string[];
+  include?: readonly string[];
+  exclude?: readonly string[];
+  safelist?: readonly string[];
+  blocklist?: readonly (string | RegExp)[];
+}
+interface CollectedStylesheetDirectives {
+  directives: StylesheetDirectives;
+  dependencies: string[];
+}
+declare function createStylesheetDirectives(): StylesheetDirectives;
+declare function hasStylesheetDirectives(directives?: StylesheetDirectives): boolean;
+declare function hasStylesheetSourceDirectives(directives?: StylesheetDirectives): boolean;
+declare function mergeStylesheetDirectives(...directives: (Partial<StylesheetDirectives> | undefined)[]): CSSDirectiveExtractionPolicy;
+declare function mergeStylesheetSourceOptions<T extends StylesheetSourceOptions>(options: T, directives?: StylesheetDirectives): T;
+declare function findStylesheetDirectiveStatements(source: string): StylesheetDirectiveStatement[];
+declare function removeStylesheetDirectiveStatements(source: string): {
+  code: string;
+  removed: boolean;
+};
+declare function collectStylesheetDirectives(source: string, file?: string, cwd?: string): StylesheetDirectives;
+declare function collectStylesheetDirectivesFromCSSGraph(file: string, source?: string, cwd?: string, graphOptions?: Pick<PrepareCSSImportGraphOptions, 'projectDir' | 'expandPackageImports'>): CollectedStylesheetDirectives;
+declare function resolveStylesheetSourcePaths(options: StylesheetSourceOptions, cwd?: string): string[];
+export { CollectedStylesheetDirectives, StylesheetDirectiveStatement, StylesheetDirectives, StylesheetSourceOptions, collectStylesheetDirectives, collectStylesheetDirectivesFromCSSGraph, createStylesheetDirectives, findStylesheetDirectiveStatements, hasLocalStyleDirectives, hasStylesheetDirectives, hasStylesheetSourceDirectives, mergeStylesheetDirectives, mergeStylesheetSourceOptions, removeStylesheetDirectiveStatements, resolveStylesheetSourcePaths };

package/dist/stylesheet/directives.js

@@ -0,0 +1,105 @@
+import { prepareCSSImportGraph } from "../node-imports.js";
+import { analyzeCSSDependencies, collectStandaloneCSSDirectiveExtractionPolicy, compileCSS, createCSSDirectiveExtractionPolicy, findStandaloneCSSDirectiveStatements, mergeCSSDirectiveExtractionPolicy, removeStandaloneCSSDirectives } from "../node-compiler.js";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { createCompilerBindingSessionSync } from "@master/css-binding/compiler/node";
+import { SourcePolicy } from "@master/css-tooling/scanner/node";
+import fg from "fast-glob";
+// src/stylesheet/directives.ts
+function hasLocalStyleDirectives(source, from) {
+	const result = compileCSS(source, {
+		preserveNativeCSS: false,
+		from
+	});
+	return Boolean(result.generatedCSS || result.styleDefinitions?.length || result.references?.length || analyzeCSSDependencies(source).usesCustomMedia);
+}
+function createStylesheetDirectives() {
+	return createCSSDirectiveExtractionPolicy();
+}
+function hasStylesheetDirectives(directives) {
+	return Boolean(directives && (directives.include.length || directives.exclude.length || directives.safelist.length || directives.safelistKeyframes.length || directives.blocklist.length || directives.preserveNative || directives.pruneNative));
+}
+function hasStylesheetSourceDirectives(directives) {
+	return Boolean(directives && (directives.include.length || directives.exclude.length));
+}
+function normalizePath(source) {
+	return source.replace(/\\/g, "/");
+}
+function normalizeSourcePattern(pattern, file, cwd = process.cwd()) {
+	if (isAbsolute(pattern)) return normalizePath(relative(cwd, pattern) || ".");
+	if (!file || file.includes("\0") || /^[a-z][a-z\d+.-]*:/i.test(file) && !/^[a-z]:[\\/]/i.test(file)) throw new Error("Resolving @source requires the declaring stylesheet file or baseFile");
+	return normalizePath(relative(cwd, resolve(cwd, dirname(file), pattern)) || ".");
+}
+function mergeStylesheetDirectives(...directives) {
+	return mergeCSSDirectiveExtractionPolicy(...directives);
+}
+function mergeStylesheetSourceOptions(options, directives) {
+	if (!directives) return options;
+	return {
+		...options,
+		include: [.../* @__PURE__ */ new Set([...options.include || [], ...directives.include])],
+		exclude: [.../* @__PURE__ */ new Set([...options.exclude || [], ...directives.exclude])],
+		safelist: [.../* @__PURE__ */ new Set([...options.safelist || [], ...directives.safelist])],
+		blocklist: [...options.blocklist || [], ...directives.blocklist]
+	};
+}
+function findStylesheetDirectiveStatements(source) {
+	return findStandaloneCSSDirectiveStatements(source);
+}
+function removeStylesheetDirectiveStatements(source) {
+	const code = removeStandaloneCSSDirectives(source);
+	return {
+		code,
+		removed: code !== source
+	};
+}
+function collectStylesheetDirectives(source, file, cwd = process.cwd()) {
+	const directives = collectStandaloneCSSDirectiveExtractionPolicy(source);
+	if (!file) return directives;
+	directives.include = directives.include.map((pattern) => normalizeSourcePattern(pattern, file, cwd));
+	directives.exclude = directives.exclude.map((pattern) => normalizeSourcePattern(pattern, file, cwd));
+	return directives;
+}
+function collectStylesheetDirectivesFromCSSGraph(file, source, cwd = process.cwd(), graphOptions = {}) {
+	const filename = resolve(file);
+	const request = prepareCSSImportGraph(filename, source, {
+		projectDir: cwd,
+		expandPackageImports: false,
+		...graphOptions
+	}, analyzeCSSDependencies);
+	const compiler = createCompilerBindingSessionSync();
+	try {
+		const graph = compiler.resolveCSSStylesheetGraph(request);
+		const nodes = new Map(graph.stylesheets.map((node) => [node.id, node]));
+		const visited = /* @__PURE__ */ new Set();
+		const policies = [];
+		const work = [[graph.entry, false]];
+		while (work.length) {
+			const [id, exit] = work.pop();
+			const node = nodes.get(id);
+			if (exit) policies.push(collectStylesheetDirectives(node.source, id, cwd));
+			else if (!visited.has(id)) {
+				visited.add(id);
+				work.push([id, true]);
+				for (const edge of [...node.imports].reverse()) if (edge.resolved) work.push([edge.resolved, false]);
+			}
+		}
+		return {
+			directives: mergeStylesheetDirectives(...policies),
+			dependencies: graph.stylesheets.map((node) => node.id)
+		};
+	} finally {
+		compiler.dispose();
+	}
+}
+function resolveStylesheetSourcePaths(options, cwd = process.cwd()) {
+	const paths = /* @__PURE__ */ new Set();
+	const policy = new SourcePolicy(cwd, options);
+	if (options.include?.length) {
+		for (const sourcePath of fg.sync([...options.include], {
+			cwd,
+			ignore: options.exclude ? [...options.exclude] : void 0
+		})) if (sourcePath && policy.accepts(sourcePath, true)) paths.add(sourcePath);
+	}
+	return [...paths];
+}
+export { collectStylesheetDirectives, collectStylesheetDirectivesFromCSSGraph, createStylesheetDirectives, findStylesheetDirectiveStatements, hasLocalStyleDirectives, hasStylesheetDirectives, hasStylesheetSourceDirectives, mergeStylesheetDirectives, mergeStylesheetSourceOptions, removeStylesheetDirectiveStatements, resolveStylesheetSourcePaths };

package/dist/stylesheet/index-public.d.ts

@@ -0,0 +1,3 @@
+import { MasterCSSCompiledStylesheet, MasterCSSPreparedStylesheet, MasterCSSRenderedStylesheetCompileOptions, MasterCSSSassCompiler, MasterCSSStylesheetAsyncResolutionOptions, MasterCSSStylesheetCollection, MasterCSSStylesheetCollectionSnapshot, MasterCSSStylesheetCompileOptions, MasterCSSStylesheetComposition, MasterCSSStylesheetCompositionOptions, MasterCSSStylesheetDeliveryOptions, MasterCSSStylesheetDependencyOptions, MasterCSSStylesheetHostOptions, MasterCSSStylesheetImportResolver, MasterCSSStylesheetImportSource, MasterCSSStylesheetKind, MasterCSSStylesheetPreparationOptions, MasterCSSStylesheetResolution, MasterCSSStylesheetResolutionOptions, MasterCSSStylesheetResourceAsset, MasterCSSStylesheetSourceSnapshot, MasterCSSStylesheetTransformOptions, MasterCSSStylesheetTransformResult, collectStylesheetDependencies, collectStylesheetEmittedGlobals, compileRenderedStylesheet, compileStylesheet, composeStylesheetHost, createStylesheetCollection, prepareStylesheet, resolveStylesheet, transformStylesheet } from "./public.js";
+import { MasterCSSLinkedStylesheet, describeLinkedStylesheet } from "./linked-stylesheet.js";
+export { type MasterCSSCompiledStylesheet, type MasterCSSLinkedStylesheet, type MasterCSSPreparedStylesheet, type MasterCSSRenderedStylesheetCompileOptions, type MasterCSSSassCompiler, type MasterCSSStylesheetAsyncResolutionOptions, MasterCSSStylesheetCollection, type MasterCSSStylesheetCollectionSnapshot, type MasterCSSStylesheetCompileOptions, type MasterCSSStylesheetComposition, type MasterCSSStylesheetCompositionOptions, type MasterCSSStylesheetDeliveryOptions, type MasterCSSStylesheetDependencyOptions, type MasterCSSStylesheetHostOptions, type MasterCSSStylesheetImportResolver, type MasterCSSStylesheetImportSource, type MasterCSSStylesheetKind, type MasterCSSStylesheetPreparationOptions, type MasterCSSStylesheetResolution, type MasterCSSStylesheetResolutionOptions, type MasterCSSStylesheetResourceAsset, type MasterCSSStylesheetSourceSnapshot, type MasterCSSStylesheetTransformOptions, type MasterCSSStylesheetTransformResult, collectStylesheetDependencies, collectStylesheetEmittedGlobals, compileRenderedStylesheet, compileStylesheet, composeStylesheetHost, createStylesheetCollection, describeLinkedStylesheet, prepareStylesheet, resolveStylesheet, transformStylesheet };

package/dist/stylesheet/index-public.js

@@ -0,0 +1,4 @@
+import { prepareStylesheetSource } from "./index.js";
+import { MasterCSSStylesheetCollection, collectStylesheetDependencies, collectStylesheetEmittedGlobals, compileRenderedStylesheet, compileStylesheet, composeStylesheetHost, createStylesheetCollection, resolveStylesheet, transformStylesheet } from "./public.js";
+import { describeLinkedStylesheet } from "./linked-stylesheet.js";
+export { MasterCSSStylesheetCollection, collectStylesheetDependencies, collectStylesheetEmittedGlobals, compileRenderedStylesheet, compileStylesheet, composeStylesheetHost, createStylesheetCollection, describeLinkedStylesheet, prepareStylesheetSource as prepareStylesheet, resolveStylesheet, transformStylesheet };

package/dist/stylesheet/index.d.ts

@@ -0,0 +1,39 @@
+import { CompileCSSResult } from "../node-compiler.js";
+import { CompileRenderedStylesheetOptions, CompileRenderedStylesheetOptions as CompileRenderedStylesheetOptions$1, CompileRenderedStylesheetResult, CompileRenderedStylesheetResult as CompileRenderedStylesheetResult$1, CompileStylesheetOptions, CompileStylesheetOptions as CompileStylesheetOptions$1, CreateExtractedCSSOptions, CreateExtractedCSSOptions as CreateExtractedCSSOptions$1, CreateExtractedCSSResult, CreateExtractedCSSResult as CreateExtractedCSSResult$1, CreateStyleEntryEmittedGlobalsOptions, CreateStyleEntryEmittedGlobalsOptions as CreateStyleEntryEmittedGlobalsOptions$1, CreateStyleEntryEmittedGlobalsResult, CreateStyleEntryEmittedGlobalsResult as CreateStyleEntryEmittedGlobalsResult$1, CreateStylesheetHostSourceOptions, CreateStylesheetHostSourceOptions as CreateStylesheetHostSourceOptions$1, RegisterStylesheetSourceOptions, RegisterStylesheetSourceOptions as RegisterStylesheetSourceOptions$1, ResolveStylesheetImportGraphOptions, ResolveStylesheetImportGraphOptions as ResolveStylesheetImportGraphOptions$1, ResolvedStylesheetSource, ResolvedStylesheetSource as ResolvedStylesheetSource$1, SassModule, ScannerCSSState, ScannerClassState, ScannerState, ScannerState as ScannerState$1, StylesheetPreparationOptions, StylesheetSource, StylesheetSources, StylesheetSources as StylesheetSources$1, TransformLocalStylesheetOptions, TransformLocalStylesheetOptions as TransformLocalStylesheetOptions$1, TransformLocalStylesheetResult, TransformLocalStylesheetResult as TransformLocalStylesheetResult$1 } from "./types.js";
+import { CollectedStylesheetDirectives, StylesheetDirectiveStatement, StylesheetDirectives, StylesheetSourceOptions, collectStylesheetDirectives, collectStylesheetDirectivesFromCSSGraph, createStylesheetDirectives, findStylesheetDirectiveStatements, hasLocalStyleDirectives, hasStylesheetDirectives, hasStylesheetSourceDirectives, mergeStylesheetDirectives, mergeStylesheetSourceOptions, removeStylesheetDirectiveStatements, resolveStylesheetSourcePaths } from "./directives.js";
+declare function cleanStyleRequest(id: string): string;
+declare function isStylesheetRequest(id: string): boolean;
+declare function replaceStylesheetImports(source: string, replacement: string): {
+  code: string;
+  replaced: boolean;
+};
+declare function resolveStylesheetImportGraph(file: string, source: string, projectDir?: string, options?: ResolveStylesheetImportGraphOptions$1): ResolvedStylesheetSource$1;
+declare function collectStylesheetDependencies(file: string, source?: string, projectDir?: string): string[];
+declare function removeStylesheetImports(source: string): {
+  code: string;
+  replaced: boolean;
+};
+declare function hasMasterStyleEntrypoint(source: string): boolean;
+declare function resolveMasterStyleSource(file: string, source: string, projectDir?: string): ResolvedStylesheetSource$1 | undefined;
+declare function isMasterCSSPackageStyleFile(id: string, projectDir?: string): boolean;
+declare function removeMasterStyleDirectives(source: string): {
+  code: string;
+  removed: boolean;
+};
+declare function createStylesheetHostSource(source: string, options?: CreateStylesheetHostSourceOptions$1): string;
+declare function isMasterStyleSource(source: string): boolean;
+declare function prepareStylesheetSource(id: string, source: string, options?: StylesheetPreparationOptions): Promise<import("./types.js").PreparedStylesheetSource>;
+declare function compileStylesheet(id: string, source: string, options: CompileStylesheetOptions$1): Promise<CompileCSSResult>;
+declare function compileRenderedStylesheet(id: string, source: string, options: CompileRenderedStylesheetOptions$1): Promise<CompileRenderedStylesheetResult$1>;
+declare function createStyleEntryEmittedGlobals(entries: string[], options: CreateStyleEntryEmittedGlobalsOptions$1): Promise<CreateStyleEntryEmittedGlobalsResult$1>;
+declare function transformLocalStylesheet(id: string, source: string, options: TransformLocalStylesheetOptions$1): Promise<TransformLocalStylesheetResult$1>;
+declare function getNativeCSS(result: {
+  css?: string;
+  generatedCSS?: string;
+  nativeCSS?: string;
+}): string;
+declare function getScannerClasses(scanner: ScannerState$1): string[];
+declare function registerStylesheetSource(scanner: ScannerState$1, stylesheetSources: StylesheetSources$1, id: string, source: string, options: RegisterStylesheetSourceOptions$1): Promise<CompileCSSResult>;
+declare function createExtractedCSSResult(options: CreateExtractedCSSOptions$1): Promise<CreateExtractedCSSResult$1>;
+declare function createExtractedCSS(options: CreateExtractedCSSOptions$1): Promise<string>;
+export { type CollectedStylesheetDirectives, type CompileRenderedStylesheetOptions, type CompileRenderedStylesheetResult, type CompileStylesheetOptions, type CreateExtractedCSSOptions, type CreateExtractedCSSResult, type CreateStyleEntryEmittedGlobalsOptions, type CreateStyleEntryEmittedGlobalsResult, type CreateStylesheetHostSourceOptions, type RegisterStylesheetSourceOptions, type ResolveStylesheetImportGraphOptions, type ResolvedStylesheetSource, type SassModule, type ScannerCSSState, type ScannerClassState, type ScannerState, type StylesheetDirectiveStatement, type StylesheetDirectives, type StylesheetSource, type StylesheetSourceOptions, type StylesheetSources, type TransformLocalStylesheetOptions, type TransformLocalStylesheetResult, cleanStyleRequest, collectStylesheetDependencies, collectStylesheetDirectives, collectStylesheetDirectivesFromCSSGraph, compileRenderedStylesheet, compileStylesheet, createExtractedCSS, createExtractedCSSResult, createStyleEntryEmittedGlobals, createStylesheetDirectives, createStylesheetHostSource, findStylesheetDirectiveStatements, getNativeCSS, getScannerClasses, hasLocalStyleDirectives, hasMasterStyleEntrypoint, hasStylesheetDirectives, hasStylesheetSourceDirectives, isMasterCSSPackageStyleFile, isMasterStyleSource, isStylesheetRequest, mergeStylesheetDirectives, mergeStylesheetSourceOptions, prepareStylesheetSource, registerStylesheetSource, removeMasterStyleDirectives, removeStylesheetDirectiveStatements, removeStylesheetImports, replaceStylesheetImports, resolveMasterStyleSource, resolveStylesheetImportGraph, resolveStylesheetSourcePaths, transformLocalStylesheet };