@master/eslint-plugin-css 0.0.0-site.1793659883.g69c9aebcf628

package/dist/rules/prefer-canonical-classes.js

@@ -0,0 +1,48 @@
+import create_rule_default from "../create-rule.js";
+import defineVisitors from "../utils/define-visitors.js";
+import resolveContext from "../utils/resolve-context.js";
+import reportLintDiagnostics from "../utils/report-lint-diagnostics.js";
+import defineSourceVisitors, { shouldUseSourceVisitors } from "../utils/define-source-visitors.js";
+import withContextRelease from "../utils/with-context-release.js";
+import { createMasterCSSLintDiagnostics, defaultCanonicalClassNameOptions } from "@master/css-tooling/lint";
+// src/rules/prefer-canonical-classes.ts
+var prefer_canonical_classes_default = create_rule_default({
+	name: "prefer-canonical-classes",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer canonical Master CSS classes" },
+		messages: { preferClass: "{{message}}" },
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: {
+				preferStaticUtilities: { type: "boolean" },
+				preferCompositionUtilities: { type: "boolean" }
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultCanonicalClassNameOptions],
+	create(context) {
+		const { settings, tooling, release } = resolveContext(context);
+		const options = {
+			...defaultCanonicalClassNameOptions,
+			...context.options[0] || {}
+		};
+		if (shouldUseSourceVisitors(context)) return withContextRelease(defineSourceVisitors({
+			context,
+			tooling,
+			ruleId: "prefer-canonical-classes",
+			ruleOptions: options
+		}), release);
+		const reportCanonicalClassList = (node, resolved) => {
+			reportLintDiagnostics(context, node, resolved, createMasterCSSLintDiagnostics(tooling.analyzeLintClassList(resolved.analysisText ?? resolved.raw, resolved.classValues, { canonicalOptions: options }).diagnostics.filter(({ ruleId }) => ruleId === "prefer-canonical-classes")));
+		};
+		return withContextRelease(defineVisitors({
+			context,
+			settings,
+			tooling
+		}, reportCanonicalClassList), release);
+	}
+});
+export { prefer_canonical_classes_default as default };

package/dist/rules/prefer-component-classes.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"remoteStylingLimit", [{}], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
+};
+export { _default as default };

package/dist/rules/prefer-component-classes.js

@@ -0,0 +1,45 @@
+import create_rule_default from "../create-rule.js";
+import defineVisitors from "../utils/define-visitors.js";
+import resolveContext from "../utils/resolve-context.js";
+import reportLintDiagnostics from "../utils/report-lint-diagnostics.js";
+import defineSourceVisitors, { shouldUseSourceVisitors } from "../utils/define-source-visitors.js";
+import withContextRelease from "../utils/with-context-release.js";
+import { createMasterCSSLintDiagnostics } from "@master/css-tooling/lint";
+// src/rules/prefer-component-classes.ts
+var prefer_component_classes_default = create_rule_default({
+	name: "prefer-component-classes",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer a component class over many classes that style other elements through combinators" },
+		messages: { remoteStylingLimit: "{{message}}" },
+		fixable: null,
+		schema: [{
+			type: "object",
+			properties: { max: {
+				type: "integer",
+				minimum: 0
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const { settings, tooling, release } = resolveContext(context);
+		const options = context.options[0] || {};
+		if (shouldUseSourceVisitors(context)) return withContextRelease(defineSourceVisitors({
+			context,
+			tooling,
+			ruleId: "prefer-component-classes",
+			ruleOptions: options
+		}), release);
+		return withContextRelease(defineVisitors({
+			context,
+			settings,
+			tooling
+		}, (node, resolved) => {
+			const diagnostics = createMasterCSSLintDiagnostics(tooling.analyzeLintClassList(resolved.analysisText ?? resolved.raw, resolved.classValues, { remoteStylingPolicy: options }).diagnostics.filter(({ ruleId }) => ruleId === "prefer-component-classes"));
+			reportLintDiagnostics(context, node, resolved, diagnostics);
+		}), release);
+	}
+});
+export { prefer_component_classes_default as default };

package/dist/rules/sort-classes.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClassOrder", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
+};
+export { _default as default };

package/dist/rules/sort-classes.js

@@ -0,0 +1,38 @@
+import create_rule_default from "../create-rule.js";
+import defineVisitors from "../utils/define-visitors.js";
+import resolveContext from "../utils/resolve-context.js";
+import reportLintDiagnostics from "../utils/report-lint-diagnostics.js";
+import defineSourceVisitors, { shouldUseSourceVisitors } from "../utils/define-source-visitors.js";
+import withContextRelease from "../utils/with-context-release.js";
+import { createMasterCSSLintDiagnostics } from "@master/css-tooling/lint";
+// src/rules/sort-classes.ts
+var sort_classes_default = create_rule_default({
+	name: "sort-classes",
+	meta: {
+		type: "layout",
+		fixable: "code",
+		docs: { description: "Sort Master CSS classes" },
+		messages: { invalidClassOrder: "{{message}}" },
+		schema: []
+	},
+	defaultOptions: [],
+	create: function(context) {
+		const { settings, tooling, release } = resolveContext(context);
+		if (shouldUseSourceVisitors(context)) return withContextRelease(defineSourceVisitors({
+			context,
+			tooling,
+			ruleId: "sort-classes"
+		}), release);
+		return withContextRelease(defineVisitors({
+			context,
+			settings,
+			tooling
+		}, (node, resolved) => {
+			const { nodes } = resolved;
+			if (nodes.length <= 1) return;
+			const diagnostics = createMasterCSSLintDiagnostics(tooling.analyzeLintClassList(resolved.analysisText ?? resolved.raw, resolved.classValues).diagnostics.filter(({ ruleId }) => ruleId === "sort-classes"));
+			reportLintDiagnostics(context, node, resolved, diagnostics);
+		}), release);
+	}
+});
+export { sort_classes_default as default };

package/dist/settings-schema.d.ts

@@ -0,0 +1,4 @@
+import { JSONSchema4 } from "@typescript-eslint/utils/json-schema";
+declare const masterCSSSettingsSchema: JSONSchema4;
+declare const noInvalidClassesOptionsSchema: JSONSchema4;
+export { masterCSSSettingsSchema as default, masterCSSSettingsSchema, noInvalidClassesOptionsSchema };

package/dist/settings-schema.js

@@ -0,0 +1,26 @@
+// src/settings-schema.ts
+const sourceMatcherSchema = {
+	type: "array",
+	items: {
+		type: "string",
+		minLength: 1
+	},
+	uniqueItems: true
+};
+const masterCSSSettingsSchema = {
+	type: "object",
+	properties: {
+		classAttributes: sourceMatcherSchema,
+		classFunctions: sourceMatcherSchema,
+		classDeclarations: sourceMatcherSchema,
+		ignoredKeys: sourceMatcherSchema,
+		manifest: { type: "object" }
+	},
+	additionalProperties: false
+};
+const noInvalidClassesOptionsSchema = {
+	type: "object",
+	properties: { disallowUnknownClass: { type: "boolean" } },
+	additionalProperties: false
+};
+export { masterCSSSettingsSchema as default, masterCSSSettingsSchema, noInvalidClassesOptionsSchema };

package/dist/settings.d.ts

@@ -0,0 +1,16 @@
+import { MasterCSSManifest } from "./utils/master-css.js";
+declare const settings: {
+  classAttributes: readonly string[];
+  classFunctions: readonly string[];
+  classDeclarations: readonly string[];
+  ignoredKeys: readonly string[];
+  manifest: any;
+};
+interface Settings {
+  readonly classAttributes?: readonly string[];
+  readonly classFunctions?: readonly string[];
+  readonly classDeclarations?: readonly string[];
+  readonly ignoredKeys: readonly string[];
+  manifest?: MasterCSSManifest;
+}
+export { Settings, settings as default };

package/dist/settings.js

@@ -0,0 +1,7 @@
+import { defaultClassLintSettings } from "@master/css-tooling/lint";
+// src/settings.ts
+const settings = {
+	...defaultClassLintSettings,
+	manifest: void 0
+};
+export { settings as default };

package/dist/utils/define-source-visitors.d.ts

@@ -0,0 +1,13 @@
+import { MasterCSSLintContentRuleOptions, MasterCSSLintRuleId } from "@master/css-tooling/lint";
+import { MasterCSSToolingSession } from "@master/css-tooling";
+import { RuleContext, RuleListener } from "@typescript-eslint/utils/ts-eslint";
+type SourceRuleOptions = MasterCSSLintContentRuleOptions[keyof MasterCSSLintContentRuleOptions];
+interface DefineSourceVisitorsOptions {
+  context: RuleContext<any, any[]>;
+  ruleId: MasterCSSLintRuleId;
+  ruleOptions?: SourceRuleOptions;
+  tooling: MasterCSSToolingSession;
+}
+declare function shouldUseSourceVisitors(context: RuleContext<any, any[]>): boolean;
+declare function defineSourceVisitors({ context, ruleId, ruleOptions, tooling }: DefineSourceVisitorsOptions): RuleListener;
+export { defineSourceVisitors as default, shouldUseSourceVisitors };

package/dist/utils/define-source-visitors.js

@@ -0,0 +1,51 @@
+import { messageIdByCode, stringifyLintDiagnosticMessageData } from "./report-lint-diagnostics.js";
+import { lintMasterCSSContent, masterCSSLintRuleIds } from "@master/css-tooling/lint";
+// src/utils/define-source-visitors.ts
+const SOURCE_LINT_FILE_RE = /\.mdx$/i;
+function shouldUseSourceVisitors(context) {
+	const filename = context.physicalFilename || context.filename;
+	return typeof filename === "string" && SOURCE_LINT_FILE_RE.test(filename);
+}
+function getFilename(context) {
+	return context.physicalFilename || context.filename || "source.mdx";
+}
+function createSingleRuleSet(ruleId) {
+	return Object.fromEntries(masterCSSLintRuleIds.map((eachRuleId) => [eachRuleId, eachRuleId === ruleId]));
+}
+function createRuleOptions(ruleId, ruleOptions) {
+	return ruleOptions ? { [ruleId]: ruleOptions } : void 0;
+}
+function reportSourceDiagnostic(context, node, diagnostic) {
+	const { sourceCode } = context;
+	const messageId = messageIdByCode[diagnostic.code];
+	const fix = diagnostic.fixes?.[0];
+	const descriptor = {
+		node,
+		loc: {
+			start: sourceCode.getLocFromIndex(diagnostic.range.start),
+			end: sourceCode.getLocFromIndex(diagnostic.range.end)
+		},
+		...messageId ? {
+			messageId,
+			data: stringifyLintDiagnosticMessageData(diagnostic)
+		} : { message: diagnostic.message }
+	};
+	if (fix) descriptor.fix = (fixer) => fixer.replaceTextRange([fix.range.start, fix.range.end], fix.text);
+	context.report(descriptor);
+}
+function defineSourceVisitors({ context, ruleId, ruleOptions, tooling }) {
+	return { Program(node) {
+		const result = lintMasterCSSContent({
+			content: context.sourceCode.getText(),
+			filePath: getFilename(context),
+			rules: createSingleRuleSet(ruleId),
+			ruleOptions: createRuleOptions(ruleId, ruleOptions),
+			lintSession: tooling
+		});
+		for (const diagnostic of result.diagnostics) {
+			if (diagnostic.ruleId !== ruleId) continue;
+			reportSourceDiagnostic(context, node, diagnostic);
+		}
+	} };
+}
+export { defineSourceVisitors as default, shouldUseSourceVisitors };

package/dist/utils/define-visitors.d.ts

@@ -0,0 +1,11 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import { Settings } from "../settings.js";
+import { MasterCSSToolingSession } from "@master/css-tooling";
+import { RuleContext, RuleListener } from "@typescript-eslint/utils/ts-eslint";
+import resolveClassNode from "./resolve-class-node.js";
+declare function defineVisitors({ context, settings, tooling }: {
+  context: RuleContext<any, any[]>;
+  settings: Settings;
+  tooling: Pick<MasterCSSToolingSession, 'tokenizeClassList' | 'decodeHTMLAttribute'>;
+}, visitNode: (node: TSESTree.Node, resolved: ReturnType<typeof resolveClassNode>) => void): RuleListener;
+export { defineVisitors as default };

package/dist/utils/define-visitors.js

@@ -0,0 +1,102 @@
+import withVisitClassNode from "./with-visit-class-node.js";
+// src/utils/define-visitors.ts
+function defineVisitors({ context, settings, tooling }, visitNode) {
+	const classAttributeRegex = new RegExp(`^(?:${settings.classAttributes.join("|")})$`);
+	const classFunctionsRegex = new RegExp(`^(?:${settings.classFunctions.join("|")})$`);
+	const classDeclarationsRegex = new RegExp(`^(?:${settings.classDeclarations.join("|")})$`);
+	const visitClassNode = withVisitClassNode(visitNode, context, tooling);
+	const getStaticName = (node) => {
+		if (!node) return;
+		if (node.type === "Identifier") return node.name;
+		if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	};
+	const getMemberExpressionName = (node) => {
+		if (!node || node.type !== "MemberExpression") return;
+		const objectName = getStaticName(node.object);
+		const propertyName = getStaticName(node.property);
+		if (!objectName || !propertyName) return;
+		return `${objectName}.${propertyName}`;
+	};
+	const getCalleeName = (node) => {
+		const calleeNode = node.callee || node.tag;
+		return getStaticName(calleeNode) || getMemberExpressionName(calleeNode);
+	};
+	const allowCalleeNode = (node) => {
+		const calleeName = getCalleeName(node);
+		return calleeName ? classFunctionsRegex.test(calleeName) : false;
+	};
+	const getPropertyName = (prop) => getStaticName(prop.key);
+	const visitUtilityDefinitions = (node) => {
+		if (!node) return;
+		if (node.type === "ArrayExpression") {
+			node.elements.forEach((element) => {
+				if (!element || element.type === "ObjectExpression") return;
+				visitClassNode(element);
+			});
+			return;
+		}
+		if (node.type !== "ObjectExpression") {
+			visitClassNode(node);
+			return;
+		}
+	};
+	const visitClassDeclarationNode = (name, node) => {
+		if (name !== "utilities") {
+			visitClassNode(node);
+			return;
+		}
+		visitUtilityDefinitions(node);
+	};
+	const CallExpression = function(node) {
+		if (!allowCalleeNode(node)) return;
+		node.arguments.forEach((node) => {
+			visitClassNode(node);
+		});
+	};
+	const scriptVisitor = {
+		CallExpression,
+		JSXAttribute: function(node) {
+			if (!node.name || !classAttributeRegex.test(node.name.name)) return;
+			if (node.value) visitClassNode(node.value);
+		},
+		SvelteAttribute: function(node) {
+			if (!node.key?.name || !classAttributeRegex.test(node.key.name)) return;
+			for (const eachValue of node.value) visitClassNode(eachValue);
+		},
+		TextAttribute: function(node) {
+			if (!node.name || !classAttributeRegex.test(node.name)) return;
+			visitClassNode(node);
+		},
+		TaggedTemplateExpression: function(node) {
+			if (allowCalleeNode(node)) {
+				visitClassNode(node.quasi);
+				return;
+			}
+		},
+		VariableDeclaration: function(node) {
+			node.declarations.forEach((decl) => {
+				if (decl.id.type === "Identifier" && classDeclarationsRegex.test(decl.id.name)) visitClassDeclarationNode(decl.id.name, decl.init);
+			});
+		},
+		ObjectExpression: function(node) {
+			node.properties.forEach((prop) => {
+				if (prop.type === "Property") {
+					const propName = getPropertyName(prop);
+					if (typeof propName === "string" && classDeclarationsRegex.test(propName)) visitClassDeclarationNode(propName, prop.value);
+				}
+			});
+		}
+	};
+	const templateBodyVisitor = {
+		CallExpression,
+		VAttribute: function(node) {
+			const name = node.key?.argument?.name || node.key?.name;
+			if (!name || !classAttributeRegex.test(name)) return;
+			if (node.value && node.value.type === "VLiteral") visitClassNode(node.value);
+			else if (node.value?.type === "VExpressionContainer" && node.value.expression) visitClassNode(node.value.expression);
+		}
+	};
+	if (context.sourceCode.parserServices == null || context.sourceCode.parserServices.defineTemplateBodyVisitor == null) return scriptVisitor;
+	else return context.sourceCode.parserServices.defineTemplateBodyVisitor(templateBodyVisitor, scriptVisitor);
+}
+export { defineVisitors as default };

package/dist/utils/dependency-stamp.d.ts

@@ -0,0 +1,10 @@
+interface DependencyStamp {
+  path: string;
+  mtimeNs: bigint;
+  ctimeNs: bigint;
+  size: bigint;
+  ino: bigint;
+}
+declare function stampDependency(path: string): DependencyStamp;
+declare function isDependencyCurrent(stamp: DependencyStamp): boolean;
+export { DependencyStamp, isDependencyCurrent, stampDependency };

package/dist/utils/dependency-stamp.js

@@ -0,0 +1,27 @@
+import { statSync } from "node:fs";
+// src/utils/dependency-stamp.ts
+function stampDependency(path) {
+	try {
+		const { mtimeNs, ctimeNs, size, ino } = statSync(path, { bigint: true });
+		return {
+			path,
+			mtimeNs,
+			ctimeNs,
+			size,
+			ino
+		};
+	} catch {
+		return {
+			path,
+			mtimeNs: -1n,
+			ctimeNs: -1n,
+			size: -1n,
+			ino: -1n
+		};
+	}
+}
+function isDependencyCurrent(stamp) {
+	const current = stampDependency(stamp.path);
+	return current.mtimeNs === stamp.mtimeNs && current.ctimeNs === stamp.ctimeNs && current.size === stamp.size && current.ino === stamp.ino;
+}
+export { isDependencyCurrent, stampDependency };

package/dist/utils/is-same-or-child-path.d.ts

@@ -0,0 +1,2 @@
+declare function isSameOrChildPath(parentPath: string, childPath: string): boolean;
+export { isSameOrChildPath as default };

package/dist/utils/is-same-or-child-path.js

@@ -0,0 +1,7 @@
+import path from "node:path";
+// src/utils/is-same-or-child-path.ts
+function isSameOrChildPath(parentPath, childPath) {
+	const relativePath = path.relative(parentPath, childPath);
+	return relativePath === "" || !!relativePath && relativePath !== ".." && !relativePath.startsWith(`..${path.sep}`) && !path.isAbsolute(relativePath);
+}
+export { isSameOrChildPath as default };

package/dist/utils/javascript-literal.d.ts

@@ -0,0 +1,3 @@
+declare function javascriptLiteralRange(raw: string, cooked: string): (start: number, end: number) => [number, number];
+declare function encodeJavaScriptLiteral(text: string, quote: string, newline?: string): string;
+export { encodeJavaScriptLiteral, javascriptLiteralRange };

package/dist/utils/javascript-literal.js

@@ -0,0 +1,51 @@
+// src/utils/javascript-literal.ts
+function javascriptLiteralRange(raw, cooked) {
+	const starts = [];
+	const ends = [];
+	for (let index = 0; index < raw.length;) {
+		const start = index++;
+		let width = 1;
+		if (raw[start] === "\\") {
+			const character = raw[index++];
+			if (character === "\r" || character === "\n" || character === "\u2028" || character === "\u2029") {
+				if (character === "\r" && raw[index] === "\n") index++;
+				width = 0;
+			} else if (character === "u") {
+				if (raw[index] === "{") {
+					const end = raw.indexOf("}", index + 1);
+					if (end === -1) return;
+					width = Number.parseInt(raw.slice(index + 1, end), 16) > 65535 ? 2 : 1;
+					index = end + 1;
+				} else index += 4;
+			} else if (character === "x") index += 2;
+			else if (/[0-7]/.test(character)) {
+				const limit = character <= "3" ? 2 : 1;
+				for (let count = 0; count < limit && /[0-7]/.test(raw[index] ?? ""); count++) index++;
+			}
+		} else if (raw[start] === "\r" && raw[index] === "\n") index++;
+		if (index > raw.length) return;
+		for (let unit = 0; unit < width; unit++) {
+			starts.push(start);
+			ends.push(index);
+		}
+	}
+	if (starts.length !== cooked.length) return;
+	return (start, end) => {
+		const rawStart = starts[start] ?? raw.length;
+		return [rawStart, start === end ? rawStart : ends[end - 1] ?? raw.length];
+	};
+}
+function encodeJavaScriptLiteral(text, quote, newline = "\n") {
+	let result = "";
+	for (let index = 0; index < text.length; index++) {
+		const character = text[index];
+		const code = text.charCodeAt(index);
+		if (character === "\\" || character === quote || quote === "`" && character === "$" && text[index + 1] === "{") result += "\\" + character;
+		else if (quote === "`" && character === "\n") result += newline;
+		else if (character === "	") result += character;
+		else if (code < 32 || code === 8232 || code === 8233 || code >= 55296 && code <= 57343) result += "\\u" + code.toString(16).padStart(4, "0");
+		else result += character;
+	}
+	return result;
+}
+export { encodeJavaScriptLiteral, javascriptLiteralRange };

package/dist/utils/master-css.d.ts

@@ -0,0 +1,3 @@
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+declare const defaultManifest: MasterCSSManifest;
+export { type MasterCSSManifest, defaultManifest };

package/dist/utils/master-css.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+// src/utils/master-css.ts
+const defaultManifest = createRequire(import.meta.url)("@master/css-preset/default-manifest.json");
+export { defaultManifest };

package/dist/utils/report-lint-diagnostics.d.ts

@@ -0,0 +1,20 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import { MasterCSSLintDiagnostic, MasterCSSLintFix } from "@master/css-tooling/lint";
+import { RuleContext } from "@typescript-eslint/utils/ts-eslint";
+import { ResolvedClassNode } from "./resolve-class-node.js";
+type FixRange = [number, number];
+interface ReportLintDiagnosticsOptions {
+  getFix?: (diagnostic: MasterCSSLintDiagnostic, fix: MasterCSSLintFix) => {
+    range: FixRange;
+    text: string;
+  } | undefined;
+}
+declare const messageIdByCode: Record<string, string>;
+declare function stringifyLintDiagnosticData(data?: MasterCSSLintDiagnostic['data']): {
+  [k: string]: string;
+};
+declare function stringifyLintDiagnosticMessageData(diagnostic: Pick<MasterCSSLintDiagnostic, 'data' | 'message'>): {
+  [k: string]: string;
+};
+declare function reportLintDiagnostics(context: RuleContext<any, any[]>, node: TSESTree.Node, resolved: ResolvedClassNode, diagnostics: readonly MasterCSSLintDiagnostic[], options?: ReportLintDiagnosticsOptions): void;
+export { reportLintDiagnostics as default, messageIdByCode, stringifyLintDiagnosticData, stringifyLintDiagnosticMessageData };

package/dist/utils/report-lint-diagnostics.js

@@ -0,0 +1,54 @@
+// src/utils/report-lint-diagnostics.ts
+const messageIdByCode = {
+	"invalid-class-order": "invalidClassOrder",
+	"invalid-class": "invalidClass",
+	"unknown-class": "disallowUnknownClass",
+	"conflicting-class": "collisionClass",
+	"partially-conflicting-class": "partialCollisionClass",
+	"prefer-canonical-class": "preferClass",
+	"prefer-native-declaration": "preferClass",
+	"prefer-variant-block": "preferClass",
+	"unapproved-raw-value": "unapprovedRawValue",
+	"remote-styling-limit": "remoteStylingLimit"
+};
+function stringifyLintDiagnosticData(data = {}) {
+	return Object.fromEntries(Object.entries(data).filter(([, value]) => value !== void 0).map(([key, value]) => [key, Array.isArray(value) ? value.join(", ") : String(value)]));
+}
+function stringifyLintDiagnosticMessageData(diagnostic) {
+	return stringifyLintDiagnosticData({
+		...diagnostic.data,
+		message: diagnostic.message
+	});
+}
+function defaultFix(resolved, fix) {
+	if (fix.scope === "directive") return;
+	const [start, end] = resolved.sourceRange?.(fix.range.start, fix.range.end) ?? [fix.range.start, fix.range.end];
+	return {
+		range: [resolved.start + start, resolved.start + end],
+		text: resolved.encodeReplacement?.(fix.text) ?? fix.text
+	};
+}
+function reportLintDiagnostics(context, node, resolved, diagnostics, options = {}) {
+	const { sourceCode } = context;
+	for (const diagnostic of diagnostics) {
+		const range = resolved.sourceRange?.(diagnostic.range.start, diagnostic.range.end) ?? [diagnostic.range.start, diagnostic.range.end];
+		const start = resolved.start + range[0];
+		const end = resolved.start + range[1];
+		const messageId = messageIdByCode[diagnostic.code];
+		const fix = diagnostic.fix && resolved.canFix !== false ? options.getFix?.(diagnostic, diagnostic.fix) || defaultFix(resolved, diagnostic.fix) : void 0;
+		const descriptor = {
+			node,
+			loc: {
+				start: sourceCode.getLocFromIndex(start),
+				end: sourceCode.getLocFromIndex(end)
+			},
+			...messageId ? {
+				messageId,
+				data: stringifyLintDiagnosticMessageData(diagnostic)
+			} : { message: diagnostic.message }
+		};
+		if (fix) descriptor.fix = (fixer) => fixer.replaceTextRange(fix.range, fix.text);
+		context.report(descriptor);
+	}
+}
+export { reportLintDiagnostics as default, messageIdByCode, stringifyLintDiagnosticData, stringifyLintDiagnosticMessageData };

package/dist/utils/resolve-class-node.d.ts

@@ -0,0 +1,26 @@
+import { MasterCSSToolingSession } from "@master/css-tooling";
+import { RuleContext } from "@typescript-eslint/utils/ts-eslint";
+type ResolvedClassListUnescape = string | false;
+interface ResolvedClassListNode {
+  type: 'class' | 'space';
+  value: string;
+  raw: string;
+  range: [number, number];
+  loc: any;
+}
+interface ResolvedClassNode {
+  nodes: ResolvedClassListNode[];
+  start: number;
+  end: number;
+  raw: string;
+  value: string;
+  unescape: ResolvedClassListUnescape;
+  classNodes: ResolvedClassListNode[];
+  classValues: string[];
+  analysisText?: string;
+  sourceRange?: (start: number, end: number) => [number, number];
+  encodeReplacement?: (text: string) => string;
+  canFix?: boolean;
+}
+declare function resolveClassNode(node: any, context: RuleContext<any, any[]>, lintSession: Pick<MasterCSSToolingSession, 'tokenizeClassList' | 'decodeHTMLAttribute'>): ResolvedClassNode | undefined;
+export { ResolvedClassListNode, ResolvedClassListUnescape, ResolvedClassNode, resolveClassNode as default };