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

package/dist/utils/get-pseudo-element-completion-items.js

@@ -0,0 +1,39 @@
+import createCSSMarkdownDocumentation from "./create-css-markdown-documentation.js";
+import sortCompletionItems from "./sort-completion-items.js";
+import { createCompletionIndex } from "./completion-index.js";
+import { createDefaultCSS, generateCSS } from "@master/css-language";
+import { CompletionItemKind } from "vscode-languageserver-protocol";
+//#region src/utils/get-pseudo-element-completion-items.ts
+const kind = CompletionItemKind.Function;
+function getPseudoElementCompletionItems(css = createDefaultCSS(), syntax, completionIndex = createCompletionIndex(css)) {
+	const completionItems = completionIndex.pseudoElementNames.map((pseudoElementName) => {
+		const name = /::(?:part|slotted)/.test(pseudoElementName) ? pseudoElementName + "()" : pseudoElementName;
+		let sortText = name.startsWith("::-") ? "zzzz" + name.slice(3) : "zz" + name.replace(/^::/, "");
+		if (sortText.endsWith("()")) sortText = "z" + sortText;
+		return {
+			label: name,
+			sortText,
+			documentation: createCSSMarkdownDocumentation(generateCSS([syntax + name.slice(2)], css, completionIndex.runtime)),
+			kind
+		};
+	});
+	for (const variant of completionIndex.pseudoElementSelectors) {
+		const selectorName = variant.token;
+		const selectorValue = variant.selector.replace(/&/g, "");
+		const name = selectorName.endsWith("(") ? selectorName + ")" : selectorName;
+		const value = typeof selectorValue === "string" ? selectorValue.endsWith("(") ? selectorValue + ")" : selectorValue : selectorValue;
+		let sortText = name.startsWith("::-") ? "zzzz" + name.slice(3) : "zz" + name.replace(/^::/, "");
+		if (sortText.endsWith("()")) sortText = "z" + sortText;
+		const completionItem = {
+			label: name,
+			documentation: createCSSMarkdownDocumentation(generateCSS([syntax + name.slice(2)], css, completionIndex.runtime)),
+			sortText,
+			kind,
+			detail: String(value)
+		};
+		completionItems.push(completionItem);
+	}
+	return sortCompletionItems(completionItems);
+}
+//#endregion
+export { getPseudoElementCompletionItems as default };

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

@@ -0,0 +1,8 @@
+import { MasterCSS } from "@master/css-language";
+import { CompletionItem } from "vscode-languageserver-protocol";
+import { CompletionIndex } from "./completion-index.js";
+
+//#region src/utils/get-query-completion-items.d.ts
+declare function getQueryCompletionItems(css: MasterCSS | undefined, triggerCharacter: string | undefined, syntax: string, completionIndex?: CompletionIndex): CompletionItem[];
+//#endregion
+export { getQueryCompletionItems as default };

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

@@ -0,0 +1,62 @@
+import createCSSMarkdownDocumentation from "./create-css-markdown-documentation.js";
+import sortCompletionItems from "./sort-completion-items.js";
+import { createCompletionIndex } from "./completion-index.js";
+import { AT_SIGN, QUERY_COMPARISON_OPERATORS, QUERY_LOGICAL_OPERATORS, createDefaultCSS, generateAt, generateCSS, getSingleAtNumberRuleNode, parseAt } from "@master/css-language";
+import { CompletionItemKind } from "vscode-languageserver-protocol";
+//#region src/utils/get-query-completion-items.ts
+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, completionIndex.runtime))
+		});
+	});
+	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, completionIndex.runtime))
+			});
+			return true;
+		}
+	};
+	for (const [token, atRule] of completionIndex.atRules) {
+		const completionItem = {
+			filterText: token,
+			insertText: token,
+			documentation: createCSSMarkdownDocumentation(generateCSS([syntax + token], css, completionIndex.runtime))
+		};
+		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, completionIndex.runtime))
+			});
+		} else if (QUERY_COMPARISON_OPERATORS.includes(triggerCharacter)) handleNumberNodes(atRule, token);
+	}
+	return sortCompletionItems(completionItems);
+}
+//#endregion
+export { getQueryCompletionItems as default };

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

@@ -0,0 +1,6 @@
+import { Range, TextDocument } from "vscode-languageserver-textdocument";
+
+//#region src/utils/get-range.d.ts
+declare function getRange(searchString: string, doc: TextDocument): Range;
+//#endregion
+export { getRange as default };

package/dist/utils/get-range.js

@@ -0,0 +1,21 @@
+//#region src/utils/get-range.ts
+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 relativeIndex = match[3].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.`);
+}
+//#endregion
+export { getRange as default };

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

@@ -0,0 +1,8 @@
+import { CompiledUtility } from "@master/css-language";
+
+//#region src/utils/get-utility-info.d.ts
+declare function getUtilityInfo(utility: CompiledUtility): {
+  detail: string | undefined;
+};
+//#endregion
+export { getUtilityInfo as default };

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

@@ -0,0 +1,16 @@
+import { getStaticUtilityDeclarations } from "@master/css-language";
+//#region src/utils/get-utility-info.ts
+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 };
+}
+//#endregion
+export { getUtilityInfo as default };

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

@@ -0,0 +1,8 @@
+import { MasterCSS } from "@master/css-language";
+import { CompletionItem } from "vscode-languageserver-protocol";
+import { CompletionIndex } from "./completion-index.js";
+
+//#region src/utils/get-value-completion-items.d.ts
+declare function getValueCompletionItems(css: MasterCSS | undefined, ruleKey: string, valuePrefix?: string, completionIndex?: CompletionIndex): CompletionItem[];
+//#endregion
+export { getValueCompletionItems as default };

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

@@ -0,0 +1,165 @@
+import createCSSMarkdownDocumentation from "./create-css-markdown-documentation.js";
+import sortCompletionItems from "./sort-completion-items.js";
+import { createCompletionIndex } from "./completion-index.js";
+import { createDefaultCSS, generateCSS, getMdnPropertySyntax, getMdnPropertyValueNames } from "@master/css-language";
+import { CompletionItemKind } from "vscode-languageserver-protocol";
+//#region src/utils/get-value-completion-items.ts
+const SCOPED_VARIABLE_PRIORITY = "aaaa";
+const NATIVE_PRIORITY = "ccccc";
+const GLOBAL_VARIABLE_PRIORITY = "zzzz";
+const ANIMATION_REFERENCE_PROPERTIES = /* @__PURE__ */ new Set(["animation", "animation-name"]);
+function getNumericSortValue(variable, rootSize) {
+	if (variable.numeric) switch (variable.numeric.unit) {
+		case "rem": return variable.numeric.value * rootSize;
+		case void 0:
+		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 uniqueKeys(...keys) {
+	return [...new Set(keys)];
+}
+function getValueCompletionItems(css = createDefaultCSS(), ruleKey, valuePrefix = "", completionIndex = createCompletionIndex(css)) {
+	const completionItems = [];
+	const addedLabels = /* @__PURE__ */ new Set();
+	const canonicalRuleKey = completionIndex.keyAliases[ruleKey] || ruleKey;
+	const valueLookupKeys = uniqueKeys(ruleKey, canonicalRuleKey);
+	const nativeKey = completionIndex.nativeUtilityKeys.get(canonicalRuleKey) || (getMdnPropertySyntax(canonicalRuleKey) ? canonicalRuleKey : void 0);
+	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, completionIndex.runtime));
+		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, completionIndex.runtime));
+		else completionItem.documentation = createCSSMarkdownDocumentation(generateCSS([ruleKey + ":" + valueToken], css, completionIndex.runtime));
+		if (variable.namespace?.startsWith("color")) if (Object.keys(variable.modes || {}).length) {
+			completionItem.kind = CompletionItemKind.Color;
+			completionItem.detail = variable.name;
+		} else {
+			const configKey = "variables." + (variable.namespace ? variable.namespace + "." + variable.key : variable.name);
+			const valueToken = variable.value ?? variable.name;
+			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 valueLookupKey of valueLookupKeys) for (const { name, variable } of completionIndex.scopedVariablesByKey.get(valueLookupKey) || []) addScopedVariableCompletionItem(variable, name);
+	for (const valueLookupKey of valueLookupKeys) for (const { value } of completionIndex.patternValuesByKey.get(valueLookupKey) || []) {
+		if (addedLabels.has(value)) continue;
+		pushCompletionItem({
+			label: value,
+			kind: CompletionItemKind.Value,
+			documentation: createCSSMarkdownDocumentation(generateCSS([ruleKey + ":" + value], css, completionIndex.runtime)),
+			detail: valueLookupKey + ": " + 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, completionIndex.runtime)),
+			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, completionIndex.runtime)),
+			detail: canonicalRuleKey + ": " + animationName
+		});
+	});
+	const usedKeys = /* @__PURE__ */ new Set();
+	for (const valueLookupKey of valueLookupKeys) for (const variableNamespace of completionIndex.nativeVariableNamespacesByProperty.get(valueLookupKey) || []) for (const variable of completionIndex.variables) {
+		const variableName = getVariableKeyByNamespace(variable.name, variableNamespace);
+		if (variableName === void 0 || 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, completionIndex.runtime)),
+			detail: nativeKey + ": " + value
+		});
+	});
+	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);
+}
+//#endregion
+export { getValueCompletionItems as default };

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

@@ -0,0 +1,8 @@
+import { MasterCSS } from "@master/css-language";
+import { CompletionItem } from "vscode-languageserver-protocol";
+import { CompletionIndex } from "./completion-index.js";
+
+//#region src/utils/query-syntax-completions.d.ts
+declare function querySyntaxCompletions(q?: string, css?: MasterCSS, completionIndex?: CompletionIndex): CompletionItem[] | undefined;
+//#endregion
+export { querySyntaxCompletions as default };

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

@@ -0,0 +1,78 @@
+import { GROUP_TRIGGER_CHARACTER, SELECTOR_TRIGGER_CHARACTERS } from "../common.js";
+import createCSSMarkdownDocumentation from "./create-css-markdown-documentation.js";
+import { createCompletionIndex, matchesIndexedName } from "./completion-index.js";
+import getPseudoClassCompletionItems from "./get-pseudo-class-completion-items.js";
+import getPseudoElementCompletionItems from "./get-pseudo-element-completion-items.js";
+import getClassCompletionItems from "./get-class-completion-items.js";
+import getValueCompletionItems from "./get-value-completion-items.js";
+import getQueryCompletionItems from "./get-query-completion-items.js";
+import { AT_SIGN, QUERY_COMPARISON_OPERATORS, QUERY_LOGICAL_OPERATORS, SELECTOR_SIGNS, createDefaultCSS, generateCSS } from "@master/css-language";
+import { CompletionItemKind } from "vscode-languageserver-protocol";
+//#region src/utils/query-syntax-completions.ts
+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);
+	if (triggerCharacter === " " || field.length === 0 || 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) : void 0;
+	const isStyle = completionIndex.componentNames.some((eachStyleName) => matchesIndexedName(field, eachStyleName));
+	const isUtility = completionIndex.utilityNames.some((eachUtilityName) => matchesIndexedName(field, eachUtilityName));
+	if (!isStyle && !isUtility) {
+		if (key === void 0 && !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, completionIndex.runtime)),
+				kind: CompletionItemKind.Class
+			});
+			return completionItems;
+		}
+	}
+}
+//#endregion
+export { querySyntaxCompletions as default };

package/dist/utils/regex.d.ts

@@ -1 +1,4 @@
-export declare const instancePattern: RegExp;
+//#region src/utils/regex.d.ts
+declare const instancePattern: RegExp;
+//#endregion
+export { instancePattern };

package/dist/utils/regex.js

@@ -0,0 +1,4 @@
+//#region src/utils/regex.ts
+const instancePattern = /[^\s:]+:\w*\(?((?<!\\)["'`])((?:\\\1|(?:(?!\1))\S)*)((?<!\\)\1)\)?|[^\s"'`]+/g;
+//#endregion
+export { instancePattern };

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

@@ -0,0 +1,6 @@
+import { CompletionItem } from "vscode-languageserver-protocol";
+
+//#region src/utils/sort-completion-items.d.ts
+declare function sortCompletionItems(items: CompletionItem[]): CompletionItem[];
+//#endregion
+export { sortCompletionItems as default };

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

@@ -0,0 +1,10 @@
+//#region src/utils/sort-completion-items.ts
+function sortCompletionItems(items) {
+	return items.sort((a, b) => {
+		const sortTextA = a.sortText || a.label;
+		const sortTextB = b.sortText || b.label;
+		return sortTextA.localeCompare(sortTextB, void 0, { numeric: true });
+	});
+}
+//#endregion
+export { sortCompletionItems as default };

package/package.json

@@ -1 +1,61 @@
-{"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.8","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.8"}
+{
+  "name": "@master/css-language-service",
+  "type": "module",
+  "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": {
+    "colorjs.io": "^0.6.1",
+    "defu": "^6.1.7",
+    "js-beautify": "^1.15.4",
+    "minimatch": "^10.2.5",
+    "vscode-languageserver-protocol": "^3.18.0",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "@master/css": "^2.0.0-rc.80",
+    "@master/css-engine": "^2.0.0-rc.80",
+    "@master/css-language": "^2.0.0-rc.80"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.125.0",
+    "vscode-languageserver": "^10.0.0",
+    "@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"
+    },
+    "./common": {
+      "types": "./dist/common.d.ts",
+      "import": "./dist/common.js",
+      "default": "./dist/common.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/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 {};