@master/css-language-service 0.0.0-site.1793659883.g69c9aebcf628

package/dist/shiki.d.ts

@@ -0,0 +1,159 @@
+import { HighlightTokenRole, MasterCSSLanguageSession, SemanticTokenModifier, SemanticTokenType } from "@master/css-tooling/language";
+import { MasterCSSLanguageServiceSettings } from "./settings.js";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { getMasterCSSShikiLanguageId, isMasterCSSClassListLanguage, isMasterCSSShikiSupportedLanguage } from "./shiki/languages.js";
+declare const MASTER_CSS_SHIKI_SCOPE_NAME = "master-css.directive.injection";
+declare const MASTER_CSS_SHIKI_INJECT_TO: readonly ['source.css', 'source.css.scss', 'source.css.less', 'source.css.postcss'];
+interface MasterCSSTextMateGrammar {
+  name: string;
+  scopeName: string;
+  injectionSelector: string;
+  patterns: any[];
+  repository: Record<string, any>;
+  [key: string]: any;
+}
+declare const MASTER_CSS_TEXTMATE_GRAMMAR: MasterCSSTextMateGrammar;
+declare function createMasterCSSShikiLanguageRegistration(): MasterCSSTextMateGrammar & {
+  injectTo: string[];
+};
+declare const masterCSSShikiLanguage: MasterCSSTextMateGrammar & {
+  injectTo: string[];
+};
+type MasterCSSShikiSemanticTokenStyleKey = SemanticTokenType | `${SemanticTokenType}.${SemanticTokenModifier}`;
+type MasterCSSShikiHighlightRoleStyleKey = HighlightTokenRole;
+type MasterCSSShikiSemanticTokenStyle = string | Record<string, string>;
+type MasterCSSShikiSemanticTokenStyles = Partial<Record<MasterCSSShikiSemanticTokenStyleKey, MasterCSSShikiSemanticTokenStyle>>;
+type MasterCSSShikiHighlightRoleStyles = Partial<Record<MasterCSSShikiHighlightRoleStyleKey, MasterCSSShikiSemanticTokenStyle>>;
+interface ShikiToken {
+  content: string;
+  offset: number;
+  color?: string;
+  htmlStyle?: Record<string, string>;
+  htmlAttrs?: Record<string, unknown>;
+  explanation?: {
+    content?: string;
+    scopes?: {
+      scopeName: string;
+    }[];
+  }[];
+  [key: string]: unknown;
+}
+interface ShikiPosition {
+  line: number;
+  character: number;
+}
+interface ShikiDecoration {
+  start: number | ShikiPosition;
+  end: number | ShikiPosition;
+  tagName?: string;
+  properties?: Record<string, unknown>;
+  alwaysWrap?: boolean;
+  transform?: (element: unknown, type: 'wrapper' | 'line' | 'token') => unknown | undefined;
+}
+interface ShikiCodeToHastOptions {
+  lang?: string;
+  decorations?: ShikiDecoration[];
+  includeExplanation?: 'scopeName' | boolean;
+  [key: string]: unknown;
+}
+interface ShikiCodeToTokensResult {
+  tokens: ShikiToken[][];
+}
+interface ShikiTransformerContext {
+  source: string;
+  options: ShikiCodeToHastOptions;
+  codeToTokens?: (code: string, options: ShikiCodeToHastOptions) => ShikiCodeToTokensResult;
+}
+interface ShikiTransformer {
+  name: string;
+  enforce: 'post';
+  tokens(this: ShikiTransformerContext, tokens: ShikiToken[][]): ShikiToken[][] | undefined;
+  line?(this: ShikiTransformerContext, line: object, lineNumber: number): void;
+  root?(this: ShikiTransformerContext, root: unknown): unknown | undefined;
+}
+interface MasterCSSShikiDecoration extends Omit<ShikiDecoration, 'start' | 'end'> {
+  start: number;
+  end: number;
+  type: SemanticTokenType;
+  role: HighlightTokenRole;
+  modifiers: SemanticTokenModifier[];
+}
+interface MasterCSSShikiClassAttributeValueWrapperOptions {
+  tagName?: string;
+  properties?: Record<string, unknown>;
+  transform?: ShikiDecoration['transform'];
+}
+interface MasterCSSShikiOptions {
+  /**
+   * Reuse caller-owned language capabilities. Full tooling sessions also work;
+   * the transformer never disposes a supplied session.
+   */
+  session?: Pick<MasterCSSLanguageSession, 'analyzeDocument' | 'classifyClassNames'>;
+  /**
+   * Class-position and manifest settings used when collecting embedded utilities.
+   */
+  settings?: MasterCSSLanguageServiceSettings;
+  /**
+   * Convenience shortcut for `settings.manifest`.
+   */
+  manifest?: MasterCSSManifest;
+  /**
+   * Shiki language id. Defaults to the `lang` passed to Shiki.
+   */
+  lang?: string;
+  /**
+   * Treat the whole source as a whitespace-separated Master CSS class list.
+   * This replaces the old standalone `.mcss` TextMate grammar use case
+   * without contributing a Master CSS language.
+   */
+  classList?: boolean;
+  /**
+   * Class prefix added to every semantic decoration.
+   *
+   * @default 'mcss-semantic'
+   */
+  classPrefix?: string;
+  /**
+   * Add `data-semantic-token-*` attributes to decorated spans.
+   *
+   * @default true
+   */
+  dataAttributes?: boolean;
+  /**
+   * Force Shiki to wrap semantic tokens instead of reusing the existing
+   * TextMate token span when possible.
+   */
+  alwaysWrap?: boolean;
+  /**
+   * Wrap each embedded class attribute/string value with its original host
+   * language token presentation while keeping Master CSS semantic spans nested
+   * inside it.
+   *
+   * @default true
+   */
+  classAttributeValueWrapper?: boolean | MasterCSSShikiClassAttributeValueWrapperOptions;
+  /**
+   * Inline styles applied by semantic token type or type.modifier. These
+   * styles intentionally replace the underlying TextMate token style for the
+   * decorated range, which keeps tokens such as `block` and `block:hover`
+   * visually aligned when they share the same semantic type.
+   */
+  semanticTokenStyles?: MasterCSSShikiSemanticTokenStyles;
+  /**
+   * Inline styles applied by CSS-native highlight role. Role styles are the
+   * most precise presentation override and are shared across host languages.
+   */
+  highlightRoleStyles?: MasterCSSShikiHighlightRoleStyles;
+  /**
+   * Resolve Master CSS semantic token scopes through the active Shiki
+   * theme when possible. When disabled, the transformer only splits tokens
+   * and attaches semantic metadata/classes unless explicit semantic styles
+   * are provided.
+   *
+   * @default true
+   */
+  matchCSSSyntaxStyles?: boolean;
+}
+declare function createMasterCSSShikiDecorations(code: string, options?: MasterCSSShikiOptions): MasterCSSShikiDecoration[];
+declare function transformerMasterCSS(options?: MasterCSSShikiOptions): ShikiTransformer;
+export { MASTER_CSS_SHIKI_INJECT_TO, MASTER_CSS_SHIKI_SCOPE_NAME, MASTER_CSS_TEXTMATE_GRAMMAR, MasterCSSShikiClassAttributeValueWrapperOptions, MasterCSSShikiDecoration, MasterCSSShikiHighlightRoleStyleKey, MasterCSSShikiHighlightRoleStyles, MasterCSSShikiOptions, MasterCSSShikiSemanticTokenStyle, MasterCSSShikiSemanticTokenStyleKey, MasterCSSShikiSemanticTokenStyles, MasterCSSTextMateGrammar, createMasterCSSShikiDecorations, createMasterCSSShikiLanguageRegistration, getMasterCSSShikiLanguageId, isMasterCSSClassListLanguage, isMasterCSSShikiSupportedLanguage, masterCSSShikiLanguage, transformerMasterCSS };

package/dist/shiki.js

@@ -0,0 +1,522 @@
+import { applyClassAttributeValueWrappers } from "./shiki/hast.js";
+import { classAttributeValueWrappersKey, cssDirectiveLanguageIds, getLanguageServiceLanguageId, getMasterCSSShikiLanguageId, isMasterCSSClassListLanguage, isMasterCSSShikiSupportedLanguage, languageServiceLanguageIds } from "./shiki/languages.js";
+import { MASTER_CSS_SEMANTIC_TOKEN_SCOPE_MAP, getMasterCSSSemanticTokenScopeKeys } from "@master/css-tooling/language";
+import masterCSSTextMateGrammar from "../syntaxes/master-css.tmLanguage.json" with { type: "json" };
+import { createLanguageSessionSync } from "@master/css-tooling/language/node";
+import defaultManifestJSON from "@master/css-preset/default-manifest.json" with { type: "json" };
+// src/shiki.ts
+const defaultManifest = defaultManifestJSON;
+const MASTER_CSS_SHIKI_SCOPE_NAME = "master-css.directive.injection";
+const MASTER_CSS_SHIKI_INJECT_TO = [
+	"source.css",
+	"source.css.scss",
+	"source.css.less",
+	"source.css.postcss"
+];
+const MASTER_CSS_TEXTMATE_GRAMMAR = masterCSSTextMateGrammar;
+function createMasterCSSShikiLanguageRegistration() {
+	return {
+		...MASTER_CSS_TEXTMATE_GRAMMAR,
+		injectTo: [...MASTER_CSS_SHIKI_INJECT_TO]
+	};
+}
+const masterCSSShikiLanguage = createMasterCSSShikiLanguageRegistration();
+function createShikiSession(options) {
+	return options.session || createLanguageSessionSync({ manifest: options.manifest ?? options.settings?.manifest ?? defaultManifest });
+}
+function stringifyStyle(style) {
+	if (typeof style === "string") return style;
+	return Object.entries(style).map(([property, value]) => `${property}:${value}`).join(";");
+}
+function resolveSemanticTokenStyle(type, modifiers, styles) {
+	if (!styles) return;
+	const matchedStyles = [styles[type], ...modifiers.map((modifier) => styles[`${type}.${modifier}`])].filter((style) => Boolean(style));
+	if (!matchedStyles.length) return;
+	return matchedStyles.map(stringifyStyle).join(";");
+}
+function resolveHighlightTokenStyle(item, options) {
+	const roleStyle = options.highlightRoleStyles?.[item.role];
+	if (roleStyle) return stringifyStyle(roleStyle);
+	return resolveSemanticTokenStyle(item.type, item.modifiers ?? [], options.semanticTokenStyles);
+}
+function splitToken(token, breakpoints) {
+	const tokens = [];
+	let lastOffset = 0;
+	for (const offset of breakpoints) {
+		if (offset > lastOffset) tokens.push({
+			...token,
+			content: token.content.slice(lastOffset, offset),
+			offset: token.offset + lastOffset
+		});
+		lastOffset = offset;
+	}
+	if (lastOffset < token.content.length) tokens.push({
+		...token,
+		content: token.content.slice(lastOffset),
+		offset: token.offset + lastOffset
+	});
+	return tokens;
+}
+function splitTokensAtOffsets(tokens, breakpoints) {
+	const sortedBreakpoints = [...new Set(breakpoints)].sort((a, b) => a - b);
+	if (!sortedBreakpoints.length) return tokens;
+	return tokens.map((line) => {
+		return line.flatMap((token) => {
+			const breakpointsInToken = sortedBreakpoints.filter((offset) => token.offset < offset && offset < token.offset + token.content.length).map((offset) => offset - token.offset);
+			return breakpointsInToken.length ? splitToken(token, breakpointsInToken) : token;
+		});
+	});
+}
+function parseStyleProperty(style) {
+	if (typeof style === "string") return Object.fromEntries(style.split(";").map((declaration) => declaration.split(":")).filter(([property, value]) => property && value).map(([property, ...value]) => [property.trim(), value.join(":").trim()]));
+	if (style && typeof style === "object" && !Array.isArray(style)) return Object.fromEntries(Object.entries(style).filter((entry) => typeof entry[1] === "string"));
+}
+function resolveClassNames(value) {
+	if (Array.isArray(value)) return value.flatMap(resolveClassNames);
+	return typeof value === "string" ? value.split(/\s+/).filter(Boolean) : [];
+}
+function mergeClassProperty(current, next) {
+	return [...resolveClassNames(current), ...resolveClassNames(next)].join(" ");
+}
+function applySemanticDecorationToToken(token, decorations, resolveSyntaxStyle) {
+	const tokenStart = token.offset;
+	const tokenEnd = token.offset + token.content.length;
+	const matchedDecorations = decorations.filter(({ start, end }) => start <= tokenStart && tokenEnd <= end);
+	if (!matchedDecorations.length) return token;
+	const htmlAttrs = { ...token.htmlAttrs };
+	const htmlStyle = { ...token.htmlStyle };
+	for (const decoration of matchedDecorations) {
+		const properties = decoration.properties ?? {};
+		if (properties.class) htmlAttrs.class = mergeClassProperty(htmlAttrs.class, properties.class);
+		const style = parseStyleProperty(properties.style);
+		if (style) {
+			for (const key of Object.keys(htmlStyle)) delete htmlStyle[key];
+			Object.assign(htmlStyle, style);
+		} else {
+			const syntaxStyle = resolveSyntaxStyle?.(token, decoration, decorations);
+			if (syntaxStyle) {
+				for (const key of Object.keys(htmlStyle)) delete htmlStyle[key];
+				Object.assign(htmlStyle, syntaxStyle);
+			}
+		}
+		for (const [name, value] of Object.entries(properties)) {
+			if (name === "class" || name === "style" || value === void 0) continue;
+			htmlAttrs[name] = typeof value === "string" ? value : String(value);
+		}
+	}
+	return {
+		...token,
+		htmlAttrs,
+		htmlStyle
+	};
+}
+function cloneStyle(style) {
+	return style && typeof style === "object" && !Array.isArray(style) ? Object.fromEntries(Object.entries(style).filter((entry) => typeof entry[1] === "string")) : void 0;
+}
+function getTokenStyleObject(token) {
+	const htmlStyle = cloneStyle(token.htmlStyle);
+	if (htmlStyle) return htmlStyle;
+	return typeof token.color === "string" ? { color: token.color } : void 0;
+}
+const SEMANTIC_SCOPE_STYLE_PROBE = [
+	"@theme {",
+	"  :root { --token: var(--value); }",
+	"}",
+	"@mixin --btn {",
+	"  display: block; &:hover { color: red; }",
+	"}",
+	".x, div > li:hover::before {",
+	"  color: red !important;",
+	"  width: 1.5rem;",
+	"  background: rgb(0 0 0 / .5);",
+	"  content: \"x\";",
+	"  content: 'x';",
+	"  --token: red;",
+	"}",
+	"@media (width >= 1px) { .y { color: var(--token); } }"
+].join("\n");
+function normalizeScope(scope) {
+	let normalizedScope = scope;
+	while (normalizedScope.endsWith(".css") || normalizedScope.endsWith(".master-css")) normalizedScope = normalizedScope.replace(/\.css$/, "").replace(/\.master-css$/, "");
+	return normalizedScope;
+}
+function getScopeCandidates(scope) {
+	return [.../* @__PURE__ */ new Set([
+		scope,
+		scope.replace(/\.css$/, ""),
+		scope.replace(/\.master-css$/, ""),
+		normalizeScope(scope)
+	])];
+}
+function getScopePrefixes(scope) {
+	const prefixes = [];
+	const bases = [
+		scope,
+		scope.replace(/\.css$/, ""),
+		scope.replace(/\.master-css$/, ""),
+		normalizeScope(scope)
+	];
+	for (const base of bases) {
+		const segments = base.split(".");
+		for (let length = segments.length; length >= 2; length--) prefixes.push(segments.slice(0, length).join("."));
+	}
+	return [...new Set(prefixes)];
+}
+function collectScopeStyleEntries(tokens) {
+	const entries = [];
+	const entryIndexes = /* @__PURE__ */ new Map();
+	for (const token of tokens) {
+		const style = getTokenStyleObject(token);
+		if (!style) continue;
+		for (const explanation of token.explanation ?? []) {
+			if (explanation.content && !token.content.includes(explanation.content)) continue;
+			const scopes = explanation.scopes ?? [];
+			const stringDelimiter = scopes.some(({ scopeName }) => scopeName.startsWith("punctuation.definition.string."));
+			for (const { scopeName } of scopes) {
+				const existingIndex = entryIndexes.get(scopeName);
+				if (existingIndex !== void 0 && !(scopeName.startsWith("string.quoted.") && entries[existingIndex].stringDelimiter && !stringDelimiter)) continue;
+				const entry = {
+					scope: scopeName,
+					normalizedScope: normalizeScope(scopeName),
+					style,
+					stringDelimiter
+				};
+				if (existingIndex === void 0) {
+					entryIndexes.set(scopeName, entries.length);
+					entries.push(entry);
+				} else entries[existingIndex] = entry;
+			}
+		}
+	}
+	return entries;
+}
+function isQuotedStringDecoration(decoration) {
+	return decoration.type === "string" && decoration.modifiers.includes("quoted");
+}
+function getQuotedStringContext(source, decoration, decorations) {
+	const index = decorations.indexOf(decoration);
+	if (index < 0) return;
+	let first = index;
+	let last = index;
+	while (first > 0 && isQuotedStringDecoration(decorations[first - 1]) && decorations[first - 1].end === decorations[first].start) first--;
+	while (last + 1 < decorations.length && isQuotedStringDecoration(decorations[last + 1]) && decorations[last].end === decorations[last + 1].start) last++;
+	const quote = source[decorations[first].start];
+	if (quote !== "\"" && quote !== "'") return;
+	return {
+		kind: quote === "\"" ? "double" : "single",
+		delimiter: index === first || index === last,
+		closing: index === last && index !== first
+	};
+}
+function findStyleByScope(entries, scope) {
+	for (const candidate of getScopeCandidates(scope)) {
+		const exact = entries.find((entry) => entry.scope === candidate || entry.normalizedScope === candidate);
+		if (exact) return exact.style;
+	}
+	for (const prefix of getScopePrefixes(scope)) {
+		const prefixed = entries.find((entry) => entry.scope === prefix || entry.normalizedScope === prefix || entry.scope.startsWith(`${prefix}.`) || entry.normalizedScope.startsWith(`${prefix}.`));
+		if (prefixed) return prefixed.style;
+	}
+}
+function createSemanticScopeStyleResolver(context, options) {
+	if (options.matchCSSSyntaxStyles === false || typeof context.codeToTokens !== "function") return;
+	try {
+		const { lang: _lang, decorations: _decorations, transformers: _transformers, ...tokenOptions } = context.options;
+		const scopeStyleEntries = collectScopeStyleEntries(context.codeToTokens(SEMANTIC_SCOPE_STYLE_PROBE, {
+			...tokenOptions,
+			lang: "css",
+			includeExplanation: "scopeName"
+		}).tokens.flat());
+		return (_token, decoration, decorations) => {
+			if (isQuotedStringDecoration(decoration)) {
+				const quoted = getQuotedStringContext(context.source, decoration, decorations);
+				if (quoted) {
+					const scope = quoted.delimiter ? `punctuation.definition.string.${quoted.closing ? "end" : "begin"}.css` : `string.quoted.${quoted.kind}.css`;
+					const style = findStyleByScope(scopeStyleEntries, scope);
+					if (style) return style;
+				}
+			}
+			for (const key of getMasterCSSSemanticTokenScopeKeys(decoration.type, decoration.modifiers)) for (const scope of MASTER_CSS_SEMANTIC_TOKEN_SCOPE_MAP[key]) {
+				const style = findStyleByScope(scopeStyleEntries, scope);
+				if (style) return style;
+			}
+		};
+	} catch {
+		return;
+	}
+}
+function createSemanticTokenDecorations(tokens, options) {
+	const classPrefix = options.classPrefix ?? "mcss-semantic";
+	const includeDataAttributes = options.dataAttributes ?? true;
+	return tokens.map(({ start, end, type, modifiers: semanticModifiers = [], role: semanticRole }) => {
+		const role = semanticRole ?? resolveHighlightRole({
+			type,
+			modifiers: semanticModifiers
+		});
+		const modifiers = semanticModifiers.filter((modifier) => modifier !== ROLE_TOKEN_MODIFIERS[role] && !(modifier === "declaration" && type !== "class"));
+		const classNames = [
+			classPrefix,
+			`${classPrefix}-${type}`,
+			`${classPrefix}-role-${role.replace(/\./g, "-")}`,
+			...modifiers.map((modifier) => `${classPrefix}-${type}-${modifier}`)
+		];
+		const style = resolveHighlightTokenStyle({
+			type,
+			role,
+			modifiers
+		}, options);
+		return {
+			start,
+			end,
+			type,
+			role,
+			modifiers,
+			alwaysWrap: options.alwaysWrap,
+			properties: {
+				class: classNames,
+				...style ? { style } : void 0,
+				...includeDataAttributes ? {
+					"data-semantic-token-type": type,
+					"data-semantic-token-modifiers": modifiers.join(" "),
+					"data-highlight-role": role
+				} : void 0
+			}
+		};
+	});
+}
+function getClassAttributeValueWrapperOption(options) {
+	return options.classAttributeValueWrapper ?? true;
+}
+function shouldCreateClassAttributeValueWrappers(options) {
+	if (!getClassAttributeValueWrapperOption(options) || options.classList) return false;
+	const lang = options.lang ? languageServiceLanguageIds[options.lang] ?? options.lang : void 0;
+	return Boolean(lang && !cssDirectiveLanguageIds.has(lang));
+}
+function getLineStartOffsets(source) {
+	const offsets = [0];
+	for (let index = 0; index < source.length; index++) if (source[index] === "\n") offsets.push(index + 1);
+	return offsets;
+}
+function resolvePositionOffset(source, lineStartOffsets, position) {
+	if (typeof position === "number") return position >= 0 && position <= source.length ? position : void 0;
+	const lineStart = lineStartOffsets[position.line];
+	if (lineStart === void 0) return;
+	const nextLineStart = lineStartOffsets[position.line + 1];
+	const lineEnd = nextLineStart === void 0 ? source.length : nextLineStart - 1;
+	let character = position.character;
+	if (character < 0) character = lineEnd - lineStart + character;
+	if (character < 0 || lineStart + character > lineEnd) return;
+	return lineStart + character;
+}
+function resolveDecorationRange(source, lineStartOffsets, decoration) {
+	const start = resolvePositionOffset(source, lineStartOffsets, decoration.start);
+	const end = resolvePositionOffset(source, lineStartOffsets, decoration.end);
+	return start === void 0 || end === void 0 ? void 0 : {
+		start,
+		end
+	};
+}
+function decorationsPartiallyIntersect(a, b) {
+	const isAHasBStart = a.start <= b.start && b.start < a.end;
+	const isAHasBEnd = a.start < b.end && b.end <= a.end;
+	const isBHasAStart = b.start <= a.start && a.start < b.end;
+	const isBHasAEnd = b.start < a.end && a.end <= b.end;
+	if (!isAHasBStart && !isAHasBEnd && !isBHasAStart && !isBHasAEnd) return false;
+	if (isAHasBStart && isAHasBEnd) return false;
+	if (isBHasAStart && isBHasAEnd) return false;
+	if (isBHasAStart && a.start === a.end) return false;
+	if (isAHasBEnd && b.start === b.end) return false;
+	return true;
+}
+function findTokenStyleForRange(tokens, range) {
+	for (const line of tokens) for (const token of line) {
+		const start = token.offset;
+		if (token.offset + token.content.length <= range.start || start >= range.end) continue;
+		if (!token.content.trim()) continue;
+		const style = getTokenStyleObject(token);
+		if (style) return stringifyStyle(style);
+	}
+}
+function withoutUndefinedProperties(properties) {
+	return Object.fromEntries(Object.entries(properties).filter(([, value]) => value !== void 0));
+}
+const markupShikiLanguageIds = /* @__PURE__ */ new Set([
+	"html",
+	"angular-html",
+	"jsx",
+	"tsx",
+	"vue",
+	"svelte",
+	"astro",
+	"markdown",
+	"mdx"
+]);
+function collectMarkupAttributeRanges(context, classPositions, lang) {
+	const ranges = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	if (!classPositions.length || !markupShikiLanguageIds.has(getMasterCSSShikiLanguageId(lang) ?? "") || !context.codeToTokens) return ranges;
+	try {
+		const { decorations: _decorations, transformers: _transformers, ...tokenOptions } = context.options;
+		const scopedTokens = context.codeToTokens(context.source, {
+			...tokenOptions,
+			includeExplanation: "scopeName"
+		}).tokens.flatMap((line) => line.map((token) => ({
+			start: token.offset,
+			end: token.offset + token.content.length,
+			scopes: token.explanation?.flatMap(({ scopes }) => scopes?.map(({ scopeName }) => scopeName) ?? []) ?? []
+		})));
+		for (const { contextRange } of classPositions) {
+			const key = `${contextRange.start}:${contextRange.end}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			if (scopedTokens.some(({ start, end, scopes }) => start < contextRange.end && end > contextRange.start && scopes.some((scope) => scope.startsWith("meta.attribute.") || scope.startsWith("meta.tag.attributes.")))) {
+				ranges.add(key);
+				continue;
+			}
+			let attributeName;
+			for (let index = scopedTokens.length - 1; index >= 0; index--) {
+				const token = scopedTokens[index];
+				if (token.end <= contextRange.start && token.scopes.some((scope) => scope.startsWith("entity.other.attribute-name."))) {
+					attributeName = token;
+					break;
+				}
+			}
+			if (attributeName && /^\s*=\s*["'`]$/.test(context.source.slice(attributeName.end, contextRange.start))) ranges.add(key);
+		}
+	} catch {}
+	return ranges;
+}
+function createClassAttributeValueWrapperDecorations(source, classPositions, tokens, options, markupAttributeRanges, existingDecorations = []) {
+	if (!shouldCreateClassAttributeValueWrappers(options)) return [];
+	const contextRanges = /* @__PURE__ */ new Map();
+	for (const { contextRange } of classPositions) {
+		if (contextRange.start >= contextRange.end) continue;
+		contextRanges.set(`${contextRange.start}:${contextRange.end}`, contextRange);
+	}
+	if (!contextRanges.size) return [];
+	const lineStartOffsets = existingDecorations.length ? getLineStartOffsets(source) : [];
+	const existingRanges = existingDecorations.map((decoration) => resolveDecorationRange(source, lineStartOffsets, decoration)).filter((range) => Boolean(range));
+	const wrapperOption = getClassAttributeValueWrapperOption(options);
+	const wrapperOptions = typeof wrapperOption === "object" ? wrapperOption : void 0;
+	return [...contextRanges.values()].filter((range) => !existingRanges.some((existingRange) => decorationsPartiallyIntersect(range, existingRange))).map((range) => {
+		const style = findTokenStyleForRange(tokens, range);
+		const defaultProperties = {
+			class: mergeClassProperty("mcss-host mcss-host-role-class-attribute-value", markupAttributeRanges.has(`${range.start}:${range.end}`) ? "mcss-host-active-on-hover" : void 0),
+			"data-master-css-host-role": "class-attribute-value",
+			style
+		};
+		const customProperties = wrapperOptions?.properties ?? {};
+		return {
+			start: range.start,
+			end: range.end,
+			tagName: wrapperOptions?.tagName ?? "span",
+			alwaysWrap: true,
+			transform: wrapperOptions?.transform,
+			properties: {
+				...withoutUndefinedProperties(defaultProperties),
+				...withoutUndefinedProperties(customProperties),
+				class: mergeClassProperty(defaultProperties.class, customProperties.class)
+			}
+		};
+	});
+}
+const ROLE_TOKEN_MODIFIERS = {
+	"block.brace": "blockBrace",
+	"declaration.separator": "declarationSeparator",
+	"declaration.terminator": "declarationTerminator",
+	"selector.combinator": "selectorCombinator",
+	"selector.punctuation": "selectorPunctuation",
+	"selector.pseudoClass.delimiter": "pseudoClassDelimiter",
+	"selector.pseudoElement.delimiter": "pseudoElementDelimiter"
+};
+function resolveHighlightRole({ type, modifiers = [] }) {
+	const modifierSet = new Set(modifiers);
+	if (modifierSet.has("blockBrace")) return "block.brace";
+	if (modifierSet.has("declarationSeparator")) return "declaration.separator";
+	if (modifierSet.has("declarationTerminator")) return "declaration.terminator";
+	if (modifierSet.has("selectorCombinator")) return "selector.combinator";
+	if (modifierSet.has("selectorPunctuation")) return "selector.punctuation";
+	if (modifierSet.has("pseudoClassDelimiter")) return "selector.pseudoClass.delimiter";
+	if (modifierSet.has("pseudoElementDelimiter")) return "selector.pseudoElement.delimiter";
+	if (modifierSet.has("pseudoClass")) return "selector.pseudoClass.name";
+	if (modifierSet.has("pseudoElement")) return "selector.pseudoElement.name";
+	if (modifierSet.has("important")) return "value.important";
+	if (modifierSet.has("query")) return "query.keyword";
+	if (type === "property") return "declaration.property";
+	if (type === "type") return "selector.type";
+	if (modifierSet.has("component")) return "utility.component";
+	if (modifierSet.has("declaration")) return "utility.semantic";
+	if (modifierSet.has("unit")) return "value.unit";
+	if (modifierSet.has("valueSeparator")) return "value.separator";
+	if (modifierSet.has("valueOperator")) return "value.operator";
+	if (modifierSet.has("functionPunctuation")) return "value.function.punctuation";
+	if (type === "function") return "value.function";
+	if (type === "number") return "value.number";
+	if (type === "string") return "value.string";
+	if (type === "variable") return "value.variable";
+	return "value.keyword";
+}
+function createMasterCSSShikiDecorations(code, options = {}) {
+	const analysis = analyzeMasterCSSShikiDocument(code, options);
+	return analysis?.semanticTokens.length ? createSemanticTokenDecorations(analysis.semanticTokens, options) : [];
+}
+function analyzeMasterCSSShikiDocument(code, options) {
+	const classList = options.classList ?? isMasterCSSClassListLanguage(options.lang);
+	const languageId = getLanguageServiceLanguageId(classList ? "plaintext" : options.lang);
+	if (!languageId) return;
+	const session = createShikiSession(options);
+	try {
+		const { classPositions, semanticTokens } = session.analyzeDocument({
+			source: code,
+			languageId,
+			...options.settings ? { settings: {
+				...options.settings.classAttributes ? { classAttributes: options.settings.classAttributes } : {},
+				...options.settings.classFunctions ? { classFunctions: options.settings.classFunctions } : {},
+				...options.settings.classDeclarations ? { classDeclarations: options.settings.classDeclarations } : {}
+			} } : {}
+		});
+		const classNames = [...new Set(classPositions.map(({ token }) => token))];
+		const semanticClasses = new Set(classNames.length ? session.classifyClassNames(classNames).classes.filter(({ kind }) => kind === "semantic" || kind === "token").map(({ className }) => className) : []);
+		const semanticUtilityStarts = new Set(classPositions.filter(({ token }) => semanticClasses.has(token)).map(({ range }) => range.start));
+		return {
+			classPositions: [...classPositions],
+			semanticTokens: semanticTokens.map((token) => token.type === "enumMember" && semanticUtilityStarts.has(token.start) ? {
+				...token,
+				role: "utility.semantic"
+			} : token)
+		};
+	} finally {
+		if (!options.session) session.dispose();
+	}
+}
+function transformerMasterCSS(options = {}) {
+	const sourceLineNumbers = /* @__PURE__ */ new WeakMap();
+	return {
+		name: "master-css",
+		enforce: "post",
+		tokens(tokens) {
+			const lang = options.lang ?? this.options.lang;
+			const classList = options.classList ?? isMasterCSSClassListLanguage(lang);
+			const resolvedOptions = {
+				...options,
+				lang,
+				classList
+			};
+			const analysis = analyzeMasterCSSShikiDocument(this.source, resolvedOptions);
+			const decorations = analysis?.semanticTokens.length ? createSemanticTokenDecorations(analysis.semanticTokens, resolvedOptions) : [];
+			const classAttributeValueWrapperDecorations = createClassAttributeValueWrapperDecorations(this.source, analysis?.classPositions ?? [], tokens, resolvedOptions, collectMarkupAttributeRanges(this, analysis?.classPositions ?? [], lang), this.options.decorations ?? []);
+			this.options[classAttributeValueWrappersKey] = classAttributeValueWrapperDecorations;
+			if (!decorations.length) return;
+			const tokensSplitAtSemanticBoundaries = splitTokensAtOffsets(tokens, decorations.flatMap(({ start, end }) => [start, end]));
+			const resolveSyntaxStyle = createSemanticScopeStyleResolver(this, resolvedOptions);
+			return tokensSplitAtSemanticBoundaries.map((line) => line.map((token) => applySemanticDecorationToToken(token, decorations, resolveSyntaxStyle)));
+		},
+		line(line, lineNumber) {
+			sourceLineNumbers.set(line, lineNumber);
+		},
+		root(root) {
+			applyClassAttributeValueWrappers(root, this.source, this.options["__masterCSSClassAttributeValueWrappers"] ?? [], sourceLineNumbers);
+		}
+	};
+}
+export { MASTER_CSS_SHIKI_INJECT_TO, MASTER_CSS_SHIKI_SCOPE_NAME, MASTER_CSS_TEXTMATE_GRAMMAR, createMasterCSSShikiDecorations, createMasterCSSShikiLanguageRegistration, getMasterCSSShikiLanguageId, isMasterCSSClassListLanguage, isMasterCSSShikiSupportedLanguage, masterCSSShikiLanguage, transformerMasterCSS };

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

@@ -0,0 +1,2 @@
+declare function beautifyCSS(text: string): any;
+export { beautifyCSS as default };