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

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

@@ -1,2 +1,6 @@
-import { TextDocument, Range } from 'vscode-languageserver-textdocument';
-export default function getRange(searchString: string, doc: TextDocument): Range;
+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

@@ -1,4 +1,8 @@
-import { type CompiledUtility } from '@master/css-language';
-export default function getUtilityInfo(utility: CompiledUtility): {
-    detail: string | undefined;
+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

@@ -1,4 +1,8 @@
-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[];
+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,161 @@
+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 getValueCompletionItems(css = createDefaultCSS(), ruleKey, valuePrefix = "", completionIndex = createCompletionIndex(css)) {
+	const completionItems = [];
+	const addedLabels = /* @__PURE__ */ new Set();
+	const canonicalRuleKey = completionIndex.keyAliases[ruleKey] || ruleKey;
+	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 { 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, completionIndex.runtime)),
+			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, 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 variableNamespace of completionIndex.nativeVariableNamespacesByProperty.get(canonicalRuleKey) || []) 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

@@ -1,4 +1,8 @@
-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;
+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.mjs → regex.js}

@@ -1,3 +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

@@ -1,2 +1,6 @@
-import type { CompletionItem } from 'vscode-languageserver-protocol';
-export default function sortCompletionItems(items: CompletionItem[]): CompletionItem[];
+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","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.73","@master/css-engine":"^2.0.0-rc.73","@master/css-language":"^2.0.0-rc.73","@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.73"},"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.73"}
+{
+  "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.74",
+    "@master/css-engine": "^2.0.0-rc.74",
+    "@master/css-language": "^2.0.0-rc.74"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.125.0",
+    "vscode-languageserver": "^10.0.0",
+    "@master/css-schema": "^2.0.0-rc.74"
+  },
+  "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.74",
+  "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/common.mjs

@@ -1 +0,0 @@
-export { AT_TRIGGER_CHARACTER, DECLARATION_SEPARATOR_TRIGGER_CHARACTER, GROUP_TRIGGER_CHARACTER, INVOKED_TRIGGER_CHARACTERS, QUERY_TRIGGER_CHARACTERS, SELECTOR_TRIGGER_CHARACTERS, VALUE_TRIGGER_CHARACTERS } from '@master/css-language';

package/dist/core.mjs

@@ -1,116 +0,0 @@
-import { ClassPositionCache, defaultCSSLanguageRuntime, getClassPositions } from '@master/css-language';
-import extend from '@techor/extend';
-import EventEmitter from 'node:events';
-import settings from './settings.mjs';
-import { minimatch } from 'minimatch';
-import inspectSyntax from './features/inspect-syntax.mjs';
-import renderSyntaxColors from './features/render-syntax-colors.mjs';
-import editSyntaxColors from './features/edit-syntax-colors.mjs';
-import renderSemanticTokens, { renderSemanticTokensAtPosition } from './features/render-semantic-tokens.mjs';
-import suggestSyntax from './features/suggest-syntax.mjs';
-import { createCompletionIndex } from './utils/completion-index.mjs';
-
-class CSSLanguageService extends EventEmitter {
-    customSettings;
-    css;
-    runtime;
-    settings;
-    completionIndex;
-    classPositionCache = new ClassPositionCache();
-    constructor(customSettings, options = {}){
-        super(), this.customSettings = customSettings;
-        this.runtime = options.runtime ?? defaultCSSLanguageRuntime;
-        this.settings = extend(settings, customSettings);
-        this.css = this.runtime.MasterCSS.create({
-            manifest: this.settings.manifest || this.runtime.defaultManifest,
-            nativeDeclarationMatcher: this.runtime.nativeDeclarationMatcher
-        });
-    }
-    getCompletionIndex() {
-        this.completionIndex ??= createCompletionIndex(this.css, this.runtime);
-        return this.completionIndex;
-    }
-    inspectSyntax(...params) {
-        if (this.settings.inspectSyntax && this.isDocumentAccepted(params[0])) return inspectSyntax?.call(this, ...params);
-    }
-    renderSyntaxColors(...params) {
-        if (this.settings.renderSyntaxColors && this.isDocumentAccepted(params[0])) return renderSyntaxColors?.call(this, ...params);
-    }
-    editSyntaxColors(...params) {
-        if (this.settings.editSyntaxColors && this.isDocumentAccepted(params[0])) return editSyntaxColors?.call(this, ...params);
-    }
-    renderSemanticTokens(...params) {
-        if (this.isDocumentAccepted(params[0])) return renderSemanticTokens?.call(this, ...params);
-    }
-    renderSemanticTokensAtPosition(...params) {
-        if (this.isDocumentAccepted(params[0])) return renderSemanticTokensAtPosition?.call(this, ...params);
-    }
-    suggestSyntax(document, position, context) {
-        if (this.settings.suggestSyntax && this.isDocumentAccepted(document)) return suggestSyntax?.call(this, document, position, context, this.getCompletionIndex());
-    }
-    getClassPositions(textDocument) {
-        return getClassPositions(textDocument, this.settings, {
-            cache: this.classPositionCache
-        });
-    }
-    getClassPosition(textDocument, position) {
-        const cachedOxcClassPosition = getClassPositions(textDocument, this.settings, {
-            position,
-            includeEmpty: true,
-            provider: 'oxc',
-            oxcMode: 'cache-only',
-            cache: this.classPositionCache
-        })[0];
-        if (cachedOxcClassPosition) return cachedOxcClassPosition;
-        const regexClassPosition = getClassPositions(textDocument, this.settings, {
-            position,
-            includeEmpty: true,
-            provider: 'regex'
-        })[0];
-        if (regexClassPosition && !regexClassPosition.raw.includes('${')) {
-            return regexClassPosition;
-        }
-        return getClassPositions(textDocument, this.settings, {
-            position,
-            includeEmpty: true,
-            provider: 'oxc',
-            cache: this.classPositionCache
-        })[0] ?? regexClassPosition;
-    }
-    getClassContextPositions(textDocument, position) {
-        const cachedOxcClassPositions = getClassPositions(textDocument, this.settings, {
-            position,
-            provider: 'oxc',
-            oxcMode: 'cache-only',
-            positionMatch: 'context',
-            cache: this.classPositionCache
-        });
-        if (cachedOxcClassPositions.length) return cachedOxcClassPositions;
-        const regexClassPositions = getClassPositions(textDocument, this.settings, {
-            position,
-            provider: 'regex',
-            positionMatch: 'context'
-        });
-        if (regexClassPositions.length && regexClassPositions.every(({ raw })=>!raw.includes('${'))) {
-            return regexClassPositions;
-        }
-        const oxcClassPositions = getClassPositions(textDocument, this.settings, {
-            position,
-            provider: 'oxc',
-            positionMatch: 'context',
-            cache: this.classPositionCache
-        });
-        return oxcClassPositions.length ? oxcClassPositions : regexClassPositions;
-    }
-    isDocumentAccepted(doc) {
-        if (!this.settings.exclude) return true;
-        for (const exclude of this.settings.exclude){
-            if (minimatch(doc.uri, exclude)) {
-                return false;
-            }
-        }
-        return true;
-    }
-}
-
-export { CSSLanguageService as default };

package/dist/features/edit-syntax-colors.mjs

@@ -1,17 +0,0 @@
-import convertColorByToken from '../utils/convert-color-token.mjs';
-
-function editSyntaxColors(document, color, range) {
-    const colorPresentations = [];
-    const selectedColorToken = document.getText(range);
-    const targetColorToken = convertColorByToken(color, selectedColorToken, this.css);
-    if (targetColorToken) colorPresentations.push({
-        label: targetColorToken,
-        textEdit: {
-            range,
-            newText: targetColorToken
-        }
-    });
-    return colorPresentations;
-}
-
-export { editSyntaxColors as default };