@master/css-language-server 2.0.0-rc.73 → 2.0.0-rc.74

package/dist/core.mjs

@@ -1,559 +0,0 @@
-import { TextDocumentSyncKind, TextDocuments, createConnection, DiagnosticSeverity } 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 { findMasterCSSWorkspaceDirectories, findCSSManifestEntryFiles } from '@master/css-project/entries';
-import { loadProjectManifest } from '@master/css-project/manifest';
-import { resolveMasterCSSWorkspacePackages } from '@master/css-project/workspace';
-import extend from '@techor/extend';
-import settings from './settings.mjs';
-import { INVOKED_TRIGGER_CHARACTERS, VALUE_TRIGGER_CHARACTERS, SELECTOR_TRIGGER_CHARACTERS, QUERY_TRIGGER_CHARACTERS, DECLARATION_SEPARATOR_TRIGGER_CHARACTER, AT_TRIGGER_CHARACTER, GROUP_TRIGGER_CHARACTER } from '@master/css-language-service/common';
-import { defaultCSSLanguageRuntime, SEMANTIC_TOKENS_LEGEND, matchesLanguageServiceNativeDeclaration } from '@master/css-language';
-import glob from 'fast-glob';
-import { URI } from 'vscode-uri';
-import { CSSDirectiveError } from '@master/css-schema/css-directives';
-
-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: [
-            ...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,
-    semanticTokensProvider: {
-        legend: SEMANTIC_TOKENS_LEGEND,
-        full: true
-    },
-    workspace: {
-        workspaceFolders: {
-            supported: true
-        }
-    }
-};
-const CSS_DIAGNOSTIC_LANGUAGE_IDS = new Set([
-    'css',
-    'scss',
-    'less'
-]);
-const SFC_DIAGNOSTIC_LANGUAGE_IDS = 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 filePathTools = getFilePathTools(fsPath);
-    const resolvedPath = filePathTools.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);
-}
-class CSSLanguageServer {
-    connection;
-    customSettings;
-    workspaceFolders = [];
-    workspaces = 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 = extend(settings, this.customSettings);
-        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.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 = extend(this.customSettings, initializationSettings);
-            this.settings = extend(settings, this.customSettings);
-            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;
-        }
-        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 [];
-    }
-    async onSemanticTokens(params) {
-        await this.init();
-        const workspace = this.findClosestWorkspace(params.textDocument.uri);
-        if (workspace?.languageService) {
-            const document = this.documents.get(params.textDocument.uri) ?? workspace.openedTextDocuments.find((document)=>document.uri === params.textDocument.uri);
-            if (document) return workspace.languageService.renderSemanticTokens(document) ?? {
-                data: []
-            };
-        }
-        return {
-            data: []
-        };
-    }
-    async onDocumentSemanticTokens(params) {
-        return this.onSemanticTokens(params);
-    }
-    async onActiveSemanticTokens(params) {
-        await this.init();
-        const workspace = this.findClosestWorkspace(params.textDocument.uri);
-        if (workspace?.languageService) {
-            const document = this.documents.get(params.textDocument.uri) ?? workspace.openedTextDocuments.find((document)=>document.uri === params.textDocument.uri);
-            if (document) return workspace.languageService.renderSemanticTokensAtPosition(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.publishCSSDirectiveDiagnostics(params.document, workspace);
-            return;
-        }
-        if (!workspace.openedTextDocuments.length) {
-            await this.initWorkspaceLanguageService(workspace);
-        }
-        workspace.openedTextDocuments.push(params.document);
-        this.publishCSSDirectiveDiagnostics(params.document, workspace);
-    }
-    async onDidChangeContent(params) {
-        await this.init();
-        const workspace = this.findClosestWorkspace(params.document.uri);
-        if (!workspace) return;
-        this.publishCSSDirectiveDiagnostics(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.publishCSSDirectiveDiagnostics(params.document, workspace);
-        const name = path.basename(URI.parse(params.document.uri).fsPath);
-        if (name.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 = extend(settings, this.customSettings);
-            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.publishCSSDirectiveDiagnostics(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 } = extend(settings, this.customSettings, customWorkspaceFolderSettings);
-        const resolvedWorkspaceDirectories = 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;
-        if (workspace !== this.globalWorkspace) {
-            try {
-                workspacePlan = await this.loadWorkspacePlan(workspace);
-            } catch (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 cwd = workspace.uri ? URI.parse(workspace.uri).fsPath : process.cwd();
-        const result = await loadProjectManifest(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) : undefined
-            ]);
-            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;
-    }
-    publishCSSDirectiveDiagnostics(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);
-            }
-        }
-        this.connection.sendDiagnostics({
-            uri: textDocument.uri,
-            diagnostics
-        });
-    }
-    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 = undefined;
-    }
-}
-
-export { ACTIVE_SEMANTIC_TOKENS_REQUEST, DOCUMENT_SEMANTIC_TOKENS_REQUEST, CSSLanguageServer as default };

package/dist/index.mjs

@@ -1,2 +0,0 @@
-export { ACTIVE_SEMANTIC_TOKENS_REQUEST, default as CSSLanguageServer, DOCUMENT_SEMANTIC_TOKENS_REQUEST, default } from './core.mjs';
-export { default as settings } from './settings.mjs';

package/dist/server.mjs

@@ -1,9 +0,0 @@
-import CSSLanguageServer from './core.mjs';
-
-const server = new CSSLanguageServer(undefined, {
-    verbose: true
-});
-server.start();
-process.on('unhandledRejection', (error)=>{
-    console.error('Unhandled rejection', error);
-});

package/dist/settings.mjs

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

package/dist/utils/create-document.mjs

@@ -1,28 +0,0 @@
-import { TextDocument } from 'vscode-languageserver-textdocument';
-import { nanoid } from 'nanoid';
-import path from 'path';
-import { URI } from 'vscode-uri';
-
-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);
-}
-
-export { createDocument as default };