@master/css-compiler 2.0.0-rc.73 → 2.0.0-rc.74

package/dist/css-transform.d.ts

@@ -1,6 +1,10 @@
-import type * as LightningCSS from 'lightningcss';
-export type CSSTransform = typeof LightningCSS.transform;
-export declare function setCSSTransform(transformer: CSSTransform): void;
-export declare function getCSSTransform(): typeof LightningCSS.transform;
-export declare function encodeCSS(source: string): Uint8Array<ArrayBuffer>;
-export declare function decodeCSS(code: Uint8Array): string;
+import * as LightningCSS from "lightningcss";
+
+//#region src/css-transform.d.ts
+type CSSTransform = typeof LightningCSS.transform;
+declare function setCSSTransform(transformer: CSSTransform): void;
+declare function getCSSTransform(): typeof LightningCSS.transform;
+declare function encodeCSS(source: string): Uint8Array<ArrayBuffer>;
+declare function decodeCSS(code: Uint8Array): string;
+//#endregion
+export { CSSTransform, decodeCSS, encodeCSS, getCSSTransform, setCSSTransform };

package/dist/css-transform.js

@@ -0,0 +1,17 @@
+//#region src/css-transform.ts
+let transform;
+function setCSSTransform(transformer) {
+	transform = transformer;
+}
+function getCSSTransform() {
+	if (!transform) throw new Error("@master/css-compiler requires a CSS transform implementation. Use the default Node entry or initialize the browser entry.");
+	return transform;
+}
+function encodeCSS(source) {
+	return new TextEncoder().encode(source);
+}
+function decodeCSS(code) {
+	return new TextDecoder().decode(code);
+}
+//#endregion
+export { decodeCSS, encodeCSS, getCSSTransform, setCSSTransform };

package/dist/diagnostics.d.ts

@@ -0,0 +1,11 @@
+//#region src/diagnostics.d.ts
+interface CompilerDiagnosticRecorder {
+  time<T>(metricId: string, callback: () => T): T;
+  addCount(metricId: string, value?: number): void;
+  setCount(metricId: string, value: number): void;
+}
+declare function timeCompilerDiagnostic<T>(diagnostics: CompilerDiagnosticRecorder | undefined, metricId: string, callback: () => T): T;
+declare function addCompilerDiagnosticCount(diagnostics: CompilerDiagnosticRecorder | undefined, metricId: string, value?: number): void;
+declare function setCompilerDiagnosticCount(diagnostics: CompilerDiagnosticRecorder | undefined, metricId: string, value: number): void;
+//#endregion
+export { CompilerDiagnosticRecorder, addCompilerDiagnosticCount, setCompilerDiagnosticCount, timeCompilerDiagnostic };

package/dist/diagnostics.js

@@ -0,0 +1,12 @@
+//#region src/diagnostics.ts
+function timeCompilerDiagnostic(diagnostics, metricId, callback) {
+	return diagnostics ? diagnostics.time(metricId, callback) : callback();
+}
+function addCompilerDiagnosticCount(diagnostics, metricId, value = 1) {
+	diagnostics?.addCount(metricId, value);
+}
+function setCompilerDiagnosticCount(diagnostics, metricId, value) {
+	diagnostics?.setCount(metricId, value);
+}
+//#endregion
+export { addCompilerDiagnosticCount, setCompilerDiagnosticCount, timeCompilerDiagnostic };

package/dist/index.d.ts

@@ -1,46 +1,49 @@
-import type { MasterCSSManifest } from '@master/css-schema/manifest';
-import { type CompileCSSOptions, type CSSReferenceStatement, type CompileCSSFileOptions, type CompileCSSResult, type ResolvedCSSImportGraph } from './core';
-export * from './core';
-export type { CompileCSSFileOptions, CompileCSSOptions, CompileCSSResult, CSSReferenceStatement, ResolvedCSSImportGraph, StandaloneCSSDirectiveStatement, StandaloneMasterDirectiveStatement } from './core';
-export interface InspectCSSResult {
-    hasMasterEntryDirective: boolean;
-    hasMasterCSSImport: boolean;
-    hasMasterEntry: boolean;
+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, StandaloneCSSDirectiveStatement, StandaloneMasterDirectiveStatement } from "./core.js";
+export * from "./core.js";
+
+//#region src/index.d.ts
+interface InspectCSSResult {
+  hasMasterEntryDirective: boolean;
+  hasMasterCSSImport: boolean;
+  hasMasterEntry: boolean;
 }
-export interface ResolveCSSImportGraphOptions {
-    projectDir?: string;
-    expandPackageImports?: boolean;
-    onReference?: (reference: CSSReferenceStatement, fromFile: string) => void;
+interface ResolveCSSImportGraphOptions {
+  projectDir?: string;
+  expandPackageImports?: boolean;
+  onReference?: (reference: CSSReferenceStatement$1, fromFile: string) => void;
 }
-export type CompileCSSManifestOptions = CompileCSSFileOptions & {
-    baseManifest?: MasterCSSManifest;
+type CompileCSSManifestOptions = CompileCSSFileOptions$1 & {
+  baseManifest?: MasterCSSManifest;
 };
-export type CompileCSSManifestSourceOptions = CompileCSSOptions & {
-    baseManifest?: MasterCSSManifest;
-    root?: string;
+type CompileCSSManifestSourceOptions = CompileCSSOptions$1 & {
+  baseManifest?: MasterCSSManifest;
+  root?: string;
 };
-export interface CompileCSSManifestResult extends Omit<CompileCSSResult, 'manifestInput'> {
-    manifest: MasterCSSManifest;
-    directives: CompileCSSResult;
+interface CompileCSSManifestResult extends Omit<CompileCSSResult$1, 'manifestInput'> {
+  manifest: MasterCSSManifest;
+  directives: CompileCSSResult$1;
 }
-export interface CompileProjectManifestResult extends CompileCSSManifestResult {
-    entries: string[];
+interface CompileProjectManifestResult extends CompileCSSManifestResult {
+  entries: string[];
 }
-export type CompileCSSManifestJSONResult = CompileCSSManifestResult & {
-    json: string;
-    directives: CompileCSSResult;
+type CompileCSSManifestJSONResult = CompileCSSManifestResult & {
+  json: string;
+  directives: CompileCSSResult$1;
 };
-export declare function resolveMasterCSSPackageEntryFile(importSource: string, fromFile?: string, projectDir?: string): string | undefined;
-export declare function inspectCSS(source: string): InspectCSSResult;
-export declare function resolveCSSImportGraph(file: string, options?: ResolveCSSImportGraphOptions): ResolvedCSSImportGraph;
-export declare function resolveMasterCSSPackageImportGraph(projectDir?: string): ResolvedCSSImportGraph;
-export declare function isMasterCSSPackageStyleFile(id: string, projectDir?: string): boolean;
-export declare function compileCSSFile(file: string, options?: CompileCSSFileOptions): CompileCSSResult;
-export declare function createManifestFromCSSResult(result: CompileCSSResult, options?: CompileCSSManifestSourceOptions): CompileCSSManifestResult;
-export declare function compileCSSManifest(source: string, options?: CompileCSSManifestSourceOptions): CompileCSSManifestResult;
-export declare function compileCSSManifestFile(file: string, options?: CompileCSSManifestOptions): CompileCSSManifestResult;
-export declare function compileProjectManifest(entries: string[], options?: CompileCSSManifestOptions): CompileProjectManifestResult;
-export declare function compileCSSManifestJSON(file: string, options?: CompileCSSManifestOptions): CompileCSSManifestJSONResult;
-export declare function compileProjectManifestJSON(entries: string[], options?: CompileCSSManifestOptions): CompileProjectManifestResult & {
-    json: string;
+declare function resolveMasterCSSPackageEntryFile(importSource: string, fromFile?: string, projectDir?: string): string | undefined;
+declare function inspectCSS(source: string): InspectCSSResult;
+declare function resolveCSSImportGraph(file: string, options?: ResolveCSSImportGraphOptions): ResolvedCSSImportGraph$1;
+declare function resolveMasterCSSPackageImportGraph(projectDir?: string): ResolvedCSSImportGraph$1;
+declare function isMasterCSSPackageStyleFile(id: string, projectDir?: string): boolean;
+declare function compileCSSFile(file: string, options?: CompileCSSFileOptions$1): CompileCSSResult$1;
+declare function createManifestFromCSSResult(result: CompileCSSResult$1, options?: CompileCSSManifestSourceOptions): 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;
+declare function compileCSSManifestJSON(file: string, options?: CompileCSSManifestOptions): CompileCSSManifestJSONResult;
+declare function compileProjectManifestJSON(entries: string[], options?: CompileCSSManifestOptions): CompileProjectManifestResult & {
+  json: string;
 };
+//#endregion
+export { type CSSReferenceStatement, type CompileCSSFileOptions, CompileCSSManifestJSONResult, CompileCSSManifestOptions, CompileCSSManifestResult, CompileCSSManifestSourceOptions, type CompileCSSOptions, type CompileCSSResult, CompileProjectManifestResult, InspectCSSResult, ResolveCSSImportGraphOptions, type ResolvedCSSImportGraph, type StandaloneCSSDirectiveStatement, type StandaloneMasterDirectiveStatement, compileCSSFile, compileCSSManifest, compileCSSManifestFile, compileCSSManifestJSON, compileProjectManifest, compileProjectManifestJSON, createManifestFromCSSResult, inspectCSS, isMasterCSSPackageStyleFile, resolveCSSImportGraph, resolveMasterCSSPackageEntryFile, resolveMasterCSSPackageImportGraph };

package/dist/index.js

@@ -0,0 +1,330 @@
+import { setCSSTransform } from "./css-transform.js";
+import { collectStandaloneCSSDirectiveExtractionPolicy, createCSSDirectiveExtractionPolicy, findStandaloneCSSDirectiveStatements, findStandaloneMasterDirectiveStatements, mergeCSSDirectiveExtractionPolicy, removeStandaloneCSSDirectives, removeStandaloneMasterDirectives } from "./lexer/standalone-master.js";
+import { compileCSS, findCSSReferenceStatements, maskManagedPatternEntryNames, parseDirectives, removeCSSReferenceStatements } from "./core.js";
+import { createMasterCSSManifest } from "./master-css-manifest.js";
+import lowerCSSDirectives from "./lower-css-directives.js";
+import { findCSSImportStatements, removeCSSImportStatements, replaceCSSImportStatements } from "./lexer/imports.js";
+import { createRequire } from "node:module";
+import { MASTER_CSS_ENTRY_DIRECTIVE_NAME } from "@master/css-lexer";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, extname, isAbsolute, resolve } from "node:path";
+import { transform } from "lightningcss";
+import { stringifyMasterCSSManifestJSON } from "@master/css-schema/manifest-json";
+//#region src/index.ts
+setCSSTransform(transform);
+const require = createRequire(import.meta.url);
+const MASTER_CSS_PACKAGE_ID = "@master/css";
+const MASTER_CSS_PACKAGE_IDS = /* @__PURE__ */ new Set([MASTER_CSS_PACKAGE_ID, "@master/css-preset"]);
+function isExpandableImportSource(source) {
+	return (source.startsWith("./") || source.startsWith("../")) && extname(source) === ".css";
+}
+function readJSONFile(file) {
+	return JSON.parse(readFileSync(file, "utf-8"));
+}
+function findPackageRoot(entryFile, packageName) {
+	let directory = dirname(entryFile);
+	while (true) {
+		const packageJSONFile = resolve(directory, "package.json");
+		if (existsSync(packageJSONFile)) try {
+			const packageJSON = readJSONFile(packageJSONFile);
+			if (packageJSON.name === packageName) return {
+				directory,
+				packageJSON
+			};
+		} catch {}
+		const parentDirectory = dirname(directory);
+		if (parentDirectory === directory) return;
+		directory = parentDirectory;
+	}
+}
+function getPackageStyleEntry(packageJSON) {
+	if (typeof packageJSON.style === "string") return packageJSON.style;
+	if (!packageJSON.exports || typeof packageJSON.exports !== "object") return;
+	const rootExport = packageJSON.exports["."];
+	if (!rootExport || typeof rootExport !== "object") return;
+	const styleExport = rootExport.style;
+	return typeof styleExport === "string" ? styleExport : void 0;
+}
+function createProjectRequire(fromFile, projectDir) {
+	return createRequire(resolve(projectDir || dirname(fromFile), "package.json"));
+}
+function resolveMasterCSSPackageEntryFile(importSource, fromFile = process.cwd(), projectDir) {
+	if (!MASTER_CSS_PACKAGE_IDS.has(importSource)) return;
+	const resolver = createProjectRequire(fromFile, projectDir);
+	let packageEntryFile;
+	try {
+		packageEntryFile = resolver.resolve(importSource);
+	} catch {
+		packageEntryFile = require.resolve(importSource);
+	}
+	const packageRoot = findPackageRoot(packageEntryFile, importSource);
+	if (!packageRoot) return;
+	const styleEntry = getPackageStyleEntry(packageRoot.packageJSON);
+	if (!styleEntry) return;
+	const styleFile = resolve(packageRoot.directory, styleEntry);
+	if (!existsSync(styleFile)) throw new Error(`${importSource} CSS style entry was not found: ${styleFile}`);
+	return styleFile;
+}
+function inspectCSS(source) {
+	const hasMasterEntryDirective = findStandaloneMasterDirectiveStatements(source).some((statement) => statement.name === MASTER_CSS_ENTRY_DIRECTIVE_NAME);
+	const hasMasterCSSImport = findCSSImportStatements(source).some((statement) => statement.source === MASTER_CSS_PACKAGE_ID);
+	return {
+		hasMasterEntryDirective,
+		hasMasterCSSImport,
+		hasMasterEntry: hasMasterEntryDirective || hasMasterCSSImport
+	};
+}
+function resolveCSSImportGraphFile(file, dependencies, dependencySet, stack, options = {}) {
+	const absoluteFile = resolve(file);
+	if (stack.includes(absoluteFile)) throw new Error(`Circular CSS import: ${[...stack, absoluteFile].join(" -> ")}`);
+	if (!existsSync(absoluteFile)) throw new Error(`CSS manifest entry file not found: ${absoluteFile}`);
+	if (!dependencySet.has(absoluteFile)) {
+		dependencySet.add(absoluteFile);
+		dependencies.push(absoluteFile);
+	}
+	const source = readFileSync(absoluteFile, "utf-8");
+	const references = findCSSReferenceStatements(source, absoluteFile);
+	for (const reference of references) options.onReference?.(reference, absoluteFile);
+	const sourceWithoutReferences = removeCSSReferenceStatements(source, absoluteFile);
+	const imports = findCSSImportStatements(sourceWithoutReferences, absoluteFile);
+	if (!imports.length) return sourceWithoutReferences;
+	const preservedImports = [];
+	const resolvedSource = replaceCSSImportStatements(sourceWithoutReferences, absoluteFile, (importStatement) => {
+		const importSource = importStatement.source;
+		const packageFile = options.expandPackageImports !== false ? resolveMasterCSSPackageEntryFile(importSource, absoluteFile, options.projectDir) : void 0;
+		if (packageFile || isExpandableImportSource(importSource)) return resolveCSSImportGraphFile(packageFile || resolve(dirname(absoluteFile), importSource), dependencies, dependencySet, [...stack, absoluteFile], options);
+		preservedImports.push(importStatement.statement.trim());
+		return "";
+	});
+	if (!preservedImports.length) return resolvedSource;
+	const firstImportStart = imports[0].start;
+	const afterImports = resolvedSource.slice(firstImportStart);
+	return resolvedSource.slice(0, firstImportStart) + preservedImports.join("\n") + (afterImports ? "\n" : "") + afterImports;
+}
+function resolveCSSImportGraph(file, options = {}) {
+	const dependencies = [];
+	const references = [];
+	return {
+		source: resolveCSSImportGraphFile(file, dependencies, /* @__PURE__ */ new Set(), [], {
+			...options,
+			onReference(reference, fromFile) {
+				references.push(reference);
+				options.onReference?.(reference, fromFile);
+			}
+		}),
+		dependencies,
+		...references.length ? { references } : {}
+	};
+}
+function resolveMasterCSSPackageImportGraph(projectDir) {
+	const entry = resolveMasterCSSPackageEntryFile(MASTER_CSS_PACKAGE_ID, projectDir || process.cwd(), projectDir);
+	if (!entry) throw new Error(`Cannot resolve ${MASTER_CSS_PACKAGE_ID} CSS entry.`);
+	return resolveCSSImportGraph(entry, { projectDir });
+}
+function stripRequest(id) {
+	return id.replace(/[?#].*$/, "");
+}
+function resolveComparablePath(file) {
+	const filename = resolve(file);
+	try {
+		return realpathSync(filename);
+	} catch {
+		return filename;
+	}
+}
+function isMasterCSSPackageStyleFile(id, projectDir) {
+	const filename = resolveComparablePath(stripRequest(id));
+	if (extname(filename) !== ".css") return false;
+	try {
+		return resolveMasterCSSPackageImportGraph(projectDir).dependencies.some((dependency) => {
+			return resolveComparablePath(dependency) === filename;
+		});
+	} catch {
+		return false;
+	}
+}
+function compileCSSFile(file, options = {}) {
+	const { root, ...compileOptions } = options;
+	const absoluteFile = isAbsolute(file) ? file : resolve(root || "", file);
+	const graph = resolveCSSImportGraph(absoluteFile, { projectDir: root });
+	return {
+		...compileCSS(compileOptions.preserveNativeCSS === false ? removeCSSImportStatements(graph.source, absoluteFile) : graph.source, {
+			...compileOptions,
+			from: absoluteFile
+		}),
+		dependencies: graph.dependencies,
+		...graph.references?.length ? { references: graph.references } : {}
+	};
+}
+function addUnique(target, values) {
+	if (!values) return;
+	for (const value of values) if (!target.includes(value)) target.push(value);
+}
+function resolveCSSReferenceFile(reference, options = {}) {
+	const fromFile = reference.file ? isAbsolute(reference.file) ? reference.file : resolve(options.root || "", reference.file) : resolve(options.root || process.cwd(), "master.css");
+	const packageFile = resolveMasterCSSPackageEntryFile(reference.source, fromFile, options.root);
+	if (packageFile) return packageFile;
+	if (isExpandableImportSource(reference.source)) return resolve(dirname(fromFile), reference.source);
+	throw new Error(`@reference only supports relative CSS files or Master CSS package entries: ${reference.source}`);
+}
+function normalizeReferenceStack(stack) {
+	return (stack || []).map((file) => resolveComparablePath(file));
+}
+function resolveCSSReferenceContext(references, options = {}) {
+	const dependencies = [];
+	const warnings = [];
+	let manifest = options.baseManifest;
+	let hasReferences = false;
+	for (const reference of references || []) {
+		const referenceFile = resolveCSSReferenceFile(reference, options);
+		const comparableReferenceFile = resolveComparablePath(referenceFile);
+		if (normalizeReferenceStack(options.referenceStack).includes(comparableReferenceFile)) throw new Error(`Circular CSS reference: ${[...options.referenceStack || [], referenceFile].join(" -> ")}`);
+		const result = compileCSSManifestFileInternal(referenceFile, {
+			...options,
+			baseManifest: manifest,
+			preserveNativeCSS: false,
+			referenceStack: options.referenceStack
+		});
+		hasReferences = true;
+		manifest = result.manifest;
+		addUnique(dependencies, result.dependencies);
+		addUnique(warnings, result.warnings);
+	}
+	return {
+		dependencies,
+		warnings,
+		...hasReferences ? { manifest } : {}
+	};
+}
+function toCompileCSSManifestResult(result, options = {}) {
+	const { manifestInput: _directiveManifestInput, ...directiveData } = result;
+	const referenceContext = resolveCSSReferenceContext(result.references, options);
+	const lowerResult = lowerCSSDirectives(result, {
+		baseManifest: options.baseManifest,
+		resolutionManifest: referenceContext.manifest,
+		onWarning: options.onWarning,
+		diagnostics: options.diagnostics
+	});
+	const dependencies = [];
+	const warnings = [];
+	addUnique(dependencies, result.dependencies);
+	addUnique(dependencies, referenceContext.dependencies);
+	addUnique(warnings, referenceContext.warnings);
+	addUnique(warnings, lowerResult.warnings);
+	const generatedCSS = lowerResult.generatedCSS || "";
+	const css = [result.nativeCSS, generatedCSS].filter(Boolean).join("\n");
+	return {
+		...directiveData,
+		dependencies,
+		manifest: lowerResult.manifest,
+		warnings,
+		generatedCSS,
+		css,
+		directives: result
+	};
+}
+function createManifestFromCSSResult(result, options = {}) {
+	return toCompileCSSManifestResult(result, options);
+}
+function compileCSSManifest(source, options = {}) {
+	const from = options.from ? stripRequest(options.from) : void 0;
+	const fromFile = from ? isAbsolute(from) ? from : resolve(options.root || "", from) : void 0;
+	return toCompileCSSManifestResult(compileCSS(source, {
+		...options,
+		...fromFile ? { from: fromFile } : {}
+	}), {
+		...options,
+		...fromFile ? {
+			from: fromFile,
+			referenceStack: [...options.referenceStack || [], fromFile]
+		} : {}
+	});
+}
+function compileCSSManifestFileInternal(file, options = {}) {
+	const absoluteFile = isAbsolute(file) ? file : resolve(options.root || "", file);
+	return toCompileCSSManifestResult(compileCSSFile(file, {
+		...options,
+		preserveNativeCSS: options.preserveNativeCSS ?? false
+	}), {
+		...options,
+		from: absoluteFile,
+		referenceStack: [...options.referenceStack || [], absoluteFile]
+	});
+}
+function compileCSSManifestFile(file, options = {}) {
+	return compileCSSManifestFileInternal(file, options);
+}
+function compileProjectManifest(entries, options = {}) {
+	const dependencies = [];
+	let extractionPolicy = createCSSDirectiveExtractionPolicy();
+	const classNames = [];
+	const nativeClassNames = [];
+	const nativeCSS = [];
+	const css = [];
+	const generatedCSS = [];
+	const warnings = [];
+	let directives = {
+		manifestInput: {},
+		extractionPolicy: createCSSDirectiveExtractionPolicy(),
+		classNames: [],
+		nativeClassNames: [],
+		nativeCSS: "",
+		css: "",
+		generatedCSS: "",
+		warnings: [],
+		dependencies: []
+	};
+	let manifest = options.baseManifest;
+	for (const entry of entries) {
+		const result = compileCSSFile(entry, {
+			...options,
+			preserveNativeCSS: options.preserveNativeCSS ?? false
+		});
+		directives = result;
+		extractionPolicy = mergeCSSDirectiveExtractionPolicy(extractionPolicy, result.extractionPolicy);
+		addUnique(dependencies, result.dependencies);
+		addUnique(classNames, result.classNames);
+		addUnique(nativeClassNames, result.nativeClassNames);
+		addUnique(warnings, result.warnings);
+		const manifestResult = toCompileCSSManifestResult(result, {
+			...options,
+			baseManifest: manifest,
+			from: entry,
+			referenceStack: [isAbsolute(entry) ? entry : resolve(options.root || "", entry)]
+		});
+		manifest = manifestResult.manifest;
+		addUnique(dependencies, manifestResult.dependencies);
+		addUnique(warnings, manifestResult.warnings);
+		const entryGeneratedCSS = manifestResult.generatedCSS || "";
+		if (result.nativeCSS) nativeCSS.push(result.nativeCSS);
+		if (entryGeneratedCSS) generatedCSS.push(entryGeneratedCSS);
+		if (manifestResult.css) css.push(manifestResult.css);
+	}
+	return {
+		entries,
+		manifest: manifest || createMasterCSSManifest(),
+		dependencies,
+		extractionPolicy,
+		classNames,
+		nativeClassNames,
+		nativeCSS: nativeCSS.join("\n"),
+		css: css.join("\n"),
+		generatedCSS: generatedCSS.join("\n"),
+		warnings,
+		directives
+	};
+}
+function toManifestJSONResult(result) {
+	return {
+		...result,
+		json: stringifyMasterCSSManifestJSON(result.manifest)
+	};
+}
+function compileCSSManifestJSON(file, options = {}) {
+	return toManifestJSONResult(compileCSSManifestFile(file, options));
+}
+function compileProjectManifestJSON(entries, options = {}) {
+	return toManifestJSONResult(compileProjectManifest(entries, options));
+}
+//#endregion
+export { collectStandaloneCSSDirectiveExtractionPolicy, compileCSS, compileCSSFile, compileCSSManifest, compileCSSManifestFile, compileCSSManifestJSON, compileProjectManifest, compileProjectManifestJSON, createCSSDirectiveExtractionPolicy, createManifestFromCSSResult, findCSSReferenceStatements, findStandaloneCSSDirectiveStatements, findStandaloneMasterDirectiveStatements, inspectCSS, isMasterCSSPackageStyleFile, maskManagedPatternEntryNames, mergeCSSDirectiveExtractionPolicy, parseDirectives, removeCSSReferenceStatements, removeStandaloneCSSDirectives, removeStandaloneMasterDirectives, resolveCSSImportGraph, resolveMasterCSSPackageEntryFile, resolveMasterCSSPackageImportGraph, setCSSTransform };

package/dist/lexer/imports.d.ts

@@ -1,13 +1,17 @@
-import type { Rule } from 'lightningcss';
-export interface CSSImportStatement {
-    start: number;
-    end: number;
-    source: string;
-    statement: string;
-    rule: Extract<Rule, {
-        type: 'import';
-    }>;
+import { Rule } from "lightningcss";
+
+//#region src/lexer/imports.d.ts
+interface CSSImportStatement {
+  start: number;
+  end: number;
+  source: string;
+  statement: string;
+  rule: Extract<Rule, {
+    type: 'import';
+  }>;
 }
-export declare function findCSSImportStatements(source: string, filename?: string): CSSImportStatement[];
-export declare function removeCSSImportStatements(source: string, filename?: string): string;
-export declare function replaceCSSImportStatements(source: string, filename: string, getReplacement: (statement: CSSImportStatement) => string | undefined): string;
+declare function findCSSImportStatements(source: string, filename?: string): CSSImportStatement[];
+declare function removeCSSImportStatements(source: string, filename?: string): string;
+declare function replaceCSSImportStatements(source: string, filename: string, getReplacement: (statement: CSSImportStatement) => string | undefined): string;
+//#endregion
+export { CSSImportStatement, findCSSImportStatements, removeCSSImportStatements, replaceCSSImportStatements };

package/dist/lexer/imports.js

@@ -0,0 +1,38 @@
+import { encodeCSS, getCSSTransform } from "../css-transform.js";
+import { createSourceLocationResolver, findAtRuleStatementEnd, removeSourceRanges, replaceSourceRanges } from "./source.js";
+import { maskManagedPatternEntryNames } from "../core.js";
+//#region src/lexer/imports.ts
+function findCSSImportStatements(source, filename = "master.css") {
+	const statements = [];
+	const maskedSource = maskManagedPatternEntryNames(source);
+	const resolveLocation = createSourceLocationResolver(maskedSource);
+	getCSSTransform()({
+		filename,
+		code: encodeCSS(maskedSource),
+		visitor: { Rule: { import(rule) {
+			const start = resolveLocation(rule.value.loc);
+			if (start === -1) return;
+			const end = findAtRuleStatementEnd(source, start);
+			if (end === -1) return;
+			statements.push({
+				start,
+				end,
+				source: rule.value.url,
+				statement: source.slice(start, end),
+				rule
+			});
+		} } }
+	});
+	return statements;
+}
+function removeCSSImportStatements(source, filename = "master.css") {
+	return removeSourceRanges(source, findCSSImportStatements(source, filename));
+}
+function replaceCSSImportStatements(source, filename, getReplacement) {
+	return replaceSourceRanges(source, findCSSImportStatements(source, filename).map((statement) => ({
+		...statement,
+		replacement: getReplacement(statement) ?? statement.statement
+	})));
+}
+//#endregion
+export { findCSSImportStatements, removeCSSImportStatements, replaceCSSImportStatements };

package/dist/lexer/source.d.ts

@@ -1,3 +1,6 @@
-import { createSourceLocationResolver, removeSourceRanges, replaceSourceRanges, type SourceRange } from '@master/css-lexer';
-export { createSourceLocationResolver, removeSourceRanges, replaceSourceRanges, type SourceRange };
-export declare function findAtRuleStatementEnd(source: string, start: number): number;
+import { SourceRange, createSourceLocationResolver, removeSourceRanges, replaceSourceRanges } from "@master/css-lexer";
+
+//#region src/lexer/source.d.ts
+declare function findAtRuleStatementEnd(source: string, start: number): number;
+//#endregion
+export { type SourceRange, createSourceLocationResolver, findAtRuleStatementEnd, removeSourceRanges, replaceSourceRanges };

package/dist/lexer/source.js

@@ -0,0 +1,8 @@
+import { createSourceLocationResolver, findCSSStatementEnd, removeSourceRanges, replaceSourceRanges } from "@master/css-lexer";
+//#region src/lexer/source.ts
+function findAtRuleStatementEnd(source, start) {
+	const statementEnd = findCSSStatementEnd(source, start);
+	return statementEnd.reason === "semicolon" ? statementEnd.end : -1;
+}
+//#endregion
+export { createSourceLocationResolver, findAtRuleStatementEnd, removeSourceRanges, replaceSourceRanges };

package/dist/lexer/standalone-master.d.ts

@@ -1,21 +1,25 @@
-import type { CSSDirectiveExtractionPolicy } from '@master/css-schema/css-directives';
-export type StandaloneCSSDirectiveName = 'master' | 'source' | 'safelist' | 'blocklist' | 'preserve';
-export interface StandaloneCSSDirectiveStatement {
-    start: number;
-    end: number;
-    atRuleName: StandaloneCSSDirectiveName;
-    name: string;
-    statement: string;
-    args: string[];
-    modifiers: string[];
+import { CSSDirectiveExtractionPolicy } from "@master/css-schema/css-directives";
+
+//#region src/lexer/standalone-master.d.ts
+type StandaloneCSSDirectiveName = 'master' | 'source' | 'safelist' | 'blocklist' | 'preserve';
+interface StandaloneCSSDirectiveStatement {
+  start: number;
+  end: number;
+  atRuleName: StandaloneCSSDirectiveName;
+  name: string;
+  statement: string;
+  args: string[];
+  modifiers: string[];
 }
-export type StandaloneMasterDirectiveStatement = StandaloneCSSDirectiveStatement & {
-    atRuleName: 'master';
+type StandaloneMasterDirectiveStatement = StandaloneCSSDirectiveStatement & {
+  atRuleName: 'master';
 };
-export declare function createCSSDirectiveExtractionPolicy(): CSSDirectiveExtractionPolicy;
-export declare function mergeCSSDirectiveExtractionPolicy(...policies: (Partial<CSSDirectiveExtractionPolicy> | undefined)[]): CSSDirectiveExtractionPolicy;
-export declare function findStandaloneCSSDirectiveStatements(source: string, filename?: string): StandaloneCSSDirectiveStatement[];
-export declare function findStandaloneMasterDirectiveStatements(source: string, filename?: string): StandaloneMasterDirectiveStatement[];
-export declare function collectStandaloneCSSDirectiveExtractionPolicy(source: string, filename?: string): CSSDirectiveExtractionPolicy;
-export declare function removeStandaloneCSSDirectives(source: string, filename?: string): string;
-export declare function removeStandaloneMasterDirectives(source: string, filename?: string): string;
+declare function createCSSDirectiveExtractionPolicy(): CSSDirectiveExtractionPolicy;
+declare function mergeCSSDirectiveExtractionPolicy(...policies: (Partial<CSSDirectiveExtractionPolicy> | undefined)[]): CSSDirectiveExtractionPolicy;
+declare function findStandaloneCSSDirectiveStatements(source: string, filename?: string): StandaloneCSSDirectiveStatement[];
+declare function findStandaloneMasterDirectiveStatements(source: string, filename?: string): StandaloneMasterDirectiveStatement[];
+declare function collectStandaloneCSSDirectiveExtractionPolicy(source: string, filename?: string): CSSDirectiveExtractionPolicy;
+declare function removeStandaloneCSSDirectives(source: string, filename?: string): string;
+declare function removeStandaloneMasterDirectives(source: string, filename?: string): string;
+//#endregion
+export { StandaloneCSSDirectiveName, StandaloneCSSDirectiveStatement, StandaloneMasterDirectiveStatement, collectStandaloneCSSDirectiveExtractionPolicy, createCSSDirectiveExtractionPolicy, findStandaloneCSSDirectiveStatements, findStandaloneMasterDirectiveStatements, mergeCSSDirectiveExtractionPolicy, removeStandaloneCSSDirectives, removeStandaloneMasterDirectives };