@master/css-language-service 2.0.0-rc.5 → 2.0.0-rc.51

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var cssDataProvider = require('./css-data-provider.cjs');
+
+function getUtilityInfo(syntax, css = new MasterCSS()) {
+    const nativeProperties = cssDataProvider.provideProperties();
+    const declarations = syntax.definition.declarations;
+    const propsLength = Object.keys(declarations || {}).length;
+    const propName = Object.keys(declarations || {})[0];
+    const propValue = declarations?.[propName];
+    let data;
+    let detail;
+    /**
+     * Remaps to native CSS properties when only one property is declared
+     * */ if (propsLength === 1) {
+        const nativeCSSPropertyData = nativeProperties.find(({ name })=>name === propName);
+        data = nativeCSSPropertyData?.values?.find(({ name })=>name === propValue || name.replace(/^-(ms|moz)-/, '') === propValue);
+        if (data) {
+            detail = `${propName}: ${propValue}`;
+        } else {
+            data = nativeCSSPropertyData;
+            detail = nativeCSSPropertyData?.syntax;
+        }
+    }
+    return {
+        docs: '/reference/' + (data ? propName : 'utilities'),
+        data,
+        detail
+    };
+}
+
+module.exports = getUtilityInfo;

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

@@ -0,0 +1,7 @@
+import { DefinedRule } from '@master/css';
+import type { IPropertyData } from 'vscode-css-languageservice';
+export default function getUtilityInfo(syntax: DefinedRule, css?: import("@master/css").MasterCSS): {
+    docs: string;
+    data: IPropertyData | undefined;
+    detail: string | undefined;
+};

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

@@ -0,0 +1,30 @@
+import cssDataProvider from './css-data-provider.mjs';
+
+function getUtilityInfo(syntax, css = new MasterCSS()) {
+    const nativeProperties = cssDataProvider.provideProperties();
+    const declarations = syntax.definition.declarations;
+    const propsLength = Object.keys(declarations || {}).length;
+    const propName = Object.keys(declarations || {})[0];
+    const propValue = declarations?.[propName];
+    let data;
+    let detail;
+    /**
+     * Remaps to native CSS properties when only one property is declared
+     * */ if (propsLength === 1) {
+        const nativeCSSPropertyData = nativeProperties.find(({ name })=>name === propName);
+        data = nativeCSSPropertyData?.values?.find(({ name })=>name === propValue || name.replace(/^-(ms|moz)-/, '') === propValue);
+        if (data) {
+            detail = `${propName}: ${propValue}`;
+        } else {
+            data = nativeCSSPropertyData;
+            detail = nativeCSSPropertyData?.syntax;
+        }
+    }
+    return {
+        docs: '/reference/' + (data ? propName : 'utilities'),
+        data,
+        detail
+    };
+}
+
+export { getUtilityInfo as default };

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

@@ -0,0 +1,185 @@
+'use strict';
+
+var vscodeLanguageserverProtocol = require('vscode-languageserver-protocol');
+var cssDataProvider = require('./css-data-provider.cjs');
+var css = require('@master/css');
+var getCssDataDocumentation = require('./get-css-data-documentation.cjs');
+var sortCompletionItems = require('./sort-completion-items.cjs');
+
+const SCOPED_VARIABLE_PRIORITY = 'aaaa';
+const AMBIGUOUS_PRIORITY = 'bbbb';
+const NATIVE_PRIORITY = 'ccccc';
+const GLOBAL_VARIABLE_PRIORITY = 'zzzz';
+function getValueCompletionItems(css$1 = new css.MasterCSS(), ruleKey) {
+    const nativeProperties = cssDataProvider.provideProperties();
+    const completionItems = [];
+    const nativeKey = css$1.definedRules.find(({ keys })=>keys.includes(ruleKey))?.id;
+    const nativePropertyData = nativeProperties.find(({ name })=>name === nativeKey);
+    const generateVariableCompletionItem = (variable, { scoped } = {
+        scoped: false
+    })=>{
+        const eachNativePropertyData = nativeProperties.find((x)=>x.name === variable.group) || nativePropertyData;
+        const appliedValue = scoped ? variable.key : variable.name;
+        const documentation = getCssDataDocumentation.getCSSDataDocumentation(eachNativePropertyData, {
+            generatedCSS: css.generateCSS([
+                ruleKey + ':' + appliedValue
+            ], css$1),
+            docs: '/reference/' + (eachNativePropertyData?.name || 'variables')
+        });
+        const completionItem = {
+            label: variable.name,
+            kind: vscodeLanguageserverProtocol.CompletionItemKind.Value
+        };
+        const conflicted = completionItems.find(({ label })=>label === variable.name);
+        if (conflicted) {
+            completionItem.label = '$(' + completionItem.label + ')';
+            completionItem.documentation = getCssDataDocumentation.getCSSDataDocumentation(eachNativePropertyData, {
+                generatedCSS: css.generateCSS([
+                    ruleKey + ':' + completionItem.label
+                ], css$1),
+                docs: '/reference/' + (eachNativePropertyData?.name || 'variables')
+            });
+        } else {
+            completionItem.documentation = getCssDataDocumentation.getCSSDataDocumentation(eachNativePropertyData, {
+                generatedCSS: css.generateCSS([
+                    ruleKey + ':' + appliedValue
+                ], css$1),
+                docs: '/reference/' + (eachNativePropertyData?.name || 'variables')
+            });
+        }
+        if (variable.type === 'color') {
+            if (Object.keys(variable.modes || {}).length) {
+                completionItem.kind = vscodeLanguageserverProtocol.CompletionItemKind.Color;
+                completionItem.detail = variable.name;
+            } else {
+                // todo: packages/core should support getTextByVariable(variable)
+                const configKey = 'variables.' + (variable.group ? variable.group + '.' + variable.key : variable.name);
+                const valueToken = variable.space && variable.value ? `${variable.space}(${variable.value.split(' ').join(',')})` : variable.value;
+                // 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 = vscodeLanguageserverProtocol.CompletionItemKind.Color;
+                completionItem.sortText = 'color-' + variable.name.replace(/(.+?)-(\d+)/, (match, prefix, num)=>prefix + num.padStart(10, '0'));
+            }
+        } else if (variable.type === 'number') {
+            if (variable.name.startsWith('-') && eachNativePropertyData?.syntax?.includes('absolute')) return;
+            completionItem.detail = String(variable.name);
+            completionItem.sortText = (variable.group || '') + (variable.value >= 0 ? String(variable.value).padStart(10, '0') : '-' + String(Math.abs(variable.value)).padStart(10, '0'));
+        } else {
+            completionItem.detail = String(variable.value || variable.name);
+        }
+        return completionItem;
+    };
+    for (const eachDefinedRule of css$1.definedRules){
+        /**
+         * Scoped variables
+         * @example box: + content -> box-sizing:content
+         */ if (eachDefinedRule.definition.key === ruleKey || eachDefinedRule.definition.subkey === ruleKey || eachDefinedRule.definition.ambiguousKeys?.includes(ruleKey)) {
+            for(const variableName in eachDefinedRule.variables){
+                if (completionItems.find(({ label })=>label === variableName)) continue;
+                const variable = eachDefinedRule.variables[variableName];
+                const completionItem = generateVariableCompletionItem(variable, {
+                    scoped: true
+                });
+                if (completionItem) {
+                    completionItem.label = variableName;
+                    completionItem.sortText = SCOPED_VARIABLE_PRIORITY + variableName;
+                    completionItem.detail = '(scope) ' + completionItem.detail;
+                    completionItems.push(completionItem);
+                }
+            }
+        }
+        /**
+         * @example animation:fade
+         */ if (eachDefinedRule.keys.includes(ruleKey) && eachDefinedRule.definition.includeAnimations) {
+            for(const animationName in css$1.animations){
+                const isNative = eachDefinedRule.definition.type && [
+                    css.SyntaxRuleType.Native,
+                    css.SyntaxRuleType.NativeShorthand
+                ].includes(eachDefinedRule.definition.type);
+                completionItems.push({
+                    label: animationName,
+                    kind: vscodeLanguageserverProtocol.CompletionItemKind.Value,
+                    documentation: getCssDataDocumentation.getCSSDataDocumentation(undefined, {
+                        generatedCSS: css.generateCSS([
+                            ruleKey + ':' + animationName
+                        ], css$1),
+                        docs: '/reference/' + css.isCoreRule(eachDefinedRule.id) && eachDefinedRule.id
+                    }),
+                    detail: isNative ? eachDefinedRule.id + ': ' + animationName : animationName
+                });
+            }
+        }
+        /**
+         * Ambiguous values
+         * @example text: -> center, left, right, justify
+         * @example t: -> center, left, right, justify
+         */ if (eachDefinedRule.definition.ambiguousKeys?.includes(ruleKey) && eachDefinedRule.definition.ambiguousValues?.length) {
+            const nativePropertyData = nativeProperties.find((x)=>x.name === eachDefinedRule.id);
+            for (const ambiguousValue of eachDefinedRule.definition.ambiguousValues){
+                if (typeof ambiguousValue !== 'string') continue;
+                const nativeValueData = nativePropertyData?.values?.find((x)=>x.name === ambiguousValue);
+                const isNative = eachDefinedRule.definition.type && [
+                    css.SyntaxRuleType.Native,
+                    css.SyntaxRuleType.NativeShorthand
+                ].includes(eachDefinedRule.definition.type);
+                completionItems.push({
+                    label: ambiguousValue,
+                    kind: vscodeLanguageserverProtocol.CompletionItemKind.Value,
+                    sortText: AMBIGUOUS_PRIORITY + ambiguousValue,
+                    documentation: getCssDataDocumentation.getCSSDataDocumentation({
+                        ...nativeValueData || {},
+                        // use nativePropertyData.reference because nativeValueData does not have references
+                        references: nativePropertyData?.references
+                    }, {
+                        generatedCSS: css.generateCSS([
+                            ruleKey + ':' + ambiguousValue
+                        ], css$1),
+                        docs: '/reference/' + css.isCoreRule(eachDefinedRule.id) && eachDefinedRule.id
+                    }),
+                    detail: isNative ? eachDefinedRule.id + ': ' + ambiguousValue : ambiguousValue
+                });
+            }
+        }
+    }
+    /**
+     * Native values
+     */ if (nativeKey) {
+        nativePropertyData?.values?.forEach((value)=>{
+            if (completionItems.find((x)=>x.label === value.name) || nativePropertyData.name === 'font' && typeof +value.name === 'number' || value.name.includes(' ')) return;
+            completionItems.push({
+                label: value.name,
+                kind: vscodeLanguageserverProtocol.CompletionItemKind.Value,
+                sortText: NATIVE_PRIORITY + (value.name.startsWith('-') ? 'zz' + value.name.slice(1) : value.name),
+                documentation: getCssDataDocumentation.getCSSDataDocumentation({
+                    ...value,
+                    // use nativePropertyData.reference because nativeValueData does not have references
+                    references: nativePropertyData?.references
+                }, {
+                    generatedCSS: css.generateCSS([
+                        ruleKey + ':' + value.name
+                    ], css$1),
+                    docs: '/reference/' + nativeKey
+                }),
+                detail: nativeKey + ': ' + value.name
+            });
+        });
+    }
+    // global variables
+    for(const variableName in css$1.variables){
+        const variable = css$1.variables[variableName];
+        const completionItem = generateVariableCompletionItem(variable);
+        if (completionItem) {
+            completionItem.sortText = GLOBAL_VARIABLE_PRIORITY + (completionItem.sortText || completionItem.label);
+            completionItem.detail = '(global) ' + completionItem.detail;
+            completionItems.push(completionItem);
+        }
+    }
+    return sortCompletionItems(completionItems);
+}
+
+module.exports = getValueCompletionItems;

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

@@ -0,0 +1,3 @@
+import { type CompletionItem } from 'vscode-languageserver-protocol';
+import { MasterCSS } from '@master/css';
+export default function getValueCompletionItems(css: MasterCSS | undefined, ruleKey: string): CompletionItem[];

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

@@ -0,0 +1,183 @@
+import { CompletionItemKind } from 'vscode-languageserver-protocol';
+import cssDataProvider from './css-data-provider.mjs';
+import { SyntaxRuleType, generateCSS, isCoreRule, MasterCSS } from '@master/css';
+import { getCSSDataDocumentation } from './get-css-data-documentation.mjs';
+import sortCompletionItems from './sort-completion-items.mjs';
+
+const SCOPED_VARIABLE_PRIORITY = 'aaaa';
+const AMBIGUOUS_PRIORITY = 'bbbb';
+const NATIVE_PRIORITY = 'ccccc';
+const GLOBAL_VARIABLE_PRIORITY = 'zzzz';
+function getValueCompletionItems(css = new MasterCSS(), ruleKey) {
+    const nativeProperties = cssDataProvider.provideProperties();
+    const completionItems = [];
+    const nativeKey = css.definedRules.find(({ keys })=>keys.includes(ruleKey))?.id;
+    const nativePropertyData = nativeProperties.find(({ name })=>name === nativeKey);
+    const generateVariableCompletionItem = (variable, { scoped } = {
+        scoped: false
+    })=>{
+        const eachNativePropertyData = nativeProperties.find((x)=>x.name === variable.group) || nativePropertyData;
+        const appliedValue = scoped ? variable.key : variable.name;
+        const documentation = getCSSDataDocumentation(eachNativePropertyData, {
+            generatedCSS: generateCSS([
+                ruleKey + ':' + appliedValue
+            ], css),
+            docs: '/reference/' + (eachNativePropertyData?.name || 'variables')
+        });
+        const completionItem = {
+            label: variable.name,
+            kind: CompletionItemKind.Value
+        };
+        const conflicted = completionItems.find(({ label })=>label === variable.name);
+        if (conflicted) {
+            completionItem.label = '$(' + completionItem.label + ')';
+            completionItem.documentation = getCSSDataDocumentation(eachNativePropertyData, {
+                generatedCSS: generateCSS([
+                    ruleKey + ':' + completionItem.label
+                ], css),
+                docs: '/reference/' + (eachNativePropertyData?.name || 'variables')
+            });
+        } else {
+            completionItem.documentation = getCSSDataDocumentation(eachNativePropertyData, {
+                generatedCSS: generateCSS([
+                    ruleKey + ':' + appliedValue
+                ], css),
+                docs: '/reference/' + (eachNativePropertyData?.name || 'variables')
+            });
+        }
+        if (variable.type === '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.group ? variable.group + '.' + variable.key : variable.name);
+                const valueToken = variable.space && variable.value ? `${variable.space}(${variable.value.split(' ').join(',')})` : variable.value;
+                // 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') {
+            if (variable.name.startsWith('-') && eachNativePropertyData?.syntax?.includes('absolute')) return;
+            completionItem.detail = String(variable.name);
+            completionItem.sortText = (variable.group || '') + (variable.value >= 0 ? String(variable.value).padStart(10, '0') : '-' + String(Math.abs(variable.value)).padStart(10, '0'));
+        } else {
+            completionItem.detail = String(variable.value || variable.name);
+        }
+        return completionItem;
+    };
+    for (const eachDefinedRule of css.definedRules){
+        /**
+         * Scoped variables
+         * @example box: + content -> box-sizing:content
+         */ if (eachDefinedRule.definition.key === ruleKey || eachDefinedRule.definition.subkey === ruleKey || eachDefinedRule.definition.ambiguousKeys?.includes(ruleKey)) {
+            for(const variableName in eachDefinedRule.variables){
+                if (completionItems.find(({ label })=>label === variableName)) continue;
+                const variable = eachDefinedRule.variables[variableName];
+                const completionItem = generateVariableCompletionItem(variable, {
+                    scoped: true
+                });
+                if (completionItem) {
+                    completionItem.label = variableName;
+                    completionItem.sortText = SCOPED_VARIABLE_PRIORITY + variableName;
+                    completionItem.detail = '(scope) ' + completionItem.detail;
+                    completionItems.push(completionItem);
+                }
+            }
+        }
+        /**
+         * @example animation:fade
+         */ if (eachDefinedRule.keys.includes(ruleKey) && eachDefinedRule.definition.includeAnimations) {
+            for(const animationName in css.animations){
+                const isNative = eachDefinedRule.definition.type && [
+                    SyntaxRuleType.Native,
+                    SyntaxRuleType.NativeShorthand
+                ].includes(eachDefinedRule.definition.type);
+                completionItems.push({
+                    label: animationName,
+                    kind: CompletionItemKind.Value,
+                    documentation: getCSSDataDocumentation(undefined, {
+                        generatedCSS: generateCSS([
+                            ruleKey + ':' + animationName
+                        ], css),
+                        docs: '/reference/' + isCoreRule(eachDefinedRule.id) && eachDefinedRule.id
+                    }),
+                    detail: isNative ? eachDefinedRule.id + ': ' + animationName : animationName
+                });
+            }
+        }
+        /**
+         * Ambiguous values
+         * @example text: -> center, left, right, justify
+         * @example t: -> center, left, right, justify
+         */ if (eachDefinedRule.definition.ambiguousKeys?.includes(ruleKey) && eachDefinedRule.definition.ambiguousValues?.length) {
+            const nativePropertyData = nativeProperties.find((x)=>x.name === eachDefinedRule.id);
+            for (const ambiguousValue of eachDefinedRule.definition.ambiguousValues){
+                if (typeof ambiguousValue !== 'string') continue;
+                const nativeValueData = nativePropertyData?.values?.find((x)=>x.name === ambiguousValue);
+                const isNative = eachDefinedRule.definition.type && [
+                    SyntaxRuleType.Native,
+                    SyntaxRuleType.NativeShorthand
+                ].includes(eachDefinedRule.definition.type);
+                completionItems.push({
+                    label: ambiguousValue,
+                    kind: CompletionItemKind.Value,
+                    sortText: AMBIGUOUS_PRIORITY + ambiguousValue,
+                    documentation: getCSSDataDocumentation({
+                        ...nativeValueData || {},
+                        // use nativePropertyData.reference because nativeValueData does not have references
+                        references: nativePropertyData?.references
+                    }, {
+                        generatedCSS: generateCSS([
+                            ruleKey + ':' + ambiguousValue
+                        ], css),
+                        docs: '/reference/' + isCoreRule(eachDefinedRule.id) && eachDefinedRule.id
+                    }),
+                    detail: isNative ? eachDefinedRule.id + ': ' + ambiguousValue : ambiguousValue
+                });
+            }
+        }
+    }
+    /**
+     * Native values
+     */ if (nativeKey) {
+        nativePropertyData?.values?.forEach((value)=>{
+            if (completionItems.find((x)=>x.label === value.name) || nativePropertyData.name === 'font' && typeof +value.name === 'number' || value.name.includes(' ')) return;
+            completionItems.push({
+                label: value.name,
+                kind: CompletionItemKind.Value,
+                sortText: NATIVE_PRIORITY + (value.name.startsWith('-') ? 'zz' + value.name.slice(1) : value.name),
+                documentation: getCSSDataDocumentation({
+                    ...value,
+                    // use nativePropertyData.reference because nativeValueData does not have references
+                    references: nativePropertyData?.references
+                }, {
+                    generatedCSS: generateCSS([
+                        ruleKey + ':' + value.name
+                    ], css),
+                    docs: '/reference/' + nativeKey
+                }),
+                detail: nativeKey + ': ' + value.name
+            });
+        });
+    }
+    // global variables
+    for(const variableName in css.variables){
+        const variable = css.variables[variableName];
+        const completionItem = generateVariableCompletionItem(variable);
+        if (completionItem) {
+            completionItem.sortText = GLOBAL_VARIABLE_PRIORITY + (completionItem.sortText || completionItem.label);
+            completionItem.detail = '(global) ' + completionItem.detail;
+            completionItems.push(completionItem);
+        }
+    }
+    return sortCompletionItems(completionItems);
+}
+
+export { getValueCompletionItems as default };

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

@@ -0,0 +1,115 @@
+'use strict';
+
+var vscodeLanguageserverProtocol = require('vscode-languageserver-protocol');
+var getPseudoClassCompletionItems = require('./get-pseudo-class-completion-items.cjs');
+var getPseudoElementCompletionItems = require('./get-pseudo-element-completion-items.cjs');
+var css = require('@master/css');
+var common = require('../common.cjs');
+var getMainCompletionItems = require('./get-main-completion-items.cjs');
+var getValueCompletionItems = require('./get-value-completion-items.cjs');
+var getQueryCompletionItems = require('./get-query-completion-items.cjs');
+var getCssDataDocumentation = require('./get-css-data-documentation.cjs');
+
+function querySyntaxCompletions(q = '', css$1 = new css.MasterCSS()) {
+    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 === common.GROUP_TRIGGER_CHARACTER || triggerCharacter === ';') {
+        return getMainCompletionItems(css$1);
+    }
+    const isGroup = field.startsWith(common.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);
+        }
+    }
+    const signs = css$1.definedRules.filter(({ definition })=>definition.sign).map(({ definition })=>definition.sign);
+    const keyMatch = field.match(new RegExp(`^[^${signs}'":\\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(`[${css.SELECTOR_SIGNS.join('')}](?=(?:[^'"]|'[^']*'|"[^"]*")*$)`);
+    const key = keyMatch ? keyMatch[0].slice(0, firstColonIndex) : undefined;
+    const componentNames = Object.keys(css$1.config.components || {});
+    const utilityNames = Object.keys(css$1.config.utilities || {});
+    const isStyle = !!componentNames.find((eachStyleName)=>new RegExp(`^${eachStyleName}(?:\\b|_)`).test(field));
+    const isUtility = !!utilityNames.find((eachUtilityName)=>new RegExp(`^${eachUtilityName}(?:\\b|_)`).test(field));
+    // check by utilities and components
+    if (!isStyle && !isUtility) {
+        if (key === undefined && !valueSeparatorMatch) {
+            /**
+             * The server capability sets '@' '~' as the trigger characters for at and adjacent selectors,
+             * but these two characters are also the prefix symbols of `animation` and `transition`,
+             * and should be filtered to prevent hints all completions items.
+             * @example class="@"
+             * @example class="~"
+             */ if (field.startsWith(css.ANIMATION_SIGN) || field.startsWith(css.TRANSITION_SIGN)) {
+                return getMainCompletionItems(css$1).filter((completionItem)=>completionItem.label.startsWith(field)).map((completionItem)=>({
+                        ...completionItem,
+                        label: completionItem.label.slice(1)
+                    }));
+            }
+            return getMainCompletionItems(css$1);
+        }
+        if (!atInvoked && !selectorInvokedRegex.test(field.slice(firstColonIndex + 1))) {
+            if (field.startsWith(css.ANIMATION_SIGN) && firstColonIndex === -1) {
+                return getValueCompletionItems(css$1, 'animation');
+            } else if (field.startsWith(css.TRANSITION_SIGN) && firstColonIndex === -1) {
+                return getValueCompletionItems(css$1, 'transition');
+            } else if (key && firstColonIndex !== -1) {
+                return getValueCompletionItems(css$1, key);
+            }
+        }
+    }
+    /**
+     * Not support conditional btn:hover and group
+     */ if (isStyle || isGroup) return;
+    if (atInvoked && [
+        css.AT_SIGN,
+        ...css.QUERY_COMPARISON_OPERATORS,
+        ...css.QUERY_LOGICAL_OPERATORS
+    ].includes(triggerCharacter)) {
+        return getQueryCompletionItems(css$1, triggerCharacter, field);
+    }
+    if (!atInvoked && common.SELECTOR_TRIGGER_CHARACTERS.includes(triggerCharacter)) {
+        const pseudoElementCompletionItems = getPseudoElementCompletionItems(css$1, field);
+        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$1, field);
+            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: getCssDataDocumentation.getCSSDataDocumentation(undefined, {
+                        generatedCSS: css.generateCSS([
+                            field + '.class'
+                        ], css$1),
+                        docs: '/guide/syntax#selectors'
+                    }),
+                    kind: vscodeLanguageserverProtocol.CompletionItemKind.Class
+                });
+            }
+            return completionItems;
+        }
+    }
+}
+
+module.exports = querySyntaxCompletions;

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

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