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

package/dist/diagnostics/index.js

@@ -0,0 +1,304 @@
+import { createExtractedCSSResult, registerStylesheetSource } from "../stylesheet/index.js";
+import { discoverManifestEntries, loadProjectManifest } from "../project/manifest.js";
+import { compareProjectSnapshots } from "./project-comparison.js";
+import { createMasterCSSDesignSystemReport, inspectResolvedProjectDesignSystem } from "./design-system.js";
+import { pathToFileURL } from "node:url";
+import path from "node:path";
+import { validateClassNames } from "@master/css-tooling/validator";
+import fs from "node:fs";
+import { MasterCSSScanner } from "@master/css-tooling/scanner/node";
+import fg from "fast-glob";
+import { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, createCompilerBindingSession } from "@master/css-binding/compiler";
+// src/diagnostics/index.ts
+const MASTER_CSS_INSPECTION_REPORT_VERSION = MASTER_CSS_DIAGNOSTICS_REPORT_VERSION;
+const DEFAULT_SOURCE_PATTERNS = ["**/*.{html,htm,js,jsx,mjs,cjs,ts,tsx,mts,cts,svelte,astro,vue,md,mdx,pug,php}"];
+const DEFAULT_IGNORE_PATTERNS = ["**/node_modules/**", "node_modules"];
+async function createBindingInspectionReport(input) {
+	using compiler = await createCompilerBindingSession();
+	return await compiler.createInspectionReport(input);
+}
+function normalizeSourcePatterns(specifiedSourcePaths) {
+	return specifiedSourcePaths?.length ? specifiedSourcePaths : DEFAULT_SOURCE_PATTERNS;
+}
+function normalizeGlobPatterns(patterns) {
+	return patterns.map((pattern) => pattern.replace(/\\/g, "/"));
+}
+function resolveSourcePaths(cwd, sourcePatterns, ignore = []) {
+	return fg.sync(normalizeGlobPatterns(sourcePatterns), {
+		cwd,
+		ignore: normalizeGlobPatterns(ignore),
+		onlyFiles: true
+	}).filter(Boolean);
+}
+function parseClassChecks(value) {
+	return typeof value === "string" ? value.split(/\s+/).map((item) => item.trim()).filter(Boolean) : (value ?? []).map((item) => item.trim()).filter(Boolean);
+}
+async function resolveFilePath(cwd, filePath, resolver) {
+	return resolver ? await resolver(filePath) : path.resolve(cwd, filePath);
+}
+function preserveWorkspacePath(cwd, filePath) {
+	let realCwd;
+	try {
+		realCwd = fs.realpathSync.native(cwd);
+	} catch {
+		return filePath;
+	}
+	if (realCwd === cwd || filePath !== realCwd && !filePath.startsWith(`${realCwd}${path.sep}`)) return filePath;
+	return path.join(cwd, path.relative(realCwd, filePath));
+}
+async function registerManagedCSSEntries(scanner, stylesheetSources, baseManifest, resolveExistingFile) {
+	const entries = [];
+	const warnings = [];
+	const errors = [];
+	stylesheetSources.clear();
+	for (const entry of await discoverManifestEntries({ root: scanner.cwd })) {
+		const filePath = preserveWorkspacePath(scanner.cwd, await resolveFilePath(scanner.cwd, entry, resolveExistingFile));
+		try {
+			const result = await registerStylesheetSource(scanner, stylesheetSources, filePath, fs.readFileSync(filePath, "utf8"), {
+				baseManifest,
+				projectDir: scanner.cwd
+			});
+			const styleSource = stylesheetSources.get(filePath);
+			entries.push({
+				filePath,
+				masterCSS: Boolean(styleSource?.masterCSS),
+				pruneNativeCSS: Boolean(styleSource?.pruneNativeCSS),
+				dependencies: [...styleSource?.dependencies ?? []].map((dependency) => preserveWorkspacePath(scanner.cwd, dependency)),
+				sourceDependencies: [...styleSource?.sourceDependencies ?? []].map((dependency) => preserveWorkspacePath(scanner.cwd, dependency)),
+				warnings: result.warnings ?? [],
+				errors: []
+			});
+			warnings.push(...result.warnings ?? []);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			entries.push({
+				filePath,
+				masterCSS: false,
+				pruneNativeCSS: false,
+				dependencies: [],
+				sourceDependencies: [],
+				warnings: [],
+				errors: [message]
+			});
+			errors.push({
+				filePath,
+				message
+			});
+		}
+	}
+	scanner.resetDependencies = Array.from(stylesheetSources.values()).flatMap((source) => source.dependencies);
+	return {
+		entries,
+		warnings,
+		errors
+	};
+}
+function inspectSourceFile(classes, source, filePath, scan, firstSourceByClass) {
+	const candidates = [...new Set(scan.candidates)];
+	const latent = candidates.filter((value) => classes.latent.has(value));
+	const valid = candidates.filter((value) => classes.valid.has(value));
+	const invalid = candidates.filter((value) => classes.invalid.has(value));
+	const usedNative = candidates.filter((value) => classes.usedNative.has(value));
+	for (const className of [
+		...latent,
+		...valid,
+		...invalid,
+		...usedNative
+	]) if (!firstSourceByClass.has(className)) firstSourceByClass.set(className, filePath);
+	return {
+		filePath,
+		source,
+		scanned: true,
+		changed: scan.changed,
+		discovered: {
+			latent,
+			valid,
+			invalid,
+			usedNative
+		}
+	};
+}
+async function inspectProject(options, capture) {
+	const cwd = path.resolve(options.cwd || process.cwd());
+	const classChecks = parseClassChecks(options.classes);
+	const specifiedPatterns = options.patterns;
+	const sourcePatterns = normalizeSourcePatterns(specifiedPatterns);
+	options.validatePatterns?.(sourcePatterns);
+	const scanner = new MasterCSSScanner({
+		manifest: options.manifest,
+		exclude: specifiedPatterns?.length ? void 0 : DEFAULT_IGNORE_PATTERNS,
+		verbose: 0
+	}, cwd);
+	const stylesheetSources = /* @__PURE__ */ new Map();
+	const firstSourceByClass = /* @__PURE__ */ new Map();
+	let reportInput;
+	let stylesheetInspection;
+	let snapshot;
+	let designSystem;
+	try {
+		let projectManifest = options.manifest;
+		let projectError;
+		try {
+			const project = await loadProjectManifest({
+				root: cwd,
+				baseManifest: options.manifest,
+				includeSourceGraph: Boolean(options.designSystem)
+			});
+			projectManifest = project.manifest;
+			if (options.designSystem) designSystem = await inspectResolvedProjectDesignSystem(project, cwd, options);
+		} catch (error) {
+			projectError = error;
+		}
+		if (projectError && options.designSystem) throw projectError;
+		await scanner.init({
+			...scanner.customOptions,
+			manifest: projectManifest
+		});
+		stylesheetInspection = await registerManagedCSSEntries(scanner, stylesheetSources, options.manifest, options.resolveExistingFile);
+		if (projectError) throw projectError;
+		const sourcePaths = resolveSourcePaths(cwd, sourcePatterns, options.ignore ?? (specifiedPatterns?.length ? [] : scanner.options.exclude)).filter((source) => scanner.isSourceAllowed(source, { explicit: Boolean(specifiedPatterns?.length) }));
+		const resolvedSourcePaths = await Promise.all(sourcePaths.map((source) => resolveFilePath(cwd, source, options.resolveExistingFile)));
+		const scans = await Promise.all(sourcePaths.map((source, index) => scanner.scanSource(source, fs.readFileSync(resolvedSourcePaths[index], "utf8"))));
+		const classes = {
+			latent: new Set(scanner.latentClasses),
+			valid: new Set(scanner.validClasses),
+			invalid: new Set(scanner.invalidClasses),
+			usedNative: new Set(scanner.usedNativeClasses)
+		};
+		const files = sourcePaths.map((source, index) => inspectSourceFile(classes, source, resolvedSourcePaths[index], scans[index], firstSourceByClass));
+		const entry = pathToFileURL(path.join(cwd, "master.snapshot.css")).href;
+		const delivery = capture ? {
+			entryURL: entry,
+			stylesheetURL: (file, variant) => `${pathToFileURL(file).href}${variant ? `?variant=${encodeURIComponent(variant)}` : ""}`,
+			resourceURL: (file) => pathToFileURL(file).href
+		} : void 0;
+		const cssResult = await createExtractedCSSResult({
+			scanner,
+			stylesheetSources,
+			baseManifest: options.manifest,
+			projectDir: scanner.cwd,
+			delivery
+		});
+		const safelist = scanner.options.safelist ?? [];
+		const blocklist = scanner.options.blocklist ?? [];
+		if (capture) {
+			if (stylesheetInspection.errors.length) throw new Error("Cannot capture a project with stylesheet errors.");
+			const delivered = cssResult;
+			const native = await createExtractedCSSResult({
+				scanner,
+				stylesheetSources,
+				baseManifest: options.manifest,
+				projectDir: cwd,
+				delivery,
+				includeGeneratedCSS: false
+			});
+			const resolvedSources = new Map(files.map((file) => [file.source, file.filePath]));
+			const consumers = /* @__PURE__ */ new Map();
+			for (const source of scanner.sources) {
+				const identity = source.parentSource ?? source.source;
+				const file = resolvedSources.get(identity) ?? identity;
+				const candidates = consumers.get(file) ?? /* @__PURE__ */ new Set();
+				for (const name of source.candidates) if (Object.values(classes).some((group) => group.has(name))) candidates.add(name);
+				consumers.set(file, candidates);
+			}
+			snapshot = {
+				version: 1,
+				manifest: scanner.manifest,
+				sources: [...[...consumers].map(([path, classes]) => ({
+					path,
+					classes: [...classes]
+				})), {
+					path: "master:safelist",
+					classes: [...safelist]
+				}],
+				stylesheets: [{
+					path: entry,
+					css: native.css
+				}, ...(native.stylesheets ?? []).map((asset) => ({
+					path: asset.href,
+					css: asset.css
+				}))],
+				outputs: [{
+					path: entry,
+					css: delivered.css
+				}, ...(delivered.stylesheets ?? []).map((asset) => ({
+					path: asset.href,
+					css: asset.css
+				}))],
+				excluded: [...options.ignore ?? scanner.options.exclude ?? [], ...blocklist.map(String)],
+				unresolved: ["Class names constructed dynamically and remote content are not exhaustively enumerated.", `Only source patterns ${JSON.stringify(sourcePatterns)} and discovered stylesheet entries are included.`]
+			};
+		}
+		reportInput = {
+			version: MASTER_CSS_DIAGNOSTICS_REPORT_VERSION,
+			cwd,
+			patterns: sourcePatterns,
+			files,
+			classes: classChecks,
+			inspections: (await validateClassNames([.../* @__PURE__ */ new Set([
+				...scanner.latentClasses,
+				...scanner.validClasses,
+				...scanner.invalidClasses,
+				...classChecks
+			])].filter((name) => !scanner.usedNativeClasses.has(name)), { manifest: scanner.manifest })).classes,
+			scanner: {
+				latent: [...scanner.latentClasses],
+				valid: [...scanner.validClasses],
+				invalid: [...scanner.invalidClasses],
+				native: [...scanner.nativeClassNames],
+				usedNative: [...scanner.usedNativeClasses],
+				safelist,
+				blocklist: blocklist.map((entry) => entry instanceof RegExp ? {
+					source: entry.source,
+					flags: entry.flags
+				} : entry),
+				resetDependencies: scanner.resetDependencies
+			},
+			stylesheets: stylesheetInspection,
+			css: {
+				included: Boolean(options.includeCss),
+				text: cssResult.css,
+				variables: Object.keys(cssResult.emittedGlobals.variables),
+				keyframes: Object.keys(cssResult.emittedGlobals.keyframes)
+			},
+			firstSourceByClass: Object.fromEntries(firstSourceByClass)
+		};
+	} catch (error) {
+		if (options.designSystem && !designSystem) throw error;
+		snapshot = void 0;
+		reportInput = {
+			version: MASTER_CSS_DIAGNOSTICS_REPORT_VERSION,
+			cwd,
+			patterns: sourcePatterns,
+			files: [],
+			classes: classChecks,
+			scanner: {},
+			stylesheets: stylesheetInspection ?? {},
+			css: {},
+			fatalError: error instanceof Error ? error.message : String(error)
+		};
+	} finally {
+		await scanner.dispose();
+	}
+	const report = await createBindingInspectionReport(reportInput);
+	return {
+		report: designSystem ? {
+			...report,
+			designSystem
+		} : report,
+		snapshot
+	};
+}
+async function createMasterCSSInspectionReport(options) {
+	return (await inspectProject(options, false)).report;
+}
+/** Capture known project consumers and resolved CSS assets in one inspection session. */
+async function captureMasterCSSProject(options) {
+	const { report, snapshot } = await inspectProject(options, true);
+	if (!snapshot) throw new Error(`Cannot capture project snapshot: ${report.diagnostics.map((item) => item.message).join("; ")}`);
+	return {
+		report,
+		snapshot
+	};
+}
+export { MASTER_CSS_INSPECTION_REPORT_VERSION, captureMasterCSSProject, compareProjectSnapshots, createMasterCSSDesignSystemReport, createMasterCSSInspectionReport };

package/dist/diagnostics/project-comparison.d.ts

@@ -0,0 +1,4 @@
+import { MasterCSSProjectComparison, MasterCSSProjectComparisonRequest } from "../index.js";
+/** Compare prepared project states without reading files or evaluating browser styles. */
+declare function compareProjectSnapshots(request: MasterCSSProjectComparisonRequest): Promise<MasterCSSProjectComparison>;
+export { compareProjectSnapshots };

package/dist/diagnostics/project-comparison.js

@@ -0,0 +1,8 @@
+import { createCompiler } from "../index.js";
+// src/diagnostics/project-comparison.ts
+/** Compare prepared project states without reading files or evaluating browser styles. */
+async function compareProjectSnapshots(request) {
+	using compiler = await createCompiler();
+	return compiler.compareProjectSnapshots(request);
+}
+export { compareProjectSnapshots };

package/dist/index.d.ts

@@ -0,0 +1,95 @@
+import { MasterCSSDiagnostic } from "@master/css-schema";
+import { MasterCSSProjectAssetChange, MasterCSSProjectComparison, MasterCSSProjectComparisonRequest, MasterCSSProjectSnapshot } from "@master/css-binding/compiler";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { MasterCSSBinding, MasterCSSWasmBindingLoadOptions } from "@master/css-binding";
+import { MasterCSSCompiler, MasterCSSCompiler as MasterCSSCompiler$1 } from "./compiler.js";
+interface MasterCSSCompilerOptions {
+  readonly binding?: MasterCSSBinding;
+  readonly wasm?: MasterCSSWasmBindingLoadOptions;
+}
+interface MasterCSSCompileOptions {
+  readonly classes?: readonly string[];
+  readonly from?: string;
+  readonly preserveNativeCSS?: boolean;
+  /** Opt in to pruning native rules in project-owned files. */
+  readonly pruneNativeCSS?: boolean;
+  /** Keep untouched native source for host transforms; incompatible with class pruning. */
+  readonly preserveNativeSource?: boolean;
+  /** Report CSS value errors by default; error rejects the complete output. */
+  readonly validation?: 'report' | 'error';
+  readonly onDiagnostic?: (diagnostic: MasterCSSDiagnostic) => void;
+}
+interface MasterCSSCompileResult {
+  /** Serialized map v3 for css when produced by a stylesheet host. */
+  readonly sourceMap?: string;
+  readonly css: string;
+  readonly nativeCSS: string;
+  readonly generatedCSS: string;
+  readonly classNames: readonly string[];
+  readonly nativeClassNames: readonly string[];
+  readonly dependencies: readonly string[];
+  readonly diagnostics: readonly MasterCSSDiagnostic[];
+  readonly directiveSummary: Readonly<{
+    readonly manifestInput: Readonly<{
+      readonly keys: readonly string[];
+      readonly counts: Readonly<Record<string, number>>;
+    }>;
+    readonly styleDefinitions: number;
+    readonly extractionPolicy: Readonly<{
+      readonly include: readonly string[];
+      readonly exclude: readonly string[];
+      readonly safelist: readonly string[];
+      readonly safelistKeyframes: readonly string[];
+      readonly blocklist: readonly (string | RegExp)[];
+      readonly preserveNative: boolean;
+      readonly pruneNative: boolean;
+    }>;
+  }>;
+}
+interface MasterCSSCompileManifestOptions extends MasterCSSCompileOptions {
+  readonly baseManifest: MasterCSSManifest;
+}
+interface MasterCSSCompileManifestResult extends MasterCSSCompileResult {
+  readonly manifest: MasterCSSManifest;
+  readonly directives: MasterCSSCompileResult;
+}
+/**
+ * Prepared files/edges and delivery URLs for boundary-preserving compilation.
+ * Resolve @reference inputs into resolutionManifest before calling this API.
+ * Supply resourceURLs to relocate parsed url()/image-set() resources before definition merging.
+ * Without that map, delivery URLs must retain the original resource bases.
+ */
+type MasterCSSCompileStylesheetsRequest = import('@master/css-binding/compiler').MasterCSSCompileStylesheetGraphRequest;
+interface MasterCSSCompileStylesheetsResult extends MasterCSSCompileManifestResult {
+  readonly entry: string;
+  /** Every stylesheet must be delivered at its href, including the entry. */
+  readonly stylesheets: readonly Readonly<import('@master/css-binding/compiler').MasterCSSCompiledStylesheet>[];
+}
+/** Prepare source boundaries before the host assigns final asset URLs. */
+type MasterCSSPrepareStylesheetBundleRequest = import('@master/css-binding/compiler').MasterCSSPrepareStylesheetBundleRequest;
+type MasterCSSStylesheetBundle = import('@master/css-binding/compiler').MasterCSSStylesheetBundle;
+/** Render all assets; relative ordinary resources/imports require explicit URL mappings. */
+type MasterCSSRenderStylesheetBundleRequest = import('@master/css-binding/compiler').MasterCSSRenderStylesheetBundleRequest;
+type MasterCSSStylesheetAsset = import('@master/css-binding/compiler').MasterCSSStylesheetAsset;
+interface MasterCSSCompilerInspection {
+  readonly hasMasterCSSImport: boolean;
+  readonly hasMasterEntry: boolean;
+  readonly directives: readonly {
+    readonly name: string;
+    readonly range: {
+      readonly start: number;
+      readonly end: number;
+    };
+    readonly preludeRange: {
+      readonly start: number;
+      readonly end: number;
+    };
+    readonly hasBlock: boolean;
+    readonly quotedStrings: number;
+  }[];
+}
+declare function createCompiler(options?: MasterCSSCompilerOptions): Promise<MasterCSSCompiler$1>;
+declare function inspectCSS(source: string): Promise<MasterCSSCompilerInspection>;
+declare function compileCSS(source: string, options?: MasterCSSCompileOptions): Promise<MasterCSSCompileResult>;
+declare function compileManifest(source: string, options: MasterCSSCompileManifestOptions): Promise<MasterCSSCompileManifestResult>;
+export { MasterCSSCompileManifestOptions, MasterCSSCompileManifestResult, MasterCSSCompileOptions, MasterCSSCompileResult, MasterCSSCompileStylesheetsRequest, MasterCSSCompileStylesheetsResult, MasterCSSCompiler, MasterCSSCompilerInspection, MasterCSSCompilerOptions, MasterCSSPrepareStylesheetBundleRequest, type MasterCSSProjectAssetChange, type MasterCSSProjectComparison, type MasterCSSProjectComparisonRequest, type MasterCSSProjectSnapshot, MasterCSSRenderStylesheetBundleRequest, MasterCSSStylesheetAsset, MasterCSSStylesheetBundle, compileCSS, compileManifest, createCompiler, inspectCSS };

package/dist/index.js

@@ -0,0 +1,34 @@
+import { MasterCSSCompiler, bindCompilerSessionInternal } from "./compiler.js";
+import { createCompilerBindingSession } from "./session.js";
+// src/index.ts
+async function createCompiler(options = {}) {
+	return bindCompilerSessionInternal(await createCompilerBindingSession({
+		binding: options.binding,
+		wasm: options.wasm
+	}));
+}
+async function inspectCSS(source) {
+	const compiler = await createCompiler();
+	try {
+		return compiler.inspectCSS(source);
+	} finally {
+		compiler.dispose();
+	}
+}
+async function compileCSS(source, options = {}) {
+	const compiler = await createCompiler();
+	try {
+		return compiler.compileCSS(source, options);
+	} finally {
+		compiler.dispose();
+	}
+}
+async function compileManifest(source, options) {
+	const compiler = await createCompiler();
+	try {
+		return compiler.compileManifest(source, options);
+	} finally {
+		compiler.dispose();
+	}
+}
+export { MasterCSSCompiler, compileCSS, compileManifest, createCompiler, inspectCSS };

package/dist/node-compiler.d.ts

@@ -0,0 +1,133 @@
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { CSSReferenceStatement, CSSReferenceStatement as CSSReferenceStatement$1, CompileCSSFileOptions, CompileCSSFileOptions as CompileCSSFileOptions$1, CompileCSSOptions, CompileCSSOptions as CompileCSSOptions$1, CompileCSSResult, CompileCSSResult as CompileCSSResult$1, ResolvedCSSImportGraph, ResolvedCSSImportGraph as ResolvedCSSImportGraph$1 } from "./contracts.js";
+import { CSSDefinitionSource, CSSDirectiveExtractionPolicy, CSSDirectiveReference } from "@master/css-schema/css-directives";
+import { PreparedCSSImportGraph, resolveMasterCSSPackageEntryFile } from "./node-imports.js";
+interface CSSDependencyImport {
+  start: number;
+  end: number;
+  statement: string;
+  source: string;
+}
+interface CSSDependencyAnalysis {
+  sourceWithoutReferences: string;
+  imports: CSSDependencyImport[];
+  resources: {
+    start: number;
+    end: number;
+    url: string;
+  }[];
+  usesCustomMedia?: boolean;
+}
+interface InspectCSSResult {
+  hasMasterCSSImport: boolean;
+  hasMasterEntry: boolean;
+  directives: {
+    name: string;
+    range: {
+      start: number;
+      end: number;
+    };
+    preludeRange: {
+      start: number;
+      end: number;
+    };
+    hasBlock: boolean;
+    quotedStrings: number;
+  }[];
+}
+interface ResolveCSSImportGraphOptions {
+  onDependency?: (file: string) => void;
+  onSource?: (file: string, source: string) => void;
+  projectDir?: string;
+  expandPackageImports?: boolean;
+  onReference?: (reference: CSSReferenceStatement$1, fromFile: string) => void;
+}
+type CompileCSSManifestOptions = CompileCSSFileOptions$1 & {
+  baseManifest?: MasterCSSManifest;
+};
+type CompileCSSManifestSourceOptions = CompileCSSOptions$1 & {
+  baseManifest?: MasterCSSManifest;
+  root?: string;
+};
+type CompileCSSManifestInternalOptions = CompileCSSManifestSourceOptions & {
+  /** Host context definitions retain file URL owners until the host publishes assets. */
+  resolveReferenceResources?: boolean;
+  definitionsOnly?: boolean;
+  referenceResources?: boolean;
+  referenceStack?: string[];
+  sourceText?: string;
+  onDependency?: (file: string) => void;
+};
+interface CompileCSSManifestResult extends Omit<CompileCSSResult$1, 'manifestInput'> {
+  sourceTexts?: Record<string, string>;
+  manifest: MasterCSSManifest;
+  resolutionManifest: MasterCSSManifest;
+  directives: CompileCSSResult$1;
+}
+interface CompileProjectManifestResult extends CompileCSSManifestResult {
+  entries: string[];
+}
+declare function inspectCSS(source: string): InspectCSSResult;
+declare function resolveCSSImportGraph(file: string, options?: ResolveCSSImportGraphOptions): ResolvedCSSImportGraph$1;
+declare function resolveCSSImportGraphSource(file: string, source: string | undefined, options?: ResolveCSSImportGraphOptions): ResolvedCSSImportGraph$1;
+declare function analyzeCSSDependencies(source: string): CSSDependencyAnalysis;
+declare function resolveMasterCSSPackageImportGraph(projectDir?: string): ResolvedCSSImportGraph$1;
+declare function stripRequestSuffix(id: string): string;
+declare function stripWindowsExtendedPathPrefix(file: string): string;
+declare function isMasterCSSPackageStyleFile(id: string, projectDir?: string): boolean;
+declare function compileCSS(source: string, options?: CompileCSSOptions$1): CompileCSSResult$1;
+declare function filterCSSExtractionCandidates(candidates: string[], blocklist?: Iterable<string | RegExp>): string[];
+declare function mergeCSSDirectiveExtractionPolicy(...policies: (Partial<CSSDirectiveExtractionPolicy> | undefined)[]): CSSDirectiveExtractionPolicy;
+declare function createCSSDirectiveExtractionPolicy(): CSSDirectiveExtractionPolicy;
+interface StandaloneCSSDirectiveStatement {
+  start: number;
+  end: number;
+  atRuleName: 'master' | 'source' | 'safelist' | 'blocklist' | 'preserve';
+  name: string;
+  statement: string;
+  args: string[];
+  modifiers: string[];
+}
+declare function findStandaloneCSSDirectiveStatements(source: string): StandaloneCSSDirectiveStatement[];
+declare function collectStandaloneCSSDirectiveExtractionPolicy(source: string): CSSDirectiveExtractionPolicy;
+declare function removeStandaloneCSSDirectives(source: string): string;
+declare function resolveCSSReferenceFile(reference: CSSDirectiveReference & {
+  resolvedFile?: string;
+}, options?: CompileCSSManifestSourceOptions): string;
+/** Compile original files independently before merging their manifest and native output. */
+declare function compileCSSManifestGraph(graph: PreparedCSSImportGraph, options?: CompileCSSManifestInternalOptions & {
+  mapReferences?: (file: string, source: string, references: CSSDirectiveReference[]) => readonly CSSDirectiveReference[];
+}): {
+  notices?: import("@master/css-schema/css-directives").CSSDirectiveNotice[];
+  definitionSources?: CSSDefinitionSource[];
+  nativeOutput?: import("@master/css-schema/css-directives").CSSNativeOutput;
+  sourceMap?: string;
+  nativeMappings?: import("@master/css-schema/css-directives").CSSOutputMapping[];
+  generatedMappings?: import("@master/css-schema/css-directives").CSSOutputMapping[];
+  manifestInput: import("@master/css-schema/css-directives").CSSDirectiveManifestInput;
+  extractionPolicy: CSSDirectiveExtractionPolicy;
+  classNames: string[];
+  nativeClassNames: string[];
+  nativeCSS: string;
+  generatedCSS: string;
+  references?: CSSDirectiveReference[];
+  styleDefinitions?: import("@master/css-schema/css-directives").CSSDirectiveStyleDefinition[];
+  dependencies: string[];
+  warnings: string[];
+  css: string;
+  outputMappings: import("@master/css-schema/css-directives").CSSOutputMapping[];
+  sourceTexts: Record<string, string>;
+  manifest: MasterCSSManifest;
+  resolutionManifest: MasterCSSManifest;
+  directives: import("@master/css-schema/css-directives").CSSDirectiveResult;
+  stylesheets: import("@master/css-binding/protocol").MasterCSSCompiledStylesheet[];
+};
+declare function createManifestFromCSSResult(result: CompileCSSResult$1, options?: CompileCSSManifestSourceOptions & {
+  sourceText?: string;
+  onDependency?: (file: string) => void;
+  resolveReferenceResources?: boolean;
+}): CompileCSSManifestResult;
+declare function compileCSSManifest(source: string, options?: CompileCSSManifestSourceOptions): CompileCSSManifestResult;
+declare function compileCSSManifestFile(file: string, options?: CompileCSSManifestOptions): CompileCSSManifestResult;
+declare function compileProjectManifest(entries: string[], options?: CompileCSSManifestOptions): CompileProjectManifestResult;
+export { CSSDependencyAnalysis, CSSDependencyImport, type CSSReferenceStatement, type CompileCSSFileOptions, CompileCSSManifestOptions, CompileCSSManifestResult, CompileCSSManifestSourceOptions, type CompileCSSOptions, type CompileCSSResult, CompileProjectManifestResult, InspectCSSResult, ResolveCSSImportGraphOptions, type ResolvedCSSImportGraph, StandaloneCSSDirectiveStatement, analyzeCSSDependencies, collectStandaloneCSSDirectiveExtractionPolicy, compileCSS, compileCSSManifest, compileCSSManifestFile, compileCSSManifestGraph, compileProjectManifest, createCSSDirectiveExtractionPolicy, createManifestFromCSSResult, filterCSSExtractionCandidates, findStandaloneCSSDirectiveStatements, inspectCSS, isMasterCSSPackageStyleFile, mergeCSSDirectiveExtractionPolicy, removeStandaloneCSSDirectives, resolveCSSImportGraph, resolveCSSImportGraphSource, resolveCSSReferenceFile, resolveMasterCSSPackageEntryFile, resolveMasterCSSPackageImportGraph, stripRequestSuffix, stripWindowsExtendedPathPrefix };