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

package/dist/language/master-css.js

@@ -0,0 +1,35 @@
+import { getMdnPropertySyntax } from "./utils/mdn-css-data.js";
+// src/language/master-css.ts
+function matchesLanguageServiceNativeDeclaration({ property }) {
+	return property.startsWith("--") || Boolean(getMdnPropertySyntax(property));
+}
+const SELECTOR_SIGNS = [
+	":",
+	"_",
+	">",
+	"+",
+	"~"
+];
+const QUERY_COMPARISON_OPERATORS = [
+	">",
+	"<",
+	"="
+];
+const QUERY_LOGICAL_OPERATORS = ["&"];
+const DELIMITER_SIGN = "|";
+const SEPARATOR_SIGN = ",";
+const AT_SIGN = "@";
+const CLASS_ATTRIBUTES = ["class", "className"];
+const CLASS_DECLARATIONS = [];
+const CLASS_FUNCTIONS = [
+	"clsx",
+	"cva",
+	"ctl",
+	"cv",
+	"class",
+	"classnames",
+	"classVariant",
+	"styled(?:\\s+)?(?:\\.\\w+)?",
+	"classList(?:\\s+)?\\.(?:add|remove|toggle|replace)"
+];
+export { AT_SIGN, CLASS_ATTRIBUTES, CLASS_DECLARATIONS, CLASS_FUNCTIONS, DELIMITER_SIGN, QUERY_COMPARISON_OPERATORS, QUERY_LOGICAL_OPERATORS, SELECTOR_SIGNS, SEPARATOR_SIGN, matchesLanguageServiceNativeDeclaration };

package/dist/language/node.d.ts

@@ -0,0 +1,21 @@
+import { MasterCSSDocumentAnalysis, MasterCSSDocumentAnalysisRequest, MasterCSSFormatDirectivesRequest, MasterCSSFormatDirectivesResult, MasterCSSLanguageInspection } from "./contracts.js";
+import { LanguageSession } from "./session.js";
+import "./index.js";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+/**
+ * Create a reusable native language-only session synchronously.
+ * Results are immutable snapshots. Dispose the session when its owner is finished.
+ */
+declare function createLanguageSessionSync(options: {
+  readonly manifest: MasterCSSManifest;
+}): LanguageSession;
+declare function analyzeDocumentSync(request: MasterCSSDocumentAnalysisRequest, options: {
+  readonly manifest: MasterCSSManifest;
+}): MasterCSSDocumentAnalysis;
+declare function inspectClassNameSync(className: string, options: {
+  readonly manifest: MasterCSSManifest;
+}): MasterCSSLanguageInspection;
+declare function formatDirectivesSync(request: MasterCSSFormatDirectivesRequest, options: {
+  readonly manifest: MasterCSSManifest;
+}): MasterCSSFormatDirectivesResult;
+export { type LanguageSession as MasterCSSLanguageSession, analyzeDocumentSync, createLanguageSessionSync, formatDirectivesSync, inspectClassNameSync };

package/dist/language/node.js

@@ -0,0 +1,36 @@
+import { bindLanguageSession } from "./session.js";
+import { createToolingBindingSync } from "@master/css-binding/tooling/node";
+// src/language/node.ts
+/**
+* Create a reusable native language-only session synchronously.
+* Results are immutable snapshots. Dispose the session when its owner is finished.
+*/
+function createLanguageSessionSync(options) {
+	const binding = createToolingBindingSync();
+	return bindLanguageSession(binding.binding, binding.createLanguageSession(options.manifest));
+}
+function analyzeDocumentSync(request, options) {
+	const session = createLanguageSessionSync(options);
+	try {
+		return session.analyzeDocument(request);
+	} finally {
+		session.dispose();
+	}
+}
+function inspectClassNameSync(className, options) {
+	const session = createLanguageSessionSync(options);
+	try {
+		return session.inspectClassName(className);
+	} finally {
+		session.dispose();
+	}
+}
+function formatDirectivesSync(request, options) {
+	const session = createLanguageSessionSync(options);
+	try {
+		return session.formatDirectives(request);
+	} finally {
+		session.dispose();
+	}
+}
+export { analyzeDocumentSync, createLanguageSessionSync, formatDirectivesSync, inspectClassNameSync };

package/dist/language/semantic/scopes.d.ts

@@ -0,0 +1,55 @@
+import { SemanticTokenModifier, SemanticTokenType } from "./types.js";
+declare const MASTER_CSS_SEMANTIC_TOKEN_SCOPE_MAP: {
+  readonly class: ["entity.other.attribute-name.class.css"];
+  readonly 'class.component': ["entity.other.attribute-name.class.css"];
+  readonly 'class.declaration': ["entity.other.attribute-name.class.css"];
+  readonly 'class.selector': ["entity.other.attribute-name.class.css"];
+  readonly enumMember: ["support.constant.property-value.css"];
+  readonly 'enumMember.directive': ["support.constant.property-value.css"];
+  readonly 'enumMember.query': ["support.constant.property-value.css"];
+  readonly 'enumMember.unit': ["keyword.other.unit"];
+  readonly property: ["support.type.property-name.css"];
+  readonly 'property.directive': ["support.type.property-name.css"];
+  readonly 'property.query': ["support.type.property-name.css"];
+  readonly variable: ["variable.other.master-css.css", "variable.css"];
+  readonly 'variable.directive': ["variable.parameter.master-css.css"];
+  readonly 'variable.selector': ["entity.other.attribute-name.id.css"];
+  readonly function: ["support.function.misc.css"];
+  readonly number: ["constant.numeric.css"];
+  readonly 'number.query': ["constant.numeric.css"];
+  readonly string: ["string.quoted.css", "string.quoted.html"];
+  readonly 'string.quoted': ["string.quoted.css", "string.quoted.html"];
+  readonly keyword: ["keyword.control.at-rule"];
+  readonly 'keyword.directive': ["keyword.control.at-rule.master-css.css"];
+  readonly 'keyword.query': ["keyword.control.at-rule"];
+  readonly modifier: ["entity.other.attribute-name.pseudo-class.css"];
+  readonly 'modifier.directive': ["storage.modifier.master-css.css"];
+  readonly 'modifier.pseudoClass': ["entity.other.attribute-name.pseudo-class.css"];
+  readonly 'modifier.pseudoElement': ["entity.other.attribute-name.pseudo-element.css"];
+  readonly operator: ["keyword.operator.css"];
+  readonly 'operator.directive': ["punctuation.section.property-list.begin.bracket.curly.css"];
+  readonly 'operator.blockBrace': ["punctuation.section.property-list.begin.bracket.curly.css", "punctuation.section.property-list.end.bracket.curly.css"];
+  readonly 'operator.declarationSeparator': ["punctuation.separator.key-value.css"];
+  readonly 'operator.declarationTerminator': ["punctuation.terminator.rule.css"];
+  readonly 'operator.directiveTerminator': ["punctuation.terminator.rule.css"];
+  readonly 'operator.functionPunctuation': ["punctuation.section.function.begin.bracket.round.css", "punctuation.section.function.end.bracket.round.css"];
+  readonly 'operator.important': ["keyword.other.important.css", "keyword.operator.important.css"];
+  readonly 'operator.pseudoClass': ["entity.other.attribute-name.pseudo-class.css"];
+  readonly 'operator.pseudoClassDelimiter': ["punctuation.definition.entity.css"];
+  readonly 'operator.pseudoElement': ["entity.other.attribute-name.pseudo-element.css"];
+  readonly 'operator.pseudoElementDelimiter': ["punctuation.definition.entity.css"];
+  readonly 'operator.query': ["keyword.operator.css"];
+  readonly 'operator.queryOperator': ["keyword.operator.comparison.css", "keyword.operator.css"];
+  readonly 'operator.queryPunctuation': ["punctuation.separator.list.comma.css", "punctuation.separator.key-value.css", "punctuation.definition.parameters.begin.bracket.round.css", "punctuation.definition.parameters.end.bracket.round.css", "punctuation.section.function.begin.bracket.round.css", "punctuation.section.function.end.bracket.round.css"];
+  readonly 'operator.selector': ["keyword.operator.combinator.css"];
+  readonly 'operator.selectorCombinator': ["keyword.operator.combinator.css"];
+  readonly 'operator.selectorPunctuation': ["punctuation.separator.list.comma.css", "punctuation.definition.entity.css", "punctuation.section.function.begin.bracket.round.css", "punctuation.section.function.end.bracket.round.css", "punctuation.definition.entity.begin.bracket.square.css", "punctuation.definition.entity.end.bracket.square.css"];
+  readonly 'operator.unit': ["keyword.operator.css"];
+  readonly 'operator.valueOperator': ["keyword.operator.css"];
+  readonly 'operator.valueSeparator': ["punctuation.separator.list.comma.css"];
+  readonly type: ["entity.name.tag.css"];
+  readonly 'type.selector': ["entity.name.tag.css"];
+};
+type MasterCSSSemanticTokenScopeKey = keyof typeof MASTER_CSS_SEMANTIC_TOKEN_SCOPE_MAP;
+declare function getMasterCSSSemanticTokenScopeKeys(type: SemanticTokenType, modifiers?: SemanticTokenModifier[]): ("class" | "class.component" | "class.declaration" | "class.selector" | "enumMember" | "enumMember.directive" | "enumMember.query" | "enumMember.unit" | "function" | "keyword" | "keyword.directive" | "keyword.query" | "modifier" | "modifier.directive" | "modifier.pseudoClass" | "modifier.pseudoElement" | "number" | "number.query" | "operator" | "operator.blockBrace" | "operator.declarationSeparator" | "operator.declarationTerminator" | "operator.directive" | "operator.directiveTerminator" | "operator.functionPunctuation" | "operator.important" | "operator.pseudoClass" | "operator.pseudoClassDelimiter" | "operator.pseudoElement" | "operator.pseudoElementDelimiter" | "operator.query" | "operator.queryOperator" | "operator.queryPunctuation" | "operator.selector" | "operator.selectorCombinator" | "operator.selectorPunctuation" | "operator.unit" | "operator.valueOperator" | "operator.valueSeparator" | "property" | "property.directive" | "property.query" | "string" | "string.quoted" | "type" | "type.selector" | "variable" | "variable.directive" | "variable.selector")[];
+export { MASTER_CSS_SEMANTIC_TOKEN_SCOPE_MAP, MasterCSSSemanticTokenScopeKey, getMasterCSSSemanticTokenScopeKeys };

package/dist/language/semantic/scopes.js

@@ -0,0 +1,73 @@
+// src/language/semantic/scopes.ts
+const MASTER_CSS_SEMANTIC_TOKEN_SCOPE_MAP = {
+	class: ["entity.other.attribute-name.class.css"],
+	"class.component": ["entity.other.attribute-name.class.css"],
+	"class.declaration": ["entity.other.attribute-name.class.css"],
+	"class.selector": ["entity.other.attribute-name.class.css"],
+	enumMember: ["support.constant.property-value.css"],
+	"enumMember.directive": ["support.constant.property-value.css"],
+	"enumMember.query": ["support.constant.property-value.css"],
+	"enumMember.unit": ["keyword.other.unit"],
+	property: ["support.type.property-name.css"],
+	"property.directive": ["support.type.property-name.css"],
+	"property.query": ["support.type.property-name.css"],
+	variable: ["variable.other.master-css.css", "variable.css"],
+	"variable.directive": ["variable.parameter.master-css.css"],
+	"variable.selector": ["entity.other.attribute-name.id.css"],
+	function: ["support.function.misc.css"],
+	number: ["constant.numeric.css"],
+	"number.query": ["constant.numeric.css"],
+	string: ["string.quoted.css", "string.quoted.html"],
+	"string.quoted": ["string.quoted.css", "string.quoted.html"],
+	keyword: ["keyword.control.at-rule"],
+	"keyword.directive": ["keyword.control.at-rule.master-css.css"],
+	"keyword.query": ["keyword.control.at-rule"],
+	modifier: ["entity.other.attribute-name.pseudo-class.css"],
+	"modifier.directive": ["storage.modifier.master-css.css"],
+	"modifier.pseudoClass": ["entity.other.attribute-name.pseudo-class.css"],
+	"modifier.pseudoElement": ["entity.other.attribute-name.pseudo-element.css"],
+	operator: ["keyword.operator.css"],
+	"operator.directive": ["punctuation.section.property-list.begin.bracket.curly.css"],
+	"operator.blockBrace": ["punctuation.section.property-list.begin.bracket.curly.css", "punctuation.section.property-list.end.bracket.curly.css"],
+	"operator.declarationSeparator": ["punctuation.separator.key-value.css"],
+	"operator.declarationTerminator": ["punctuation.terminator.rule.css"],
+	"operator.directiveTerminator": ["punctuation.terminator.rule.css"],
+	"operator.functionPunctuation": ["punctuation.section.function.begin.bracket.round.css", "punctuation.section.function.end.bracket.round.css"],
+	"operator.important": ["keyword.other.important.css", "keyword.operator.important.css"],
+	"operator.pseudoClass": ["entity.other.attribute-name.pseudo-class.css"],
+	"operator.pseudoClassDelimiter": ["punctuation.definition.entity.css"],
+	"operator.pseudoElement": ["entity.other.attribute-name.pseudo-element.css"],
+	"operator.pseudoElementDelimiter": ["punctuation.definition.entity.css"],
+	"operator.query": ["keyword.operator.css"],
+	"operator.queryOperator": ["keyword.operator.comparison.css", "keyword.operator.css"],
+	"operator.queryPunctuation": [
+		"punctuation.separator.list.comma.css",
+		"punctuation.separator.key-value.css",
+		"punctuation.definition.parameters.begin.bracket.round.css",
+		"punctuation.definition.parameters.end.bracket.round.css",
+		"punctuation.section.function.begin.bracket.round.css",
+		"punctuation.section.function.end.bracket.round.css"
+	],
+	"operator.selector": ["keyword.operator.combinator.css"],
+	"operator.selectorCombinator": ["keyword.operator.combinator.css"],
+	"operator.selectorPunctuation": [
+		"punctuation.separator.list.comma.css",
+		"punctuation.definition.entity.css",
+		"punctuation.section.function.begin.bracket.round.css",
+		"punctuation.section.function.end.bracket.round.css",
+		"punctuation.definition.entity.begin.bracket.square.css",
+		"punctuation.definition.entity.end.bracket.square.css"
+	],
+	"operator.unit": ["keyword.operator.css"],
+	"operator.valueOperator": ["keyword.operator.css"],
+	"operator.valueSeparator": ["punctuation.separator.list.comma.css"],
+	type: ["entity.name.tag.css"],
+	"type.selector": ["entity.name.tag.css"]
+};
+function getMasterCSSSemanticTokenScopeKeys(type, modifiers = []) {
+	const keys = [];
+	for (const modifier of [...modifiers].reverse()) keys.push(`${type}.${modifier}`);
+	keys.push(type);
+	return keys.filter((key) => key in MASTER_CSS_SEMANTIC_TOKEN_SCOPE_MAP);
+}
+export { MASTER_CSS_SEMANTIC_TOKEN_SCOPE_MAP, getMasterCSSSemanticTokenScopeKeys };

package/dist/language/semantic/types.d.ts

@@ -0,0 +1,11 @@
+import { SEMANTIC_TOKEN_MODIFIERS, SEMANTIC_TOKEN_TYPES } from "../common.js";
+type SemanticTokenType = typeof SEMANTIC_TOKEN_TYPES[number];
+type SemanticTokenModifier = typeof SEMANTIC_TOKEN_MODIFIERS[number];
+type HighlightTokenRole = 'block.brace' | 'declaration.property' | 'declaration.separator' | 'declaration.terminator' | 'query.keyword' | 'selector.combinator' | 'selector.pseudoClass.delimiter' | 'selector.pseudoClass.name' | 'selector.pseudoElement.delimiter' | 'selector.pseudoElement.name' | 'selector.punctuation' | 'selector.type' | 'utility.component' | 'utility.semantic' | 'value.important' | 'value.function' | 'value.function.punctuation' | 'value.keyword' | 'value.number' | 'value.operator' | 'value.separator' | 'value.string' | 'value.unit' | 'value.variable';
+interface SemanticTokenItem {
+  start: number;
+  end: number;
+  type: SemanticTokenType;
+  modifiers?: SemanticTokenModifier[];
+}
+export { HighlightTokenRole, SemanticTokenItem, SemanticTokenModifier, SemanticTokenType };

package/dist/language/semantic/types.js

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

package/dist/language/session.d.ts

@@ -0,0 +1,37 @@
+import { MasterCSSDocumentAnalysis, MasterCSSDocumentAnalysisRequest, MasterCSSFormatDirectivesRequest, MasterCSSFormatDirectivesResult, MasterCSSLanguageClassifications, MasterCSSLanguageColorCandidate, MasterCSSLanguageColorPresentation, MasterCSSLanguageColorTokens, MasterCSSLanguageCompletionIndex, MasterCSSLanguageInspection as MasterCSSLanguageInspection$1, MasterCSSLanguageTokenFamilies, MasterCSSNativeDeclarationCompletion, MasterCSSNativeDeclarationCompletionRequest } from "./contracts.js";
+import { MasterCSSNativeDeclarationCandidate } from "@master/css-binding/tooling";
+interface BindingLanguageSession {
+  prepareDocument(request: unknown): {
+    readonly id: number;
+    readonly nativeCandidates: readonly MasterCSSNativeDeclarationCandidate[];
+  };
+  finishDocument(id: number, nativeSupport: boolean[]): unknown;
+  cancelDocument(id: number): void;
+  analyzeDocument(request: unknown): unknown;
+  formatDirectives(request: unknown): unknown;
+  nativeDeclarationCompletion(request: unknown): unknown;
+  nativeDeclarationCandidates(classNames: string[]): unknown;
+  classifyClassNames(classNames: string[], nativeSupport?: boolean[]): unknown;
+  inspectClassName(className: string, nativeSupport?: boolean[]): unknown;
+  tokenFamilies(): unknown;
+  completionIndex(): unknown;
+  colorPresentation(colorToken: string): unknown;
+  colorTokens(candidates: unknown): unknown;
+  dispose(): void;
+}
+interface LanguageSession extends Disposable {
+  readonly binding: 'native' | 'wasm';
+  analyzeDocument(request: MasterCSSDocumentAnalysisRequest): MasterCSSDocumentAnalysis;
+  formatDirectives(request: MasterCSSFormatDirectivesRequest): MasterCSSFormatDirectivesResult;
+  /** The completion context at a cursor inside a `(property:value)` head; undefined elsewhere. */
+  nativeDeclarationCompletion(request: MasterCSSNativeDeclarationCompletionRequest): MasterCSSNativeDeclarationCompletion | undefined;
+  classifyClassNames(classNames: readonly string[]): MasterCSSLanguageClassifications;
+  inspectClassName(className: string): MasterCSSLanguageInspection$1;
+  tokenFamilies(): MasterCSSLanguageTokenFamilies;
+  completionIndex(): MasterCSSLanguageCompletionIndex;
+  colorPresentation(colorToken: string): MasterCSSLanguageColorPresentation;
+  colorTokens(candidates: readonly MasterCSSLanguageColorCandidate[]): MasterCSSLanguageColorTokens;
+  dispose(): void;
+}
+declare function bindLanguageSession(binding: LanguageSession['binding'], session: BindingLanguageSession, nativeClassNames?: readonly string[]): LanguageSession;
+export { LanguageSession, bindLanguageSession };

package/dist/language/session.js

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

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

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

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

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

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

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

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

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

package/dist/lexer/index.d.ts

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

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

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

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

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

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