@master/css-language-service 2.0.0-rc.7 → 2.0.0-rc.70

package/dist/utils/get-query-completion-items.mjs

@@ -0,0 +1,77 @@
+import { AT_SIGN, QUERY_COMPARISON_OPERATORS, generateCSS, QUERY_LOGICAL_OPERATORS, generateAt, parseAt, createDefaultCSS, getSingleAtNumberRuleNode } from '@master/css-language';
+import { CompletionItemKind } from 'vscode-languageserver-protocol';
+import sortCompletionItems from './sort-completion-items.mjs';
+import createCSSMarkdownDocumentation from './create-css-markdown-documentation.mjs';
+import { createCompletionIndex } from './completion-index.mjs';
+
+function getQueryCompletionItems(css = createDefaultCSS(), triggerCharacter = AT_SIGN, syntax, completionIndex = createCompletionIndex(css)) {
+    const completionItems = [];
+    if (!QUERY_COMPARISON_OPERATORS.includes(triggerCharacter)) {
+        [
+            'media',
+            'container',
+            'supports'
+        ].forEach((name)=>{
+            completionItems.push({
+                label: triggerCharacter + name + '()',
+                filterText: name + '()',
+                insertText: name + '()',
+                sortText: name + '()',
+                documentation: createCSSMarkdownDocumentation(generateCSS([
+                    syntax + name + '()'
+                ], css))
+            });
+        });
+    }
+    const handleNumberNodes = (atRule, token)=>{
+        const numberNode = getSingleAtNumberRuleNode(atRule.nodes);
+        if (numberNode) {
+            const prevComparisonCharacter = syntax.charAt(syntax.length - 2);
+            const comparisonCharacter = prevComparisonCharacter === '>' || prevComparisonCharacter === '<' ? prevComparisonCharacter + triggerCharacter : triggerCharacter;
+            const text = generateAt(parseAt(comparisonCharacter + token, css));
+            completionItems.push({
+                label: comparisonCharacter + token,
+                sortText: CompletionItemKind.Keyword + comparisonCharacter + String(Math.round(numberNode.value)).padStart(12, '0'),
+                filterText: token,
+                insertText: token,
+                detail: text,
+                kind: CompletionItemKind.Keyword,
+                documentation: createCSSMarkdownDocumentation(generateCSS([
+                    syntax + token
+                ], css))
+            });
+            return true;
+        }
+    };
+    for (const [token, atRule] of completionIndex.atRules){
+        const completionItem = {
+            filterText: token,
+            insertText: token,
+            documentation: createCSSMarkdownDocumentation(generateCSS([
+                syntax + token
+            ], css))
+        };
+        if ([
+            AT_SIGN,
+            ...QUERY_LOGICAL_OPERATORS
+        ].includes(triggerCharacter)) {
+            if (handleNumberNodes(atRule, token)) continue;
+            const text = generateAt(parseAt(triggerCharacter + token, css));
+            completionItems.push({
+                ...completionItem,
+                label: triggerCharacter + token,
+                detail: text,
+                sortText: CompletionItemKind.Keyword + token,
+                kind: CompletionItemKind.Keyword,
+                documentation: createCSSMarkdownDocumentation(generateCSS([
+                    syntax + token
+                ], css))
+            });
+        } else if (QUERY_COMPARISON_OPERATORS.includes(triggerCharacter)) {
+            handleNumberNodes(atRule, token);
+        }
+    }
+    return sortCompletionItems(completionItems);
+}
+
+export { getQueryCompletionItems as default };

package/dist/utils/get-range.d.ts

@@ -0,0 +1,2 @@
+import { TextDocument, Range } from 'vscode-languageserver-textdocument';
+export default function getRange(searchString: string, doc: TextDocument): Range;

package/dist/utils/get-range.mjs

@@ -0,0 +1,21 @@
+function getRange(searchString, doc) {
+    const text = doc.getText();
+    const regex = new RegExp(`(\\b(?:className|class)\\s*=\\s*(['"\`]))(.*?)\\2`, 'gs');
+    let match;
+    while((match = regex.exec(text)) !== null){
+        match[0];
+        const attrStartIndex = match.index + match[1].length;
+        const className = match[3];
+        const relativeIndex = className.indexOf(searchString);
+        if (relativeIndex !== -1) {
+            const absoluteIndex = attrStartIndex + relativeIndex;
+            return {
+                start: doc.positionAt(absoluteIndex),
+                end: doc.positionAt(absoluteIndex + searchString.length)
+            };
+        }
+    }
+    throw new Error(`Cannot find "${searchString}" in any class attribute.`);
+}
+
+export { getRange as default };

package/dist/utils/get-utility-info.d.ts

@@ -0,0 +1,4 @@
+import { type CompiledUtility } from '@master/css-language';
+export default function getUtilityInfo(utility: CompiledUtility): {
+    detail: string | undefined;
+};

package/dist/utils/get-utility-info.mjs

@@ -0,0 +1,19 @@
+import { getStaticUtilityDeclarations } from '@master/css-language';
+
+function getUtilityInfo(utility) {
+    const declarations = getStaticUtilityDeclarations(utility);
+    const propsLength = Object.keys(declarations || {}).length;
+    const propName = Object.keys(declarations || {})[0];
+    const propValue = declarations?.[propName];
+    let detail;
+    /**
+     * Remaps to native CSS properties when only one property is declared
+     * */ if (propsLength === 1) {
+        detail = `${propName}: ${propValue}`;
+    }
+    return {
+        detail
+    };
+}
+
+export { getUtilityInfo as default };

package/dist/utils/get-value-completion-items.d.ts

@@ -0,0 +1,4 @@
+import { type CompletionItem } from 'vscode-languageserver-protocol';
+import { MasterCSS } from '@master/css-language';
+import { type CompletionIndex } from './completion-index';
+export default function getValueCompletionItems(css: MasterCSS | undefined, ruleKey: string, valuePrefix?: string, completionIndex?: CompletionIndex): CompletionItem[];

package/dist/utils/get-value-completion-items.mjs

@@ -0,0 +1,203 @@
+import { CompletionItemKind } from 'vscode-languageserver-protocol';
+import { getMdnPropertySyntax, getMdnPropertyValueNames, generateCSS, createDefaultCSS } from '@master/css-language';
+import { builtinKeyAliases } from '@master/css-engine';
+import createCSSMarkdownDocumentation from './create-css-markdown-documentation.mjs';
+import sortCompletionItems from './sort-completion-items.mjs';
+import { createCompletionIndex } from './completion-index.mjs';
+
+const SCOPED_VARIABLE_PRIORITY = 'aaaa';
+const NATIVE_PRIORITY = 'ccccc';
+const GLOBAL_VARIABLE_PRIORITY = 'zzzz';
+const ANIMATION_REFERENCE_PROPERTIES = new Set([
+    'animation',
+    'animation-name'
+]);
+function getNumericSortValue(variable, rootSize) {
+    if (variable.numeric) {
+        switch(variable.numeric.unit){
+            case 'rem':
+                return variable.numeric.value * rootSize;
+            case undefined:
+            case '':
+            case 'px':
+                return variable.numeric.value;
+        }
+    }
+    return typeof variable.value === 'number' ? variable.value : 0;
+}
+function getVariableKeyByNamespace(variableName, namespace) {
+    const negative = variableName.startsWith('-');
+    const positiveName = negative ? variableName.slice(1) : variableName;
+    if (positiveName !== namespace && !positiveName.startsWith(namespace + '-')) return;
+    const key = positiveName === namespace ? '' : positiveName.slice(namespace.length + 1);
+    return negative ? '-' + key : key;
+}
+function getValueCompletionItems(css = createDefaultCSS(), ruleKey, valuePrefix = '', completionIndex = createCompletionIndex(css)) {
+    const completionItems = [];
+    const addedLabels = new Set();
+    const canonicalRuleKey = builtinKeyAliases[ruleKey] || ruleKey;
+    const nativeUtilityKey = completionIndex.nativeUtilityKeys.get(canonicalRuleKey);
+    const nativeKey = nativeUtilityKey || (getMdnPropertySyntax(canonicalRuleKey) ? canonicalRuleKey : undefined);
+    const nativePropertyValues = getMdnPropertyValueNames(nativeKey);
+    const pushCompletionItem = (completionItem)=>{
+        completionItems.push(completionItem);
+        addedLabels.add(completionItem.label);
+    };
+    const generateVariableCompletionItem = (variable, { appliedValue, label, negative, scoped } = {})=>{
+        const nativePropertySyntax = getMdnPropertySyntax(variable.namespace) || getMdnPropertySyntax(nativeKey);
+        if (variable.type === 'number' && variable.name.startsWith('-') && nativePropertySyntax?.includes('absolute')) return;
+        const valueToken = appliedValue ?? (scoped ? variable.key : variable.name);
+        const documentation = createCSSMarkdownDocumentation(generateCSS([
+            ruleKey + ':' + valueToken
+        ], css));
+        const completionItemLabel = label ?? variable.name;
+        const conflicted = addedLabels.has(completionItemLabel);
+        const completionItem = {
+            label: conflicted ? 'var(--' + completionItemLabel + ')' : completionItemLabel,
+            kind: CompletionItemKind.Value
+        };
+        if (conflicted) {
+            completionItem.documentation = createCSSMarkdownDocumentation(generateCSS([
+                ruleKey + ':' + completionItem.label
+            ], css));
+        } else {
+            completionItem.documentation = createCSSMarkdownDocumentation(generateCSS([
+                ruleKey + ':' + valueToken
+            ], css));
+        }
+        if (variable.namespace?.startsWith('color')) {
+            if (Object.keys(variable.modes || {}).length) {
+                completionItem.kind = CompletionItemKind.Color;
+                completionItem.detail = variable.name;
+            } else {
+                // todo: packages/core should support getTextByVariable(variable)
+                const configKey = 'variables.' + (variable.namespace ? variable.namespace + '.' + variable.key : variable.name);
+                const valueToken = variable.value ?? variable.name;
+                // detail is shown in the detail pane
+                // todo: variable.token should be recorded as original config variable
+                completionItem.detail = String(configKey);
+                completionItem.documentation = {
+                    kind: 'markdown',
+                    value: valueToken + '\n\n' + documentation?.value
+                };
+                completionItem.kind = CompletionItemKind.Color;
+                completionItem.sortText = 'color-' + variable.name.replace(/(.+?)-(\d+)/, (match, prefix, num)=>prefix + num.padStart(10, '0'));
+            }
+        } else if (variable.type === 'number') {
+            completionItem.detail = String(variable.name);
+            const value = getNumericSortValue(variable, css.settings.rootSize);
+            const sortValue = negative ? -Math.abs(value) : value;
+            completionItem.sortText = (variable.namespace || '') + (sortValue >= 0 ? String(sortValue).padStart(10, '0') : '-' + String(Math.abs(sortValue)).padStart(10, '0'));
+        } else {
+            completionItem.detail = String(variable.value || variable.name);
+        }
+        return completionItem;
+    };
+    const addScopedVariableCompletionItem = (variable, variableName)=>{
+        if (addedLabels.has(variableName)) return;
+        const completionItem = generateVariableCompletionItem(variable, {
+            scoped: true
+        });
+        if (completionItem) {
+            completionItem.label = variableName;
+            completionItem.sortText = SCOPED_VARIABLE_PRIORITY + (completionItem.sortText || variableName);
+            completionItem.detail = '(scope) ' + completionItem.detail;
+            pushCompletionItem(completionItem);
+        }
+        const negativeVariableName = '-' + variableName;
+        if (valuePrefix.startsWith('-') && variableName[0] !== '-' && variable.type === 'number' && !addedLabels.has(negativeVariableName)) {
+            const negativeCompletionItem = generateVariableCompletionItem(variable, {
+                appliedValue: negativeVariableName,
+                label: negativeVariableName,
+                negative: true,
+                scoped: true
+            });
+            if (negativeCompletionItem) {
+                negativeCompletionItem.sortText = SCOPED_VARIABLE_PRIORITY + (negativeCompletionItem.sortText || negativeVariableName);
+                negativeCompletionItem.detail = '(scope) ' + negativeCompletionItem.detail;
+                pushCompletionItem(negativeCompletionItem);
+            }
+        }
+    };
+    /**
+     * Scoped variables
+     * @example box: + content -> box-sizing:content
+     */ for (const { name, variable } of completionIndex.scopedVariablesByKey.get(canonicalRuleKey) || []){
+        addScopedVariableCompletionItem(variable, name);
+    }
+    for (const { value } of completionIndex.patternValuesByKey.get(canonicalRuleKey) || []){
+        if (addedLabels.has(value)) continue;
+        pushCompletionItem({
+            label: value,
+            kind: CompletionItemKind.Value,
+            documentation: createCSSMarkdownDocumentation(generateCSS([
+                ruleKey + ':' + value
+            ], css)),
+            detail: canonicalRuleKey + ': ' + value
+        });
+    }
+    /**
+     * @example animation:fade|fast animate:fade animation-name:fade
+     */ for (const animationUtility of completionIndex.animationUtilitiesByKey.get(canonicalRuleKey) || []){
+        css.animations.forEach((_, animationName)=>{
+            pushCompletionItem({
+                label: animationName,
+                kind: CompletionItemKind.Value,
+                documentation: createCSSMarkdownDocumentation(generateCSS([
+                    ruleKey + ':' + animationName
+                ], css)),
+                detail: animationUtility.detailPrefix ? animationUtility.detailPrefix + ': ' + animationName : animationName
+            });
+        });
+    }
+    if (ANIMATION_REFERENCE_PROPERTIES.has(canonicalRuleKey)) {
+        css.animations.forEach((_, animationName)=>{
+            if (addedLabels.has(animationName)) return;
+            pushCompletionItem({
+                label: animationName,
+                kind: CompletionItemKind.Value,
+                documentation: createCSSMarkdownDocumentation(generateCSS([
+                    ruleKey + ':' + animationName
+                ], css)),
+                detail: canonicalRuleKey + ': ' + animationName
+            });
+        });
+    }
+    const usedKeys = new Set();
+    for (const variableNamespace of completionIndex.nativeVariableNamespacesByProperty.get(canonicalRuleKey) || []){
+        for (const variable of completionIndex.variables){
+            const variableName = getVariableKeyByNamespace(variable.name, variableNamespace);
+            if (variableName === undefined || usedKeys.has(variableName)) continue;
+            usedKeys.add(variableName);
+            addScopedVariableCompletionItem(variable, variableName);
+        }
+    }
+    /**
+     * Native values
+     */ if (nativeKey) {
+        nativePropertyValues.forEach((value)=>{
+            if (addedLabels.has(value) || nativeKey === 'font' && typeof +value === 'number' || value.includes(' ')) return;
+            pushCompletionItem({
+                label: value,
+                kind: CompletionItemKind.Value,
+                sortText: NATIVE_PRIORITY + (value.startsWith('-') ? 'zz' + value.slice(1) : value),
+                documentation: createCSSMarkdownDocumentation(generateCSS([
+                    ruleKey + ':' + value
+                ], css)),
+                detail: nativeKey + ': ' + value
+            });
+        });
+    }
+    // global variables
+    completionIndex.variables.forEach((variable)=>{
+        const completionItem = generateVariableCompletionItem(variable);
+        if (completionItem) {
+            completionItem.sortText = GLOBAL_VARIABLE_PRIORITY + (completionItem.sortText || completionItem.label);
+            completionItem.detail = '(global) ' + completionItem.detail;
+            pushCompletionItem(completionItem);
+        }
+    });
+    return sortCompletionItems(completionItems);
+}
+
+export { getValueCompletionItems as default };

package/dist/utils/query-syntax-completions.d.ts

@@ -0,0 +1,4 @@
+import { type CompletionItem } from 'vscode-languageserver-protocol';
+import { MasterCSS } from '@master/css-language';
+import { type CompletionIndex } from './completion-index';
+export default function querySyntaxCompletions(q?: string, css?: MasterCSS, completionIndex?: CompletionIndex): CompletionItem[] | undefined;

package/dist/utils/query-syntax-completions.mjs

@@ -0,0 +1,94 @@
+import { CompletionItemKind } from 'vscode-languageserver-protocol';
+import getPseudoClassCompletionItems from './get-pseudo-class-completion-items.mjs';
+import getPseudoElementCompletionItems from './get-pseudo-element-completion-items.mjs';
+import { GROUP_TRIGGER_CHARACTER, AT_SIGN, SELECTOR_SIGNS, QUERY_COMPARISON_OPERATORS, QUERY_LOGICAL_OPERATORS, SELECTOR_TRIGGER_CHARACTERS, generateCSS, createDefaultCSS } from '@master/css-language';
+import getClassCompletionItems from './get-class-completion-items.mjs';
+import getValueCompletionItems from './get-value-completion-items.mjs';
+import getQueryCompletionItems from './get-query-completion-items.mjs';
+import createCSSMarkdownDocumentation from './create-css-markdown-documentation.mjs';
+import { matchesIndexedName, createCompletionIndex } from './completion-index.mjs';
+
+function querySyntaxCompletions(q = '', css = createDefaultCSS(), completionIndex = createCompletionIndex(css)) {
+    const fields = q.split(' ');
+    let field = fields[fields.length - 1];
+    const triggerCharacter = q.charAt(q.length - 1);
+    const invoked = triggerCharacter === ' ' || field.length === 0;
+    if (invoked || field === GROUP_TRIGGER_CHARACTER || triggerCharacter === ';') {
+        return getClassCompletionItems(css, completionIndex);
+    }
+    const isGroup = field.startsWith(GROUP_TRIGGER_CHARACTER);
+    if (isGroup) {
+        const declarationSeparatorMatches = Array.from(field.matchAll(/;(?=(?:[^'"]|'[^']*'|"[^"]*")*$)/g));
+        if (declarationSeparatorMatches.length) {
+            field = field.slice(declarationSeparatorMatches[declarationSeparatorMatches.length - 1].index + 1);
+        } else {
+            field = field.slice(1);
+        }
+    }
+    if (field.startsWith(AT_SIGN) || field.startsWith('~')) {
+        return [];
+    }
+    const keyMatch = field.match(/^[^'":\s]+:/);
+    const atMatches = Array.from(field.matchAll(/@(?=(?:[^'"]|'[^']*'|"[^"]*")*$)/g));
+    const valueSeparatorMatch = field.match(/\|(?=(?:[^'"]|'[^']*'|"[^"]*")*$)/g);
+    const atInvoked = atMatches.findIndex(({ index })=>index !== 0) !== -1;
+    const firstColonIndex = keyMatch ? keyMatch[0].length - 1 : -1;
+    const selectorInvokedRegex = new RegExp(`[${SELECTOR_SIGNS.join('')}](?=(?:[^'"]|'[^']*'|"[^"]*")*$)`);
+    const key = keyMatch ? keyMatch[0].slice(0, firstColonIndex) : undefined;
+    const isStyle = completionIndex.componentNames.some((eachStyleName)=>matchesIndexedName(field, eachStyleName));
+    const isUtility = completionIndex.utilityNames.some((eachUtilityName)=>matchesIndexedName(field, eachUtilityName));
+    // check by utilities and components
+    if (!isStyle && !isUtility) {
+        if (key === undefined && !valueSeparatorMatch) {
+            return getClassCompletionItems(css, completionIndex);
+        }
+        if (!atInvoked && !selectorInvokedRegex.test(field.slice(firstColonIndex + 1))) {
+            if (key && firstColonIndex !== -1) {
+                return getValueCompletionItems(css, key, field.slice(firstColonIndex + 1), completionIndex);
+            }
+        }
+    }
+    /**
+     * Not support conditional btn:hover and group
+     */ if (isStyle || isGroup) return;
+    if (atInvoked && [
+        AT_SIGN,
+        ...QUERY_COMPARISON_OPERATORS,
+        ...QUERY_LOGICAL_OPERATORS
+    ].includes(triggerCharacter)) {
+        return getQueryCompletionItems(css, triggerCharacter, field, completionIndex);
+    }
+    if (!atInvoked && SELECTOR_TRIGGER_CHARACTERS.includes(triggerCharacter)) {
+        const pseudoElementCompletionItems = getPseudoElementCompletionItems(css, field, completionIndex);
+        if (field.endsWith('::')) {
+            /**
+             * Consider trigger characters and fix insertText.
+             * @incorrect class="text-center::" -> class="text-center::::after"
+             * @correct class="text-center::" -> class="text-center::after"
+             */ pseudoElementCompletionItems.forEach((completionItem)=>completionItem.insertText = completionItem.label.slice(2));
+            return pseudoElementCompletionItems;
+        } else {
+            const completionItems = getPseudoClassCompletionItems(css, field, completionIndex);
+            completionItems.push(...pseudoElementCompletionItems);
+            /**
+             * Consider trigger characters and fix insertText.
+             * @incorrect class="text-center:" -> class="text-center::active"
+             * @correct class="text-center:" -> class="text-center:active"
+             */ if (triggerCharacter === ':') {
+                completionItems.forEach((completionItem)=>completionItem.insertText = completionItem.label.slice(1));
+            } else {
+                completionItems.push({
+                    label: '.<class>',
+                    insertText: '.',
+                    documentation: createCSSMarkdownDocumentation(generateCSS([
+                        field + '.class'
+                    ], css)),
+                    kind: CompletionItemKind.Class
+                });
+            }
+            return completionItems;
+        }
+    }
+}
+
+export { querySyntaxCompletions as default };

package/dist/utils/regex.mjs

@@ -0,0 +1,3 @@
+const instancePattern = /[^\s:]+:\w*\(?((?<!\\)["'`])((?:\\\1|(?:(?!\1))\S)*)((?<!\\)\1)\)?|[^\s"'`]+/g;
+
+export { instancePattern };

package/dist/utils/sort-completion-items.d.ts

@@ -0,0 +1,2 @@
+import type { CompletionItem } from 'vscode-languageserver-protocol';
+export default function sortCompletionItems(items: CompletionItem[]): CompletionItem[];

package/dist/utils/sort-completion-items.mjs

@@ -0,0 +1,11 @@
+/* localeCompare equals to the real vscode completion items sorting */ function sortCompletionItems(items) {
+    return items.sort((a, b)=>{
+        const sortTextA = a.sortText || a.label;
+        const sortTextB = b.sortText || b.label;
+        return sortTextA.localeCompare(sortTextB, undefined, {
+            numeric: true
+        });
+    });
+}
+
+export { sortCompletionItems as default };

package/package.json

@@ -1 +1 @@
-{"name":"@master/css-language-service","scripts":{"build":"techor pack --platform node --declare","dev":"pnpm run build --watch","type-check":"tsc --noEmit","lint":"eslint src"},"description":"Master CSS Language Service","author":"Aoyue Design LLC.","license":"MIT","dependencies":{"@babel/parser":"^7.22.7","@master/css":"^2.0.0-rc.7","color-convert":"^2.0.1","js-beautify":"^1.14.7"},"devDependencies":{"@types/color-convert":"^2.0.0","vscode-css-languageservice":"^6.2.5","vscode-languageserver-types":"^3.17.3"},"main":"./dist/index.bundle.js","types":"./dist/index.d.ts","exports":{".":"./dist/index.bundle.js","./settings":"./dist/settings.bundle.js"},"typesVersions":{"*":{"./":["./dist/index.d.ts"],"./settings":["./dist/settings.d.ts"]}},"files":["dist"],"publishConfig":{"access":"public"},"version":"2.0.0-rc.7"}
+{"name":"@master/css-language-service","type":"module","scripts":{"build":"techor build \"src/**/*.ts\" --formats esm","dev":"pnpm build --watch","type-check":"tsc --noEmit","lint":"eslint","test":"vitest"},"description":"Master CSS Language Service","author":"Aoyue Design LLC.","license":"MIT","repository":{"type":"git","url":"https://github.com/master-co/css.git","directory":"packages/language-service"},"dependencies":{"@master/css":"^2.0.0-rc.70","@master/css-engine":"^2.0.0-rc.70","@master/css-language":"^2.0.0-rc.70","@techor/extend":"^3.2.5","colorjs.io":"^0.6.1","js-beautify":"^1.15.4","minimatch":"^10.2.5","vscode-languageserver-protocol":"^3.18.0","vscode-languageserver-textdocument":"^1.0.12"},"devDependencies":{"@types/vscode":"^1.125.0","vscode-languageserver":"^10.0.0","@master/css-schema":"^2.0.0-rc.70"},"sideEffects":false,"main":"./dist/index.mjs","module":"./dist/index.mjs","jsnext:main":"./dist/index.mjs","esnext":"./dist/index.mjs","types":"./dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.mjs","default":"./dist/index.mjs"},"./common":{"types":"./dist/common.d.ts","import":"./dist/common.mjs","default":"./dist/common.mjs"}},"files":["dist"],"publishConfig":{"access":"public","provenance":true},"version":"2.0.0-rc.70"}

package/dist/constant.d.ts

@@ -1,33 +0,0 @@
-import type { CompletionItem } from 'vscode-languageserver-types';
-interface MasterCssKey {
-    key: string[];
-    colored: boolean;
-    values: Array<string | CompletionItem>;
-}
-export declare const masterCssSelectors: (string | {
-    label: string;
-    kind: number;
-})[];
-export declare const masterCssElements: (string | {
-    label: string;
-    kind: number;
-})[];
-export declare const masterCssMedia: (string | {
-    label: string;
-    kind: number;
-})[];
-export declare const masterCssOtherKeys: string[];
-export declare const masterCssCommonValues: (string | {
-    label: string;
-    kind: number;
-})[];
-export declare const commonUnit: any;
-export declare const masterCssKeyValues: MasterCssKey[];
-export declare const masterCssType: {
-    type: string;
-    values: (string | {
-        label: string;
-        kind: number;
-    })[];
-}[];
-export {};