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

package/dist/language/session.js

@@ -1,87 +0,0 @@
-import { freezeToolingResult } from "../immutable.js";
-import { withCSSValueValidation } from "../value-validation.js";
-import { MASTER_CSS_LANGUAGE_BATCH_VERSION } from "@master/css-binding/tooling";
-import { MasterCSSError } from "@master/css-schema";
-// src/language/session.ts
-function parse(value) {
-	return value;
-}
-function validate(value) {
-	if (value.version !== MASTER_CSS_LANGUAGE_BATCH_VERSION) throw new MasterCSSError({
-		code: "LANGUAGE_BATCH_VERSION_MISMATCH",
-		domain: "tooling",
-		message: `Expected Master CSS language batch version ${MASTER_CSS_LANGUAGE_BATCH_VERSION}, received ${String(value.version)}.`
-	});
-	return freezeToolingResult(value);
-}
-function bindLanguageSession(binding, session, nativeClassNames = []) {
-	const nativeClasses = new Set(nativeClassNames);
-	let disposed = false;
-	const assertActive = () => {
-		if (disposed) throw new MasterCSSError({
-			code: "SESSION_DISPOSED",
-			domain: "tooling",
-			message: "The Master CSS language session has been disposed."
-		});
-	};
-	const dispose = () => {
-		if (disposed) return;
-		disposed = true;
-		completionIndexCache = void 0;
-		session.dispose();
-	};
-	let completionIndexCache;
-	return {
-		binding,
-		analyzeDocument(request) {
-			assertActive();
-			const prepared = session.prepareDocument(request);
-			try {
-				return validate(parse(session.finishDocument(prepared.id, [])));
-			} finally {
-				session.cancelDocument(prepared.id);
-			}
-		},
-		formatDirectives(request) {
-			assertActive();
-			return validate(parse(session.formatDirectives(request)));
-		},
-		nativeDeclarationCompletion(request) {
-			assertActive();
-			const completion = parse(session.nativeDeclarationCompletion(request));
-			return completion ? validate(completion) : void 0;
-		},
-		classifyClassNames(classNames) {
-			assertActive();
-			const values = [...classNames];
-			return validate(parse(session.classifyClassNames(values)));
-		},
-		inspectClassName(className) {
-			assertActive();
-			const result = parse(session.inspectClassName(className));
-			return validate(withCSSValueValidation({
-				...result,
-				diagnostics: nativeClasses.has(className) && !result.rules.length ? [] : result.diagnostics ?? []
-			}));
-		},
-		tokenFamilies() {
-			assertActive();
-			return validate(parse(session.tokenFamilies()));
-		},
-		completionIndex() {
-			assertActive();
-			return completionIndexCache ||= validate(parse(session.completionIndex()));
-		},
-		colorPresentation(token) {
-			assertActive();
-			return validate(parse(session.colorPresentation(token)));
-		},
-		colorTokens(candidates) {
-			assertActive();
-			return validate(parse(session.colorTokens(candidates)));
-		},
-		dispose,
-		[Symbol.dispose]: dispose
-	};
-}
-export { bindLanguageSession };

package/dist/language/settings.d.ts

@@ -1,13 +0,0 @@
-import { MasterCSSManifest } from "@master/css-schema/manifest";
-interface ClassPositionSettings {
-  classAttributes?: string[];
-  classFunctions?: string[];
-  classDeclarations?: string[];
-  classAttributeBindings?: Record<string, [string, string] | false>;
-}
-declare const languageSettings: LanguageSettings;
-interface LanguageSettings extends ClassPositionSettings {
-  manifest?: MasterCSSManifest;
-  embeddedSyntaxHighlighting?: 'active' | 'always' | 'off';
-}
-export { ClassPositionSettings, LanguageSettings, languageSettings as default };

package/dist/language/settings.js

@@ -1,19 +0,0 @@
-import { CLASS_ATTRIBUTES, CLASS_DECLARATIONS, CLASS_FUNCTIONS } from "./master-css.js";
-// src/language/settings.ts
-const languageSettings = {
-	classAttributes: CLASS_ATTRIBUTES,
-	classAttributeBindings: {
-		"className": ["{", "}"],
-		"class": ["{", "}"],
-		"class:list": ["{", "}"],
-		":class": ["\"", "\""],
-		"v-bind:class": ["\"", "\""],
-		"[class]": ["\"", "\""],
-		"[className]": ["\"", "\""],
-		"[ngClass]": ["\"", "\""]
-	},
-	classDeclarations: CLASS_DECLARATIONS,
-	classFunctions: CLASS_FUNCTIONS,
-	embeddedSyntaxHighlighting: "active"
-};
-export { languageSettings as default };

package/dist/language/utils/mdn-css-data.d.ts

@@ -1,5 +0,0 @@
-declare function getMdnPropertySyntax(name: string | undefined): string | undefined;
-declare function getMdnPropertyValueNames(name: string | undefined): string[];
-declare function getMdnPseudoClassNames(): string[];
-declare function getMdnPseudoElementNames(): string[];
-export { getMdnPropertySyntax, getMdnPropertyValueNames, getMdnPseudoClassNames, getMdnPseudoElementNames };

package/dist/language/utils/mdn-css-data.js

@@ -1,63 +0,0 @@
-import propertiesJSON from "mdn-data/css/properties.json" with { type: "json" };
-import selectorsJSON from "mdn-data/css/selectors.json" with { type: "json" };
-import syntaxesJSON from "mdn-data/css/syntaxes.json" with { type: "json" };
-// src/language/utils/mdn-css-data.ts
-const mdnCSSData = {
-	properties: propertiesJSON,
-	selectors: selectorsJSON,
-	syntaxes: syntaxesJSON
-};
-const PAGE_PSEUDO_CLASS_NAMES = /* @__PURE__ */ new Set([
-	":first",
-	":left",
-	":right",
-	":blank"
-]);
-const REFERENCE_RE = /<('([^']+)'|([a-zA-Z][\w-]*)(?:\s+[^>]*)?)>/g;
-const TOKEN_RE = /-?[a-zA-Z_][\w-]*/g;
-const VENDOR_PREFIX_RE = /^-(?:webkit|moz|ms)-/;
-const NON_KEYWORD_TOKENS = /* @__PURE__ */ new Set([
-	"∞",
-	"n",
-	"of"
-]);
-function unique(values) {
-	return [...new Set(values)];
-}
-function getMdnPropertySyntax(name) {
-	if (!name) return;
-	const exactSyntax = mdnCSSData.properties[name]?.syntax;
-	if (exactSyntax) return exactSyntax;
-	if (VENDOR_PREFIX_RE.test(name)) return mdnCSSData.properties[name.replace(VENDOR_PREFIX_RE, "")]?.syntax;
-}
-function getSyntaxByReference(name) {
-	return mdnCSSData.properties[name]?.syntax || mdnCSSData.syntaxes[name]?.syntax;
-}
-function collectSyntaxKeywordValues(syntax, seen = /* @__PURE__ */ new Set()) {
-	if (!syntax) return [];
-	const values = [];
-	let syntaxWithoutReferences = syntax;
-	for (const match of syntax.matchAll(REFERENCE_RE)) {
-		const referenceName = match[2] || match[3];
-		if (!referenceName || seen.has(referenceName)) continue;
-		seen.add(referenceName);
-		values.push(...collectSyntaxKeywordValues(getSyntaxByReference(referenceName), seen));
-		syntaxWithoutReferences = syntaxWithoutReferences.replace(match[0], " ");
-	}
-	for (const match of syntaxWithoutReferences.matchAll(TOKEN_RE)) {
-		const value = match[0];
-		if (NON_KEYWORD_TOKENS.has(value) || /^-?\d/.test(value)) continue;
-		values.push(value);
-	}
-	return unique(values);
-}
-function getMdnPropertyValueNames(name) {
-	return unique(collectSyntaxKeywordValues(getMdnPropertySyntax(name)));
-}
-function getMdnPseudoClassNames() {
-	return Object.keys(mdnCSSData.selectors).filter((name) => name.startsWith(":") && !name.startsWith("::") && !PAGE_PSEUDO_CLASS_NAMES.has(name));
-}
-function getMdnPseudoElementNames() {
-	return Object.keys(mdnCSSData.selectors).filter((name) => name.startsWith("::"));
-}
-export { getMdnPropertySyntax, getMdnPropertyValueNames, getMdnPseudoClassNames, getMdnPseudoElementNames };

package/dist/lexer/browser.d.ts

@@ -1,6 +0,0 @@
-import { LexerSession, LexerSessionError } from "./session.js";
-import { MasterCSSWasmBindingLoadOptions } from "@master/css-binding/tooling";
-declare function createLexerSession(options?: {
-  wasm?: MasterCSSWasmBindingLoadOptions;
-}): Promise<LexerSession>;
-export { type LexerSession, LexerSessionError, createLexerSession };

package/dist/lexer/browser.js

@@ -1,11 +0,0 @@
-import { LexerSessionError, bindLexerSession } from "./session.js";
-import { createToolingBinding } from "@master/css-binding/tooling";
-// src/lexer/browser.ts
-async function createLexerSession(options = {}) {
-	const tooling = await createToolingBinding({
-		binding: "wasm",
-		wasm: options.wasm
-	});
-	return bindLexerSession(tooling.binding, await tooling.createLexerSession());
-}
-export { LexerSessionError, createLexerSession };

package/dist/lexer/contracts.d.ts

@@ -1,41 +0,0 @@
-interface MasterCSSSourceRange {
-  readonly start: number;
-  readonly end: number;
-}
-interface MasterCSSClassListInput {
-  readonly source: string;
-  readonly unescape?: readonly string[];
-}
-interface MasterCSSClassListAnalysisRequest {
-  readonly classLists?: readonly MasterCSSClassListInput[];
-  readonly cssSources?: readonly string[];
-  readonly escapeIdentifiers?: readonly string[];
-}
-interface MasterCSSClassListItem {
-  readonly range: MasterCSSSourceRange;
-  readonly raw: string;
-  readonly token: string;
-}
-interface MasterCSSCSSDirectiveAnalysis {
-  readonly name: string;
-  readonly range: MasterCSSSourceRange;
-  readonly preludeRange: MasterCSSSourceRange;
-  readonly hasBlock: boolean;
-  readonly quotedStrings: number;
-}
-interface MasterCSSCSSImportAnalysis {
-  readonly range: MasterCSSSourceRange;
-  readonly statement: string;
-  readonly source?: string;
-}
-interface MasterCSSCSSAnalysis {
-  readonly directives: readonly MasterCSSCSSDirectiveAnalysis[];
-  readonly imports: readonly MasterCSSCSSImportAnalysis[];
-}
-interface MasterCSSClassListAnalysis {
-  readonly version: 1;
-  readonly classLists: readonly (readonly MasterCSSClassListItem[])[];
-  readonly cssSources: readonly MasterCSSCSSAnalysis[];
-  readonly escapedIdentifiers: readonly string[];
-}
-export { MasterCSSCSSAnalysis, MasterCSSCSSDirectiveAnalysis, MasterCSSCSSImportAnalysis, MasterCSSClassListAnalysis, MasterCSSClassListAnalysisRequest, MasterCSSClassListInput, MasterCSSClassListItem, MasterCSSSourceRange };

package/dist/lexer/contracts.js

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

package/dist/lexer/index.d.ts

@@ -1,8 +0,0 @@
-import { MasterCSSCSSAnalysis, MasterCSSCSSDirectiveAnalysis, MasterCSSCSSImportAnalysis, MasterCSSClassListAnalysis, MasterCSSClassListAnalysisRequest, MasterCSSClassListInput, MasterCSSClassListItem, MasterCSSSourceRange } from "./contracts.js";
-import { MasterCSSBinding } from "@master/css-binding";
-import { MasterCSSManifest } from "@master/css-schema/manifest";
-declare function analyzeClassList(request: MasterCSSClassListAnalysisRequest, options: {
-  readonly manifest: MasterCSSManifest;
-  readonly binding?: MasterCSSBinding;
-}): Promise<MasterCSSClassListAnalysis>;
-export { type MasterCSSCSSAnalysis, type MasterCSSCSSDirectiveAnalysis, type MasterCSSCSSImportAnalysis, type MasterCSSClassListAnalysis, type MasterCSSClassListAnalysisRequest, type MasterCSSClassListInput, type MasterCSSClassListItem, type MasterCSSSourceRange, analyzeClassList };

package/dist/lexer/index.js

@@ -1,11 +0,0 @@
-import { createToolingSession } from "../tooling-session.js";
-// src/lexer/index.ts
-async function analyzeClassList(request, options) {
-	const session = await createToolingSession(options);
-	try {
-		return session.analyzeClassList(request);
-	} finally {
-		session.dispose();
-	}
-}
-export { analyzeClassList };

package/dist/lexer/node.d.ts

@@ -1,7 +0,0 @@
-import { MasterCSSClassListAnalysis, MasterCSSClassListAnalysisRequest } from "./contracts.js";
-import "./index.js";
-import { MasterCSSManifest } from "@master/css-schema/manifest";
-declare function analyzeClassListSync(request: MasterCSSClassListAnalysisRequest, options: {
-  readonly manifest: MasterCSSManifest;
-}): MasterCSSClassListAnalysis;
-export { analyzeClassListSync };

package/dist/lexer/node.js

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

package/dist/lexer/session.d.ts

@@ -1,17 +0,0 @@
-import { MasterCSSLexerBatch, MasterCSSLexerBatchRequest } from "@master/css-binding/tooling";
-type LexerBatchRequest = MasterCSSLexerBatchRequest;
-interface BindingLexerSession {
-  analyze(request: unknown): unknown;
-  dispose(): void;
-}
-interface LexerSession {
-  readonly binding: 'native' | 'wasm';
-  analyze(request: LexerBatchRequest): MasterCSSLexerBatch;
-  dispose(): void;
-}
-declare class LexerSessionError extends Error {
-  readonly code: 'NATIVE_UNAVAILABLE' | 'LEXER_BATCH_VERSION_MISMATCH';
-  constructor(code: 'NATIVE_UNAVAILABLE' | 'LEXER_BATCH_VERSION_MISMATCH', message: string);
-}
-declare function bindLexerSession(binding: LexerSession['binding'], session: BindingLexerSession): LexerSession;
-export { LexerBatchRequest, LexerSession, LexerSessionError, bindLexerSession };

package/dist/lexer/session.js

@@ -1,25 +0,0 @@
-import { MASTER_CSS_LEXER_BATCH_VERSION } from "@master/css-binding/tooling";
-// src/lexer/session.ts
-var LexerSessionError = class extends Error {
-	code;
-	constructor(code, message) {
-		super(message);
-		this.code = code;
-		this.name = "LexerSessionError";
-	}
-};
-function parse(value) {
-	const result = value;
-	if (result.version !== MASTER_CSS_LEXER_BATCH_VERSION) throw new LexerSessionError("LEXER_BATCH_VERSION_MISMATCH", `Expected Master CSS lexer batch version ${MASTER_CSS_LEXER_BATCH_VERSION}, received ${String(result.version)}.`);
-	return result;
-}
-function bindLexerSession(binding, session) {
-	return {
-		binding,
-		analyze(request) {
-			return parse(session.analyze(request));
-		},
-		dispose: () => session.dispose()
-	};
-}
-export { LexerSessionError, bindLexerSession };

package/dist/lint/analysis.d.ts

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

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

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

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

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

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

package/dist/lint/constants.js

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

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

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

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

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

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