@master/css-language-server 2.0.0-rc.8 → 2.0.0-rc.80

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Aoyue Design LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+<br>
+<div align="center">
+
+<p align="center">
+    <a href="https://css.master.co">
+        <picture>
+            <source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/33840671/201701649-3bb7d698-abec-4d5f-ac30-ccc4d7bafcd4.svg">
+            <source media="(prefers-color-scheme: light)" srcset="https://user-images.githubusercontent.com/33840671/201703010-77bf2373-9899-40cc-98f5-30cf9b546941.svg">
+            <img alt="Master CSS" src="https://user-images.githubusercontent.com/33840671/201703010-77bf2373-9899-40cc-98f5-30cf9b546941.svg" width="100%">
+        </picture>
+    </a>
+</p>
+<p align="center">Language Server for Master CSS</p>
+
+<p align="center">
+    <a aria-label="GitHub release (latest by date including pre-releases)" href="https://github.com/master-co/css/releases">
+        <picture>
+            <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/github/v/release/master-co/css?include_prereleases&color=212022&label=&style=for-the-badge&logo=github&logoColor=fff">
+            <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/github/v/release/master-co/css?include_prereleases&color=f6f7f8&label=&style=for-the-badge&logo=github&logoColor=%23000">
+            <img alt="NPM Version" src="https://img.shields.io/github/v/release/master-co/css?include_prereleases&color=f6f7f8&label=&style=for-the-badge&logo=github">
+        </picture>
+    </a>
+    <a aria-label="NPM Package" href="https://www.npmjs.com/package/@master/css-language-server">
+        <picture>
+            <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/npm/dm/@master/css-language-server?color=212022&label=%20&logo=npm&style=for-the-badge">
+            <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/npm/dm/@master/css-language-server?color=f6f7f8&label=%20&logo=npm&style=for-the-badge">
+            <img alt="NPM package ( download / month )" src="https://img.shields.io/npm/dm/@master/css-language-server?color=f6f7f8&label=%20&logo=npm&style=for-the-badge">
+        </picture>
+    </a>
+    <a aria-label="JSDelivr" href="https://www.jsdelivr.com/package/npm/@master/css-language-server">
+        <picture>
+            <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/jsdelivr/npm/hm/@master/css-language-server?color=212022&label=%20&logo=jsdelivr&style=for-the-badge">
+            <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/jsdelivr/npm/hm/@master/css-language-server?color=f6f7f8&label=%20&logo=jsdelivr&style=for-the-badge">
+            <img alt="JSDelivr hits (npm scoped)" src="https://img.shields.io/jsdelivr/npm/hm/@master/css-language-server?color=f6f7f8&label=%20&logo=jsdelivr&style=for-the-badge">
+        </picture>
+    </a>
+    <a aria-label="Discord Community" href="https://discord.gg/sZNKpAAAw6">
+        <picture>
+            <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/discord/917780624314613760?color=212022&label=%20&logo=discord&style=for-the-badge">
+            <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/discord/917780624314613760?color=f6f7f8&label=%20&logo=discord&style=for-the-badge">
+            <img alt="Discord online" src="https://img.shields.io/discord/917780624314613760?color=f6f7f8&label=%20&logo=discord&style=for-the-badge">
+        </picture>
+    </a>
+    <a aria-label="Follow @mastercorg" href="https://twitter.com/mastercorg">
+        <picture>
+            <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/static/v1?label=%20&message=twitter&color=212022&logo=twitter&style=for-the-badge">
+            <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/static/v1?label=%20&message=twitter&color=f6f7f8&logo=twitter&style=for-the-badge">
+            <img alt="Follow @mastercorg" src="https://img.shields.io/static/v1?label=%20&message=twitter&color=f6f7f8&logo=twitter&style=for-the-badge">
+        </picture>
+    </a>
+    <a aria-label="Github Actions" href="https://github.com/master-co/css/actions/workflows/ci-release.yml">
+        <picture>
+            <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/github/actions/workflow/status/master-co/css/ci-release.yml?branch=rc&label=%20&message=twitter&color=212022&logo=githubactions&style=for-the-badge">
+            <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/github/actions/workflow/status/master-co/css/ci-release.yml?branch=rc&label=%20&message=twitter&color=f6f7f8&logo=githubactions&style=for-the-badge&logoColor=%23000">
+            <img alt="Github release actions" src="https://img.shields.io/github/actions/workflow/status/master-co/css/ci-release.yml?branch=rc&label=%20&message=twitter&color=f6f7f8&logo=githubactions&style=for-the-badge&logoColor=%23000">
+        </picture>
+    </a>
+</p>
+
+</div>
+
+## Installation
+
+```bash
+npm install @master/css-language-server
+```
+
+## Usage
+
+```js
+import CSSLanguageServer from '@master/css-language-server'
+
+const languageServer = new CSSLanguageServer(connection, customSettings)
+```
+
+`CSSLanguageServer` wraps `@master/css-language-service` with LSP workspace lifecycle, completion, hover, document color, color presentation, semantic token, and directive formatting handlers.
+
+Diagnostics are intentionally limited to language-server-owned behavior: CSS directive diagnostics and project manifest loading diagnostics. Class syntax and policy rules such as sorting, canonical class preference, conflict detection, invalid classes, and raw-value approval are owned by `@master/eslint-plugin-css`.
+
+## Semantic tokens
+
+The language server supports full-document and active-position semantic tokens.
+
+| `embeddedSyntaxHighlighting` | Behavior |
+| --- | --- |
+| `always` | Advertises the standard LSP `semanticTokensProvider` and handles `textDocument/semanticTokens/full`. |
+| `active` | Uses the VS Code extension request for active class-context highlighting. |
+| `off` | Disables embedded utility highlighting. |
+
+CSS directive syntax is highlighted by the shared TextMate grammar. Server semantic tokens cover Master CSS class-list spans and directive class-list spans such as `@compose` and `@safelist`.
+
+## Formatting
+
+The server advertises `documentFormattingProvider` and `documentRangeFormattingProvider` when `formatDirectives` is enabled. Formatting returns directive-only edits for CSS, SCSS, and LESS documents, plus CSS-family `<style>` blocks in Vue, Svelte, and Astro documents.
+
+Directive formatting normalizes safe directive spacing and repairs class-list important markers such as `bg:transparent !` to `bg:transparent!`. It does not run the compiler and does not change generated CSS output.
+
+## Settings
+
+```js
+import { settings } from '@master/css-language-server'
+```
+
+| Setting | Type | Default | Description |
+| --- | --- | --- | --- |
+| `workspaces` | `FastGlobPattern[] \| 'auto'` | `'auto'` | Workspace roots where independent language services are created. The root workspace is always included. |
+| `verbose` | `boolean` | `false` | Print server logs. |
+| `formatDirectives` | `boolean` | `true` | Enables LSP document and range formatting for Master CSS directives. |
+| `embeddedSyntaxHighlighting` | `'active' \| 'always' \| 'off'` | `'active'` | Inherited language-service semantic token mode. |
+
+With `workspaces: 'auto'`, the server creates workspaces from CSS files importing `@master/css`, CSS files containing the lightweight `@master entry;` marker, and `package.json` files that declare Master CSS package dependencies.

package/dist/core.d.ts

@@ -0,0 +1,72 @@
+import { ClientCapabilities, ColorPresentationParams, CompletionParams, Connection, DidChangeConfigurationParams, DocumentColorParams, DocumentFormattingParams, DocumentRangeFormattingParams, HoverParams, InitializeParams, InitializeResult, RemoteConsole, SemanticTokensParams, TextDocumentChangeEvent, TextDocumentPositionParams, TextDocuments, TextEdit, WorkspaceFolder } from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import CSSLanguageService from "@master/css-language-service";
+import { MasterCSSWorkspacePackageResolution } from "@master/css-project/workspace";
+import { CSSLanguageRuntime } from "@master/css-language";
+import { Settings as Settings$1 } from "./settings.js";
+
+//#region src/core.d.ts
+declare interface Workspace {
+  uri: string;
+  openedTextDocuments: TextDocument[];
+  languageService?: CSSLanguageService;
+  languageServiceSettings: Settings$1;
+  languageRuntime?: CSSLanguageRuntime;
+  languageRuntimeResolution?: MasterCSSWorkspacePackageResolution;
+  languageRuntimeSource?: 'workspace' | 'bundled';
+  manifestErrors?: unknown[];
+  planEntries?: string[];
+}
+declare const ACTIVE_SEMANTIC_TOKENS_REQUEST = "masterCSS/renderActiveSemanticTokens";
+declare const DOCUMENT_SEMANTIC_TOKENS_REQUEST = "masterCSS/renderDocumentSemanticTokens";
+declare class CSSLanguageServer {
+  connection: Connection;
+  customSettings?: Settings$1 | undefined;
+  workspaceFolders: WorkspaceFolder[];
+  workspaces: Map<string, Workspace>;
+  globalWorkspace: Workspace;
+  documents: TextDocuments<TextDocument>;
+  initializing?: Promise<void>;
+  clientCapabilities: ClientCapabilities;
+  settings?: Settings$1;
+  console: RemoteConsole;
+  private disposables;
+  constructor(connection?: Connection, customSettings?: Settings$1 | undefined);
+  start(): void;
+  init(): Promise<void>;
+  onInitialize(params: InitializeParams): InitializeResult;
+  onHover(params: HoverParams): Promise<import("vscode-languageserver-protocol").Hover | undefined>;
+  onCompletion(params: CompletionParams): Promise<import("vscode-languageserver-protocol").CompletionItem[] | undefined>;
+  onDocumentColor(params: DocumentColorParams): Promise<import("vscode-languageserver-protocol").ColorInformation[]>;
+  onColorPresentation(params: ColorPresentationParams): Promise<import("vscode-languageserver-protocol").ColorPresentation[]>;
+  private getWorkspaceDocument;
+  onDocumentFormatting(params: DocumentFormattingParams): Promise<TextEdit[]>;
+  onDocumentRangeFormatting(params: DocumentRangeFormattingParams): Promise<TextEdit[]>;
+  onSemanticTokens(params: SemanticTokensParams): Promise<import("vscode-languageserver-protocol").SemanticTokens>;
+  onDocumentSemanticTokens(params: SemanticTokensParams): Promise<import("vscode-languageserver-protocol").SemanticTokens>;
+  onActiveSemanticTokens(params: TextDocumentPositionParams): Promise<import("vscode-languageserver-protocol").SemanticTokens>;
+  onDidOpen(params: TextDocumentChangeEvent<TextDocument>): Promise<void>;
+  onDidChangeContent(params: TextDocumentChangeEvent<TextDocument>): Promise<void>;
+  onDidClose(params: TextDocumentChangeEvent<TextDocument>): Promise<void>;
+  onDidSave(params: TextDocumentChangeEvent<TextDocument>): Promise<void>;
+  onDidChangeConfiguration({
+    settings: changedSettings
+  }: DidChangeConfigurationParams): Promise<void>;
+  private initWorkspaceFolder;
+  initWorkspaceLanguageService(workspace: Workspace): Promise<void>;
+  private loadWorkspacePlan;
+  private loadWorkspaceLanguageRuntime;
+  private importWorkspaceModule;
+  destroyLanguageService(workspace: Workspace): void;
+  findClosestWorkspace(textDocumentURI: string): Workspace;
+  private publishDiagnostics;
+  private createCSSDirectiveDiagnostics;
+  private createManifestLoadingDiagnostics;
+  private createCSSDirectiveDiagnostic;
+  private createCSSDirectiveRelatedInformation;
+  private createCSSDirectiveRange;
+  private refreshSemanticTokens;
+  stop(): void;
+}
+//#endregion
+export { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, Workspace, CSSLanguageServer as default };

package/dist/core.js

@@ -0,0 +1,533 @@
+import settings$1 from "./settings.js";
+import { DiagnosticSeverity, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import CSSLanguageService from "@master/css-language-service";
+import { compileCSSManifest } from "@master/css-compiler";
+import { findCSSManifestEntryFiles, findMasterCSSWorkspaceDirectories } from "@master/css-project/entries";
+import { loadProjectManifest } from "@master/css-project/manifest";
+import { resolveMasterCSSWorkspacePackages } from "@master/css-project/workspace";
+import { defu } from "defu";
+import { AT_TRIGGER_CHARACTER, DECLARATION_SEPARATOR_TRIGGER_CHARACTER, GROUP_TRIGGER_CHARACTER, INVOKED_TRIGGER_CHARACTERS, QUERY_TRIGGER_CHARACTERS, SELECTOR_TRIGGER_CHARACTERS, VALUE_TRIGGER_CHARACTERS } from "@master/css-language-service/common";
+import { SEMANTIC_TOKENS_LEGEND, defaultCSSLanguageRuntime, matchesLanguageServiceNativeDeclaration } from "@master/css-language";
+import glob from "fast-glob";
+import { URI } from "vscode-uri";
+import { CSSDirectiveError } from "@master/css-schema/css-directives";
+//#region src/core.ts
+const ACTIVE_SEMANTIC_TOKENS_REQUEST = "masterCSS/renderActiveSemanticTokens";
+const DOCUMENT_SEMANTIC_TOKENS_REQUEST = "masterCSS/renderDocumentSemanticTokens";
+const SERVER_CAPABILITIES = {
+	textDocumentSync: TextDocumentSyncKind.Incremental,
+	completionProvider: {
+		resolveProvider: false,
+		workDoneProgress: false,
+		triggerCharacters: [.../* @__PURE__ */ new Set([
+			...INVOKED_TRIGGER_CHARACTERS,
+			...VALUE_TRIGGER_CHARACTERS,
+			...SELECTOR_TRIGGER_CHARACTERS,
+			...QUERY_TRIGGER_CHARACTERS,
+			DECLARATION_SEPARATOR_TRIGGER_CHARACTER,
+			AT_TRIGGER_CHARACTER,
+			GROUP_TRIGGER_CHARACTER
+		])]
+	},
+	colorProvider: true,
+	hoverProvider: true,
+	documentFormattingProvider: true,
+	documentRangeFormattingProvider: true,
+	semanticTokensProvider: {
+		legend: SEMANTIC_TOKENS_LEGEND,
+		full: true
+	},
+	workspace: { workspaceFolders: { supported: true } }
+};
+const CSS_DIAGNOSTIC_LANGUAGE_IDS = /* @__PURE__ */ new Set([
+	"css",
+	"scss",
+	"less"
+]);
+const SFC_DIAGNOSTIC_LANGUAGE_IDS = /* @__PURE__ */ new Set([
+	"vue",
+	"svelte",
+	"astro"
+]);
+const STYLE_BLOCK_RE = /<style\b([^>]*)>([\s\S]*?)<\/style>/gi;
+function isCSSDiagnosticDocument(textDocument) {
+	return CSS_DIAGNOSTIC_LANGUAGE_IDS.has(textDocument.languageId) || SFC_DIAGNOSTIC_LANGUAGE_IDS.has(textDocument.languageId);
+}
+function getSFCStyleLanguage(attributes) {
+	const match = /\blang\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s>]+))/i.exec(attributes);
+	return (match?.[1] || match?.[2] || match?.[3] || "css").toLowerCase();
+}
+function getCSSDiagnosticSources(textDocument) {
+	const text = textDocument.getText();
+	if (CSS_DIAGNOSTIC_LANGUAGE_IDS.has(textDocument.languageId)) return [{
+		source: text,
+		offset: 0
+	}];
+	if (!SFC_DIAGNOSTIC_LANGUAGE_IDS.has(textDocument.languageId)) return [];
+	const sources = [];
+	STYLE_BLOCK_RE.lastIndex = 0;
+	for (const match of text.matchAll(STYLE_BLOCK_RE)) {
+		const styleLanguage = getSFCStyleLanguage(match[1]);
+		if (!CSS_DIAGNOSTIC_LANGUAGE_IDS.has(styleLanguage)) continue;
+		const source = match[2];
+		const offset = (match.index || 0) + match[0].indexOf(source);
+		sources.push({
+			source,
+			offset
+		});
+	}
+	return sources;
+}
+function isCSSDirectiveError(error) {
+	return error instanceof CSSDirectiveError || !!error && typeof error === "object" && error.name === "CSSDirectiveError" && typeof error.code === "string";
+}
+function getInitializationSettings(initializationOptions) {
+	if (!initializationOptions || typeof initializationOptions !== "object") return;
+	const options = initializationOptions;
+	return options.masterCSS ?? options;
+}
+function isWindowsFilePath(fsPath) {
+	return /^[a-z]:[\\/]/i.test(fsPath) || fsPath.startsWith("\\\\") || fsPath.startsWith("//");
+}
+function getFilePathTools(...fsPaths) {
+	return fsPaths.some(isWindowsFilePath) ? path.win32 : path;
+}
+function toComparableFilePath(uri) {
+	const parsedURI = URI.parse(uri);
+	if (parsedURI.scheme !== "file") return;
+	const fsPath = parsedURI.fsPath;
+	if (!fsPath) return;
+	const resolvedPath = getFilePathTools(fsPath).resolve(fsPath);
+	return isWindowsFilePath(resolvedPath) ? resolvedPath.toLowerCase() : resolvedPath;
+}
+function containsFilePath(parentPath, childPath) {
+	const filePathTools = getFilePathTools(parentPath, childPath);
+	const relativePath = filePathTools.relative(parentPath, childPath);
+	return relativePath === "" || !!relativePath && relativePath !== ".." && !relativePath.startsWith(`..${filePathTools.sep}`) && !filePathTools.isAbsolute(relativePath);
+}
+var CSSLanguageServer = class {
+	connection;
+	customSettings;
+	workspaceFolders = [];
+	workspaces = /* @__PURE__ */ new Map();
+	globalWorkspace = {
+		uri: "",
+		openedTextDocuments: [],
+		languageServiceSettings: this.settings,
+		languageRuntime: defaultCSSLanguageRuntime,
+		languageRuntimeSource: "bundled"
+	};
+	documents;
+	initializing;
+	clientCapabilities = {};
+	settings;
+	console;
+	disposables = [];
+	constructor(connection = process.argv.includes("--stdio") ? createConnection(process.stdin, process.stdout) : createConnection(), customSettings) {
+		this.connection = connection;
+		this.customSettings = customSettings;
+		this.documents = new TextDocuments(TextDocument);
+		this.settings = defu(this.customSettings, settings$1);
+		this.globalWorkspace.languageServiceSettings = this.settings;
+		this.console = new Proxy(this.connection.console, { get: (target, prop) => {
+			if (!this.settings?.verbose) return () => {};
+			return this.connection.console[prop];
+		} });
+	}
+	start() {
+		this.disposables.push(this.documents.onDidSave(this.onDidSave.bind(this)), this.documents.onDidOpen(this.onDidOpen.bind(this)), this.documents.onDidChangeContent(this.onDidChangeContent.bind(this)), this.documents.onDidClose(this.onDidClose.bind(this)), this.documents.listen(this.connection), this.connection.onDidChangeConfiguration(this.onDidChangeConfiguration.bind(this)), this.connection.onHover(this.onHover.bind(this)), this.connection.onCompletion(this.onCompletion.bind(this)), this.connection.onDocumentColor(this.onDocumentColor.bind(this)), this.connection.onColorPresentation(this.onColorPresentation.bind(this)), this.connection.onDocumentFormatting(this.onDocumentFormatting.bind(this)), this.connection.onDocumentRangeFormatting(this.onDocumentRangeFormatting.bind(this)), this.connection.languages.semanticTokens.on(this.onSemanticTokens.bind(this)), this.connection.onRequest(DOCUMENT_SEMANTIC_TOKENS_REQUEST, this.onDocumentSemanticTokens.bind(this)), this.connection.onRequest(ACTIVE_SEMANTIC_TOKENS_REQUEST, this.onActiveSemanticTokens.bind(this)), this.connection.onInitialize(this.onInitialize.bind(this)), this.connection.onInitialized(() => this.init()));
+		this.connection.listen();
+	}
+	init() {
+		if (this.initializing) return this.initializing;
+		return this.initializing = new Promise(async (resolve) => {
+			await Promise.all(this.workspaceFolders.map((folder) => this.initWorkspaceFolder(folder.uri)));
+			resolve();
+		});
+	}
+	onInitialize(params) {
+		this.clientCapabilities = params.capabilities;
+		const initializationSettings = getInitializationSettings(params.initializationOptions);
+		if (initializationSettings) {
+			this.customSettings = defu(initializationSettings, this.customSettings);
+			this.settings = defu(this.customSettings, settings$1);
+			this.globalWorkspace.languageServiceSettings = this.settings;
+		}
+		if (params.workspaceFolders?.length) this.workspaceFolders = params.workspaceFolders;
+		const capabilities = { ...SERVER_CAPABILITIES };
+		if (this.settings?.embeddedSyntaxHighlighting !== "always") delete capabilities.semanticTokensProvider;
+		if (!this.settings?.formatDirectives) {
+			delete capabilities.documentFormattingProvider;
+			delete capabilities.documentRangeFormattingProvider;
+		}
+		return { capabilities };
+	}
+	async onHover(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.textDocument.uri);
+		if (workspace?.languageService) {
+			const document = this.documents.get(params.textDocument.uri);
+			if (document) return workspace.languageService.inspectSyntax(document, params.position);
+		}
+	}
+	async onCompletion(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.textDocument.uri);
+		if (workspace?.languageService) {
+			const document = this.documents.get(params.textDocument.uri);
+			if (document) return workspace.languageService.suggestSyntax(document, params.position, params.context);
+		}
+	}
+	async onDocumentColor(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.textDocument.uri);
+		if (workspace?.languageService) {
+			const document = this.documents.get(params.textDocument.uri);
+			if (document) return await workspace.languageService.renderSyntaxColors(document) ?? [];
+		}
+		return [];
+	}
+	async onColorPresentation(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.textDocument.uri);
+		if (workspace?.languageService) {
+			const document = this.documents.get(params.textDocument.uri);
+			if (document) return workspace.languageService.editSyntaxColors(document, params.color, params.range) ?? [];
+		}
+		return [];
+	}
+	getWorkspaceDocument(uri) {
+		const workspace = this.findClosestWorkspace(uri);
+		if (!workspace?.languageService) return;
+		const document = this.documents.get(uri) ?? workspace.openedTextDocuments.find((document) => document.uri === uri);
+		if (!document) return;
+		return {
+			workspace,
+			document
+		};
+	}
+	async onDocumentFormatting(params) {
+		await this.init();
+		const context = this.getWorkspaceDocument(params.textDocument.uri);
+		return context?.workspace.languageService?.formatDirectives(context.document) ?? [];
+	}
+	async onDocumentRangeFormatting(params) {
+		await this.init();
+		const context = this.getWorkspaceDocument(params.textDocument.uri);
+		return context?.workspace.languageService?.formatDirectives(context.document, params.range) ?? [];
+	}
+	async onSemanticTokens(params) {
+		await this.init();
+		const context = this.getWorkspaceDocument(params.textDocument.uri);
+		if (context) return context.workspace.languageService?.renderSemanticTokens(context.document) ?? { data: [] };
+		return { data: [] };
+	}
+	async onDocumentSemanticTokens(params) {
+		return this.onSemanticTokens(params);
+	}
+	async onActiveSemanticTokens(params) {
+		await this.init();
+		const context = this.getWorkspaceDocument(params.textDocument.uri);
+		if (context) return context.workspace.languageService?.renderSemanticTokensAtPosition(context.document, params.position) ?? { data: [] };
+		return { data: [] };
+	}
+	async onDidOpen(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.document.uri);
+		if (!workspace) return;
+		if (workspace.openedTextDocuments.includes(params.document)) {
+			this.publishDiagnostics(params.document, workspace);
+			return;
+		}
+		if (!workspace.openedTextDocuments.length) await this.initWorkspaceLanguageService(workspace);
+		workspace.openedTextDocuments.push(params.document);
+		this.publishDiagnostics(params.document, workspace);
+	}
+	async onDidChangeContent(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.document.uri);
+		if (!workspace) return;
+		this.publishDiagnostics(params.document, workspace);
+	}
+	async onDidClose(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.document.uri);
+		if (!workspace) return;
+		workspace.openedTextDocuments.splice(workspace.openedTextDocuments.indexOf(params.document), 1);
+		this.connection.sendDiagnostics({
+			uri: params.document.uri,
+			diagnostics: []
+		});
+		if (!workspace.openedTextDocuments.length) this.destroyLanguageService(workspace);
+	}
+	async onDidSave(params) {
+		await this.init();
+		const workspace = this.findClosestWorkspace(params.document.uri);
+		if (!workspace) return;
+		this.publishDiagnostics(params.document, workspace);
+		if (path.basename(URI.parse(params.document.uri).fsPath).endsWith(".css")) {
+			this.refreshSemanticTokens();
+			this.connection.sendRequest("masterCSS/restart", { title: "Updating Master CSS configuration" });
+		}
+	}
+	async onDidChangeConfiguration({ settings: changedSettings }) {
+		await this.init();
+		if (changedSettings?.masterCSS) {
+			this.connection.sendNotification("masterCSS/globalSettingsChanged", changedSettings.masterCSS);
+			this.customSettings = changedSettings.masterCSS;
+			this.settings = defu(this.customSettings, settings$1);
+			this.globalWorkspace.languageServiceSettings = this.settings;
+			this.refreshSemanticTokens();
+			this.connection.sendRequest("masterCSS/restart", { title: "Updating Master CSS settings" });
+			for (const workspace of [this.globalWorkspace, ...this.workspaces.values()]) for (const document of workspace.openedTextDocuments) this.publishDiagnostics(document, workspace);
+		}
+	}
+	async initWorkspaceFolder(workspaceFolderURI) {
+		const workspaceFolderCWD = URI.parse(workspaceFolderURI).fsPath;
+		let customWorkspaceFolderSettings;
+		if (this.clientCapabilities.workspace?.configuration) customWorkspaceFolderSettings = await this.connection.workspace.getConfiguration({
+			scopeUri: workspaceFolderURI,
+			section: "masterCSS"
+		});
+		const { workspaces, ...languageServiceSettings } = defu(customWorkspaceFolderSettings, this.customSettings, settings$1);
+		const resolvedWorkspaceDirectories = /* @__PURE__ */ new Set([workspaceFolderCWD]);
+		if (workspaceFolderCWD) this.console.info(`Registered workspace folder ${workspaceFolderURI}`);
+		else this.console.info(`Registered global workspace folder`);
+		if (workspaces === "auto") for (const workspaceDir of await findMasterCSSWorkspaceDirectories(workspaceFolderCWD)) resolvedWorkspaceDirectories.add(workspaceDir);
+		else if (workspaces?.length) (await glob(workspaces, {
+			cwd: workspaceFolderCWD,
+			absolute: true,
+			onlyDirectories: true,
+			ignore: ["**/node_modules/**"]
+		})).forEach((workspaceDir) => resolvedWorkspaceDirectories.add(path.resolve(workspaceDir)));
+		for (const workspaceDir of resolvedWorkspaceDirectories) {
+			const workspaceURI = URI.file(workspaceDir).toString();
+			this.console.info(`Added workspace ${workspaceURI}`);
+			this.workspaces.set(workspaceURI, {
+				uri: workspaceURI,
+				openedTextDocuments: [],
+				languageServiceSettings,
+				planEntries: await findCSSManifestEntryFiles(workspaceDir)
+			});
+		}
+	}
+	async initWorkspaceLanguageService(workspace) {
+		workspace.languageRuntime = await this.loadWorkspaceLanguageRuntime(workspace);
+		let workspacePlan;
+		workspace.manifestErrors = [];
+		if (workspace !== this.globalWorkspace) {
+			try {
+				workspacePlan = await this.loadWorkspacePlan(workspace);
+			} catch (e) {
+				workspace.manifestErrors = [e];
+				this.console.info(`Failed to load manifest from ${workspace.uri}`);
+				this.console.error(e instanceof Error ? e.stack : e.toString());
+			}
+			if (workspacePlan) this.console.info(`Initialized workspace ${workspace.planEntries?.length ? "(with manifest entry)" : "(with manifest)"} ${workspace.uri}`);
+			else this.console.info(`Initialized workspace ${workspace.uri}`);
+		}
+		workspace.languageService = new CSSLanguageService({
+			...workspace.languageServiceSettings,
+			manifest: workspacePlan
+		}, { runtime: workspace.languageRuntime });
+	}
+	async loadWorkspacePlan(workspace) {
+		const result = await loadProjectManifest(workspace.uri ? URI.parse(workspace.uri).fsPath : process.cwd(), { baseManifest: (workspace.languageRuntime ?? defaultCSSLanguageRuntime).defaultManifest });
+		return result.entries.length ? result.manifest : workspace.languageServiceSettings.manifest;
+	}
+	async loadWorkspaceLanguageRuntime(workspace) {
+		if (workspace === this.globalWorkspace || !workspace.uri) {
+			workspace.languageRuntimeSource = "bundled";
+			return defaultCSSLanguageRuntime;
+		}
+		const cwd = URI.parse(workspace.uri).fsPath;
+		let resolution;
+		try {
+			resolution = resolveMasterCSSWorkspacePackages(cwd);
+			workspace.languageRuntimeResolution = resolution;
+			const missingPackages = [
+				!resolution.css && "@master/css",
+				!resolution.engine && "@master/css-engine",
+				!resolution.presetManifest && "@master/css-preset/default-manifest.json"
+			].filter(Boolean);
+			if (missingPackages.length) throw new Error(`Missing workspace package(s): ${missingPackages.join(", ")}`);
+			const cssPackage = resolution.css;
+			const enginePackage = resolution.engine;
+			const presetManifestPackage = resolution.presetManifest;
+			if (!cssPackage || !enginePackage || !presetManifestPackage) throw new Error("Missing required workspace Master CSS runtime packages.");
+			const [cssModule, engineModule, utilityTypeModule] = await Promise.all([
+				this.importWorkspaceModule(cssPackage.entry),
+				this.importWorkspaceModule(enginePackage.entry),
+				resolution.utilityType ? this.importWorkspaceModule(resolution.utilityType.entry) : void 0
+			]);
+			const MasterCSS = cssModule.MasterCSS || cssModule.default;
+			const builtinKeyAliases = engineModule.builtinKeyAliases;
+			const builtinNativeValueNamespaces = engineModule.builtinNativeValueNamespaces;
+			if (!MasterCSS) throw new Error(`Missing MasterCSS export from ${cssPackage.entry}`);
+			if (!builtinKeyAliases) throw new Error(`Missing builtinKeyAliases export from ${enginePackage.entry}`);
+			if (!builtinNativeValueNamespaces) throw new Error(`Missing builtinNativeValueNamespaces export from ${enginePackage.entry}`);
+			const manifest = JSON.parse(await readFile(presetManifestPackage.entry, "utf8"));
+			workspace.languageRuntimeSource = "workspace";
+			this.console.info(`Using workspace Master CSS runtime ${cssPackage.version ?? "(unknown version)"} from ${cssPackage.directory}`);
+			if (resolution.errors.length) this.console.info(`Workspace Master CSS runtime optional resolution warnings: ${resolution.errors.map(({ name, message }) => `${name}: ${message}`).join("; ")}`);
+			return {
+				MasterCSS,
+				UtilityType: utilityTypeModule?.UtilityType || utilityTypeModule?.default || defaultCSSLanguageRuntime.UtilityType,
+				defaultManifest: manifest,
+				builtinKeyAliases,
+				builtinNativeValueNamespaces,
+				nativeDeclarationMatcher: matchesLanguageServiceNativeDeclaration
+			};
+		} catch (error) {
+			workspace.languageRuntimeSource = "bundled";
+			this.console.info(`Using bundled Master CSS runtime for ${workspace.uri}`);
+			if (resolution?.errors.length) this.console.info(`Workspace Master CSS package resolution errors: ${resolution.errors.map(({ name, message }) => `${name}: ${message}`).join("; ")}`);
+			this.console.error(error instanceof Error ? error.stack || error.message : String(error));
+			return defaultCSSLanguageRuntime;
+		}
+	}
+	async importWorkspaceModule(path) {
+		return await import(pathToFileURL(path).href);
+	}
+	destroyLanguageService(workspace) {
+		this.console.info(`Destroyed workspace ${workspace.uri}`);
+		delete workspace.languageService;
+	}
+	findClosestWorkspace(textDocumentURI) {
+		const documentPath = toComparableFilePath(textDocumentURI);
+		if (!documentPath) {
+			this.console.info(`This is an external document ${textDocumentURI} with the global workspace`);
+			return this.globalWorkspace;
+		}
+		let foundWorkspace;
+		let foundWorkspacePath = "";
+		for (const [uri, workspace] of this.workspaces) {
+			if (!uri) continue;
+			const workspacePath = toComparableFilePath(uri);
+			if (!workspacePath) continue;
+			if (containsFilePath(workspacePath, documentPath) && workspacePath.length > foundWorkspacePath.length) {
+				foundWorkspace = workspace;
+				foundWorkspacePath = workspacePath;
+			}
+		}
+		if (foundWorkspace) return foundWorkspace;
+		this.console.info(`This is an external document ${textDocumentURI} with the global workspace`);
+		return this.globalWorkspace;
+	}
+	publishDiagnostics(textDocument, workspace) {
+		const diagnostics = [];
+		diagnostics.push(...this.createManifestLoadingDiagnostics(textDocument, workspace));
+		diagnostics.push(...this.createCSSDirectiveDiagnostics(textDocument, workspace));
+		this.connection.sendDiagnostics({
+			uri: textDocument.uri,
+			diagnostics
+		});
+	}
+	createCSSDirectiveDiagnostics(textDocument, workspace) {
+		if (!isCSSDiagnosticDocument(textDocument)) return [];
+		const diagnostics = [];
+		const documentFile = path.resolve(URI.parse(textDocument.uri).fsPath);
+		for (const { source, offset } of getCSSDiagnosticSources(textDocument)) try {
+			compileCSSManifest(source, {
+				from: documentFile,
+				baseManifest: (workspace.languageRuntime ?? defaultCSSLanguageRuntime).defaultManifest
+			});
+		} catch (error) {
+			if (!isCSSDirectiveError(error)) continue;
+			const diagnostic = this.createCSSDirectiveDiagnostic(error, textDocument, documentFile, offset);
+			if (diagnostic) diagnostics.push(diagnostic);
+		}
+		return diagnostics;
+	}
+	createManifestLoadingDiagnostics(textDocument, workspace) {
+		if (!workspace.manifestErrors?.length) return [];
+		const documentFile = path.resolve(URI.parse(textDocument.uri).fsPath);
+		return workspace.manifestErrors.map((error) => {
+			const directiveError = isCSSDirectiveError(error) ? error : void 0;
+			const source = directiveError?.source;
+			return {
+				range: source && (!source.file || path.resolve(source.file) === documentFile) ? this.createCSSDirectiveRange(source, textDocument, documentFile, 0) : {
+					start: {
+						line: 0,
+						character: 0
+					},
+					end: {
+						line: 0,
+						character: 0
+					}
+				},
+				severity: DiagnosticSeverity.Error,
+				code: "manifest-loading-error",
+				source: "Master CSS",
+				message: `Failed to load Master CSS manifest: ${error instanceof Error ? error.message : String(error)}`,
+				relatedInformation: directiveError ? this.createCSSDirectiveRelatedInformation(directiveError.related, textDocument, documentFile, 0) : void 0
+			};
+		});
+	}
+	createCSSDirectiveDiagnostic(error, textDocument, documentFile, sourceOffset) {
+		if (error.source?.file && path.resolve(error.source.file) !== documentFile) return;
+		return {
+			range: this.createCSSDirectiveRange(error.source, textDocument, documentFile, sourceOffset),
+			severity: DiagnosticSeverity.Error,
+			code: error.code,
+			source: "Master CSS",
+			message: error.message,
+			relatedInformation: this.createCSSDirectiveRelatedInformation(error.related, textDocument, documentFile, sourceOffset)
+		};
+	}
+	createCSSDirectiveRelatedInformation(related, textDocument, documentFile, sourceOffset) {
+		if (!related?.length) return;
+		return related.map(({ message, source }) => ({
+			message,
+			location: {
+				uri: source?.file ? URI.file(source.file).toString() : textDocument.uri,
+				range: this.createCSSDirectiveRange(source, textDocument, documentFile, sourceOffset)
+			}
+		}));
+	}
+	createCSSDirectiveRange(source, textDocument, documentFile, sourceOffset) {
+		if (source?.file && path.resolve(source.file) !== documentFile) return source.loc ? {
+			start: {
+				line: Math.max(0, source.loc.start.line - 1),
+				character: Math.max(0, source.loc.start.column - 1)
+			},
+			end: {
+				line: Math.max(0, source.loc.end.line - 1),
+				character: Math.max(0, source.loc.end.column - 1)
+			}
+		} : {
+			start: {
+				line: 0,
+				character: 0
+			},
+			end: {
+				line: 0,
+				character: 0
+			}
+		};
+		const start = Math.max(0, (source?.range.start || 0) + sourceOffset);
+		const end = Math.max(start, (source?.range.end || 0) + sourceOffset);
+		return {
+			start: textDocument.positionAt(start),
+			end: textDocument.positionAt(end)
+		};
+	}
+	refreshSemanticTokens() {
+		if (this.settings?.embeddedSyntaxHighlighting !== "always") return;
+		if (!this.clientCapabilities.workspace?.semanticTokens?.refreshSupport) return;
+		this.connection.languages.semanticTokens.refresh();
+	}
+	stop() {
+		this.connection.sendNotification("masterCSS/dispose");
+		this.disposables.forEach((disposable) => disposable.dispose());
+		this.disposables.length = 0;
+		this.connection.dispose();
+		this.initializing = void 0;
+	}
+};
+//#endregion
+export { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, CSSLanguageServer as default };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import settings, { Settings } from "./settings.js";
+import CSSLanguageServer, { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, Workspace, default as core_default } from "./core.js";
+export { ACTIVE_SEMANTIC_TOKENS_REQUEST, CSSLanguageServer, DOCUMENT_SEMANTIC_TOKENS_REQUEST, type Settings, type Workspace, core_default as default, settings };

package/dist/index.js

@@ -0,0 +1,3 @@
+import settings from "./settings.js";
+import CSSLanguageServer, { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST } from "./core.js";
+export { ACTIVE_SEMANTIC_TOKENS_REQUEST, CSSLanguageServer, DOCUMENT_SEMANTIC_TOKENS_REQUEST, CSSLanguageServer as default, settings };

package/dist/server.d.ts

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

package/dist/server.js

@@ -0,0 +1,8 @@
+import CSSLanguageServer from "./core.js";
+//#region src/server.ts
+new CSSLanguageServer(void 0, { verbose: true }).start();
+process.on("unhandledRejection", (error) => {
+	console.error("Unhandled rejection", error);
+});
+//#endregion
+export {};

package/dist/settings.d.ts

@@ -0,0 +1,11 @@
+import { Settings as Settings$1 } from "@master/css-language-service";
+import { Pattern } from "fast-glob";
+
+//#region src/settings.d.ts
+declare const settings: Settings;
+declare type Settings = Settings$1 & {
+  workspaces?: Pattern[] | 'auto';
+  verbose?: boolean;
+};
+//#endregion
+export { Settings, settings as default };

package/dist/settings.js

@@ -0,0 +1,9 @@
+import { settings as settings$1 } from "@master/css-language-service";
+//#region src/settings.ts
+const settings = {
+	...settings$1,
+	workspaces: "auto",
+	verbose: false
+};
+//#endregion
+export { settings as default };

package/dist/utils/create-document.d.ts

@@ -0,0 +1,9 @@
+import { TextDocument } from "vscode-languageserver-textdocument";
+
+//#region src/utils/create-document.d.ts
+declare function createDocument(text: string, options?: {
+  lang?: string;
+  dir?: string;
+}): TextDocument;
+//#endregion
+export { createDocument as default };

package/dist/utils/create-document.js

@@ -0,0 +1,28 @@
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { URI } from "vscode-uri";
+import { nanoid } from "nanoid";
+import path from "path";
+//#region src/utils/create-document.ts
+const extOfLang = {
+	typescript: "ts",
+	typescriptreact: "tsx",
+	javascript: "js",
+	javascriptreact: "jsx",
+	css: "css",
+	scss: "scss",
+	less: "less",
+	html: "html",
+	json: "json",
+	vue: "vue",
+	svelte: "svelte",
+	astro: "astro"
+};
+function createDocument(text, options) {
+	const lang = options?.lang || "html";
+	const dir = options?.dir || "./";
+	const filePath = path.join(dir, `${nanoid()}.${extOfLang[lang]}`);
+	const fileURI = URI.file(filePath).toString();
+	return TextDocument.create(fileURI, lang, 0, text);
+}
+//#endregion
+export { createDocument as default };

package/package.json

@@ -1 +1,60 @@
-{"name":"@master/css-language-server","scripts":{"build":"techor pack --platform node --declare","dev":"pnpm run build --watch","type-check":"tsc --noEmit","lint":"eslint src","test":"jest"},"description":"Master CSS Language Server","author":"Aoyue Design LLC.","license":"MIT","dependencies":{"@master/css":"^2.0.0-rc.8","@master/css-language-service":"^2.0.0-rc.8","explore-config":"^2.5.24","js-beautify":"^1.14.7","minimatch":"^9.0.1","vscode-languageserver":"^7.0.0","vscode-languageserver-textdocument":"^1.0.9"},"main":"./dist/server.bundle.js","types":"./dist/server.d.ts","files":["dist"],"publishConfig":{"access":"public"},"version":"2.0.0-rc.8"}
+{
+  "name": "@master/css-language-server",
+  "type": "module",
+  "description": "Master CSS Language Server",
+  "author": "Aoyue Design LLC.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/master-co/css.git",
+    "directory": "packages/language-server"
+  },
+  "dependencies": {
+    "defu": "^6.1.7",
+    "fast-glob": "^3.3.3",
+    "js-beautify": "^1.15.4",
+    "nanoid": "^5.1.15",
+    "vscode-languageserver": "^10.0.0",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "vscode-uri": "^3.1.0",
+    "@master/css": "^2.0.0-rc.80",
+    "@master/css-language": "^2.0.0-rc.80",
+    "@master/css-language-service": "^2.0.0-rc.80",
+    "@master/css-project": "^2.0.0-rc.80",
+    "@master/css-compiler": "^2.0.0-rc.80",
+    "@master/css-schema": "^2.0.0-rc.80"
+  },
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "jsnext:main": "./dist/index.js",
+  "esnext": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "default": "./dist/server.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "version": "2.0.0-rc.80",
+  "scripts": {
+    "build": "tsdown --config ../../shared/tsdown-package.config.ts",
+    "dev": "tsdown --config ../../shared/tsdown-package.config.ts --watch",
+    "type-check": "tsc -b tsconfig.typecheck.json",
+    "lint": "eslint",
+    "test": "vitest"
+  }
+}

package/dist/server.bundle.js

@@ -1 +0,0 @@
-"use strict";var W=Object.create;var S=Object.defineProperty;var U=Object.getOwnPropertyDescriptor;var H=Object.getOwnPropertyNames;var K=Object.getPrototypeOf,L=Object.prototype.hasOwnProperty;var E=(t,e,n,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of H(e))!L.call(t,i)&&i!==n&&S(t,i,{get:()=>e[i],enumerable:!(s=U(e,i))||s.enumerable});return t};var h=(t,e,n)=>(n=t!=null?W(K(t)):{},E(e||!t||!t.__esModule?S(n,"default",{value:t,enumerable:!0}):n,t));var u=require("vscode-languageserver/node"),w=require("@master/css"),b=require("minimatch"),P=require("vscode-languageserver-textdocument"),k=h(require("path")),T=require("url"),o=require("@master/css-language-service"),v=h(require("explore-config")),a=(0,u.createConnection)(u.ProposedFeatures.all),f=new u.TextDocuments(P.TextDocument),C=!1,D=!1,O=!1,l,g,I;var M=o.settings,p=new Map;a.onDidChangeConfiguration(t=>{C?p.clear():M=t.settings.masterCSS||o.settings,f.all().forEach(y)});async function B(t){if(!C)return Promise.resolve(M);let e=p.get(t);return e||(e=a.workspace.getConfiguration({scopeUri:t,section:"masterCSS"}),p.set(t,e)),e}f.onDidClose(t=>{p.delete(t.document.uri)});f.onDidOpen(t=>{y(t.document)});f.onDidSave(async t=>{k.default.parse(t.document.uri).name==="master.css"&&await A(t.document.uri)});async function y(t){l=await B(t.uri),await A(t.uri)}async function A(t){let e=await a.workspace.getWorkspaceFolders(),n;if(e?.length===1?n=e[0]:n=e?.find(s=>t.includes(s.uri)),n?.uri){let s=(0,T.fileURLToPath)(n.uri.replace("%3A",":"));I=(0,v.default)(l.config||"master.css.*",{cwd:s}),g=new w.MasterCSS(I)}}a.onInitialize(t=>{let e=t.capabilities;C=!!(e.workspace&&e.workspace.configuration),D=!!(e.workspace&&e.workspace.workspaceFolders),O=!!(e.textDocument&&e.textDocument.publishDiagnostics&&e.textDocument.publishDiagnostics.relatedInformation);let n={capabilities:{textDocumentSync:u.TextDocumentSyncKind.Incremental,completionProvider:{resolveProvider:!0,workDoneProgress:!1,triggerCharacters:[":","@","'"]},colorProvider:{},hoverProvider:!0}};return D&&(n.capabilities.workspace={workspaceFolders:{supported:!0}}),n});a.onInitialized(()=>{C&&a.client.register(u.DidChangeConfigurationNotification.type,void 0)});a.onCompletion(t=>{if(l.suggestions==!0&&x(t.textDocument.uri)){let e=t.textDocument.uri,n=f.get(e),s=e.substring(e.lastIndexOf(".")+1),i=t.position;if(n){let c=n.getText(),d=n.offsetAt(i)??0,r=n.offsetAt({line:i.line-100,character:0})??0,F=n.offsetAt({line:i.line+100,character:0})??void 0,R=(0,o.positionCheck)(c.substring(r,F),d,r,l.classMatch).IsMatch,z=n.getText({start:{line:i.line,character:0},end:{line:i.line,character:i.character}}).trim(),m=(0,o.getLastInstance)(z,i,s);if(m.isInstance==!0&&R==!0)return(0,o.getCompletionItem)(m.lastKey,m.triggerKey,m.isStart,m.language,g);if(m.isInstance==!0&&(0,o.checkConfigColorsBlock)(n,t.position)==!0)return(0,o.getConfigColorsCompletionItem)(g)}}return[]});a.onCompletionResolve(t=>t);a.onDocumentColor(async t=>{if(l==null)return[];if(l.previewColors==!0&&x(t.textDocument.uri)){let e=t.textDocument.uri,n=f.get(e);if(n){let s=n.getText()??"";if(typeof n==null)return[];let i=await(0,o.getDocumentColors)(s,g),c=new Set;return i.filter(r=>c.has(r.index.start)?!1:(c.add(r.index.start),!0)).map(r=>({range:{start:n.positionAt(r.index.start),end:n.positionAt(r.index.end)},color:r.color}))}}return[]});a.onColorPresentation(t=>{if(l.previewColors==!0&&x(t.textDocument.uri)){let e=f.get(t.textDocument.uri);if(e){let n=e.getText(),s=["(?<=colors:\\s*{\\s*.*)([^}]*)}"],i=e.offsetAt(t.range.start)??0,c=e.offsetAt({line:t.range.start.line-100,character:0})??0,d=e.offsetAt({line:t.range.start.line+100,character:0})??void 0,r=(0,o.positionCheck)(n.substring(c,d),i,c,s);return(0,o.getColorPresentation)(t,r.IsMatch)}}return[]});a.onHover(t=>{if(l.inspect==!0&&x(t.textDocument.uri)){let e=f.get(t.textDocument.uri),n=t.position;if(e){let s=e.getText(),i=e.offsetAt(n)??0,c=e.offsetAt({line:n.line-100,character:0})??0,d=e.offsetAt({line:n.line+100,character:0})??void 0,r=(0,o.positionCheck)(s.substring(c,d),i,c,l.classMatch);if(r.IsMatch)return(0,o.doHover)(r.instance.instanceString,N(r.instance.index,e),I)}}return null});function x(t){for(let e of l.files.exclude)if((0,b.minimatch)(t,e))return!1;return!0}function N(t,e){return{start:e.positionAt(t.start),end:e.positionAt(t.end)}}f.listen(a);a.listen();