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

package/dist/lint/analysis.d.ts

@@ -0,0 +1,90 @@
+import { CanonicalClassNameOptions, RawValuePolicyOptions, RemoteStylingPolicyOptions } from "./contracts.js";
+import { MasterCSSLintDiagnosticData, MasterCSSLintRuleId } from "./diagnostics.js";
+interface MasterCSSLintClassConflict {
+  readonly className: string;
+  readonly conflicts: readonly string[];
+}
+interface MasterCSSLintPartialClassConflict {
+  readonly className: string;
+  readonly conflict: string;
+}
+interface MasterCSSLintAnalysis {
+  readonly version: 4;
+  readonly sortedClassNames: readonly string[];
+  readonly conflicts: readonly MasterCSSLintClassConflict[];
+  readonly partialConflicts: readonly MasterCSSLintPartialClassConflict[];
+}
+interface MasterCSSLintClassListOptions {
+  readonly disallowUnknownClass?: boolean;
+  readonly rawValuePolicy?: RawValuePolicyOptions;
+  readonly remoteStylingPolicy?: RemoteStylingPolicyOptions;
+  readonly canonicalOptions?: CanonicalClassNameOptions;
+}
+interface MasterCSSLintEdit {
+  readonly range: Readonly<{
+    start: number;
+    end: number;
+  }>;
+  readonly text: string;
+  readonly scope: 'class-list';
+}
+interface MasterCSSLintDiagnosticInput {
+  readonly ruleId: MasterCSSLintRuleId;
+  readonly code: string;
+  readonly message: string;
+  readonly range: Readonly<{
+    start: number;
+    end: number;
+  }>;
+  readonly data?: MasterCSSLintDiagnosticData;
+  readonly fix?: MasterCSSLintEdit;
+}
+interface MasterCSSLintClassListAnalysis {
+  readonly version: 4;
+  readonly analysis: MasterCSSLintAnalysis;
+  readonly diagnostics: readonly MasterCSSLintDiagnosticInput[];
+  readonly sortEdit?: MasterCSSLintEdit;
+  readonly conflictEdit?: MasterCSSLintEdit;
+  readonly conflictRange?: Readonly<{
+    start: number;
+    end: number;
+  }>;
+}
+interface MasterCSSLintCanonicalClassSuggestion {
+  readonly className: string;
+  readonly recommended: string;
+}
+interface MasterCSSLintCanonicalClassGroupSuggestion {
+  readonly classNames: readonly string[];
+  readonly recommended: string;
+}
+interface MasterCSSLintRawValueCandidate {
+  readonly className: string;
+  readonly key: string;
+  readonly segments: readonly string[];
+  readonly properties: readonly string[];
+}
+interface MasterCSSLintDocumentAnalysis {
+  readonly diagnostics: readonly import('@master/css-binding/tooling').MasterCSSDiagnostic[];
+  readonly classPositions: readonly Readonly<{
+    range: Readonly<{
+      start: number;
+      end: number;
+    }>;
+    contextRange: Readonly<{
+      start: number;
+      end: number;
+    }>;
+    raw: string;
+    token: string;
+  }>[];
+}
+interface MasterCSSLintToken {
+  readonly range: Readonly<{
+    start: number;
+    end: number;
+  }>;
+  readonly raw: string;
+  readonly token: string;
+}
+export { MasterCSSLintAnalysis, MasterCSSLintCanonicalClassGroupSuggestion, MasterCSSLintCanonicalClassSuggestion, MasterCSSLintClassConflict, MasterCSSLintClassListAnalysis, MasterCSSLintClassListOptions, MasterCSSLintDiagnosticInput, MasterCSSLintDocumentAnalysis, MasterCSSLintEdit, MasterCSSLintPartialClassConflict, MasterCSSLintRawValueCandidate, MasterCSSLintToken };

package/dist/lint/analysis.js

@@ -0,0 +1 @@
+export {};

package/dist/lint/binding-session.d.ts

@@ -0,0 +1,21 @@
+import { CanonicalClassNameOptions } from "./contracts.js";
+import { MasterCSSLintAnalysis, MasterCSSLintCanonicalClassGroupSuggestion, MasterCSSLintCanonicalClassSuggestion, MasterCSSLintClassListAnalysis, MasterCSSLintClassListOptions, MasterCSSLintDocumentAnalysis, MasterCSSLintRawValueCandidate, MasterCSSLintToken } from "./analysis.js";
+import { MasterCSSLanguageBindingSession, MasterCSSLintBindingSession, MasterCSSValidatorBindingSession } from "@master/css-binding/tooling";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+interface LintSession {
+  suggestClasses: MasterCSSLintBindingSession['suggestClasses'];
+  inspectDesignSystem: MasterCSSLintBindingSession['inspectDesignSystem'];
+  tokenizeClassList(classList: string, unescape?: string | false): readonly MasterCSSLintToken[];
+  analyzeDocument(source: string, languageId: string): MasterCSSLintDocumentAnalysis;
+  analyze(classNames: string[]): MasterCSSLintAnalysis;
+  canonicalClassGroups(classNames: string[], options?: CanonicalClassNameOptions): readonly MasterCSSLintCanonicalClassGroupSuggestion[];
+  canonicalClassNames(classNames: string[], options?: CanonicalClassNameOptions): readonly MasterCSSLintCanonicalClassSuggestion[];
+  rawValueCandidates(classNames: string[]): readonly MasterCSSLintRawValueCandidate[];
+  analyzeClassList(classList: string, classNames: string[], options?: MasterCSSLintClassListOptions): MasterCSSLintClassListAnalysis;
+  dispose(): void;
+}
+declare function bindLintSession(lint: MasterCSSLintBindingSession, validator: MasterCSSValidatorBindingSession, language: MasterCSSLanguageBindingSession): LintSession;
+declare function createLintSession(manifest: MasterCSSManifest, options?: {
+  readonly binding?: 'auto' | 'native' | 'wasm';
+}): Promise<LintSession>;
+export { LintSession, bindLintSession, createLintSession };

package/dist/lint/binding-session.js

@@ -0,0 +1,97 @@
+import { validateRuleDeclarations } from "../value-validation.js";
+import { MASTER_CSS_LINT_BATCH_VERSION, createToolingBinding } from "@master/css-binding/tooling";
+// src/lint/binding-session.ts
+function resolveRawValuePolicy(options) {
+	if (!options) return;
+	if (options.allowRawValues) return {
+		allowRawValues: true,
+		allowProperties: options.allowProperties || [],
+		requireProperties: options.requireProperties || [],
+		allowedPatterns: []
+	};
+	return {
+		allowRawValues: false,
+		allowProperties: options.allowProperties || [],
+		requireProperties: options.requireProperties || [],
+		allowedPatterns: options.allowedPatterns || []
+	};
+}
+function collectHostRuleErrors(batch) {
+	return batch.classes.map(({ rules }) => rules.map(({ text }) => validateRuleDeclarations(text).filter((declaration) => declaration.status === "invalid").map((declaration) => `Invalid CSS value: ${declaration.property}:${declaration.value}`)));
+}
+function bindLintSession(lint, validator, language) {
+	const resolveInputs = (classNames) => {
+		const validation = validator.generateClassRules(classNames);
+		return {
+			nativeSupport: void 0,
+			...lint.resolveValidation(validation, collectHostRuleErrors(validation))
+		};
+	};
+	return {
+		inspectDesignSystem: (request) => lint.inspectDesignSystem(request),
+		suggestClasses: (declarations) => lint.suggestClasses(declarations),
+		tokenizeClassList(classList, unescape) {
+			return language.analyzeDocument({
+				source: classList,
+				languageId: "class-list",
+				hostRanges: [{
+					start: 0,
+					end: classList.length,
+					unescape: unescape ? [unescape] : []
+				}]
+			}).classPositions;
+		},
+		analyzeDocument(source, languageId) {
+			return language.analyzeDocument({
+				source,
+				languageId
+			});
+		},
+		analyze(classNames) {
+			const inputs = resolveInputs(classNames);
+			return lint.analyze(classNames, inputs.nativeSupport, inputs.invalidGeneratedClasses);
+		},
+		canonicalClassNames(classNames, options) {
+			const inputs = resolveInputs(classNames);
+			return lint.canonicalClassNames(classNames, inputs.nativeSupport, options).suggestions;
+		},
+		canonicalClassGroups(classNames, options) {
+			const inputs = resolveInputs(classNames);
+			return lint.canonicalClassGroups(classNames, inputs.nativeSupport, options).suggestions;
+		},
+		rawValueCandidates(classNames) {
+			const inputs = resolveInputs(classNames);
+			return lint.rawValueCandidates(classNames, inputs.nativeSupport, inputs.invalidGeneratedClasses).candidates;
+		},
+		analyzeClassList(classList, classNames, options) {
+			const inputs = resolveInputs(classNames);
+			return lint.analyzeClassListPolicy({
+				version: MASTER_CSS_LINT_BATCH_VERSION,
+				classList,
+				classNames,
+				nativeSupport: inputs.nativeSupport,
+				invalidGeneratedClasses: inputs.invalidGeneratedClasses,
+				validationErrors: inputs.validationErrors,
+				disallowUnknownClass: options?.disallowUnknownClass,
+				canonicalOptions: options?.canonicalOptions,
+				rawValuePolicy: resolveRawValuePolicy(options?.rawValuePolicy),
+				remoteStylingPolicy: options?.remoteStylingPolicy && { ...options.remoteStylingPolicy }
+			});
+		},
+		dispose() {
+			lint.dispose();
+			validator.dispose();
+			language.dispose();
+		}
+	};
+}
+async function createLintSession(manifest, options = {}) {
+	const tooling = await createToolingBinding({ binding: options.binding });
+	const [lint, validator, language] = await Promise.all([
+		tooling.createLintSession(manifest),
+		tooling.createValidatorSession(manifest),
+		tooling.createLanguageSession(manifest)
+	]);
+	return bindLintSession(lint, validator, language);
+}
+export { bindLintSession, createLintSession };

package/dist/lint/constants.d.ts

@@ -0,0 +1,7 @@
+declare const defaultClassLintSettings: Readonly<{
+  classAttributes: readonly string[];
+  classFunctions: readonly string[];
+  classDeclarations: readonly string[];
+  ignoredKeys: readonly string[];
+}>;
+export { defaultClassLintSettings };

package/dist/lint/constants.js

@@ -0,0 +1,18 @@
+// src/lint/constants.ts
+const defaultClassLintSettings = Object.freeze({
+	classAttributes: Object.freeze(["class", "className"]),
+	classFunctions: Object.freeze([
+		"clsx",
+		"cva",
+		"ctl",
+		"cv",
+		"class",
+		"classnames",
+		"classVariant",
+		"styled(?:\\s+)?(?:\\.\\w+)?",
+		"classList(?:\\s+)?\\.(?:add|remove|toggle|replace)"
+	]),
+	classDeclarations: Object.freeze([]),
+	ignoredKeys: Object.freeze(["compoundVariants", "defaultVariants"])
+});
+export { defaultClassLintSettings };

package/dist/lint/contracts.d.ts

@@ -0,0 +1,17 @@
+interface RawValuePolicyOptions {
+  allowRawValues?: boolean;
+  allowProperties?: readonly string[];
+  /** Limit enforcement to these native properties; omitted or empty means all token-backed properties. */
+  requireProperties?: readonly string[];
+  allowedPatterns?: readonly string[];
+}
+interface RemoteStylingPolicyOptions {
+  /** Classes in one list that may style other elements through a combinator (`_`, `>`, `+`, `~`); default 3. */
+  max?: number;
+}
+interface CanonicalClassNameOptions {
+  preferStaticUtilities?: boolean;
+  preferCompositionUtilities?: boolean;
+}
+declare const defaultCanonicalClassNameOptions: Readonly<Required<CanonicalClassNameOptions>>;
+export { CanonicalClassNameOptions, RawValuePolicyOptions, RemoteStylingPolicyOptions, defaultCanonicalClassNameOptions };

package/dist/lint/contracts.js

@@ -0,0 +1,6 @@
+// src/lint/contracts.ts
+const defaultCanonicalClassNameOptions = Object.freeze({
+	preferStaticUtilities: true,
+	preferCompositionUtilities: true
+});
+export { defaultCanonicalClassNameOptions };

package/dist/lint/diagnostic-format.d.ts

@@ -0,0 +1,5 @@
+declare function quoteDiagnosticValue(value: string): string;
+declare function formatClassName(className: string): string;
+declare function formatClassList(classNames: string[] | string): string;
+declare function formatReason(reason: string): string;
+export { formatClassList, formatClassName, formatReason, quoteDiagnosticValue };

package/dist/lint/diagnostic-format.js

@@ -0,0 +1,15 @@
+// src/lint/diagnostic-format.ts
+function quoteDiagnosticValue(value) {
+	return JSON.stringify(value);
+}
+function formatClassName(className) {
+	return quoteDiagnosticValue(className);
+}
+function formatClassList(classNames) {
+	return quoteDiagnosticValue(Array.isArray(classNames) ? classNames.join(" ") : classNames);
+}
+function formatReason(reason) {
+	const normalized = reason.trim();
+	return /[.!?]$/.test(normalized) ? normalized : `${normalized}.`;
+}
+export { formatClassList, formatClassName, formatReason, quoteDiagnosticValue };

package/dist/lint/diagnostics.d.ts

@@ -0,0 +1,42 @@
+import { CanonicalClassNameOptions, RawValuePolicyOptions, RemoteStylingPolicyOptions } from "./contracts.js";
+interface MasterCSSClassListEditOptions {
+  unescape?: string | false;
+}
+type MasterCSSLintRuleId = 'sort-classes' | 'no-invalid-classes' | 'no-conflicting-classes' | 'prefer-canonical-classes' | 'no-unapproved-raw-values' | 'prefer-component-classes';
+type MasterCSSLintDiagnosticSeverity = 'error' | 'warning';
+interface MasterCSSLintRange {
+  start: number;
+  end: number;
+}
+interface MasterCSSLintFix {
+  range: MasterCSSLintRange;
+  text: string;
+  scope?: 'class-list' | 'directive';
+}
+type MasterCSSLintDiagnosticData = Record<string, string | number | boolean | string[] | null | undefined>;
+interface MasterCSSLintDiagnostic {
+  ruleId: MasterCSSLintRuleId;
+  code: string;
+  message: string;
+  severity: MasterCSSLintDiagnosticSeverity;
+  range: MasterCSSLintRange;
+  data?: MasterCSSLintDiagnosticData;
+  fix?: MasterCSSLintFix;
+}
+interface MasterCSSLintReport {
+  diagnostics: MasterCSSLintDiagnostic[];
+}
+interface MasterCSSLintReportOptions extends MasterCSSClassListEditOptions {
+  severity?: MasterCSSLintDiagnosticSeverity;
+}
+interface MasterCSSInvalidClassesReportOptions extends MasterCSSLintReportOptions {
+  disallowUnknownClass?: boolean;
+}
+interface MasterCSSCanonicalClassesReportOptions extends MasterCSSLintReportOptions, CanonicalClassNameOptions {}
+interface MasterCSSUnapprovedRawValueClassesReportOptions extends MasterCSSLintReportOptions, RawValuePolicyOptions {}
+interface MasterCSSComponentClassesReportOptions extends MasterCSSLintReportOptions, RemoteStylingPolicyOptions {}
+interface MasterCSSClassListLintReportOptions extends MasterCSSInvalidClassesReportOptions, RawValuePolicyOptions, CanonicalClassNameOptions {
+  rules?: Partial<Record<MasterCSSLintRuleId, boolean>>;
+  severities?: Partial<Record<MasterCSSLintRuleId, MasterCSSLintDiagnosticSeverity>>;
+}
+export { MasterCSSCanonicalClassesReportOptions, MasterCSSClassListEditOptions, MasterCSSClassListLintReportOptions, MasterCSSComponentClassesReportOptions, MasterCSSInvalidClassesReportOptions, MasterCSSLintDiagnostic, MasterCSSLintDiagnosticData, MasterCSSLintDiagnosticSeverity, MasterCSSLintFix, MasterCSSLintRange, MasterCSSLintReport, MasterCSSLintReportOptions, MasterCSSLintRuleId, MasterCSSUnapprovedRawValueClassesReportOptions };

package/dist/lint/diagnostics.js

@@ -0,0 +1 @@
+export {};

package/dist/lint/index.d.ts

@@ -0,0 +1,21 @@
+import { CanonicalClassNameOptions, RawValuePolicyOptions, RemoteStylingPolicyOptions, defaultCanonicalClassNameOptions } from "./contracts.js";
+import { MasterCSSCanonicalClassesReportOptions, MasterCSSClassListEditOptions, MasterCSSClassListLintReportOptions, MasterCSSComponentClassesReportOptions, MasterCSSInvalidClassesReportOptions, MasterCSSLintDiagnostic, MasterCSSLintDiagnosticData, MasterCSSLintDiagnosticSeverity, MasterCSSLintFix, MasterCSSLintRange, MasterCSSLintReport, MasterCSSLintReportOptions, MasterCSSLintRuleId, MasterCSSUnapprovedRawValueClassesReportOptions } from "./diagnostics.js";
+import { MasterCSSLintAnalysis, MasterCSSLintCanonicalClassGroupSuggestion, MasterCSSLintCanonicalClassSuggestion, MasterCSSLintClassConflict, MasterCSSLintClassListAnalysis, MasterCSSLintClassListOptions, MasterCSSLintDiagnosticInput, MasterCSSLintDocumentAnalysis, MasterCSSLintEdit, MasterCSSLintPartialClassConflict, MasterCSSLintRawValueCandidate, MasterCSSLintToken } from "./analysis.js";
+import { defaultClassLintSettings } from "./constants.js";
+import { MasterCSSFixContentOptions, MasterCSSLintContentOptions, MasterCSSLintContentRuleOptions, MasterCSSLintDiagnosticSourceKind, MasterCSSLintFileResult, MasterCSSLintFileSourceKind, MasterCSSLintSourceDiagnostic, MasterCSSLintSourceFix, MasterCSSLintSourceFixKind, MasterCSSLintSourceFixSafety, MasterCSSLintSourceLocation, MasterCSSLintSourceLocationRange, MasterCSSLintSummary, defaultMasterCSSLintRules, fixMasterCSSContent, lintMasterCSSContent, masterCSSLintRuleIds, resolveMasterCSSLintRules, summarizeMasterCSSLintFiles } from "./source.js";
+import { MasterCSSClassSuggestions, MasterCSSClassSuggestions as MasterCSSClassSuggestions$1, MasterCSSDesignSystemCollision, MasterCSSDesignSystemComponent, MasterCSSDesignSystemDiagnostic, MasterCSSDesignSystemReport, MasterCSSDesignSystemRequest, MasterCSSDesignSystemStylesheet, MasterCSSDesignTokenMetadata, MasterCSSStylesheetAncestor, MasterCSSStylesheetTokenReference } from "@master/css-binding/tooling";
+import { MasterCSSBinding } from "@master/css-binding";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+/** Suggest markup classes for an isolated declaration block, leaving uncertain blocks in CSS. */
+declare function suggestClasses(declarations: string, options: {
+  readonly manifest: MasterCSSManifest;
+  readonly binding?: MasterCSSBinding;
+}): Promise<MasterCSSClassSuggestions$1>;
+/** Tool-only policy and metadata; never part of an executable manifest or runtime program. */
+type MasterCSSDesignSystemOptions = Omit<import('@master/css-binding/tooling').MasterCSSDesignSystemRequest, 'stylesheets'>;
+declare function lintClassNames(classNames: readonly string[], options: {
+  readonly manifest: MasterCSSManifest;
+  readonly binding?: MasterCSSBinding;
+}): Promise<MasterCSSLintAnalysis>;
+declare function createMasterCSSLintDiagnostics(diagnostics: readonly MasterCSSLintDiagnosticInput[], severity?: MasterCSSLintDiagnosticSeverity): readonly MasterCSSLintDiagnostic[];
+export { type CanonicalClassNameOptions, type MasterCSSCanonicalClassesReportOptions, type MasterCSSClassListEditOptions, type MasterCSSClassListLintReportOptions, type MasterCSSClassSuggestions, type MasterCSSComponentClassesReportOptions, type MasterCSSDesignSystemCollision, type MasterCSSDesignSystemComponent, type MasterCSSDesignSystemDiagnostic, MasterCSSDesignSystemOptions, type MasterCSSDesignSystemReport, type MasterCSSDesignSystemRequest, type MasterCSSDesignSystemStylesheet, type MasterCSSDesignTokenMetadata, type MasterCSSFixContentOptions, type MasterCSSInvalidClassesReportOptions, type MasterCSSLintAnalysis, type MasterCSSLintCanonicalClassGroupSuggestion, type MasterCSSLintCanonicalClassSuggestion, type MasterCSSLintClassConflict, type MasterCSSLintClassListAnalysis, type MasterCSSLintClassListOptions, type MasterCSSLintContentOptions, type MasterCSSLintContentRuleOptions, type MasterCSSLintDiagnostic, type MasterCSSLintDiagnosticData, type MasterCSSLintDiagnosticInput, type MasterCSSLintDiagnosticSeverity, type MasterCSSLintDiagnosticSourceKind, type MasterCSSLintDocumentAnalysis, type MasterCSSLintEdit, type MasterCSSLintFileResult, type MasterCSSLintFileSourceKind, type MasterCSSLintFix, type MasterCSSLintPartialClassConflict, type MasterCSSLintRange, type MasterCSSLintRawValueCandidate, type MasterCSSLintReport, type MasterCSSLintReportOptions, type MasterCSSLintRuleId, type MasterCSSLintSourceDiagnostic, type MasterCSSLintSourceFix, type MasterCSSLintSourceFixKind, type MasterCSSLintSourceFixSafety, type MasterCSSLintSourceLocation, type MasterCSSLintSourceLocationRange, type MasterCSSLintSummary, type MasterCSSLintToken, type MasterCSSStylesheetAncestor, type MasterCSSStylesheetTokenReference, type MasterCSSUnapprovedRawValueClassesReportOptions, type RawValuePolicyOptions, type RemoteStylingPolicyOptions, createMasterCSSLintDiagnostics, defaultCanonicalClassNameOptions, defaultClassLintSettings, defaultMasterCSSLintRules, fixMasterCSSContent, lintClassNames, lintMasterCSSContent, masterCSSLintRuleIds, resolveMasterCSSLintRules, suggestClasses, summarizeMasterCSSLintFiles };

package/dist/lint/index.js

@@ -0,0 +1,30 @@
+import { createToolingSession } from "../tooling-session.js";
+import { defaultMasterCSSLintRules, fixMasterCSSContent, lintMasterCSSContent, masterCSSLintRuleIds, resolveMasterCSSLintRules, summarizeMasterCSSLintFiles } from "./source.js";
+import { defaultCanonicalClassNameOptions } from "./contracts.js";
+import { defaultClassLintSettings } from "./constants.js";
+// src/lint/index.ts
+/** Suggest markup classes for an isolated declaration block, leaving uncertain blocks in CSS. */
+async function suggestClasses(declarations, options) {
+	const session = await createToolingSession(options);
+	try {
+		return session.suggestClasses(declarations);
+	} finally {
+		session.dispose();
+	}
+}
+async function lintClassNames(classNames, options) {
+	const session = await createToolingSession(options);
+	try {
+		return session.lintClassNames(classNames);
+	} finally {
+		session.dispose();
+	}
+}
+function createMasterCSSLintDiagnostics(diagnostics, severity = "warning") {
+	return Object.freeze(diagnostics.map((diagnostic) => Object.freeze({
+		...diagnostic,
+		severity,
+		fix: diagnostic.fix
+	})));
+}
+export { createMasterCSSLintDiagnostics, defaultCanonicalClassNameOptions, defaultClassLintSettings, defaultMasterCSSLintRules, fixMasterCSSContent, lintClassNames, lintMasterCSSContent, masterCSSLintRuleIds, resolveMasterCSSLintRules, suggestClasses, summarizeMasterCSSLintFiles };

package/dist/lint/node.d.ts

@@ -0,0 +1,6 @@
+import { MasterCSSLintAnalysis } from "./analysis.js";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+declare function lintClassNamesSync(classNames: readonly string[], options: {
+  readonly manifest: MasterCSSManifest;
+}): MasterCSSLintAnalysis;
+export { lintClassNamesSync };

package/dist/lint/node.js

@@ -0,0 +1,11 @@
+import { createToolingSessionSync } from "../node.js";
+// src/lint/node.ts
+function lintClassNamesSync(classNames, options) {
+	const session = createToolingSessionSync(options);
+	try {
+		return session.lintClassNames(classNames);
+	} finally {
+		session.dispose();
+	}
+}
+export { lintClassNamesSync };

package/dist/lint/rule-signatures.d.ts

@@ -0,0 +1,23 @@
+declare function stable(value: unknown): string;
+declare function equalDeclarations(a: unknown, b: unknown): boolean;
+declare function equalVariants(a: {
+  selectorText?: string;
+  conditions?: unknown;
+  layerName?: string;
+  variantBranchKey?: string;
+}, b: {
+  selectorText?: string;
+  conditions?: unknown;
+  layerName?: string;
+  variantBranchKey?: string;
+}): boolean;
+declare function getDeclarationPropertySignature(rule: {
+  declarations?: object;
+}): string;
+declare function getDeclarationSignature(rule: {
+  declarations?: object;
+}): string;
+declare function getRulesSignature(rules: {
+  declarations?: object;
+}[]): string;
+export { equalDeclarations, equalVariants, getDeclarationPropertySignature, getDeclarationSignature, getRulesSignature, stable };

package/dist/lint/rule-signatures.js

@@ -0,0 +1,27 @@
+// src/lint/rule-signatures.ts
+function stable(value) {
+	if (!value || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+	return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${stable(item)}`).join(",")}}`;
+}
+function equalDeclarations(a, b) {
+	if (!a || !b || typeof a !== "object" || typeof b !== "object") return stable(a) === stable(b);
+	const aKeys = Object.keys(a).sort();
+	const bKeys = Object.keys(b).sort();
+	return stable(aKeys) === stable(bKeys);
+}
+function equalVariants(a, b) {
+	const branchA = a.variantBranchKey;
+	const branchB = b.variantBranchKey;
+	return (branchA !== void 0 || branchB !== void 0 ? branchA === branchB : a.selectorText === b.selectorText) && a.layerName === b.layerName && stable(a.conditions) === stable(b.conditions);
+}
+function getDeclarationPropertySignature(rule) {
+	return Object.keys(rule.declarations || {}).sort().join("\0");
+}
+function getDeclarationSignature(rule) {
+	return stable(rule.declarations || {});
+}
+function getRulesSignature(rules) {
+	return rules.map(getDeclarationSignature).sort().join("\0");
+}
+export { equalDeclarations, equalVariants, getDeclarationPropertySignature, getDeclarationSignature, getRulesSignature, stable };

package/dist/lint/source.d.ts

@@ -0,0 +1,70 @@
+import { MasterCSSCanonicalClassesReportOptions, MasterCSSComponentClassesReportOptions, MasterCSSInvalidClassesReportOptions, MasterCSSLintDiagnosticData, MasterCSSLintDiagnosticSeverity, MasterCSSLintRange, MasterCSSLintRuleId, MasterCSSUnapprovedRawValueClassesReportOptions } from "./diagnostics.js";
+import { MasterCSSToolingSession } from "../tooling-session.js";
+declare const masterCSSLintRuleIds: readonly MasterCSSLintRuleId[];
+declare const defaultMasterCSSLintRules: Readonly<Record<MasterCSSLintRuleId, boolean>>;
+type MasterCSSLintFileSourceKind = 'source' | 'stylesheet' | 'manifest';
+type MasterCSSLintDiagnosticSourceKind = 'class-attribute' | 'class-expression' | 'manifest';
+type MasterCSSLintSourceFixKind = 'class-list';
+type MasterCSSLintSourceFixSafety = 'safe';
+interface MasterCSSLintSourceLocation {
+  line: number;
+  column: number;
+}
+interface MasterCSSLintSourceLocationRange {
+  start: MasterCSSLintSourceLocation;
+  end: MasterCSSLintSourceLocation;
+}
+interface MasterCSSLintSourceFix {
+  kind: MasterCSSLintSourceFixKind;
+  safety: MasterCSSLintSourceFixSafety;
+  range: MasterCSSLintRange;
+  text: string;
+  description: string;
+  requiresFormatting: boolean;
+}
+interface MasterCSSLintSourceDiagnostic {
+  ruleId?: MasterCSSLintRuleId | 'manifest';
+  code: string;
+  severity: MasterCSSLintDiagnosticSeverity;
+  message: string;
+  range: MasterCSSLintRange;
+  loc: MasterCSSLintSourceLocationRange;
+  source: 'Master CSS';
+  sourceKind: MasterCSSLintDiagnosticSourceKind;
+  data?: MasterCSSLintDiagnosticData;
+  fixes?: MasterCSSLintSourceFix[];
+}
+interface MasterCSSLintFileResult {
+  filePath: string;
+  languageId: string;
+  sourceKind: MasterCSSLintFileSourceKind;
+  diagnostics: MasterCSSLintSourceDiagnostic[];
+}
+interface MasterCSSLintSummary {
+  files: number;
+  diagnostics: number;
+  errors: number;
+  warnings: number;
+  fixable: number;
+  safeFixes: number;
+}
+interface MasterCSSLintContentOptions {
+  content: string;
+  filePath: string;
+  rules?: Partial<Record<MasterCSSLintRuleId, boolean>>;
+  ruleOptions?: MasterCSSLintContentRuleOptions;
+  severities?: Partial<Record<MasterCSSLintRuleId, MasterCSSLintDiagnosticSeverity>>;
+  lintSession: Pick<MasterCSSToolingSession, 'analyzeLintClassList' | 'analyzeLintDocument' | 'tokenizeClassList'>;
+}
+type MasterCSSFixContentOptions = MasterCSSLintContentOptions;
+interface MasterCSSLintContentRuleOptions {
+  'no-invalid-classes'?: MasterCSSInvalidClassesReportOptions;
+  'prefer-canonical-classes'?: MasterCSSCanonicalClassesReportOptions;
+  'no-unapproved-raw-values'?: MasterCSSUnapprovedRawValueClassesReportOptions;
+  'prefer-component-classes'?: MasterCSSComponentClassesReportOptions;
+}
+declare function resolveMasterCSSLintRules(option: string | undefined): Record<MasterCSSLintRuleId, boolean>;
+declare function lintMasterCSSContent(options: MasterCSSLintContentOptions): MasterCSSLintFileResult;
+declare function fixMasterCSSContent(options: MasterCSSFixContentOptions): string;
+declare function summarizeMasterCSSLintFiles(files: MasterCSSLintFileResult[]): MasterCSSLintSummary;
+export { MasterCSSFixContentOptions, MasterCSSLintContentOptions, MasterCSSLintContentRuleOptions, MasterCSSLintDiagnosticSourceKind, MasterCSSLintFileResult, MasterCSSLintFileSourceKind, MasterCSSLintSourceDiagnostic, MasterCSSLintSourceFix, MasterCSSLintSourceFixKind, MasterCSSLintSourceFixSafety, MasterCSSLintSourceLocation, MasterCSSLintSourceLocationRange, MasterCSSLintSummary, defaultMasterCSSLintRules, fixMasterCSSContent, lintMasterCSSContent, masterCSSLintRuleIds, resolveMasterCSSLintRules, summarizeMasterCSSLintFiles };