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

package/dist/lint/diagnostics.d.ts

@@ -1,42 +0,0 @@
-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

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

package/dist/lint/index.d.ts

@@ -1,21 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,27 +0,0 @@
-// 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

@@ -1,70 +0,0 @@
-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 };

package/dist/lint/source.js

@@ -1,261 +0,0 @@
-// src/lint/source.ts
-const MAX_FIX_PASSES = 10;
-const masterCSSLintRuleIds = Object.freeze([
-	"sort-classes",
-	"no-invalid-classes",
-	"no-conflicting-classes",
-	"prefer-canonical-classes",
-	"no-unapproved-raw-values",
-	"prefer-component-classes"
-]);
-const defaultMasterCSSLintRules = Object.freeze({
-	"sort-classes": true,
-	"no-invalid-classes": true,
-	"no-conflicting-classes": true,
-	"prefer-canonical-classes": true,
-	"no-unapproved-raw-values": false,
-	"prefer-component-classes": false
-});
-const languageByExtension = {
-	".astro": "astro",
-	".css": "css",
-	".htm": "html",
-	".html": "html",
-	".js": "javascript",
-	".mjs": "javascript",
-	".cjs": "javascript",
-	".jsx": "javascriptreact",
-	".less": "less",
-	".md": "markdown",
-	".mdx": "mdx",
-	".mts": "typescript",
-	".cts": "typescript",
-	".php": "html",
-	".pug": "html",
-	".scss": "scss",
-	".svelte": "svelte",
-	".ts": "typescript",
-	".tsx": "typescriptreact",
-	".vue": "vue"
-};
-const stylesheetLanguageIds = /* @__PURE__ */ new Set([
-	"css",
-	"scss",
-	"less"
-]);
-function resolveMasterCSSLintRules(option) {
-	if (!option) return { ...defaultMasterCSSLintRules };
-	const resolved = Object.fromEntries(masterCSSLintRuleIds.map((ruleId) => [ruleId, false]));
-	for (const rule of option.split(",").map((item) => item.trim()).filter(Boolean)) {
-		if (rule === "recommended") {
-			Object.assign(resolved, defaultMasterCSSLintRules);
-			continue;
-		}
-		if (rule === "all") {
-			for (const ruleId of masterCSSLintRuleIds) resolved[ruleId] = true;
-			continue;
-		}
-		if (!masterCSSLintRuleIds.includes(rule)) throw new Error(`Unknown Master CSS lint rule "${rule}".`);
-		resolved[rule] = true;
-	}
-	return resolved;
-}
-function resolveRules(rules) {
-	return {
-		...defaultMasterCSSLintRules,
-		...rules
-	};
-}
-function getLanguageId(filePath) {
-	const separator = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
-	const dot = filePath.lastIndexOf(".");
-	const extension = dot > separator ? filePath.slice(dot).toLowerCase() : "";
-	return languageByExtension[extension] || "html";
-}
-function getFileSourceKind(languageId) {
-	return stylesheetLanguageIds.has(languageId) ? "stylesheet" : "source";
-}
-function detectClassListUnescape(content, range) {
-	const quote = content[range.start - 1];
-	return quote === "\"" || quote === "'" || quote === "`" ? quote : false;
-}
-function inferClassSourceKind(content, range) {
-	const prefix = content.slice(Math.max(0, range.start - 80), range.start);
-	return /(?:^|[\s{<])(?:class|className|class:list|:class|v-bind:class|\[class\]|\[className\]|\[ngClass\])\s*=\s*(?:"|'|`|\{[^]*$)/.test(prefix) ? "class-attribute" : "class-expression";
-}
-function collectClassListContexts(content, filePath, lintSession, analysis = lintSession.analyzeLintDocument(content, getLanguageId(filePath))) {
-	const positions = analysis.classPositions;
-	const contexts = /* @__PURE__ */ new Map();
-	for (const position of positions) {
-		const contextRange = position.contextRange;
-		const key = `${contextRange.start}:${contextRange.end}`;
-		const existing = contexts.get(key);
-		if (existing) {
-			existing.classNames.push(position.token);
-			existing.transformed ||= position.raw !== position.token;
-			continue;
-		}
-		contexts.set(key, {
-			range: contextRange,
-			text: content.slice(contextRange.start, contextRange.end),
-			sourceKind: inferClassSourceKind(content, contextRange),
-			unescape: detectClassListUnescape(content, contextRange),
-			classNames: [position.token],
-			transformed: position.raw !== position.token
-		});
-	}
-	return [...contexts.values()].map((context) => {
-		const tokens = lintSession.tokenizeClassList(context.text, context.unescape).map((item) => item.token);
-		context.transformed ||= tokens.length !== context.classNames.length || tokens.some((token, index) => token !== context.classNames[index]);
-		return context;
-	}).sort((a, b) => a.range.start - b.range.start || a.range.end - b.range.end);
-}
-function offsetToLocation(content, offset) {
-	let line = 1;
-	let lineStart = 0;
-	for (let index = 0; index < offset; index++) if (content[index] === "\n") {
-		line++;
-		lineStart = index + 1;
-	}
-	return {
-		line,
-		column: offset - lineStart + 1
-	};
-}
-function toLocationRange(content, range) {
-	return {
-		start: offsetToLocation(content, range.start),
-		end: offsetToLocation(content, range.end)
-	};
-}
-function createContextLintDiagnostics(context, rules, options) {
-	return Object.values(rules).some(Boolean) ? options.lintSession.analyzeLintClassList(context.text, context.classNames, {
-		disallowUnknownClass: options.ruleOptions?.["no-invalid-classes"]?.disallowUnknownClass,
-		rawValuePolicy: rules["no-unapproved-raw-values"] ? options.ruleOptions?.["no-unapproved-raw-values"] || {} : void 0,
-		canonicalOptions: rules["prefer-canonical-classes"] ? options.ruleOptions?.["prefer-canonical-classes"] || {} : void 0,
-		remoteStylingPolicy: rules["prefer-component-classes"] ? { max: options.ruleOptions?.["prefer-component-classes"]?.max } : void 0
-	}).diagnostics.filter(({ ruleId }) => rules[ruleId]).map((diagnostic) => ({
-		...diagnostic,
-		severity: options.severities?.[diagnostic.ruleId] || (diagnostic.ruleId === "no-invalid-classes" ? "error" : "warning"),
-		fix: diagnostic.fix
-	})) : [];
-}
-function toSourceFix(context, fix) {
-	if (context.transformed) return;
-	return {
-		kind: "class-list",
-		safety: "safe",
-		range: {
-			start: context.range.start + fix.range.start,
-			end: context.range.start + fix.range.end
-		},
-		text: fix.text,
-		description: "Replace the class list text.",
-		requiresFormatting: false
-	};
-}
-function toSourceDiagnostic(content, context, diagnostic) {
-	const range = context.transformed ? context.range : {
-		start: context.range.start + diagnostic.range.start,
-		end: context.range.start + diagnostic.range.end
-	};
-	const fix = diagnostic.fix && toSourceFix(context, diagnostic.fix);
-	return {
-		ruleId: diagnostic.ruleId,
-		code: diagnostic.code,
-		severity: diagnostic.severity,
-		message: diagnostic.message,
-		range,
-		loc: toLocationRange(content, range),
-		source: "Master CSS",
-		sourceKind: context.sourceKind,
-		...diagnostic.data ? { data: diagnostic.data } : {},
-		...fix ? { fixes: [fix] } : {}
-	};
-}
-function lintMasterCSSContent(options) {
-	const diagnostics = [];
-	const rules = resolveRules(options.rules);
-	const document = options.lintSession.analyzeLintDocument(options.content, getLanguageId(options.filePath));
-	for (const diagnostic of document.diagnostics ?? []) {
-		if (diagnostic.severity === "info") continue;
-		const range = diagnostic.range ?? {
-			start: 0,
-			end: 0
-		};
-		diagnostics.push({
-			code: diagnostic.code,
-			severity: diagnostic.severity,
-			message: diagnostic.message,
-			range,
-			loc: toLocationRange(options.content, range),
-			source: "Master CSS",
-			sourceKind: "class-expression"
-		});
-	}
-	for (const context of collectClassListContexts(options.content, options.filePath, options.lintSession, document)) diagnostics.push(...createContextLintDiagnostics(context, rules, options).map((diagnostic) => toSourceDiagnostic(options.content, context, diagnostic)));
-	const languageId = getLanguageId(options.filePath);
-	return {
-		filePath: options.filePath,
-		languageId,
-		sourceKind: getFileSourceKind(languageId),
-		diagnostics
-	};
-}
-function applyReplacement(content, range, text) {
-	return content.slice(0, range.start) + text + content.slice(range.end);
-}
-function applyFixes(content, fixes) {
-	let fixed = content;
-	for (const fix of fixes) fixed = applyReplacement(fixed, fix.range, fix.text);
-	return fixed;
-}
-function fixClassListText(context, rules, options) {
-	if (context.transformed) return context.text;
-	let fixed = context.text;
-	for (let pass = 0; pass < MAX_FIX_PASSES; pass++) {
-		const fix = createContextLintDiagnostics({
-			...context,
-			range: {
-				start: 0,
-				end: fixed.length
-			},
-			text: fixed,
-			classNames: options.lintSession.tokenizeClassList(fixed, context.unescape).map(({ token }) => token)
-		}, rules, options).map((diagnostic) => diagnostic.fix).find((fix) => Boolean(fix));
-		if (!fix) return fixed;
-		const next = applyReplacement(fixed, fix.range, fix.text);
-		if (next === fixed) return fixed;
-		fixed = next;
-	}
-	return fixed;
-}
-function fixSafeClassLists(content, filePath, rules, options) {
-	return applyFixes(content, collectClassListContexts(content, filePath, options.lintSession).map((context) => ({
-		range: context.range,
-		text: fixClassListText(context, rules, options)
-	})).filter((replacement) => content.slice(replacement.range.start, replacement.range.end) !== replacement.text).sort((a, b) => b.range.start - a.range.start || b.range.end - a.range.end).map((replacement) => ({
-		kind: "class-list",
-		safety: "safe",
-		range: replacement.range,
-		text: replacement.text,
-		description: "Replace the class list text.",
-		requiresFormatting: false
-	})));
-}
-function fixMasterCSSContent(options) {
-	return fixSafeClassLists(options.content, options.filePath, resolveRules(options.rules), options);
-}
-function summarizeMasterCSSLintFiles(files) {
-	const diagnostics = files.flatMap((file) => file.diagnostics);
-	const fixes = diagnostics.flatMap((diagnostic) => diagnostic.fixes ?? []);
-	return {
-		files: files.length,
-		diagnostics: diagnostics.length,
-		errors: diagnostics.filter((diagnostic) => diagnostic.severity === "error").length,
-		warnings: diagnostics.filter((diagnostic) => diagnostic.severity === "warning").length,
-		fixable: diagnostics.filter((diagnostic) => diagnostic.fixes?.length).length,
-		safeFixes: fixes.filter((fix) => fix.safety === "safe").length
-	};
-}
-export { defaultMasterCSSLintRules, fixMasterCSSContent, lintMasterCSSContent, masterCSSLintRuleIds, resolveMasterCSSLintRules, summarizeMasterCSSLintFiles };

package/dist/math-types.d.ts

@@ -1,11 +0,0 @@
-import { CssNode } from "@eslint/css-tree";
-declare const mathFunctions: Set<string>;
-/** Substitute only proven result types into a disposable grammar AST. Never
- * evaluate values, ranges, variable substitutions, or mutate emitted CSS.
- * A nested calc may have a compound intermediate type which its parent cancels.
- */
-declare function validateMathTypes(ast: CssNode, matches: (value: CssNode) => boolean): {
-  ast: CssNode;
-  status?: 'valid' | 'invalid' | 'unknown';
-};
-export { mathFunctions, validateMathTypes };