@jesscss/diagnostics-core 2.0.0-alpha.11

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Matthew Dean
+
+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/lib/cst-analysis.d.ts

@@ -0,0 +1,15 @@
+import type { CssCstNode } from '@jesscss/css-parser';
+export type CstIndexEntry = {
+    node: CssCstNode;
+    start: number;
+    end: number;
+};
+export type CstIndex = {
+    nodes: CstIndexEntry[];
+    spanOf(node: CssCstNode): {
+        start: number;
+        end: number;
+    } | undefined;
+    findNodeAtOffset(offset: number): CssCstNode | null;
+};
+export declare function buildCstIndex(root: CssCstNode): CstIndex;

package/lib/index.cjs

@@ -0,0 +1,503 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _jesscss_css_parser = require("@jesscss/css-parser");
+let _jesscss_jess_parser_cst = require("@jesscss/jess-parser/cst");
+let _jesscss_less_parser_cst = require("@jesscss/less-parser/cst");
+let _jesscss_scss_parser_cst = require("@jesscss/scss-parser/cst");
+let _jesscss_core_ast = require("@jesscss/core/ast");
+//#region src/metadata.ts
+const require$1 = (0, require("node:module").createRequire)(require("url").pathToFileURL(__filename).href);
+const webCssData = require$1("@vscode/web-custom-data/data/browsers.css-data.json");
+const knownCssProperties = require$1("known-css-properties");
+function ownValue(value, key) {
+	if (typeof value !== "object" || value === null) return;
+	return Object.getOwnPropertyDescriptor(value, key)?.value;
+}
+function arrayField(value, key) {
+	const field = ownValue(value, key);
+	return Array.isArray(field) ? field : [];
+}
+function stringField(value, key) {
+	const field = ownValue(value, key);
+	return typeof field === "string" ? field : void 0;
+}
+const cssProperties = arrayField(knownCssProperties, "all").filter((value) => typeof value === "string");
+const CSS_PROPERTY_SET = new Set(cssProperties.map((property) => property.toLowerCase()));
+const WEB_PROPERTY_SET = new Set(arrayField(webCssData, "properties").map((property) => stringField(property, "name")?.toLowerCase()).filter((name) => typeof name === "string" && name.length > 0));
+const AT_RULE_SET = new Set(arrayField(webCssData, "atDirectives").map((rule) => stringField(rule, "name")?.toLowerCase()).filter((name) => typeof name === "string" && name.length > 0));
+const defaultCssDiagnosticMetadata = {
+	isKnownProperty(name) {
+		const lower = name.toLowerCase();
+		return CSS_PROPERTY_SET.has(lower) || WEB_PROPERTY_SET.has(lower);
+	},
+	isKnownAtRule(name) {
+		const lower = name.startsWith("@") ? name.toLowerCase() : `@${name.toLowerCase()}`;
+		return AT_RULE_SET.has(lower);
+	}
+};
+//#endregion
+//#region src/tolerant-cst.ts
+const LINT_CODES = {
+	emptyRules: "lint/empty-rules",
+	unknownProperties: "lint/unknown-property",
+	unknownAtRules: "lint/unknown-at-rule",
+	duplicateProperties: "lint/duplicate-property",
+	hexColorLength: "lint/hex-color-length",
+	zeroUnits: "lint/zero-units",
+	unsupportedSassForm: "unsupported/sass-form"
+};
+const LENGTH_UNITS = new Set([
+	"px",
+	"em",
+	"rem",
+	"ex",
+	"ch",
+	"cap",
+	"ic",
+	"lh",
+	"rlh",
+	"vw",
+	"vh",
+	"vi",
+	"vb",
+	"vmin",
+	"vmax",
+	"cm",
+	"mm",
+	"q",
+	"in",
+	"pt",
+	"pc"
+]);
+const DIALECT_AT_RULES = {
+	css: /* @__PURE__ */ new Set(),
+	less: new Set(["plugin"]),
+	scss: new Set([
+		"mixin",
+		"include",
+		"function",
+		"return",
+		"if",
+		"else",
+		"each",
+		"for",
+		"while",
+		"use",
+		"forward",
+		"content",
+		"extend",
+		"at-root",
+		"debug",
+		"warn",
+		"error"
+	]),
+	jess: new Set([
+		"mixin",
+		"include",
+		"function",
+		"return",
+		"if",
+		"else",
+		"each",
+		"for",
+		"while",
+		"use",
+		"forward",
+		"from",
+		"compose",
+		"content",
+		"extend",
+		"at-root",
+		"debug",
+		"warn",
+		"error"
+	])
+};
+const RULESET_TYPES = new Set([
+	"Ruleset",
+	"DirectScssRule",
+	"DirectJessRule"
+]);
+const ATRULE_TYPES = new Set([
+	"AtRuleBlock",
+	"AtRuleStatement",
+	"UnknownAtRuleBlock",
+	"QueryAtRuleBlock",
+	"OpaqueAtRuleBlock"
+]);
+const DECLARATION_TYPES = new Set([
+	"Declaration",
+	"DirectScssDeclaration",
+	"DirectJessDeclaration"
+]);
+const DIMENSION_TYPES = new Set([
+	"Dimension",
+	"DirectScssDimension",
+	"DirectJessDimension"
+]);
+const FORWARD_AS_PREFIX = /\bas\s+\S+-\*/;
+const FORWARD_VISIBILITY = /\b(show|hide)\b/;
+function isCstNode$1(c) {
+	return c._tag === "node";
+}
+function isAstRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function astChildrenOf(value, key) {
+	if (!isAstRecord(value)) return [];
+	const child = value[key];
+	return Array.isArray(child) ? child : [];
+}
+function forwardPreludeOf(node, nodeStart, src) {
+	let afterPath = false;
+	for (const child of node.children) {
+		if (isCstNode$1(child)) {
+			if (child.grammarType === "Quoted") afterPath = true;
+			continue;
+		}
+		if (!afterPath) continue;
+		const normalized = src.slice(nodeStart + Number(child.span.start), nodeStart + Number(child.span.end)).replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n\r]*/g, " ").replace(/\s+/g, " ").trim();
+		if (normalized === ";" || normalized.toLowerCase() === "with") continue;
+		return normalized;
+	}
+	return null;
+}
+function propNameOf(slice) {
+	const colon = slice.indexOf(":");
+	return (colon >= 0 ? slice.slice(0, colon) : slice).trim();
+}
+function absoluteStart(base, node) {
+	return base + Number(node.span.start);
+}
+function absoluteEnd(base, node) {
+	return base + Number(node.span.end);
+}
+function isWhitespaceOnly(source, start, end) {
+	for (let i = start; i < end; i++) {
+		const code = source.charCodeAt(i);
+		if (code !== 9 && code !== 10 && code !== 12 && code !== 13 && code !== 32) return false;
+	}
+	return true;
+}
+function atRuleNameEnd(source, start, end) {
+	let i = start + 1;
+	while (i < end) {
+		const code = source.charCodeAt(i);
+		if (!(code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 45 || code === 95)) break;
+		i++;
+	}
+	return i;
+}
+function lineCommentStartBetween(source, start, end) {
+	for (let i = start; i < end - 1; i++) if (source.charCodeAt(i) === 47 && source.charCodeAt(i + 1) === 47) return i;
+	return -1;
+}
+function declarationEnd(source, start, blockEnd) {
+	const semi = source.indexOf(";", start);
+	if (semi < 0 || semi > blockEnd) return blockEnd;
+	return semi + 1;
+}
+function locateDeclaration(source, name, cursor, blockEnd) {
+	let search = cursor;
+	while (search < blockEnd) {
+		const nameStart = source.indexOf(name, search);
+		if (nameStart < 0 || nameStart >= blockEnd) return null;
+		const colon = source.indexOf(":", nameStart + name.length);
+		if (colon < 0 || colon >= blockEnd) return null;
+		const lineComment = lineCommentStartBetween(source, nameStart + name.length, colon);
+		if (lineComment < 0) return {
+			nameStart,
+			declarationEnd: declarationEnd(source, colon + 1, blockEnd),
+			valueStart: colon + 1
+		};
+		search = lineComment + 2;
+	}
+	return null;
+}
+function findValueSource(source, src, start, end) {
+	if (src.length === 0) return;
+	const valueStart = source.indexOf(src, start);
+	if (valueStart < 0 || valueStart >= end) return;
+	return {
+		start: valueStart,
+		end: valueStart + src.length
+	};
+}
+function blankStrings(value) {
+	return value.replace(/"[^"]*"|'[^']*'/g, (m) => " ".repeat(m.length));
+}
+function blankStringsAndComments(value) {
+	return value.replace(/\/\*[\s\S]*?\*\/|\/\/[^\n\r]*|"[^"]*"|'[^']*'/g, (m) => " ".repeat(m.length));
+}
+function isDeclarationValueContext(source, offset) {
+	const lastBlockOpen = source.lastIndexOf("{", offset);
+	const lastBlockClose = source.lastIndexOf("}", offset);
+	if (lastBlockOpen < 0 || lastBlockClose > lastBlockOpen) return false;
+	const lastStatement = Math.max(lastBlockOpen, source.lastIndexOf(";", offset));
+	return source.lastIndexOf(":", offset) > lastStatement;
+}
+function diagnostic(code, defaultSeverity, message, start, end, filePath) {
+	return {
+		code,
+		phase: code.startsWith("parse/") ? "parse" : "lint",
+		source: "jess",
+		message,
+		reason: "",
+		fix: "",
+		defaultSeverity,
+		filePath,
+		start,
+		end: Math.max(start, end)
+	};
+}
+function metadataWithDefaults(metadata) {
+	return {
+		isKnownProperty(name) {
+			return metadata?.isKnownProperty?.(name) ?? defaultCssDiagnosticMetadata.isKnownProperty(name);
+		},
+		isKnownAtRule(name) {
+			return metadata?.isKnownAtRule?.(name) ?? defaultCssDiagnosticMetadata.isKnownAtRule(name);
+		}
+	};
+}
+function parseDocForLanguage(source, language) {
+	if (language === "less") return (0, _jesscss_less_parser_cst.parseLessDoc)(source);
+	if (language === "scss") return (0, _jesscss_scss_parser_cst.parseScssDoc)(source);
+	if (language === "jess") return (0, _jesscss_jess_parser_cst.parseJessDoc)(source);
+	return (0, _jesscss_css_parser.parseCssDoc)(source);
+}
+function parseDiagnosticsForDoc(doc, filePath) {
+	const diagnostics = [];
+	for (const error of doc.errors) diagnostics.push(diagnostic("parse/syntax-error", "error", "Unexpected syntax", Number(error.span.start), Number(error.span.end), filePath));
+	if (doc.unconsumedFrom !== null) diagnostics.push(diagnostic("parse/syntax-error", "error", "Unexpected input", doc.unconsumedFrom, doc.unconsumedFrom + 1, filePath));
+	return diagnostics;
+}
+function cstLintDiagnostics(root, source, language, metadata, filePath, tolerantSourceScan = true) {
+	const out = [];
+	const emitted = /* @__PURE__ */ new Set();
+	const cssData = metadataWithDefaults(metadata);
+	const dialectAtRules = DIALECT_AT_RULES[language];
+	const push = (code, severity, message, start, end) => {
+		const key = `${code}:${start}:${Math.max(start, end)}`;
+		if (emitted.has(key)) return;
+		emitted.add(key);
+		out.push(diagnostic(code, severity, message, start, end, filePath));
+	};
+	const visit = (node, base) => {
+		const start = absoluteStart(base, node);
+		const end = absoluteEnd(base, node);
+		if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) return;
+		const gt = node.grammarType;
+		if (RULESET_TYPES.has(gt)) {
+			const open = source.indexOf("{", start);
+			const close = source.lastIndexOf("}", end - 1);
+			if (open >= start && close > open && isWhitespaceOnly(source, open + 1, close)) push(LINT_CODES.emptyRules, "warning", "Do not use empty rulesets", start, end);
+		}
+		if (gt === "ScssAtRootFilter") push(LINT_CODES.unsupportedSassForm, "warning", "@at-root prelude/filter forms are not yet supported in Jess. Write the hoisted rules directly instead.", start, end);
+		if (gt === "ScssForward") {
+			const prelude = forwardPreludeOf(node, start, source);
+			if (prelude !== null) {
+				if (FORWARD_AS_PREFIX.test(prelude)) push(LINT_CODES.unsupportedSassForm, "warning", "@forward with \"as <prefix>-*\" prefixing is not supported in Jess and will never be. Use explicit namespacing instead.", start, end);
+				if (FORWARD_VISIBILITY.test(prelude)) push(LINT_CODES.unsupportedSassForm, "warning", "@forward with \"show\"/\"hide\" lists is not supported in Jess and will never be. Visibility control belongs to the module itself.", start, end);
+			}
+		}
+		if (ATRULE_TYPES.has(gt)) {
+			if (source.charCodeAt(start) === 64) {
+				const nameEnd = atRuleNameEnd(source, start, end);
+				if (nameEnd > start + 1) {
+					const rawName = source.slice(start + 1, nameEnd);
+					const name = rawName.toLowerCase();
+					if (!cssData.isKnownAtRule(name) && !dialectAtRules.has(name)) push(LINT_CODES.unknownAtRules, "warning", `Unknown at-rule @${rawName}`, start, nameEnd);
+				}
+			}
+		}
+		if (DIMENSION_TYPES.has(gt)) {
+			const slice = source.slice(start, end).trim();
+			const m = /^([+-]?(?:\d+\.?\d*|\.\d+))([a-z%]+)$/i.exec(slice);
+			if (m && Number(m[1]) === 0 && LENGTH_UNITS.has(m[2].toLowerCase())) push(LINT_CODES.zeroUnits, "hint", `The unit "${m[2]}" is unnecessary for a zero value`, start, end);
+		}
+		if (DECLARATION_TYPES.has(gt)) {
+			const slice = source.slice(start, end);
+			const colon = slice.indexOf(":");
+			const name = propNameOf(slice);
+			if (name.length > 0) {
+				const lower = name.toLowerCase();
+				if (!(lower.startsWith("--") || lower.startsWith("-") || lower.startsWith("$") || lower.startsWith("@") || lower.includes("#{") || lower.includes("@{") || lower.includes("${")) && !cssData.isKnownProperty(lower)) {
+					const nameStart = start + slice.indexOf(name);
+					push(LINT_CODES.unknownProperties, "warning", `Unknown property: '${name}'`, nameStart, nameStart + name.length);
+				}
+			}
+			if (colon >= 0) {
+				const valueStart = colon + 1;
+				const value = blankStrings(slice.slice(valueStart));
+				const hexRe = /#([0-9a-fA-F]+)/g;
+				let hm;
+				while ((hm = hexRe.exec(value)) !== null) {
+					const digits = hm[1].length;
+					if (digits !== 3 && digits !== 4 && digits !== 6 && digits !== 8) {
+						const hexStart = start + valueStart + hm.index;
+						push(LINT_CODES.hexColorLength, "error", `Hex color '${hm[0]}' does not have 3, 4, 6 or 8 digits`, hexStart, hexStart + hm[0].length);
+					}
+				}
+			}
+		}
+		let seenProps;
+		for (const child of node.children) {
+			if (!isCstNode$1(child)) continue;
+			if (DECLARATION_TYPES.has(child.grammarType)) {
+				const childStart = absoluteStart(start, child);
+				const childEnd = absoluteEnd(start, child);
+				const name = propNameOf(source.slice(childStart, childEnd));
+				if (name.length > 0 && !name.includes("#{") && !name.includes("@{") && !name.includes("${")) {
+					const key = name.toLowerCase();
+					seenProps ??= /* @__PURE__ */ new Map();
+					if (seenProps.has(key)) push(LINT_CODES.duplicateProperties, "warning", `Duplicate property '${name}'`, childStart, childEnd);
+					else seenProps.set(key, true);
+				}
+			}
+			visit(child, start);
+		}
+	};
+	visit(root, 0);
+	if (tolerantSourceScan) {
+		const sourceForHexScan = blankStringsAndComments(source);
+		const sourceHexRe = /#([0-9a-fA-F]+)/g;
+		let match;
+		while ((match = sourceHexRe.exec(sourceForHexScan)) !== null) {
+			const digits = match[1].length;
+			if (digits !== 3 && digits !== 4 && digits !== 6 && digits !== 8 && isDeclarationValueContext(sourceForHexScan, match.index)) push(LINT_CODES.hexColorLength, "error", `Hex color '${match[0]}' does not have 3, 4, 6 or 8 digits`, match.index, match.index + match[0].length);
+		}
+	}
+	return out;
+}
+function visitValueDimensions(value, source, start, end, visit) {
+	if (Array.isArray(value)) {
+		for (const child of value) visitValueDimensions(child, source, start, end, visit);
+		return;
+	}
+	if (!isAstRecord(value)) return;
+	if (value.type === "Dimension" && value.number === 0 && typeof value.unit === "string" && typeof value.src === "string") visit(value.src, value.unit, findValueSource(source, value.src, start, end));
+	for (const child of Object.values(value)) if (isAstRecord(child) || Array.isArray(child)) visitValueDimensions(child, source, start, end, visit);
+}
+function cssAstLintDiagnostics(source, metadata, filePath) {
+	let root;
+	try {
+		root = (0, _jesscss_css_parser.parse)(source);
+	} catch {
+		return null;
+	}
+	const out = [];
+	const cssData = metadataWithDefaults(metadata);
+	const push = (code, severity, message, start, end) => {
+		out.push(diagnostic(code, severity, message, start, end, filePath));
+	};
+	const visitBody = (children, bodySpan) => {
+		const seenProps = /* @__PURE__ */ new Map();
+		let cursor = bodySpan?.start ?? 0;
+		const bodyEnd = bodySpan?.end ?? source.length;
+		for (const child of children) {
+			if (!isAstRecord(child)) continue;
+			if (child.type === "Declaration" && typeof child.name === "string") {
+				const located = locateDeclaration(source, child.name, cursor, bodyEnd);
+				const nameStart = located?.nameStart ?? cursor;
+				const declarationEndValue = located?.declarationEnd ?? nameStart + child.name.length;
+				const key = child.name.toLowerCase();
+				if (!(key.startsWith("--") || key.startsWith("-")) && !cssData.isKnownProperty(key)) push(LINT_CODES.unknownProperties, "warning", `Unknown property: '${child.name}'`, nameStart, nameStart + child.name.length);
+				if (seenProps.has(key)) push(LINT_CODES.duplicateProperties, "warning", `Duplicate property '${child.name}'`, nameStart, declarationEndValue);
+				else seenProps.set(key, true);
+				visitValueDimensions(child.value, source, located?.valueStart ?? nameStart, declarationEndValue, (src, unit, span) => {
+					if (LENGTH_UNITS.has(unit.toLowerCase())) push(LINT_CODES.zeroUnits, "hint", `The unit "${unit}" is unnecessary for a zero value`, span?.start ?? nameStart, span?.end ?? nameStart + src.length);
+				});
+				cursor = declarationEndValue;
+			} else {
+				visitAstNode(child);
+				const span = (0, _jesscss_core_ast.sourceSpanOf)(child) ?? (0, _jesscss_core_ast.bodySpanOf)(child);
+				if (span && span.end > cursor) cursor = span.end;
+			}
+		}
+	};
+	const visitAstNode = (node) => {
+		if (!isAstRecord(node)) return;
+		if (node.type === "Rule") {
+			const bodySpan = (0, _jesscss_core_ast.bodySpanOf)(node);
+			const body = astChildrenOf(node, "body");
+			if (body.length === 0 && bodySpan && isWhitespaceOnly(source, bodySpan.start, bodySpan.end)) {
+				const span = (0, _jesscss_core_ast.sourceSpanOf)(node) ?? bodySpan;
+				push(LINT_CODES.emptyRules, "warning", "Do not use empty rulesets", span.start, span.end);
+			}
+			visitBody(body, bodySpan);
+			return;
+		}
+		if ((node.type === "AtRuleStatement" || node.type === "AtRuleBlock") && typeof node.name === "string") {
+			const rawName = node.name.startsWith("@") ? node.name.slice(1) : node.name;
+			const lower = rawName.toLowerCase();
+			const span = (0, _jesscss_core_ast.sourceSpanOf)(node);
+			if (span && !cssData.isKnownAtRule(lower)) push(LINT_CODES.unknownAtRules, "warning", `Unknown at-rule @${rawName}`, span.start, span.start + rawName.length + 1);
+			if (node.type === "AtRuleBlock") visitBody(astChildrenOf(node, "body"), (0, _jesscss_core_ast.bodySpanOf)(node));
+			return;
+		}
+		visitBody(astChildrenOf(node, "children"), void 0);
+	};
+	visitAstNode(root);
+	return out;
+}
+function collectTolerantDiagnostics(input) {
+	if (input.language === "css") {
+		const cssAstDiagnostics = cssAstLintDiagnostics(input.source, input.metadata, input.filePath);
+		if (cssAstDiagnostics !== null) return { diagnostics: cssAstDiagnostics };
+	}
+	const doc = parseDocForLanguage(input.source, input.language);
+	const needsTolerantSourceScan = doc.errors.length > 0 || doc.unconsumedFrom !== null;
+	const lintDiagnostics = doc.tree ? cstLintDiagnostics(doc.tree, input.source, input.language, input.metadata, input.filePath, needsTolerantSourceScan) : [];
+	return { diagnostics: [...parseDiagnosticsForDoc(doc, input.filePath), ...lintDiagnostics] };
+}
+//#endregion
+//#region src/cst-analysis.ts
+function isCstNode(c) {
+	return c._tag === "node";
+}
+const INDEX_CACHE = /* @__PURE__ */ new WeakMap();
+function buildCstIndex(root) {
+	const cached = INDEX_CACHE.get(root);
+	if (cached) return cached;
+	const out = [];
+	const abs = /* @__PURE__ */ new Map();
+	const walk = (node, base) => {
+		const s = base + Number(node.span.start);
+		const e = base + Number(node.span.end);
+		abs.set(node, [s, e]);
+		if (Number.isFinite(s) && Number.isFinite(e) && e >= s) out.push({
+			node,
+			start: s,
+			end: e
+		});
+		for (const child of node.children) if (isCstNode(child)) walk(child, s);
+	};
+	walk(root, 0);
+	out.sort((a, b) => a.start - b.start || a.end - b.end);
+	const index = {
+		nodes: out,
+		spanOf(node) {
+			const a = abs.get(node);
+			return a ? {
+				start: a[0],
+				end: a[1]
+			} : void 0;
+		},
+		findNodeAtOffset(offset) {
+			let best = null;
+			for (const entry of out) if (entry.start <= offset && offset <= entry.end) {
+				if (!best || entry.end - entry.start <= best.end - best.start) best = entry;
+			}
+			return best?.node ?? null;
+		}
+	};
+	INDEX_CACHE.set(root, index);
+	return index;
+}
+//#endregion
+exports.LINT_CODES = LINT_CODES;
+exports.buildCstIndex = buildCstIndex;
+exports.collectTolerantDiagnostics = collectTolerantDiagnostics;
+exports.cstLintDiagnostics = cstLintDiagnostics;
+exports.defaultCssDiagnosticMetadata = defaultCssDiagnosticMetadata;
+exports.parseDocForLanguage = parseDocForLanguage;

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export { LINT_CODES, collectTolerantDiagnostics, cstLintDiagnostics, parseDocForLanguage } from './tolerant-cst.js';
+export { buildCstIndex, type CstIndex, type CstIndexEntry } from './cst-analysis.js';
+export { defaultCssDiagnosticMetadata } from './metadata.js';
+export type { CollectDiagnosticsInput, CollectDiagnosticsResult, CssDiagnosticMetadata, DiagnosticSeverityName, JessLanguage, SourceDiagnostic } from './types.js';

package/lib/index.js

@@ -0,0 +1,498 @@
+import { createRequire } from "node:module";
+import { parse, parseCssDoc } from "@jesscss/css-parser";
+import { parseJessDoc } from "@jesscss/jess-parser/cst";
+import { parseLessDoc } from "@jesscss/less-parser/cst";
+import { parseScssDoc } from "@jesscss/scss-parser/cst";
+import { bodySpanOf, sourceSpanOf } from "@jesscss/core/ast";
+//#region src/metadata.ts
+const require = createRequire(import.meta.url);
+const webCssData = require("@vscode/web-custom-data/data/browsers.css-data.json");
+const knownCssProperties = require("known-css-properties");
+function ownValue(value, key) {
+	if (typeof value !== "object" || value === null) return;
+	return Object.getOwnPropertyDescriptor(value, key)?.value;
+}
+function arrayField(value, key) {
+	const field = ownValue(value, key);
+	return Array.isArray(field) ? field : [];
+}
+function stringField(value, key) {
+	const field = ownValue(value, key);
+	return typeof field === "string" ? field : void 0;
+}
+const cssProperties = arrayField(knownCssProperties, "all").filter((value) => typeof value === "string");
+const CSS_PROPERTY_SET = new Set(cssProperties.map((property) => property.toLowerCase()));
+const WEB_PROPERTY_SET = new Set(arrayField(webCssData, "properties").map((property) => stringField(property, "name")?.toLowerCase()).filter((name) => typeof name === "string" && name.length > 0));
+const AT_RULE_SET = new Set(arrayField(webCssData, "atDirectives").map((rule) => stringField(rule, "name")?.toLowerCase()).filter((name) => typeof name === "string" && name.length > 0));
+const defaultCssDiagnosticMetadata = {
+	isKnownProperty(name) {
+		const lower = name.toLowerCase();
+		return CSS_PROPERTY_SET.has(lower) || WEB_PROPERTY_SET.has(lower);
+	},
+	isKnownAtRule(name) {
+		const lower = name.startsWith("@") ? name.toLowerCase() : `@${name.toLowerCase()}`;
+		return AT_RULE_SET.has(lower);
+	}
+};
+//#endregion
+//#region src/tolerant-cst.ts
+const LINT_CODES = {
+	emptyRules: "lint/empty-rules",
+	unknownProperties: "lint/unknown-property",
+	unknownAtRules: "lint/unknown-at-rule",
+	duplicateProperties: "lint/duplicate-property",
+	hexColorLength: "lint/hex-color-length",
+	zeroUnits: "lint/zero-units",
+	unsupportedSassForm: "unsupported/sass-form"
+};
+const LENGTH_UNITS = new Set([
+	"px",
+	"em",
+	"rem",
+	"ex",
+	"ch",
+	"cap",
+	"ic",
+	"lh",
+	"rlh",
+	"vw",
+	"vh",
+	"vi",
+	"vb",
+	"vmin",
+	"vmax",
+	"cm",
+	"mm",
+	"q",
+	"in",
+	"pt",
+	"pc"
+]);
+const DIALECT_AT_RULES = {
+	css: /* @__PURE__ */ new Set(),
+	less: new Set(["plugin"]),
+	scss: new Set([
+		"mixin",
+		"include",
+		"function",
+		"return",
+		"if",
+		"else",
+		"each",
+		"for",
+		"while",
+		"use",
+		"forward",
+		"content",
+		"extend",
+		"at-root",
+		"debug",
+		"warn",
+		"error"
+	]),
+	jess: new Set([
+		"mixin",
+		"include",
+		"function",
+		"return",
+		"if",
+		"else",
+		"each",
+		"for",
+		"while",
+		"use",
+		"forward",
+		"from",
+		"compose",
+		"content",
+		"extend",
+		"at-root",
+		"debug",
+		"warn",
+		"error"
+	])
+};
+const RULESET_TYPES = new Set([
+	"Ruleset",
+	"DirectScssRule",
+	"DirectJessRule"
+]);
+const ATRULE_TYPES = new Set([
+	"AtRuleBlock",
+	"AtRuleStatement",
+	"UnknownAtRuleBlock",
+	"QueryAtRuleBlock",
+	"OpaqueAtRuleBlock"
+]);
+const DECLARATION_TYPES = new Set([
+	"Declaration",
+	"DirectScssDeclaration",
+	"DirectJessDeclaration"
+]);
+const DIMENSION_TYPES = new Set([
+	"Dimension",
+	"DirectScssDimension",
+	"DirectJessDimension"
+]);
+const FORWARD_AS_PREFIX = /\bas\s+\S+-\*/;
+const FORWARD_VISIBILITY = /\b(show|hide)\b/;
+function isCstNode$1(c) {
+	return c._tag === "node";
+}
+function isAstRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function astChildrenOf(value, key) {
+	if (!isAstRecord(value)) return [];
+	const child = value[key];
+	return Array.isArray(child) ? child : [];
+}
+function forwardPreludeOf(node, nodeStart, src) {
+	let afterPath = false;
+	for (const child of node.children) {
+		if (isCstNode$1(child)) {
+			if (child.grammarType === "Quoted") afterPath = true;
+			continue;
+		}
+		if (!afterPath) continue;
+		const normalized = src.slice(nodeStart + Number(child.span.start), nodeStart + Number(child.span.end)).replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n\r]*/g, " ").replace(/\s+/g, " ").trim();
+		if (normalized === ";" || normalized.toLowerCase() === "with") continue;
+		return normalized;
+	}
+	return null;
+}
+function propNameOf(slice) {
+	const colon = slice.indexOf(":");
+	return (colon >= 0 ? slice.slice(0, colon) : slice).trim();
+}
+function absoluteStart(base, node) {
+	return base + Number(node.span.start);
+}
+function absoluteEnd(base, node) {
+	return base + Number(node.span.end);
+}
+function isWhitespaceOnly(source, start, end) {
+	for (let i = start; i < end; i++) {
+		const code = source.charCodeAt(i);
+		if (code !== 9 && code !== 10 && code !== 12 && code !== 13 && code !== 32) return false;
+	}
+	return true;
+}
+function atRuleNameEnd(source, start, end) {
+	let i = start + 1;
+	while (i < end) {
+		const code = source.charCodeAt(i);
+		if (!(code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 45 || code === 95)) break;
+		i++;
+	}
+	return i;
+}
+function lineCommentStartBetween(source, start, end) {
+	for (let i = start; i < end - 1; i++) if (source.charCodeAt(i) === 47 && source.charCodeAt(i + 1) === 47) return i;
+	return -1;
+}
+function declarationEnd(source, start, blockEnd) {
+	const semi = source.indexOf(";", start);
+	if (semi < 0 || semi > blockEnd) return blockEnd;
+	return semi + 1;
+}
+function locateDeclaration(source, name, cursor, blockEnd) {
+	let search = cursor;
+	while (search < blockEnd) {
+		const nameStart = source.indexOf(name, search);
+		if (nameStart < 0 || nameStart >= blockEnd) return null;
+		const colon = source.indexOf(":", nameStart + name.length);
+		if (colon < 0 || colon >= blockEnd) return null;
+		const lineComment = lineCommentStartBetween(source, nameStart + name.length, colon);
+		if (lineComment < 0) return {
+			nameStart,
+			declarationEnd: declarationEnd(source, colon + 1, blockEnd),
+			valueStart: colon + 1
+		};
+		search = lineComment + 2;
+	}
+	return null;
+}
+function findValueSource(source, src, start, end) {
+	if (src.length === 0) return;
+	const valueStart = source.indexOf(src, start);
+	if (valueStart < 0 || valueStart >= end) return;
+	return {
+		start: valueStart,
+		end: valueStart + src.length
+	};
+}
+function blankStrings(value) {
+	return value.replace(/"[^"]*"|'[^']*'/g, (m) => " ".repeat(m.length));
+}
+function blankStringsAndComments(value) {
+	return value.replace(/\/\*[\s\S]*?\*\/|\/\/[^\n\r]*|"[^"]*"|'[^']*'/g, (m) => " ".repeat(m.length));
+}
+function isDeclarationValueContext(source, offset) {
+	const lastBlockOpen = source.lastIndexOf("{", offset);
+	const lastBlockClose = source.lastIndexOf("}", offset);
+	if (lastBlockOpen < 0 || lastBlockClose > lastBlockOpen) return false;
+	const lastStatement = Math.max(lastBlockOpen, source.lastIndexOf(";", offset));
+	return source.lastIndexOf(":", offset) > lastStatement;
+}
+function diagnostic(code, defaultSeverity, message, start, end, filePath) {
+	return {
+		code,
+		phase: code.startsWith("parse/") ? "parse" : "lint",
+		source: "jess",
+		message,
+		reason: "",
+		fix: "",
+		defaultSeverity,
+		filePath,
+		start,
+		end: Math.max(start, end)
+	};
+}
+function metadataWithDefaults(metadata) {
+	return {
+		isKnownProperty(name) {
+			return metadata?.isKnownProperty?.(name) ?? defaultCssDiagnosticMetadata.isKnownProperty(name);
+		},
+		isKnownAtRule(name) {
+			return metadata?.isKnownAtRule?.(name) ?? defaultCssDiagnosticMetadata.isKnownAtRule(name);
+		}
+	};
+}
+function parseDocForLanguage(source, language) {
+	if (language === "less") return parseLessDoc(source);
+	if (language === "scss") return parseScssDoc(source);
+	if (language === "jess") return parseJessDoc(source);
+	return parseCssDoc(source);
+}
+function parseDiagnosticsForDoc(doc, filePath) {
+	const diagnostics = [];
+	for (const error of doc.errors) diagnostics.push(diagnostic("parse/syntax-error", "error", "Unexpected syntax", Number(error.span.start), Number(error.span.end), filePath));
+	if (doc.unconsumedFrom !== null) diagnostics.push(diagnostic("parse/syntax-error", "error", "Unexpected input", doc.unconsumedFrom, doc.unconsumedFrom + 1, filePath));
+	return diagnostics;
+}
+function cstLintDiagnostics(root, source, language, metadata, filePath, tolerantSourceScan = true) {
+	const out = [];
+	const emitted = /* @__PURE__ */ new Set();
+	const cssData = metadataWithDefaults(metadata);
+	const dialectAtRules = DIALECT_AT_RULES[language];
+	const push = (code, severity, message, start, end) => {
+		const key = `${code}:${start}:${Math.max(start, end)}`;
+		if (emitted.has(key)) return;
+		emitted.add(key);
+		out.push(diagnostic(code, severity, message, start, end, filePath));
+	};
+	const visit = (node, base) => {
+		const start = absoluteStart(base, node);
+		const end = absoluteEnd(base, node);
+		if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) return;
+		const gt = node.grammarType;
+		if (RULESET_TYPES.has(gt)) {
+			const open = source.indexOf("{", start);
+			const close = source.lastIndexOf("}", end - 1);
+			if (open >= start && close > open && isWhitespaceOnly(source, open + 1, close)) push(LINT_CODES.emptyRules, "warning", "Do not use empty rulesets", start, end);
+		}
+		if (gt === "ScssAtRootFilter") push(LINT_CODES.unsupportedSassForm, "warning", "@at-root prelude/filter forms are not yet supported in Jess. Write the hoisted rules directly instead.", start, end);
+		if (gt === "ScssForward") {
+			const prelude = forwardPreludeOf(node, start, source);
+			if (prelude !== null) {
+				if (FORWARD_AS_PREFIX.test(prelude)) push(LINT_CODES.unsupportedSassForm, "warning", "@forward with \"as <prefix>-*\" prefixing is not supported in Jess and will never be. Use explicit namespacing instead.", start, end);
+				if (FORWARD_VISIBILITY.test(prelude)) push(LINT_CODES.unsupportedSassForm, "warning", "@forward with \"show\"/\"hide\" lists is not supported in Jess and will never be. Visibility control belongs to the module itself.", start, end);
+			}
+		}
+		if (ATRULE_TYPES.has(gt)) {
+			if (source.charCodeAt(start) === 64) {
+				const nameEnd = atRuleNameEnd(source, start, end);
+				if (nameEnd > start + 1) {
+					const rawName = source.slice(start + 1, nameEnd);
+					const name = rawName.toLowerCase();
+					if (!cssData.isKnownAtRule(name) && !dialectAtRules.has(name)) push(LINT_CODES.unknownAtRules, "warning", `Unknown at-rule @${rawName}`, start, nameEnd);
+				}
+			}
+		}
+		if (DIMENSION_TYPES.has(gt)) {
+			const slice = source.slice(start, end).trim();
+			const m = /^([+-]?(?:\d+\.?\d*|\.\d+))([a-z%]+)$/i.exec(slice);
+			if (m && Number(m[1]) === 0 && LENGTH_UNITS.has(m[2].toLowerCase())) push(LINT_CODES.zeroUnits, "hint", `The unit "${m[2]}" is unnecessary for a zero value`, start, end);
+		}
+		if (DECLARATION_TYPES.has(gt)) {
+			const slice = source.slice(start, end);
+			const colon = slice.indexOf(":");
+			const name = propNameOf(slice);
+			if (name.length > 0) {
+				const lower = name.toLowerCase();
+				if (!(lower.startsWith("--") || lower.startsWith("-") || lower.startsWith("$") || lower.startsWith("@") || lower.includes("#{") || lower.includes("@{") || lower.includes("${")) && !cssData.isKnownProperty(lower)) {
+					const nameStart = start + slice.indexOf(name);
+					push(LINT_CODES.unknownProperties, "warning", `Unknown property: '${name}'`, nameStart, nameStart + name.length);
+				}
+			}
+			if (colon >= 0) {
+				const valueStart = colon + 1;
+				const value = blankStrings(slice.slice(valueStart));
+				const hexRe = /#([0-9a-fA-F]+)/g;
+				let hm;
+				while ((hm = hexRe.exec(value)) !== null) {
+					const digits = hm[1].length;
+					if (digits !== 3 && digits !== 4 && digits !== 6 && digits !== 8) {
+						const hexStart = start + valueStart + hm.index;
+						push(LINT_CODES.hexColorLength, "error", `Hex color '${hm[0]}' does not have 3, 4, 6 or 8 digits`, hexStart, hexStart + hm[0].length);
+					}
+				}
+			}
+		}
+		let seenProps;
+		for (const child of node.children) {
+			if (!isCstNode$1(child)) continue;
+			if (DECLARATION_TYPES.has(child.grammarType)) {
+				const childStart = absoluteStart(start, child);
+				const childEnd = absoluteEnd(start, child);
+				const name = propNameOf(source.slice(childStart, childEnd));
+				if (name.length > 0 && !name.includes("#{") && !name.includes("@{") && !name.includes("${")) {
+					const key = name.toLowerCase();
+					seenProps ??= /* @__PURE__ */ new Map();
+					if (seenProps.has(key)) push(LINT_CODES.duplicateProperties, "warning", `Duplicate property '${name}'`, childStart, childEnd);
+					else seenProps.set(key, true);
+				}
+			}
+			visit(child, start);
+		}
+	};
+	visit(root, 0);
+	if (tolerantSourceScan) {
+		const sourceForHexScan = blankStringsAndComments(source);
+		const sourceHexRe = /#([0-9a-fA-F]+)/g;
+		let match;
+		while ((match = sourceHexRe.exec(sourceForHexScan)) !== null) {
+			const digits = match[1].length;
+			if (digits !== 3 && digits !== 4 && digits !== 6 && digits !== 8 && isDeclarationValueContext(sourceForHexScan, match.index)) push(LINT_CODES.hexColorLength, "error", `Hex color '${match[0]}' does not have 3, 4, 6 or 8 digits`, match.index, match.index + match[0].length);
+		}
+	}
+	return out;
+}
+function visitValueDimensions(value, source, start, end, visit) {
+	if (Array.isArray(value)) {
+		for (const child of value) visitValueDimensions(child, source, start, end, visit);
+		return;
+	}
+	if (!isAstRecord(value)) return;
+	if (value.type === "Dimension" && value.number === 0 && typeof value.unit === "string" && typeof value.src === "string") visit(value.src, value.unit, findValueSource(source, value.src, start, end));
+	for (const child of Object.values(value)) if (isAstRecord(child) || Array.isArray(child)) visitValueDimensions(child, source, start, end, visit);
+}
+function cssAstLintDiagnostics(source, metadata, filePath) {
+	let root;
+	try {
+		root = parse(source);
+	} catch {
+		return null;
+	}
+	const out = [];
+	const cssData = metadataWithDefaults(metadata);
+	const push = (code, severity, message, start, end) => {
+		out.push(diagnostic(code, severity, message, start, end, filePath));
+	};
+	const visitBody = (children, bodySpan) => {
+		const seenProps = /* @__PURE__ */ new Map();
+		let cursor = bodySpan?.start ?? 0;
+		const bodyEnd = bodySpan?.end ?? source.length;
+		for (const child of children) {
+			if (!isAstRecord(child)) continue;
+			if (child.type === "Declaration" && typeof child.name === "string") {
+				const located = locateDeclaration(source, child.name, cursor, bodyEnd);
+				const nameStart = located?.nameStart ?? cursor;
+				const declarationEndValue = located?.declarationEnd ?? nameStart + child.name.length;
+				const key = child.name.toLowerCase();
+				if (!(key.startsWith("--") || key.startsWith("-")) && !cssData.isKnownProperty(key)) push(LINT_CODES.unknownProperties, "warning", `Unknown property: '${child.name}'`, nameStart, nameStart + child.name.length);
+				if (seenProps.has(key)) push(LINT_CODES.duplicateProperties, "warning", `Duplicate property '${child.name}'`, nameStart, declarationEndValue);
+				else seenProps.set(key, true);
+				visitValueDimensions(child.value, source, located?.valueStart ?? nameStart, declarationEndValue, (src, unit, span) => {
+					if (LENGTH_UNITS.has(unit.toLowerCase())) push(LINT_CODES.zeroUnits, "hint", `The unit "${unit}" is unnecessary for a zero value`, span?.start ?? nameStart, span?.end ?? nameStart + src.length);
+				});
+				cursor = declarationEndValue;
+			} else {
+				visitAstNode(child);
+				const span = sourceSpanOf(child) ?? bodySpanOf(child);
+				if (span && span.end > cursor) cursor = span.end;
+			}
+		}
+	};
+	const visitAstNode = (node) => {
+		if (!isAstRecord(node)) return;
+		if (node.type === "Rule") {
+			const bodySpan = bodySpanOf(node);
+			const body = astChildrenOf(node, "body");
+			if (body.length === 0 && bodySpan && isWhitespaceOnly(source, bodySpan.start, bodySpan.end)) {
+				const span = sourceSpanOf(node) ?? bodySpan;
+				push(LINT_CODES.emptyRules, "warning", "Do not use empty rulesets", span.start, span.end);
+			}
+			visitBody(body, bodySpan);
+			return;
+		}
+		if ((node.type === "AtRuleStatement" || node.type === "AtRuleBlock") && typeof node.name === "string") {
+			const rawName = node.name.startsWith("@") ? node.name.slice(1) : node.name;
+			const lower = rawName.toLowerCase();
+			const span = sourceSpanOf(node);
+			if (span && !cssData.isKnownAtRule(lower)) push(LINT_CODES.unknownAtRules, "warning", `Unknown at-rule @${rawName}`, span.start, span.start + rawName.length + 1);
+			if (node.type === "AtRuleBlock") visitBody(astChildrenOf(node, "body"), bodySpanOf(node));
+			return;
+		}
+		visitBody(astChildrenOf(node, "children"), void 0);
+	};
+	visitAstNode(root);
+	return out;
+}
+function collectTolerantDiagnostics(input) {
+	if (input.language === "css") {
+		const cssAstDiagnostics = cssAstLintDiagnostics(input.source, input.metadata, input.filePath);
+		if (cssAstDiagnostics !== null) return { diagnostics: cssAstDiagnostics };
+	}
+	const doc = parseDocForLanguage(input.source, input.language);
+	const needsTolerantSourceScan = doc.errors.length > 0 || doc.unconsumedFrom !== null;
+	const lintDiagnostics = doc.tree ? cstLintDiagnostics(doc.tree, input.source, input.language, input.metadata, input.filePath, needsTolerantSourceScan) : [];
+	return { diagnostics: [...parseDiagnosticsForDoc(doc, input.filePath), ...lintDiagnostics] };
+}
+//#endregion
+//#region src/cst-analysis.ts
+function isCstNode(c) {
+	return c._tag === "node";
+}
+const INDEX_CACHE = /* @__PURE__ */ new WeakMap();
+function buildCstIndex(root) {
+	const cached = INDEX_CACHE.get(root);
+	if (cached) return cached;
+	const out = [];
+	const abs = /* @__PURE__ */ new Map();
+	const walk = (node, base) => {
+		const s = base + Number(node.span.start);
+		const e = base + Number(node.span.end);
+		abs.set(node, [s, e]);
+		if (Number.isFinite(s) && Number.isFinite(e) && e >= s) out.push({
+			node,
+			start: s,
+			end: e
+		});
+		for (const child of node.children) if (isCstNode(child)) walk(child, s);
+	};
+	walk(root, 0);
+	out.sort((a, b) => a.start - b.start || a.end - b.end);
+	const index = {
+		nodes: out,
+		spanOf(node) {
+			const a = abs.get(node);
+			return a ? {
+				start: a[0],
+				end: a[1]
+			} : void 0;
+		},
+		findNodeAtOffset(offset) {
+			let best = null;
+			for (const entry of out) if (entry.start <= offset && offset <= entry.end) {
+				if (!best || entry.end - entry.start <= best.end - best.start) best = entry;
+			}
+			return best?.node ?? null;
+		}
+	};
+	INDEX_CACHE.set(root, index);
+	return index;
+}
+//#endregion
+export { LINT_CODES, buildCstIndex, collectTolerantDiagnostics, cstLintDiagnostics, defaultCssDiagnosticMetadata, parseDocForLanguage };

package/lib/metadata.d.ts

@@ -0,0 +1,2 @@
+import type { CssDiagnosticMetadata } from './types.js';
+export declare const defaultCssDiagnosticMetadata: CssDiagnosticMetadata;

package/lib/tolerant-cst.d.ts

@@ -0,0 +1,15 @@
+import { type CssCstNode, type ParseDoc } from '@jesscss/css-parser';
+import type { CollectDiagnosticsInput, CollectDiagnosticsResult, CssDiagnosticMetadata, JessLanguage, SourceDiagnostic } from './types.js';
+export declare const LINT_CODES: {
+    readonly emptyRules: "lint/empty-rules";
+    readonly unknownProperties: "lint/unknown-property";
+    readonly unknownAtRules: "lint/unknown-at-rule";
+    readonly duplicateProperties: "lint/duplicate-property";
+    readonly hexColorLength: "lint/hex-color-length";
+    readonly zeroUnits: "lint/zero-units";
+    readonly unsupportedSassForm: "unsupported/sass-form";
+};
+export declare function parseDocForLanguage(source: string, language: JessLanguage): ParseDoc<CssCstNode>;
+export declare function parseDiagnosticsForDoc(doc: ParseDoc<CssCstNode>, filePath?: string): SourceDiagnostic[];
+export declare function cstLintDiagnostics(root: CssCstNode, source: string, language: JessLanguage, metadata?: Partial<CssDiagnosticMetadata>, filePath?: string, tolerantSourceScan?: boolean): SourceDiagnostic[];
+export declare function collectTolerantDiagnostics(input: CollectDiagnosticsInput): CollectDiagnosticsResult;

package/lib/types.d.ts

@@ -0,0 +1,28 @@
+import type { Phase } from '@jesscss/core';
+export type JessLanguage = 'css' | 'less' | 'scss' | 'jess';
+export type DiagnosticSeverityName = 'error' | 'warning' | 'information' | 'hint';
+export interface SourceDiagnostic {
+    readonly code: string;
+    readonly phase: Phase;
+    readonly source: 'jess';
+    readonly message: string;
+    readonly reason: string;
+    readonly fix: string;
+    readonly defaultSeverity: DiagnosticSeverityName;
+    readonly filePath?: string;
+    readonly start: number;
+    readonly end: number;
+}
+export interface CssDiagnosticMetadata {
+    isKnownProperty(name: string): boolean;
+    isKnownAtRule(name: string): boolean;
+}
+export interface CollectDiagnosticsInput {
+    readonly source: string;
+    readonly language: JessLanguage;
+    readonly filePath?: string;
+    readonly metadata?: Partial<CssDiagnosticMetadata>;
+}
+export interface CollectDiagnosticsResult {
+    readonly diagnostics: readonly SourceDiagnostic[];
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@jesscss/diagnostics-core",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Shared Jess stylesheet diagnostics for editor and CLI surfaces",
+  "version": "2.0.0-alpha.11",
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "main": "lib/index.cjs",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "@vscode/web-custom-data": "^0.6.2",
+    "known-css-properties": "~0.37.0",
+    "@jesscss/core": "2.0.0-alpha.11",
+    "@jesscss/css-parser": "2.0.0-alpha.11",
+    "@jesscss/jess-parser": "2.0.0-alpha.11",
+    "@jesscss/less-parser": "2.0.0-alpha.11",
+    "@jesscss/scss-parser": "2.0.0-alpha.11"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "~5.8.2",
+    "vitest": "^4.1.0"
+  },
+  "author": "Matthew Dean <matthew-dean@users.noreply.github.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jesscss/jess/issues"
+  },
+  "homepage": "https://github.com/jesscss/jess#readme",
+  "module": "lib/index.js",
+  "scripts": {
+    "build": "pnpm compile",
+    "compile": "tsdown --tsconfig tsconfig.build.json --no-dts && tsc -p tsconfig.build.json --emitDeclarationOnly --noCheck",
+    "test": "vitest --watch=false",
+    "lint": "eslint '**/*.{js,ts}'"
+  }
+}