@cssdoc/providers 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Danny Wahl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @cssdoc/providers
+
+The host-agnostic language-service core. Given a [`@cssdoc/index`](../index), it produces diagnostics,
+completions, hover, and definitions — built from modular per-aspect modules (modifier, custom property,
+structure, function, state, condition, plus record and part). Every cssdoc integration — the Stylelint
+and ESLint plugins, and the language server — is a thin translation of these into its host's API.
+
+## API
+
+```ts
+import { createIndex } from "@cssdoc/index";
+import {
+  lintModel, // author-side hygiene
+  checkClassUsage, // consumer-side: unknown/deprecated modifiers
+  checkPropertyUsage, // consumer-side: unknown var(--…) (opt-in)
+  completeClasses, // components, or a component's modifiers
+  completeCustomProperties,
+  hoverForClass,
+  definitionForClass,
+} from "@cssdoc/providers";
+
+const index = createIndex(css, { file: "components.css" });
+checkClassUsage([{ base: "btn", tokens: ["btn", "-x"], token: "-x" }], index);
+```
+
+Adding an aspect is one module in `aspects.ts` plus a line in the aggregate — no adapter changes.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,127 @@
+import { ClassUsage, CssDocIndex, Location, Location as Location$1, PropertyAssignment, PropertyUsage, SourceSpan, SourceSpan as SourceSpan$1 } from "@cssdoc/index";
+
+//#region src/types.d.ts
+/** Diagnostic severity. */
+type Severity = "error" | "warning";
+/** One diagnostic from an aspect. */
+interface Diagnostic {
+  /** The aspect that produced it (e.g. `modifier`). */
+  aspect: string;
+  /** The rule name (e.g. `unknown-modifier`). */
+  rule: string;
+  /** A human-readable message. */
+  message: string;
+  /** The record it concerns, when applicable. */
+  record?: string;
+  /** The source span, when known (author-side comes from the index; usage-side from the usage). */
+  span?: SourceSpan$1;
+  /** Severity (defaults to `warning`). */
+  severity: Severity;
+}
+/** What kind of thing a completion inserts. */
+type CompletionKind = "component" | "modifier" | "part" | "property" | "function" | "state";
+/** One completion item. */
+interface Completion {
+  /** The text to insert (e.g. `-color-secondary`, `--value`). */
+  label: string;
+  kind: CompletionKind;
+  /** A short type/hint shown beside the label. */
+  detail?: string;
+  /** Markdown documentation. */
+  documentation?: string;
+  /** Whether the item is deprecated. */
+  deprecated?: boolean;
+}
+/** Hover content (markdown). */
+interface Hover {
+  contents: string;
+}
+/** Options that tune usage checks. */
+interface UsageOptions {
+  /**
+   * When set, a `var(--name)` whose name starts with this prefix but isn't a declared custom property
+   * is flagged as unknown. Off by default, since consumed properties are often external tokens.
+   */
+  propertyPrefix?: string;
+}
+//#endregion
+//#region src/syntax.d.ts
+/** The result of matching a value against a syntax. */
+interface SyntaxMatch {
+  /** Whether the value conforms. True when skipped — we don't flag what we can't check. */
+  ok: boolean;
+  /** True when the value couldn't be checked statically (universal `*`, `var()`/`env()`, CSS-wide keyword). */
+  skipped: boolean;
+}
+/**
+ * Whether `value` conforms to a `@property` `syntax` string (e.g. `<length>`, `<color> | none`,
+ * `<length>+`). Universal syntax (`*`), substitution values, and CSS-wide keywords are skipped.
+ *
+ * @param syntax - The `@property` `syntax` descriptor.
+ * @param value - The CSS value to check.
+ * @returns Whether it matches, and whether the check was skipped.
+ */
+declare function matchesSyntax(syntax: string, value: string): SyntaxMatch;
+//#endregion
+//#region src/aspects.d.ts
+declare const record: {
+  model(index: CssDocIndex): Diagnostic[];
+  completions(index: CssDocIndex): Completion[];
+  hover(base: string, index: CssDocIndex): Hover | undefined;
+  definition(base: string, index: CssDocIndex): Location$1 | undefined;
+};
+declare const modifier: {
+  model(index: CssDocIndex): Diagnostic[];
+  classUsage(usage: ClassUsage, index: CssDocIndex): Diagnostic[];
+  completions(base: string, index: CssDocIndex): Completion[];
+  hover(base: string, token: string, index: CssDocIndex): Hover | undefined;
+  definition(base: string, token: string, index: CssDocIndex): Location$1 | undefined;
+};
+declare const part: {
+  model(index: CssDocIndex): Diagnostic[];
+};
+declare const customProperty: {
+  /** Author-side: a registered property's default (`initial-value`/`@defaultValue`) must match its syntax. */model(index: CssDocIndex): Diagnostic[]; /** Consumer-side: an assignment `--name: value` must match the property's declared syntax. */
+  assignment(a: PropertyAssignment, index: CssDocIndex): Diagnostic[];
+  propertyUsage(usage: PropertyUsage, index: CssDocIndex, options: UsageOptions): Diagnostic[];
+  completions(index: CssDocIndex): Completion[];
+  hover(name: string, index: CssDocIndex): Hover | undefined;
+  definition(name: string, index: CssDocIndex): Location$1 | undefined;
+};
+declare const func: {
+  completions(index: CssDocIndex): Completion[];
+  hover(name: string, index: CssDocIndex): Hover | undefined;
+  definition(name: string, index: CssDocIndex): Location$1 | undefined;
+};
+//#endregion
+//#region src/index.d.ts
+/** The aspect names covered, in a stable order (the extension point for future aspects). */
+declare const ASPECTS: readonly ["record", "modifier", "part", "custom-property", "structure", "function", "state", "condition"];
+/** Author-side hygiene diagnostics over the whole model (missing summaries, undocumented members, drift, invalid defaults). */
+declare function lintModel(index: CssDocIndex): Diagnostic[];
+/** Consumer-side diagnostics for custom-property assignments (`--x: value` must match its `@property` syntax). */
+declare function checkPropertyAssignments(assignments: readonly PropertyAssignment[], index: CssDocIndex): Diagnostic[];
+/** Consumer-side diagnostics for class-attribute usage (unknown or deprecated modifiers). */
+declare function checkClassUsage(usages: readonly ClassUsage[], index: CssDocIndex): Diagnostic[];
+/** Consumer-side diagnostics for `var(--…)` references (unknown custom properties; opt-in via prefix). */
+declare function checkPropertyUsage(usages: readonly PropertyUsage[], index: CssDocIndex, options?: UsageOptions): Diagnostic[];
+/** Completions for a class attribute: modifiers of `base` when given, else the component classes. */
+declare function completeClasses(base: string | undefined, index: CssDocIndex): Completion[];
+/** Completions for `var(--…)`: the declared custom properties. */
+declare function completeCustomProperties(index: CssDocIndex): Completion[];
+/** Completions for a value position: the custom functions. */
+declare function completeFunctions(index: CssDocIndex): Completion[];
+/** Hover for a class token: the modifier's docs, else the component's. */
+declare function hoverForClass(base: string, token: string, index: CssDocIndex): Hover | undefined;
+/** Hover for a `var(--…)` custom property. */
+declare function hoverForCustomProperty(name: string, index: CssDocIndex): Hover | undefined;
+/** Hover for a custom function. */
+declare function hoverForFunction(name: string, index: CssDocIndex): Hover | undefined;
+/** Definition of a class token: the modifier's rule, else the component's. */
+declare function definitionForClass(base: string, token: string, index: CssDocIndex): Location$1 | undefined;
+/** Definition of a custom property (its `@property` rule). */
+declare function definitionForCustomProperty(name: string, index: CssDocIndex): Location$1 | undefined;
+/** Definition of a custom function (its `@function` rule). */
+declare function definitionForFunction(name: string, index: CssDocIndex): Location$1 | undefined;
+//#endregion
+export { ASPECTS, Completion, CompletionKind, Diagnostic, Hover, type Location, Severity, type SourceSpan, SyntaxMatch, UsageOptions, checkClassUsage, checkPropertyAssignments, checkPropertyUsage, completeClasses, completeCustomProperties, completeFunctions, customProperty, definitionForClass, definitionForCustomProperty, definitionForFunction, func, hoverForClass, hoverForCustomProperty, hoverForFunction, lintModel, matchesSyntax, modifier, part, record };

package/dist/index.mjs

@@ -0,0 +1,401 @@
+import { memberKey } from "@cssdoc/index";
+import { fork } from "css-tree";
+//#region src/syntax.ts
+/**
+* Match a CSS value against a registered custom property's `@property` `syntax` descriptor, using
+* css-tree's lexer. This is what lets the value rules reject `--gap: red` when `--gap` is declared
+* `<length>`. Values that are runtime-substituted (`var()`, `env()`) or CSS-wide keywords can't be
+* validated statically, so they're skipped rather than flagged (we never warn on what we can't check).
+*
+* @module
+*/
+const PROBE = "-cssdoc-syntax-probe";
+const CSS_WIDE = /^(?:initial|inherit|unset|revert|revert-layer)$/iu;
+const SUBSTITUTION = /\b(?:var|env)\(/iu;
+const lexerCache = /* @__PURE__ */ new Map();
+function lexerFor(syntax) {
+	const cached = lexerCache.get(syntax);
+	if (cached !== void 0) return cached;
+	let lexer = null;
+	try {
+		lexer = fork({ properties: { [PROBE]: syntax } }).lexer;
+	} catch {
+		lexer = null;
+	}
+	lexerCache.set(syntax, lexer);
+	return lexer;
+}
+/**
+* Whether `value` conforms to a `@property` `syntax` string (e.g. `<length>`, `<color> | none`,
+* `<length>+`). Universal syntax (`*`), substitution values, and CSS-wide keywords are skipped.
+*
+* @param syntax - The `@property` `syntax` descriptor.
+* @param value - The CSS value to check.
+* @returns Whether it matches, and whether the check was skipped.
+*/
+function matchesSyntax(syntax, value) {
+	const s = syntax.trim();
+	const v = value.trim();
+	if (!s || s === "*") return {
+		ok: true,
+		skipped: true
+	};
+	if (!v || CSS_WIDE.test(v) || SUBSTITUTION.test(v)) return {
+		ok: true,
+		skipped: true
+	};
+	const lexer = lexerFor(s);
+	if (!lexer) return {
+		ok: true,
+		skipped: true
+	};
+	return {
+		ok: lexer.matchProperty(PROBE, v).error === null,
+		skipped: false
+	};
+}
+//#endregion
+//#region src/aspects.ts
+/**
+* The aspect modules. Each documented aspect contributes some of: author-side model diagnostics,
+* consumer-side usage diagnostics, completions, hover, and definitions. All six aspects the model
+* carries are represented; the component hover folds in the structure, state, and condition facts, and
+* the generators (phase 3) surface them further. `index.ts` aggregates these into the public API.
+*
+* @module
+*/
+const stripDot = (name) => name.replace(/^\./u, "");
+const warn = (d) => ({
+	...d,
+	severity: "warning"
+});
+const record = {
+	model(index) {
+		const out = [];
+		for (const info of index.records) if (!info.entry.summary?.trim()) out.push(warn({
+			aspect: "record",
+			rule: "missing-summary",
+			message: `Record "${info.entry.name}" has no @summary.`,
+			record: info.entry.name,
+			span: info.span
+		}));
+		return out;
+	},
+	completions(index) {
+		return index.entries.map((entry) => ({
+			label: stripDot(entry.className),
+			kind: "component",
+			detail: entry.kind,
+			documentation: entry.summary,
+			deprecated: Boolean(entry.deprecated)
+		}));
+	},
+	hover(base, index) {
+		const entry = index.componentForClass(base);
+		if (!entry) return void 0;
+		const lines = [`\`${entry.className}\` — ${entry.kind}`];
+		if (entry.summary) lines.push("", entry.summary);
+		if (entry.remarks) lines.push("", entry.remarks);
+		const facets = [
+			entry.modifiers.length && `${entry.modifiers.length} modifiers`,
+			entry.parts.length && `${entry.parts.length} parts`,
+			entry.states.length && `${entry.states.length} states`,
+			entry.cssPropertiesDeclared.length && `${entry.cssPropertiesDeclared.length} custom properties`,
+			entry.functions.length && `${entry.functions.length} functions`,
+			entry.conditions.length && `${entry.conditions.length} conditions`
+		].filter(Boolean);
+		if (facets.length) lines.push("", facets.join(" · "));
+		if (entry.deprecated) lines.push("", `**Deprecated** — ${entry.deprecated}`);
+		return { contents: lines.join("\n") };
+	},
+	definition(base, index) {
+		const entry = index.componentForClass(base);
+		return entry ? index.location(entry.name, "record") : void 0;
+	}
+};
+const modifier = {
+	model(index) {
+		const out = [];
+		for (const info of index.records) {
+			const name = info.entry.name;
+			for (const m of info.entry.modifiers) {
+				const span = info.memberSpans.get(memberKey("modifier", m.name)) ?? info.span;
+				if (!m.description?.trim() && !m.deprecated) out.push(warn({
+					aspect: "modifier",
+					rule: "undocumented-modifier",
+					message: `Modifier ".${m.name}" of "${name}" has no @modifier description.`,
+					record: name,
+					span
+				}));
+				if (m.deprecated && !m.deprecated.canonical && !m.deprecated.note?.trim()) out.push(warn({
+					aspect: "modifier",
+					rule: "deprecated-requires-canonical",
+					message: `Deprecated modifier ".${m.name}" of "${name}" needs a canonical replacement ({@link -x}) or a note.`,
+					record: name,
+					span
+				}));
+			}
+			for (const authored of info.authoredModifiers) if (!info.selectorText.includes(`.${authored}`)) out.push(warn({
+				aspect: "modifier",
+				rule: "name-not-in-css",
+				message: `Documented modifier ".${authored}" of "${name}" is not defined by any selector.`,
+				record: name,
+				span: info.span
+			}));
+		}
+		return out;
+	},
+	classUsage(usage, index) {
+		if (!usage.base || !usage.token.startsWith("-")) return [];
+		const entry = index.componentForClass(usage.base);
+		if (!entry) return [];
+		if (!index.isModifier(usage.base, usage.token)) return [warn({
+			aspect: "modifier",
+			rule: "unknown-modifier",
+			message: `".${usage.token}" is not a documented modifier of "${entry.name}".`,
+			record: entry.name,
+			span: usage.loc
+		})];
+		const dep = index.deprecationOf(usage.base, usage.token);
+		if (dep) {
+			const advice = dep.canonical ? `use ".${dep.canonical}"` : dep.note ?? "no replacement given";
+			return [warn({
+				aspect: "modifier",
+				rule: "deprecated-modifier",
+				message: `Modifier ".${usage.token}" of "${entry.name}" is deprecated — ${advice}.`,
+				record: entry.name,
+				span: usage.loc
+			})];
+		}
+		return [];
+	},
+	completions(base, index) {
+		const entry = index.componentForClass(base);
+		if (!entry) return [];
+		return entry.modifiers.map((m) => ({
+			label: `-${m.name.replace(/^-/u, "")}`,
+			kind: "modifier",
+			detail: m.prop,
+			documentation: m.description,
+			deprecated: Boolean(m.deprecated)
+		}));
+	},
+	hover(base, token, index) {
+		const entry = index.componentForClass(base);
+		const m = entry?.modifiers.find((x) => x.name === stripDot(token));
+		if (!m) return void 0;
+		const lines = [`\`.${m.name}\` — modifier of \`${entry.className}\``];
+		if (m.description) lines.push("", m.description);
+		if (m.deprecated) {
+			const advice = m.deprecated.canonical ? `use \`.${m.deprecated.canonical}\`` : m.deprecated.note ?? "";
+			lines.push("", `**Deprecated** — ${advice}`);
+		}
+		return { contents: lines.join("\n") };
+	},
+	definition(base, token, index) {
+		const entry = index.componentForClass(base);
+		return entry ? index.location(entry.name, memberKey("modifier", stripDot(token))) : void 0;
+	}
+};
+const part = { model(index) {
+	const out = [];
+	for (const info of index.records) {
+		const name = info.entry.name;
+		for (const p of info.entry.parts) if (!p.description?.trim()) out.push(warn({
+			aspect: "part",
+			rule: "undocumented-part",
+			message: `Part ".${p.name}" of "${name}" has no @part description.`,
+			record: name,
+			span: info.memberSpans.get(memberKey("part", p.name)) ?? info.span
+		}));
+		for (const authored of info.authoredParts) if (!info.selectorText.includes(`.${authored}`)) out.push(warn({
+			aspect: "part",
+			rule: "name-not-in-css",
+			message: `Documented part ".${authored}" of "${name}" is not defined by any selector.`,
+			record: name,
+			span: info.span
+		}));
+	}
+	return out;
+} };
+function findProperty(index, name) {
+	for (const rec of index.records) {
+		const i = rec.entry.cssPropertiesDeclared.findIndex((p) => p.name === name);
+		if (i >= 0) return {
+			record: rec,
+			index: i
+		};
+	}
+}
+const customProperty = {
+	/** Author-side: a registered property's default (`initial-value`/`@defaultValue`) must match its syntax. */
+	model(index) {
+		const out = [];
+		for (const { property, record } of index.allCustomProperties()) {
+			if (!property.syntax || property.defaultValue === void 0) continue;
+			const m = matchesSyntax(property.syntax, property.defaultValue);
+			if (m.skipped || m.ok) continue;
+			out.push(warn({
+				aspect: "custom-property",
+				rule: "invalid-default-value",
+				message: `Default \`${property.defaultValue}\` of \`${property.name}\` doesn't match its syntax \`${property.syntax}\`.`,
+				record,
+				span: index.location(record, memberKey("property", property.name))?.span
+			}));
+		}
+		return out;
+	},
+	/** Consumer-side: an assignment `--name: value` must match the property's declared syntax. */
+	assignment(a, index) {
+		const found = findProperty(index, a.name);
+		if (!found) return [];
+		const property = found.record.entry.cssPropertiesDeclared[found.index];
+		if (!property.syntax) return [];
+		const m = matchesSyntax(property.syntax, a.value);
+		if (m.skipped || m.ok) return [];
+		return [warn({
+			aspect: "custom-property",
+			rule: "invalid-property-value",
+			message: `\`${a.value}\` doesn't match the declared syntax \`${property.syntax}\` of \`${a.name}\`.`,
+			record: found.record.entry.name,
+			span: a.loc
+		})];
+	},
+	propertyUsage(usage, index, options) {
+		const out = [];
+		if (usage.fallback) {
+			const found = findProperty(index, usage.name);
+			const property = found?.record.entry.cssPropertiesDeclared[found.index];
+			if (property?.syntax) {
+				const m = matchesSyntax(property.syntax, usage.fallback);
+				if (!m.skipped && !m.ok) out.push(warn({
+					aspect: "custom-property",
+					rule: "invalid-fallback-value",
+					message: `\`var(${usage.name}, …)\` fallback \`${usage.fallback}\` doesn't match the declared syntax \`${property.syntax}\`.`,
+					span: usage.loc
+				}));
+			}
+		}
+		if (options.propertyPrefix && usage.name.startsWith(options.propertyPrefix) && !findProperty(index, usage.name)) out.push(warn({
+			aspect: "custom-property",
+			rule: "unknown-custom-property",
+			message: `\`${usage.name}\` is not a documented custom property.`,
+			span: usage.loc
+		}));
+		return out;
+	},
+	completions(index) {
+		return index.allCustomProperties().map(({ property }) => ({
+			label: property.name,
+			kind: "property",
+			detail: property.syntax,
+			documentation: property.description
+		}));
+	},
+	hover(name, index) {
+		const found = findProperty(index, name);
+		if (!found) return void 0;
+		const p = found.record.entry.cssPropertiesDeclared[found.index];
+		const lines = [`\`${p.name}\`${p.syntax ? ` — \`${p.syntax}\`` : ""}`];
+		if (p.defaultValue) lines.push("", `Default: \`${p.defaultValue}\``);
+		if (p.description) lines.push("", p.description);
+		return { contents: lines.join("\n") };
+	},
+	definition(name, index) {
+		const found = findProperty(index, name);
+		return found ? index.location(found.record.entry.name, memberKey("property", name)) : void 0;
+	}
+};
+const func = {
+	completions(index) {
+		return index.allFunctions().map(({ fn }) => ({
+			label: fn.name,
+			kind: "function",
+			detail: fn.result ? `(${fn.parameters.join(", ")}) → ${fn.result}` : `(${fn.parameters.join(", ")})`,
+			documentation: fn.description
+		}));
+	},
+	hover(name, index) {
+		const match = index.allFunctions().find(({ fn }) => fn.name === name);
+		if (!match) return void 0;
+		const { fn } = match;
+		const sig = `\`${fn.name}(${fn.parameters.join(", ")})\`${fn.result ? ` → \`${fn.result}\`` : ""}`;
+		return { contents: fn.description ? `${sig}\n\n${fn.description}` : sig };
+	},
+	definition(name, index) {
+		const match = index.allFunctions().find(({ fn }) => fn.name === name);
+		return match ? index.location(match.record, memberKey("function", name)) : void 0;
+	}
+};
+//#endregion
+//#region src/index.ts
+/** The aspect names covered, in a stable order (the extension point for future aspects). */
+const ASPECTS = [
+	"record",
+	"modifier",
+	"part",
+	"custom-property",
+	"structure",
+	"function",
+	"state",
+	"condition"
+];
+/** Author-side hygiene diagnostics over the whole model (missing summaries, undocumented members, drift, invalid defaults). */
+function lintModel(index) {
+	return [
+		...record.model(index),
+		...modifier.model(index),
+		...part.model(index),
+		...customProperty.model(index)
+	];
+}
+/** Consumer-side diagnostics for custom-property assignments (`--x: value` must match its `@property` syntax). */
+function checkPropertyAssignments(assignments, index) {
+	return assignments.flatMap((a) => customProperty.assignment(a, index));
+}
+/** Consumer-side diagnostics for class-attribute usage (unknown or deprecated modifiers). */
+function checkClassUsage(usages, index) {
+	return usages.flatMap((usage) => modifier.classUsage(usage, index));
+}
+/** Consumer-side diagnostics for `var(--…)` references (unknown custom properties; opt-in via prefix). */
+function checkPropertyUsage(usages, index, options = {}) {
+	return usages.flatMap((usage) => customProperty.propertyUsage(usage, index, options));
+}
+/** Completions for a class attribute: modifiers of `base` when given, else the component classes. */
+function completeClasses(base, index) {
+	return base ? modifier.completions(base, index) : record.completions(index);
+}
+/** Completions for `var(--…)`: the declared custom properties. */
+function completeCustomProperties(index) {
+	return customProperty.completions(index);
+}
+/** Completions for a value position: the custom functions. */
+function completeFunctions(index) {
+	return func.completions(index);
+}
+/** Hover for a class token: the modifier's docs, else the component's. */
+function hoverForClass(base, token, index) {
+	return modifier.hover(base, token, index) ?? record.hover(base, index);
+}
+/** Hover for a `var(--…)` custom property. */
+function hoverForCustomProperty(name, index) {
+	return customProperty.hover(name, index);
+}
+/** Hover for a custom function. */
+function hoverForFunction(name, index) {
+	return func.hover(name, index);
+}
+/** Definition of a class token: the modifier's rule, else the component's. */
+function definitionForClass(base, token, index) {
+	return modifier.definition(base, token, index) ?? record.definition(base, index);
+}
+/** Definition of a custom property (its `@property` rule). */
+function definitionForCustomProperty(name, index) {
+	return customProperty.definition(name, index);
+}
+/** Definition of a custom function (its `@function` rule). */
+function definitionForFunction(name, index) {
+	return func.definition(name, index);
+}
+//#endregion
+export { ASPECTS, checkClassUsage, checkPropertyAssignments, checkPropertyUsage, completeClasses, completeCustomProperties, completeFunctions, customProperty, definitionForClass, definitionForCustomProperty, definitionForFunction, func, hoverForClass, hoverForCustomProperty, hoverForFunction, lintModel, matchesSyntax, modifier, part, record };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@cssdoc/providers",
+  "version": "0.1.0",
+  "description": "Host-agnostic aspect providers over the @cssdoc/index — diagnostics, completions, hover, and definitions for modifiers, custom properties, structure, functions, states, and conditions.",
+  "keywords": [
+    "css",
+    "cssdoc",
+    "documentation",
+    "language-service"
+  ],
+  "homepage": "https://cssdoc.dev",
+  "bugs": "https://github.com/thedannywahl/cssdoc/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thedannywahl/cssdoc.git",
+    "directory": "packages/providers"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "css-tree": "^3.2.1",
+    "@cssdoc/core": "0.1.0",
+    "@cssdoc/index": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/css-tree": "^2.3.11",
+    "@types/node": "^24.13.3",
+    "publint": "^0.3.21",
+    "typescript": "^6.0.3",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.4",
+    "vite-plus": "0.2.4"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check",
+    "publint": "publint"
+  }
+}