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

package/dist/stylesheet/index.js

@@ -0,0 +1,501 @@
+import { prepareCSSImportGraph } from "../node-imports.js";
+import { analyzeCSSDependencies, createManifestFromCSSResult, filterCSSExtractionCandidates, inspectCSS, isMasterCSSPackageStyleFile as isMasterCSSPackageStyleFile$1, resolveCSSImportGraphSource, resolveMasterCSSPackageImportGraph, stripRequestSuffix } from "../node-compiler.js";
+import { collectStylesheetDirectives, collectStylesheetDirectivesFromCSSGraph, createStylesheetDirectives, findStylesheetDirectiveStatements, hasLocalStyleDirectives, hasStylesheetDirectives, hasStylesheetSourceDirectives, mergeStylesheetDirectives, mergeStylesheetSourceOptions, removeStylesheetDirectiveStatements, resolveStylesheetSourcePaths } from "./directives.js";
+import { hasStylesheetResourceReferences, renderCompiledManifestCSS } from "./render.js";
+import { compileDeliveredSource, compileStylesheetMetadata, composeDeliveredStylesheets, registerDeliveredStylesheet } from "./delivery.js";
+import { mapStylesheetError } from "./source-context.js";
+import { compilePreparedStylesheet } from "./compiled-source.js";
+import { compileRenderedDelivery } from "./render-delivery.js";
+import { prepareSassSource } from "./source.js";
+import { pathToFileURL } from "node:url";
+import { extname, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { createToolingSessionSync } from "@master/css-tooling/node";
+// src/stylesheet/index.ts
+const STYLESHEET_REQUEST_RE = /\.(css|scss|sass)(?:[?#].*)?$/;
+const VIRTUAL_CSS_ID = "virtual:master-utilities.css";
+const MASTER_CSS_MODULE_IDS = ["@master/css"];
+function normalizeStylesheetModuleIds() {
+	return new Set(MASTER_CSS_MODULE_IDS);
+}
+function cleanStyleRequest(id) {
+	if (id.startsWith("\0")) return id;
+	return stripRequestSuffix(id);
+}
+function getStyleRequestSearchParams(id) {
+	const queryStart = id.indexOf("?");
+	return queryStart === -1 ? new URLSearchParams() : new URLSearchParams(id.slice(queryStart + 1));
+}
+function getStyleRequestExtension(id) {
+	const cleanExtension = extname(cleanStyleRequest(id));
+	if (cleanExtension === ".css" || cleanExtension === ".scss" || cleanExtension === ".sass") return cleanExtension;
+	const lang = getStyleRequestSearchParams(id).get("lang");
+	if (lang === "css" || lang === "scss" || lang === "sass") return "." + lang;
+	return cleanExtension;
+}
+function isStyleModuleRequest(source) {
+	return getStyleRequestSearchParams(source).get("type") === "style";
+}
+function isStylesheetRequest(id) {
+	return STYLESHEET_REQUEST_RE.test(id) || isStyleModuleRequest(id) && [
+		".css",
+		".scss",
+		".sass"
+	].includes(getStyleRequestExtension(id));
+}
+function replaceStylesheetImports(source, replacement) {
+	const ids = /* @__PURE__ */ new Set([...normalizeStylesheetModuleIds(), VIRTUAL_CSS_ID]);
+	const imports = analyzeCSSDependencies(source).imports;
+	let replaced = false;
+	let code = source;
+	for (const statement of imports.toReversed()) {
+		if (!ids.has(statement.source)) continue;
+		code = code.slice(0, statement.start) + replacement + code.slice(statement.end);
+		replaced = true;
+	}
+	return {
+		code,
+		replaced
+	};
+}
+function isExpandableStyleImportSource(source) {
+	return (source.startsWith("./") || source.startsWith("../")) && extname(source) === ".css";
+}
+function findImportStatements(source) {
+	return analyzeCSSDependencies(source).imports;
+}
+function resolveStylesheetImportGraph(file, source, projectDir, options = {}) {
+	if (!STYLESHEET_REQUEST_RE.test(cleanStyleRequest(file))) return {
+		source,
+		dependencies: [cleanStyleRequest(file)]
+	};
+	return resolveCSSImportGraphSource(cleanStyleRequest(file), source, {
+		projectDir,
+		expandPackageImports: options.expandMasterCSSPackage !== false
+	});
+}
+function collectStylesheetDependencies(file, source, projectDir) {
+	const dependencies = /* @__PURE__ */ new Set();
+	const filename = cleanStyleRequest(file);
+	dependencies.add(filename);
+	let resolvedSource = source;
+	if (resolvedSource === void 0) try {
+		resolvedSource = readFileSync(filename, "utf-8");
+	} catch {
+		return [...dependencies];
+	}
+	try {
+		const graph = prepareCSSImportGraph(filename, resolvedSource, {
+			projectDir,
+			expandPackageImports: false
+		}, analyzeCSSDependencies);
+		for (const dependency of Object.keys(graph.files)) dependencies.add(cleanStyleRequest(dependency));
+	} catch {}
+	return [...dependencies];
+}
+function removeStylesheetImports(source) {
+	return replaceStylesheetImports(source, "");
+}
+function hasMasterStyleEntrypoint(source) {
+	return inspectCSS(source).hasMasterEntry;
+}
+function resolveMasterStyleSource(file, source, projectDir) {
+	if (!isStylesheetRequest(file)) return;
+	const sourceHasMasterEntry = hasMasterStyleEntrypoint(source);
+	let unresolvedPackageSource;
+	try {
+		unresolvedPackageSource = resolveStylesheetImportGraph(file, source, projectDir, { expandMasterCSSPackage: false });
+	} catch (error) {
+		if (!sourceHasMasterEntry) return;
+		throw error;
+	}
+	if (!isMasterStyleSource(unresolvedPackageSource.source)) return;
+	return resolveStylesheetImportGraph(file, source, projectDir);
+}
+function isMasterCSSPackageStyleFile(id, projectDir) {
+	return isMasterCSSPackageStyleFile$1(id, projectDir);
+}
+function removeMasterStyleDirectives(source) {
+	return removeStylesheetDirectiveStatements(source);
+}
+function isStylesheetHostImport(importSource, masterImport) {
+	return importSource === masterImport || masterImport === "@master/css" && normalizeStylesheetModuleIds().has(importSource);
+}
+function createStylesheetHostSource(source, options = {}) {
+	const masterImport = options.masterImport || "@master/css";
+	const masterSource = options.masterSource;
+	const hasMasterSource = Object.prototype.hasOwnProperty.call(options, "masterSource");
+	const cleanSource = removeMasterStyleDirectives(source).code;
+	const imports = findImportStatements(cleanSource);
+	const preservedImports = [];
+	for (const importStatement of imports) {
+		const importSource = importStatement.source;
+		if (!importSource) continue;
+		if (importSource === VIRTUAL_CSS_ID || normalizeStylesheetModuleIds().has(importSource)) {
+			if (!hasMasterSource && isStylesheetHostImport(importSource, masterImport)) preservedImports.push(importStatement.statement.trim());
+			continue;
+		}
+		if (!isExpandableStyleImportSource(importSource)) preservedImports.push(importStatement.statement.trim());
+	}
+	if (hasMasterSource) {
+		if (masterSource) preservedImports.push(masterSource);
+	} else if (!preservedImports.some((statement) => {
+		const importSource = findImportStatements(statement)[0]?.source;
+		return importSource && isStylesheetHostImport(importSource, masterImport);
+	})) preservedImports.unshift(`@import "${masterImport}";`);
+	return preservedImports.join("\n");
+}
+function resolveMasterCSSPackageCompileSource(projectDir) {
+	const graph = resolveMasterCSSPackageImportGraph(projectDir);
+	return {
+		source: removeMasterStyleDirectives(removeStylesheetImports(graph.source).code).code,
+		dependencies: graph.dependencies
+	};
+}
+function isMasterStyleSource(source) {
+	return hasMasterStyleEntrypoint(source);
+}
+function prepareStylesheetSource(id, source, options = {}) {
+	return prepareSassSource(cleanStyleRequest(id), source, getStyleRequestExtension(id.startsWith("\0") && options.baseFile ? options.baseFile : id), options);
+}
+async function preprocessStylesheet(source, id, options) {
+	const extension = getStyleRequestExtension(id);
+	if (extension !== ".scss" && extension !== ".sass") return source;
+	return (await prepareStylesheetSource(id, source, options)).source;
+}
+async function compileStylesheet(id, source, options) {
+	const { result, finalizedResult, outputMap } = await compileStylesheetResult(id, source, options);
+	return {
+		...result,
+		dependencies: finalizedResult.dependencies,
+		warnings: finalizedResult.warnings,
+		notices: finalizedResult.notices,
+		css: finalizedResult.css,
+		generatedCSS: finalizedResult.generatedCSS,
+		sourceMap: outputMap(finalizedResult.css)
+	};
+}
+async function compileStylesheetResult(id, source, options, resolveImports = false) {
+	const prepared = await prepareStylesheetSource(id, source, options);
+	return compilePreparedStylesheet(cleanStyleRequest(id), prepared.source, {
+		...options,
+		sourceMap: options.sourceMap ?? prepared.sourceMap
+	}, resolveImports);
+}
+async function compileRenderedStylesheet(id, source, options) {
+	if (options.delivery) {
+		const prepared = await prepareStylesheetSource(id, source, options);
+		const filename = id.startsWith("\0") ? id : resolve(options.projectDir ?? "", cleanStyleRequest(id));
+		const result = await compileRenderedDelivery(filename, prepared.source, {
+			...options,
+			delivery: {
+				...options.delivery,
+				onDependency: (file) => {
+					options.onDependency?.(file);
+					if (options.delivery.onDependency !== options.onDependency) options.delivery.onDependency?.(file);
+				},
+				baseFile: options.delivery.baseFile ?? options.baseFile,
+				sourceMap: options.delivery.sourceMap ?? options.sourceMap ?? prepared.sourceMap
+			}
+		});
+		return {
+			...result,
+			dependencies: [.../* @__PURE__ */ new Set([...prepared.dependencies, ...result.dependencies])]
+		};
+	}
+	const { compileOptions, finalizedResult, result, outputMap } = await compileStylesheetResult(id, source, options, true);
+	const renderedCSS = renderCompiledManifestCSS({
+		manifest: finalizedResult.resolutionManifest,
+		nativeCSS: finalizedResult.css,
+		classNames: compileOptions.classes,
+		emittedGlobals: options.emittedGlobals
+	});
+	return {
+		...result,
+		dependencies: finalizedResult.dependencies,
+		warnings: finalizedResult.warnings,
+		notices: finalizedResult.notices,
+		css: renderedCSS.css,
+		sourceMap: outputMap(renderedCSS.css, renderedCSS.outputMappings),
+		nativeCSS: renderedCSS.nativeCSS,
+		generatedCSS: renderedCSS.generatedCSS,
+		emittedGlobals: renderedCSS.emittedGlobals,
+		manifest: finalizedResult.manifest,
+		renderedCSS
+	};
+}
+function createEmptyStyleEntryEmittedGlobals() {
+	return {
+		variables: {},
+		keyframes: {}
+	};
+}
+function hasEmittedGlobals(emittedGlobals) {
+	return Boolean(Object.keys(emittedGlobals?.variables || {}).length || Object.keys(emittedGlobals?.keyframes || {}).length);
+}
+async function createStyleEntryEmittedGlobals(entries, options) {
+	const dependencies = /* @__PURE__ */ new Set();
+	let baseManifest = options.baseManifest;
+	let emittedGlobals = createEmptyStyleEntryEmittedGlobals();
+	for (const entry of [...new Set(entries)].sort()) {
+		const filename = cleanStyleRequest(entry);
+		const source = await preprocessStylesheet(readFileSync(filename, "utf-8"), filename, options);
+		const result = compileStylesheetMetadata(filename, source, {
+			...options,
+			baseManifest,
+			preserveNativeCSS: true
+		});
+		if (!result) continue;
+		for (const dependency of result.directives.dependencies) dependencies.add(cleanStyleRequest(dependency));
+		const renderedCSS = renderCompiledManifestCSS({
+			manifest: result.manifest,
+			nativeCSS: result.stylesheets.map((stylesheet) => stylesheet.css),
+			emittedGlobals
+		});
+		if (hasEmittedGlobals(renderedCSS.emittedGlobals)) emittedGlobals = renderedCSS.emittedGlobals;
+		baseManifest = result.manifest;
+	}
+	return {
+		emittedGlobals,
+		dependencies: [...dependencies]
+	};
+}
+async function transformLocalStylesheet(id, source, options) {
+	let local = false;
+	let native = false;
+	try {
+		if (isStylesheetRequest(id)) {
+			native = !hasLocalStyleDirectives(source, cleanStyleRequest(id));
+			local = Boolean(options.delivery || options.transformNativeStylesheets || !native);
+		}
+	} catch (error) {
+		throw mapStylesheetError(error, cleanStyleRequest(id), options, source);
+	}
+	if (!isStylesheetRequest(id) || !local) return {
+		code: source,
+		dependencies: [],
+		transformed: false
+	};
+	const { emittedGlobals, generatedGlobals = "inline", preserveUnchangedNativeCSS = false, ...compileOptions } = options;
+	if (generatedGlobals !== "inline" && generatedGlobals !== "separate") throw new TypeError("generatedGlobals must be inline or separate.");
+	if (options.delivery) {
+		const dependencies = /* @__PURE__ */ new Set();
+		const compiled = await compileDeliveredSource(cleanStyleRequest(id), await preprocessStylesheet(source, id, options), {
+			...compileOptions,
+			preserveUnchangedNativeCSS,
+			delivery: {
+				...options.delivery,
+				onDependency: (file) => {
+					dependencies.add(file);
+					options.delivery.onDependency?.(file);
+				}
+			},
+			preserveNativeCSS: true
+		});
+		if (!compiled) return {
+			code: source,
+			dependencies: preserveUnchangedNativeCSS ? [...dependencies] : [],
+			transformed: false
+		};
+		const rendered = renderCompiledManifestCSS({
+			manifest: compiled.resolutionManifest,
+			nativeCSS: compiled.stylesheets.map((asset) => asset.css),
+			includeGeneratedCSS: false,
+			emittedGlobals
+		});
+		const code = [compiled.directives.css, generatedGlobals === "inline" && rendered.generatedCSS].filter(Boolean).join("\n\n");
+		return {
+			code,
+			transformed: true,
+			dependencies: compiled.directives.dependencies,
+			...generatedGlobals === "separate" && rendered.generatedCSS ? { globalStylesheet: { css: rendered.generatedCSS } } : {},
+			stylesheets: compiled.stylesheets.filter((asset) => asset.id !== compiled.entry).map(({ id, href, css }) => ({
+				id,
+				href,
+				css
+			})),
+			resources: compiled.resources,
+			result: {
+				...compiled.directives,
+				css: code,
+				generatedCSS: rendered.generatedCSS
+			}
+		};
+	}
+	const { result, finalizedResult, outputMap } = await compileStylesheetResult(id, source, {
+		...compileOptions,
+		preserveNativeSource: compileOptions.preserveNativeSource ?? native,
+		preserveNativeCSS: true
+	});
+	if (native && !hasStylesheetResourceReferences(finalizedResult.resolutionManifest, finalizedResult.css || result.nativeCSS || "")) return {
+		code: source,
+		dependencies: finalizedResult.dependencies,
+		transformed: false
+	};
+	const renderedCSS = renderCompiledManifestCSS({
+		manifest: finalizedResult.resolutionManifest,
+		nativeCSS: finalizedResult.css || result.nativeCSS,
+		includeGeneratedCSS: false,
+		emittedGlobals
+	});
+	const transformedResult = {
+		...result,
+		dependencies: finalizedResult.dependencies,
+		warnings: finalizedResult.warnings,
+		notices: finalizedResult.notices,
+		css: generatedGlobals === "separate" ? renderedCSS.nativeCSS : renderedCSS.css,
+		sourceMap: outputMap(generatedGlobals === "separate" ? renderedCSS.nativeCSS : renderedCSS.css, generatedGlobals === "separate" ? [] : renderedCSS.outputMappings),
+		generatedCSS: renderedCSS.generatedCSS
+	};
+	return {
+		code: transformedResult.css || transformedResult.nativeCSS || "",
+		...generatedGlobals === "separate" && renderedCSS.generatedCSS ? { globalStylesheet: { css: renderedCSS.generatedCSS } } : {},
+		dependencies: [.../* @__PURE__ */ new Set([cleanStyleRequest(id), ...transformedResult.dependencies || []])],
+		transformed: true,
+		result: transformedResult
+	};
+}
+function getNativeCSS(result) {
+	if (result.nativeCSS !== void 0) return result.nativeCSS;
+	const css = result.css || "";
+	const generatedCSS = result.generatedCSS || "";
+	if (generatedCSS && css.endsWith(generatedCSS)) return css.slice(0, -generatedCSS.length).trim();
+	return css;
+}
+function hasCompiledStyleManifestInput(result) {
+	return Boolean(Object.keys(result.manifestInput || {}).length || result.styleDefinitions?.length);
+}
+function getScannerClasses(scanner) {
+	return filterCSSExtractionCandidates([.../* @__PURE__ */ new Set([
+		...scanner.latentClasses || [],
+		...scanner.validClasses || [],
+		...scanner.usedNativeClasses || [],
+		...scanner.options.safelist || []
+	])], scanner.options.blocklist);
+}
+function getStylesheetOptionClasses(options, manifest, projectDir = process.cwd()) {
+	const classes = new Set(options.safelist || []);
+	const tooling = createToolingSessionSync({ manifest });
+	try {
+		for (const sourcePath of resolveStylesheetSourcePaths(options, projectDir)) {
+			const absolutePath = resolve(projectDir, sourcePath);
+			const extracted = tooling.extractSource({ files: [{
+				source: absolutePath,
+				content: readFileSync(absolutePath, "utf-8")
+			}] }).files[0];
+			if (extracted.diagnostics.length) throw new Error(`${absolutePath}: ${extracted.diagnostics[0].message}`);
+			for (const className of extracted.candidates) classes.add(className);
+		}
+	} finally {
+		tooling.dispose();
+	}
+	return filterCSSExtractionCandidates([...classes], options.blocklist);
+}
+function getStyleSourceClasses(scanner, styleSource, baseClasses, projectDir) {
+	if (!hasStylesheetDirectives(styleSource.directives)) return baseClasses;
+	const scopedOptions = mergeStylesheetSourceOptions({
+		...scanner.options,
+		exclude: scanner.customOptions ? scanner.customOptions.exclude : scanner.options.exclude
+	}, styleSource.directives);
+	const classes = hasStylesheetSourceDirectives(styleSource.directives) ? getStylesheetOptionClasses(scopedOptions, scanner.css.manifest, projectDir) : [...baseClasses, ...styleSource.directives.safelist || []];
+	return filterCSSExtractionCandidates([...new Set(classes)], scopedOptions.blocklist);
+}
+async function registerStylesheetSource(scanner, stylesheetSources, id, source, options) {
+	if (options.delivery) return registerDeliveredStylesheet(scanner, stylesheetSources, id, source, options);
+	const filename = cleanStyleRequest(id);
+	const prepared = await prepareStylesheetSource(filename, source, options);
+	const compileOptions = {
+		...options,
+		delivery: defaultCollectionDelivery(options.projectDir ?? scanner.cwd, {
+			...options,
+			sourceMap: options.sourceMap ?? prepared.sourceMap
+		})
+	};
+	return registerDeliveredStylesheet(scanner, stylesheetSources, filename, prepared.source, compileOptions, true);
+}
+function defaultCollectionDelivery(projectDir, options) {
+	return {
+		entryURL: pathToFileURL(resolve(projectDir, "master.css")).href,
+		stylesheetURL: (file, variant) => pathToFileURL(variant ?? file).href,
+		resourceURL: (file) => pathToFileURL(file).href,
+		baseFile: options.baseFile,
+		sourceMap: options.sourceMap,
+		onDependency: options.onDependency
+	};
+}
+function hasMasterCSSPackageSource(stylesheetSources) {
+	return Array.from(stylesheetSources?.values() || []).some((styleSource) => styleSource.masterCSS);
+}
+async function compileMasterCSSPackage(projectDir, options) {
+	const graph = resolveMasterCSSPackageCompileSource(projectDir);
+	return {
+		...await compileStylesheet(graph.dependencies[0] || "@master/css", graph.source, options),
+		dependencies: graph.dependencies
+	};
+}
+function createEmptyExtractedCSSResult(css = "") {
+	return {
+		css,
+		emittedGlobals: {
+			variables: {},
+			keyframes: {}
+		}
+	};
+}
+async function createExtractedCSSResult(options) {
+	const { scanner, stylesheetSources, manifest: planOption, includeGeneratedCSS = true, includeNativeCSS = true, includeMasterBaseCSS = true, ...compileOptions } = options;
+	const classes = compileOptions.classes ?? getScannerClasses(scanner);
+	if (compileOptions.delivery || stylesheetSources?.size && [...stylesheetSources.values()].every((source) => source.graph)) {
+		const inlineImports = !compileOptions.delivery;
+		return composeDeliveredStylesheets(stylesheetSources ?? /* @__PURE__ */ new Map(), {
+			...compileOptions,
+			delivery: compileOptions.delivery ?? defaultCollectionDelivery(compileOptions.projectDir ?? scanner.cwd, compileOptions),
+			manifest: planOption,
+			includeGeneratedCSS,
+			includeNativeCSS,
+			includeMasterBaseCSS
+		}, classes, (source) => getStyleSourceClasses(scanner, source, classes, compileOptions.projectDir ?? scanner.cwd), inlineImports);
+	}
+	if (!planOption && !compileOptions.classes && !stylesheetSources?.size) return createEmptyExtractedCSSResult(includeGeneratedCSS ? scanner.css.text : "");
+	const hasMasterCSS = hasMasterCSSPackageSource(stylesheetSources);
+	const explicitPlan = planOption;
+	const masterCSSResult = hasMasterCSS ? await compileMasterCSSPackage(compileOptions.projectDir, compileOptions) : void 0;
+	const entryStyleResults = await Promise.all(Array.from(stylesheetSources || []).map(([id, styleSource]) => compileStylesheet(id, styleSource.source, {
+		...compileOptions,
+		references: styleSource.references,
+		pruneNativeCSS: styleSource.pruneNativeCSS,
+		classes: styleSource.pruneNativeCSS ? getStyleSourceClasses(scanner, styleSource, classes, compileOptions.projectDir ?? scanner.cwd) : void 0
+	})));
+	const styleResults = [...masterCSSResult ? [masterCSSResult] : [], ...entryStyleResults];
+	let mergedPlan = explicitPlan ?? compileOptions.baseManifest;
+	const finalizedStyleResults = /* @__PURE__ */ new Map();
+	for (const result of styleResults) {
+		if (!hasCompiledStyleManifestInput(result)) continue;
+		const finalizedResult = createManifestFromCSSResult(result, {
+			...compileOptions,
+			baseManifest: mergedPlan
+		});
+		mergedPlan = finalizedResult.manifest;
+		finalizedStyleResults.set(result, finalizedResult);
+	}
+	const nativeCSS = [...includeMasterBaseCSS ? [...masterCSSResult ? [getNativeCSS(finalizedStyleResults.get(masterCSSResult) || masterCSSResult)] : []] : [], ...includeNativeCSS ? entryStyleResults.map((result) => finalizedStyleResults.get(result)?.css || result.nativeCSS).filter(Boolean) : []];
+	const generatedClasses = new Set(classes);
+	if (includeGeneratedCSS) for (const styleSource of stylesheetSources?.values() || []) {
+		if (!hasStylesheetDirectives(styleSource.directives)) continue;
+		for (const className of getStyleSourceClasses(scanner, styleSource, classes, compileOptions.projectDir ?? scanner.cwd)) generatedClasses.add(className);
+	}
+	const renderedCSS = renderCompiledManifestCSS({
+		manifest: mergedPlan,
+		nativeCSS,
+		classNames: generatedClasses,
+		includeGeneratedCSS
+	});
+	return {
+		css: renderedCSS.css,
+		emittedGlobals: renderedCSS.emittedGlobals
+	};
+}
+async function createExtractedCSS(options) {
+	return (await createExtractedCSSResult(options)).css;
+}
+export { 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 };

package/dist/stylesheet/linked-stylesheet.d.ts

@@ -0,0 +1,10 @@
+/** A final stylesheet a server-rendered page may link, as `@master/css-server` reads it. */
+interface MasterCSSLinkedStylesheet {
+  readonly href: string;
+  readonly css: string;
+  /** Import specifiers of the listed stylesheets it imports, in order, relative to `href`. */
+  readonly imports: readonly string[];
+}
+/** Describes final adapter CSS and which of `stylesheetURLs` it imports. */
+declare function describeLinkedStylesheet(css: string, href: string, stylesheetURLs?: readonly string[]): MasterCSSLinkedStylesheet;
+export { MasterCSSLinkedStylesheet, describeLinkedStylesheet };

package/dist/stylesheet/linked-stylesheet.js

@@ -0,0 +1,13 @@
+import { analyzeCSSDependencies } from "../node-compiler.js";
+// src/stylesheet/linked-stylesheet.ts
+/** Describes final adapter CSS and which of `stylesheetURLs` it imports. */
+function describeLinkedStylesheet(css, href, stylesheetURLs = []) {
+	const base = new URL(href, "https://master-css-delivery.invalid/");
+	const listed = new Set(stylesheetURLs.map((url) => new URL(url, base).href));
+	return {
+		href,
+		css,
+		imports: analyzeCSSDependencies(css).imports.map((imported) => imported.source).filter((specifier) => listed.has(new URL(specifier, base).href))
+	};
+}
+export { describeLinkedStylesheet };

package/dist/stylesheet/output-map.d.ts

@@ -0,0 +1,20 @@
+import { ValidationSource } from "../value-validation.js";
+import { CSSOutputMapping } from "@master/css-schema/css-directives";
+interface StylesheetOutputContext {
+  file: string;
+  source: string;
+  compilationFile: string;
+  sourceMap?: string;
+  graph?: {
+    sourceMappings?: CSSOutputMapping[];
+    sources: Record<string, string>;
+  };
+}
+declare function stylesheetOutputMap(code: string, mappings: readonly CSSOutputMapping[], context: StylesheetOutputContext, mappedLength?: number): string;
+/** The concatenation order is supplied by the owning compiler result. */
+declare function stylesheetOutputMappings(nativeCSS: string, native?: readonly CSSOutputMapping[], generated?: readonly CSSOutputMapping[]): CSSOutputMapping[];
+/** Exact graph copies also form the input map for structured lowering errors. */
+declare function stylesheetInputMap(code: string, context: StylesheetOutputContext): string;
+/** Map validation to the same authoring segments as browser devtools. */
+declare function stylesheetValidationSource(css: string, source?: string, sourceMap?: string, mappings?: readonly CSSOutputMapping[]): ValidationSource;
+export { StylesheetOutputContext, stylesheetInputMap, stylesheetOutputMap, stylesheetOutputMappings, stylesheetValidationSource };