@jesscss/less-parser 2.0.0-alpha.11 → 2.0.0-alpha.13

package/README.md

@@ -9,11 +9,15 @@ The Less grammar, layered on the CSS base parser, with core-free CST entry point
 
 ## What it is
 
-The Less grammar is the shared CSS grammar plus a Less delta:
-`lessGrammar = compose([cssGrammar, <Less delta>])`. It adds `@variable` /
-`@{interpolation}`, mixins, and the rest of Less on top of the spec-aligned CSS
-base in [`@jesscss/css-parser`](https://www.npmjs.com/package/@jesscss/css-parser),
-built on [parseman](https://www.npmjs.com/package/parseman) — **the fastest
+The Less grammar extends the spec-aligned CSS base in
+[`@jesscss/css-parser`](https://www.npmjs.com/package/@jesscss/css-parser):
+unchanged CSS structure remains CSS-owned, and Less changes only the smallest
+child, value slot, or reference its syntax requires. It adds `@variable` /
+`@{interpolation}`, mixins, and the rest of Less. Parseman currently compiles
+the CSS and Less host factories from shared recognition artifacts rather than
+literally composing a terminal `cssGrammar` artifact; that macro boundary does
+not relax the ownership rule. It is built on
+[parseman](https://www.npmjs.com/package/parseman) — **the fastest
 general-purpose JavaScript parser** in its
 [published benchmarks](https://matthew-dean.github.io/parseman/guide/benchmarks)
 (see `@jesscss/css-parser` for figures and engineering details). It is the parser
@@ -73,9 +77,49 @@ Pass a different `startRule` (any capitalized grammar rule, e.g. `'SelectorList'
 | --- | --- | --- |
 | `@jesscss/less-parser/cst` | `parseLessCst` | Core-free parse of a Less string to a CST. |
 | `@jesscss/less-parser/cst` | `LessCstNode`, `LessCstLeaf`, `LessCstError`, `LessCstChild`, `LessCstParseResult`, `LessCstType` (types) | CST type definitions (aliases of the shared `@jesscss/css-parser/cst` types). |
-| `@jesscss/less-parser/grammar` | `lessGrammar` | The compiled Less grammar (a rule map). Extend it with `compose()` or drive it directly with parseman's `run`. |
+| `@jesscss/less-parser/grammar` | `lessGrammar` | The compiled Less AST grammar (a rule map). Extend it with `compose()` or drive it directly with parseman's `run`. See the variant table below. |
 | `@jesscss/less-parser` (`.`) | `parse` | Parse Less directly to canonical AST v2 `Stylesheet`. It does not load the CST grammar. |
 
+### Line-aware entries
+
+`parse` and the CST parsers come in two bindings, one per compiled table, so an
+entry never loads a table it does not parse with:
+
+| Entry | Export | Tree | Positions |
+| --- | --- | --- | --- |
+| `@jesscss/less-parser` (`.`) | `parse` | AST | no |
+| `@jesscss/less-parser/positions` | `parse` | AST | yes |
+| `@jesscss/less-parser/cst` | `parseLessCst`, `parseLessDoc` | CST | no |
+| `@jesscss/less-parser/cst/positions` | `parseLessCst`, `parseLessDoc` | CST | yes |
+
+The `/positions` entries export the same names bound to the line-aware table:
+switching is a change of import specifier, not of call site.
+
+### Choosing a grammar build
+
+Each compiled grammar is a standalone multi-megabyte artifact, so the four
+variants ship as four separate files. Importing one never loads the others.
+Pick by the two questions the subpath name answers — which tree, and whether
+source positions are tracked:
+
+| Subpath | Export | Tree | Positions |
+| --- | --- | --- | --- |
+| `@jesscss/less-parser/grammar/ast` | `lessGrammar` | AST | no |
+| `@jesscss/less-parser/grammar/ast/positions` | `lessPositionsGrammar` | AST | yes |
+| `@jesscss/less-parser/grammar/cst` | `lessCstGrammar` | CST | no |
+| `@jesscss/less-parser/grammar/cst/positions` | `lessCstPositionsGrammar` | CST | yes |
+
+`@jesscss/less-parser/grammar` is an alias for `/grammar/ast`, the build the
+shipping `parse()` route uses. It is not a barrel: it exposes the AST variant
+only, so importing it cannot pull the other three in.
+
+The positions variants set `startLine`/`startColumn` on every span. There is no
+`trackLines` option: an option would force one module to name both tables, and
+Node executes every module it statically imports, so the choice is which entry
+you import. Error tolerance is not a property of a build — the CST runner
+collects `result.errors` on either CST variant.
+
+
 ## Default CST shape
 
 The CST is parseman's, produced by the shared `cssCstBuildHost`. Three kinds of node:
@@ -95,7 +139,7 @@ Parsing `@c: red;\n.foo { color: @c; }` yields (abridged):
     { "_tag": "node", "type": "VarDeclaration", "grammarType": "VarDeclaration", "span": { "start": 0, "end": 8 },
       "children": [
         { "_tag": "leaf", "value": "@c" }, { "_tag": "leaf", "value": ":" },
-        { "_tag": "node", "type": "NamedColor", "grammarType": "NamedColor",
+        { "_tag": "node", "type": "Keyword", "grammarType": "Keyword",
           "children": [ { "_tag": "leaf", "value": "red" } ] },
         { "_tag": "leaf", "value": ";" }
       ] },
@@ -115,9 +159,9 @@ Parsing `@c: red;\n.foo { color: @c; }` yields (abridged):
 }
 ```
 
-Note the Less-specific nodes: a top-level `@c: …` becomes a `VarDeclaration`, a `@c` value becomes a `Reference`, and the color keyword `red` parses as `NamedColor` (the CSS-only grammar has no such rule — see `@jesscss/css-parser`).
+Note the Less-specific nodes: a top-level `@c: …` becomes a `VarDeclaration`, and a `@c` value becomes a `Reference`. The color keyword `red` parses as a plain `Keyword` — the same node every dialect uses (NamedColor→Keyword convergence); its colour-ness is resolved only when it is operated on.
 
-Pass `{ collapse: true }` to unwrap single-child wrapper types (`Reference`, `NamedColor`, `InterpolatedSelector`) into their child.
+Pass `{ collapse: true }` to unwrap single-child wrapper types (`Reference`, `InterpolatedSelector`) into their child.
 
 ### Name-independent condition arguments
 
@@ -133,7 +177,7 @@ The grammar is decoupled from the tree it builds. Every capitalized rule is a pa
 import { run } from 'parseman'
 import { lessGrammar } from '@jesscss/less-parser/grammar'
 
-const myHost = (type, children, fields, span) => ({ type, span, children: children.filter(Boolean) })
+const myHost = (type, children, fields, span) => ({ type, span, rules: children.filter(Boolean) })
 
 const result = run(lessGrammar.Stylesheet, '@c: red; .foo { color: @c; }', {
   build: myHost,
@@ -148,7 +192,7 @@ The `BuildHost` signature (from parseman):
 ```ts
 type BuildHost = (
   type: string,
-  children: readonly unknown[],
+  rules: readonly unknown[],
   fields: FieldMap | undefined,
   span: { start: number; end: number },
   rawChildren: readonly unknown[],

package/lib/chunks/parse-with.cjs

@@ -0,0 +1,172 @@
+const require_parse_error = require("../parse-error.cjs");
+const require_trivia_labels = require("./trivia-labels.cjs");
+let parseman = require("parseman");
+let _jesscss_core_diagnostics = require("@jesscss/core/diagnostics");
+let _jesscss_core_ast = require("@jesscss/core/ast");
+Object.freeze({ mathMode: "parens-division" });
+//#endregion
+//#region src/parse-with.ts
+/**
+* The `parse()`/`safeParse()` bodies, shared by the two AST entries.
+*
+* The grammar table arrives as an argument rather than being chosen from a
+* boolean inside this module: Node does not tree-shake, so a module that names
+* both compiled tables executes both at load time. Each entry imports exactly
+* the one table it parses with, and this module imports none.
+*/
+const EMPTY_LAYOUT = Object.freeze([]);
+const SPACE_LAYOUT = Object.freeze([" "]);
+function isStylesheet(value) {
+	return typeof value === "object" && value !== null && "type" in value && value.type === "Stylesheet" && "rules" in value && Array.isArray(value.rules);
+}
+/**
+* The one currently typed Less import-query feature is a `Block` containing a
+* colon `Operation`. Its right operand already carries a parser source start,
+* so an exact trivia lookup can retain the comment boundary without walking or
+* classifying source bytes. Opaque tail forms keep their existing byte owner.
+*/
+function retainTypedImportTailTrivia(statement, trivia) {
+	const prelude = statement.prelude;
+	if (prelude?.type !== "Sequence") return false;
+	const tail = prelude.parts[1];
+	if (tail?.type !== "Block" || (0, _jesscss_core_ast.isValueSlotArray)(tail.value) || tail.value.type !== "Operation" || tail.value.operator !== ":") return false;
+	const rightStart = (0, _jesscss_core_ast.sourceStartOf)(tail.value.right);
+	if (rightStart === _jesscss_core_ast.NO_SPAN) return false;
+	const between = trivia.lookup(rightStart, "before");
+	if (between === void 0) return false;
+	(0, _jesscss_core_ast.withValueBoundaryTrivia)(tail.value, EMPTY_LAYOUT, {
+		before: null,
+		between,
+		after: null
+	});
+	return true;
+}
+/**
+* Project only root-hoisted CSS-import boundaries through the canonical trivia
+* adapter. The grammar carries the statement edges and typed-tail start in
+* fixed private Smi slots, so each lookup names an exact parser-owned boundary
+* and public source provenance, AST/CST shape, and bytes remain unchanged.
+*/
+function retainRootImportBoundaryTrivia(document, trivia) {
+	if (trivia === void 0) return;
+	for (const rule of document.rules) {
+		if (rule.type !== "AtRuleStatement") continue;
+		const start = (0, _jesscss_core_ast.importSourceStartOf)(rule);
+		if (start === _jesscss_core_ast.NO_SPAN) continue;
+		const tailStart = (0, _jesscss_core_ast.importTailStartOf)(rule);
+		const before = trivia.lookup(start + rule.name.length, "after") ?? null;
+		const between = tailStart === _jesscss_core_ast.NO_SPAN ? null : trivia.lookup(tailStart, "before") ?? null;
+		const after = trivia.lookup((0, _jesscss_core_ast.importSourceEndOf)(rule) - 1, "before") ?? null;
+		const hasInnerBoundary = retainTypedImportTailTrivia(rule, trivia);
+		if (before !== null || between !== null || after !== null || hasInnerBoundary) {
+			const prelude = rule.prelude;
+			(0, _jesscss_core_ast.withValueBoundaryTrivia)(prelude, (0, _jesscss_core_ast.valueLayoutOf)(prelude) ?? (prelude.type === "Sequence" ? SPACE_LAYOUT : EMPTY_LAYOUT), {
+				before,
+				between,
+				after
+			});
+		}
+	}
+}
+/**
+* Line/column at a bare offset. The leftover-input offset is not the start of
+* any span the run returned — `result.span` covers the text that *was*
+* consumed — so the position has to be derived from the offset itself. Only
+* ever reached on a throw path, so building the index here costs a parse
+* nothing.
+*/
+function positionAt(input, offset) {
+	const { line, col } = (0, parseman.offsetToLineCol)((0, parseman.buildLineIndex)(input), offset);
+	return {
+		line,
+		column: col
+	};
+}
+/**
+* Line/column for a failure span. The compiled table without line tracking
+* leaves a span's line fields unset, so fall back to deriving them; an error
+* that reports an offset but no line is barely actionable in an editor.
+*/
+function lineOptions(input, span) {
+	if (span.startLine === void 0) return positionAt(input, span.start);
+	return {
+		line: span.startLine,
+		column: span.startColumn,
+		endLine: span.endLine,
+		endColumn: span.endColumn
+	};
+}
+function parseWith(grammar, input, options = {}) {
+	const entry = grammar.Stylesheet;
+	const trivia = grammar.whitespace;
+	if (entry === void 0 || trivia === void 0) throw new TypeError("Less AST grammar is missing its public document entry.");
+	const result = (0, parseman.run)(entry, input, {
+		trivia,
+		state: {
+			source: input,
+			mathMode: options.mathMode ?? "parens-division"
+		},
+		rootTrivia: { select: require_trivia_labels.commentTriviaLabels }
+	});
+	if (!result.ok) throw new require_parse_error.LessParseError(result.span.start, result.expected, lineOptions(input, result.span));
+	if (result.unconsumedFrom !== null) {
+		if (isStylesheet(result.value) && result.value.rules.length > 0) throw new require_parse_error.LessParseError(result.unconsumedFrom, [], {
+			message: "Unexpected Less input after a complete stylesheet.",
+			reason: "The parser consumed a complete Less stylesheet before this token, so the remaining text is not part of any rule, declaration, or at-rule.",
+			fix: "Remove the extra input or wrap it in valid Less syntax.",
+			...positionAt(input, result.unconsumedFrom)
+		});
+		throw new require_parse_error.LessParseError(result.unconsumedFrom, [], {
+			message: "Unexpected Less syntax.",
+			reason: "The parser could not match this token as the start of a Less rule, declaration, or at-rule.",
+			fix: "Remove the token or rewrite it as valid Less syntax.",
+			...positionAt(input, result.unconsumedFrom)
+		});
+	}
+	if (!isStylesheet(result.value)) throw new require_parse_error.LessParseError(result.span.end, [], {
+		...positionAt(input, result.span.end),
+		message: "Less parser did not produce a stylesheet.",
+		reason: "The Less parser matched the input but returned a value that is not a stylesheet document.",
+		fix: "Report this as a parser bug with the source that triggered it."
+	});
+	const triviaMap = (0, _jesscss_core_ast.createTriviaMapFromParseman)(input, result.rootTrivia?.index);
+	retainRootImportBoundaryTrivia(result.value, result.rootTrivia === void 0 ? void 0 : triviaMap);
+	return (0, _jesscss_core_ast.withTriviaMap)((0, _jesscss_core_ast.withSourceSpan)(result.value, result.span), triviaMap);
+}
+/**
+* The `safeParse` body for the product plugin path. Parser packages own
+* recognition facts; this boundary attaches file/source context once and
+* returns normalized diagnostics for compiler and CLI consumers to render.
+*/
+function safeParseWith(grammar, filePath, input, options = {}) {
+	try {
+		return {
+			document: parseWith(grammar, input, options),
+			errors: [],
+			warnings: []
+		};
+	} catch (error) {
+		return {
+			errors: [(0, _jesscss_core_diagnostics.parserDiagnostic)({
+				dialect: "Less",
+				error,
+				filePath,
+				source: input
+			})],
+			warnings: []
+		};
+	}
+}
+//#endregion
+Object.defineProperty(exports, "parseWith", {
+	enumerable: true,
+	get: function() {
+		return parseWith;
+	}
+});
+Object.defineProperty(exports, "safeParseWith", {
+	enumerable: true,
+	get: function() {
+		return safeParseWith;
+	}
+});

package/lib/chunks/parse-with.js

@@ -0,0 +1,161 @@
+import { LessParseError } from "../parse-error.js";
+import { t as commentTriviaLabels } from "./trivia-labels.js";
+import { buildLineIndex, offsetToLineCol, run } from "parseman";
+import { parserDiagnostic } from "@jesscss/core/diagnostics";
+import { NO_SPAN, createTriviaMapFromParseman, importSourceEndOf, importSourceStartOf, importTailStartOf, isValueSlotArray, sourceStartOf, valueLayoutOf, withSourceSpan, withTriviaMap, withValueBoundaryTrivia } from "@jesscss/core/ast";
+Object.freeze({ mathMode: "parens-division" });
+//#endregion
+//#region src/parse-with.ts
+/**
+* The `parse()`/`safeParse()` bodies, shared by the two AST entries.
+*
+* The grammar table arrives as an argument rather than being chosen from a
+* boolean inside this module: Node does not tree-shake, so a module that names
+* both compiled tables executes both at load time. Each entry imports exactly
+* the one table it parses with, and this module imports none.
+*/
+const EMPTY_LAYOUT = Object.freeze([]);
+const SPACE_LAYOUT = Object.freeze([" "]);
+function isStylesheet(value) {
+	return typeof value === "object" && value !== null && "type" in value && value.type === "Stylesheet" && "rules" in value && Array.isArray(value.rules);
+}
+/**
+* The one currently typed Less import-query feature is a `Block` containing a
+* colon `Operation`. Its right operand already carries a parser source start,
+* so an exact trivia lookup can retain the comment boundary without walking or
+* classifying source bytes. Opaque tail forms keep their existing byte owner.
+*/
+function retainTypedImportTailTrivia(statement, trivia) {
+	const prelude = statement.prelude;
+	if (prelude?.type !== "Sequence") return false;
+	const tail = prelude.parts[1];
+	if (tail?.type !== "Block" || isValueSlotArray(tail.value) || tail.value.type !== "Operation" || tail.value.operator !== ":") return false;
+	const rightStart = sourceStartOf(tail.value.right);
+	if (rightStart === NO_SPAN) return false;
+	const between = trivia.lookup(rightStart, "before");
+	if (between === void 0) return false;
+	withValueBoundaryTrivia(tail.value, EMPTY_LAYOUT, {
+		before: null,
+		between,
+		after: null
+	});
+	return true;
+}
+/**
+* Project only root-hoisted CSS-import boundaries through the canonical trivia
+* adapter. The grammar carries the statement edges and typed-tail start in
+* fixed private Smi slots, so each lookup names an exact parser-owned boundary
+* and public source provenance, AST/CST shape, and bytes remain unchanged.
+*/
+function retainRootImportBoundaryTrivia(document, trivia) {
+	if (trivia === void 0) return;
+	for (const rule of document.rules) {
+		if (rule.type !== "AtRuleStatement") continue;
+		const start = importSourceStartOf(rule);
+		if (start === NO_SPAN) continue;
+		const tailStart = importTailStartOf(rule);
+		const before = trivia.lookup(start + rule.name.length, "after") ?? null;
+		const between = tailStart === NO_SPAN ? null : trivia.lookup(tailStart, "before") ?? null;
+		const after = trivia.lookup(importSourceEndOf(rule) - 1, "before") ?? null;
+		const hasInnerBoundary = retainTypedImportTailTrivia(rule, trivia);
+		if (before !== null || between !== null || after !== null || hasInnerBoundary) {
+			const prelude = rule.prelude;
+			withValueBoundaryTrivia(prelude, valueLayoutOf(prelude) ?? (prelude.type === "Sequence" ? SPACE_LAYOUT : EMPTY_LAYOUT), {
+				before,
+				between,
+				after
+			});
+		}
+	}
+}
+/**
+* Line/column at a bare offset. The leftover-input offset is not the start of
+* any span the run returned — `result.span` covers the text that *was*
+* consumed — so the position has to be derived from the offset itself. Only
+* ever reached on a throw path, so building the index here costs a parse
+* nothing.
+*/
+function positionAt(input, offset) {
+	const { line, col } = offsetToLineCol(buildLineIndex(input), offset);
+	return {
+		line,
+		column: col
+	};
+}
+/**
+* Line/column for a failure span. The compiled table without line tracking
+* leaves a span's line fields unset, so fall back to deriving them; an error
+* that reports an offset but no line is barely actionable in an editor.
+*/
+function lineOptions(input, span) {
+	if (span.startLine === void 0) return positionAt(input, span.start);
+	return {
+		line: span.startLine,
+		column: span.startColumn,
+		endLine: span.endLine,
+		endColumn: span.endColumn
+	};
+}
+function parseWith(grammar, input, options = {}) {
+	const entry = grammar.Stylesheet;
+	const trivia = grammar.whitespace;
+	if (entry === void 0 || trivia === void 0) throw new TypeError("Less AST grammar is missing its public document entry.");
+	const result = run(entry, input, {
+		trivia,
+		state: {
+			source: input,
+			mathMode: options.mathMode ?? "parens-division"
+		},
+		rootTrivia: { select: commentTriviaLabels }
+	});
+	if (!result.ok) throw new LessParseError(result.span.start, result.expected, lineOptions(input, result.span));
+	if (result.unconsumedFrom !== null) {
+		if (isStylesheet(result.value) && result.value.rules.length > 0) throw new LessParseError(result.unconsumedFrom, [], {
+			message: "Unexpected Less input after a complete stylesheet.",
+			reason: "The parser consumed a complete Less stylesheet before this token, so the remaining text is not part of any rule, declaration, or at-rule.",
+			fix: "Remove the extra input or wrap it in valid Less syntax.",
+			...positionAt(input, result.unconsumedFrom)
+		});
+		throw new LessParseError(result.unconsumedFrom, [], {
+			message: "Unexpected Less syntax.",
+			reason: "The parser could not match this token as the start of a Less rule, declaration, or at-rule.",
+			fix: "Remove the token or rewrite it as valid Less syntax.",
+			...positionAt(input, result.unconsumedFrom)
+		});
+	}
+	if (!isStylesheet(result.value)) throw new LessParseError(result.span.end, [], {
+		...positionAt(input, result.span.end),
+		message: "Less parser did not produce a stylesheet.",
+		reason: "The Less parser matched the input but returned a value that is not a stylesheet document.",
+		fix: "Report this as a parser bug with the source that triggered it."
+	});
+	const triviaMap = createTriviaMapFromParseman(input, result.rootTrivia?.index);
+	retainRootImportBoundaryTrivia(result.value, result.rootTrivia === void 0 ? void 0 : triviaMap);
+	return withTriviaMap(withSourceSpan(result.value, result.span), triviaMap);
+}
+/**
+* The `safeParse` body for the product plugin path. Parser packages own
+* recognition facts; this boundary attaches file/source context once and
+* returns normalized diagnostics for compiler and CLI consumers to render.
+*/
+function safeParseWith(grammar, filePath, input, options = {}) {
+	try {
+		return {
+			document: parseWith(grammar, input, options),
+			errors: [],
+			warnings: []
+		};
+	} catch (error) {
+		return {
+			errors: [parserDiagnostic({
+				dialect: "Less",
+				error,
+				filePath,
+				source: input
+			})],
+			warnings: []
+		};
+	}
+}
+//#endregion
+export { safeParseWith as n, parseWith as t };

package/lib/chunks/trivia-labels.cjs

@@ -0,0 +1,18 @@
+//#region src/trivia-labels.ts
+/**
+* Root-trivia label selection for the Less grammar.
+*
+* This is a plain fact about the grammar's trivia arm labels, so it lives in a
+* leaf module with no imports. Reading it from the CST entry instead would make
+* every consumer of the package entry load the compiled CST grammar tables:
+* Node's ESM loader does not tree-shake, so an unused named import still
+* executes the module it is taken from, and each table is multiple megabytes.
+*/
+const commentTriviaLabels = ["lineComment", "blockComment"];
+//#endregion
+Object.defineProperty(exports, "commentTriviaLabels", {
+	enumerable: true,
+	get: function() {
+		return commentTriviaLabels;
+	}
+});

package/lib/chunks/trivia-labels.js

@@ -0,0 +1,13 @@
+//#region src/trivia-labels.ts
+/**
+* Root-trivia label selection for the Less grammar.
+*
+* This is a plain fact about the grammar's trivia arm labels, so it lives in a
+* leaf module with no imports. Reading it from the CST entry instead would make
+* every consumer of the package entry load the compiled CST grammar tables:
+* Node's ESM loader does not tree-shake, so an unused named import still
+* executes the module it is taken from, and each table is multiple megabytes.
+*/
+const commentTriviaLabels = ["lineComment", "blockComment"];
+//#endregion
+export { commentTriviaLabels as t };

package/lib/cst/positions.cjs

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_trivia_labels = require("../chunks/trivia-labels.cjs");
+let _jesscss_css_parser_cst_host = require("@jesscss/css-parser/cst-host");
+let src_grammar_cst_positions_js = require("../grammar/cst/positions.cjs");
+//#region src/cst/positions.ts
+/**
+* The line-aware Less CST entry: the `./cst` functions bound to the compiled
+* table that tracks lines and columns. Tolerant error recovery is a property of
+* the CST runner, not of the table, so `result.errors` is collected here
+* exactly as it is on `./cst` — this entry adds line/column facts and nothing
+* else. It never loads the offsets-only table.
+*/
+/** Parse Less to a CST whose spans carry line and column facts. */
+function parseLessCst(input, startRule = "Stylesheet", options) {
+	return (0, _jesscss_css_parser_cst_host.parseCst)(src_grammar_cst_positions_js.lessCstPositionsGrammar, input, startRule, options, require_trivia_labels.commentTriviaLabels);
+}
+/** Incremental (`.edit()`-able) Less document with line and column facts. */
+function parseLessDoc(input, startRule = "Stylesheet") {
+	return (0, _jesscss_css_parser_cst_host.parseDocCst)(src_grammar_cst_positions_js.lessCstPositionsGrammar, input, startRule);
+}
+//#endregion
+exports.commentTriviaLabels = require_trivia_labels.commentTriviaLabels;
+exports.parseLessCst = parseLessCst;
+exports.parseLessDoc = parseLessDoc;

package/lib/cst/positions.d.ts

@@ -0,0 +1,8 @@
+import { type CssCstNode, type CssCstParseOptions, type CssCstParseResult, type ParseDoc } from '@jesscss/css-parser/cst-host';
+export { commentTriviaLabels } from '../trivia-labels.js';
+/** Parse Less to a CST whose spans carry line and column facts. */
+export declare function parseLessCst(input: string, startRule?: string, options?: CssCstParseOptions): CssCstParseResult;
+/** Incremental (`.edit()`-able) Less document with line and column facts. */
+export declare function parseLessDoc(input: string, startRule?: string): ParseDoc<CssCstNode>;
+export type { CssCstChild as LessCstChild, CssCstError as LessCstError, CssCstLeaf as LessCstLeaf, CssCstNode as LessCstNode, CssCstParseOptions as LessCstParseOptions, CssCstParseResult as LessCstParseResult, CssCstType as LessCstType } from '@jesscss/css-parser/cst-host';
+//# sourceMappingURL=positions.d.ts.map

package/lib/cst/positions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"positions.d.ts","sourceRoot":"","sources":["../../src/cst/positions.ts"],"names":[],"mappings":"AAQA,OAAO,EAAyB,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,KAAK,iBAAiB,EAAE,KAAK,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAGtJ,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,mEAAmE;AACnE,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,SAAS,SAAe,EACxB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,iBAAiB,CAQnB;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,SAAS,SAAe,GACvB,QAAQ,CAAC,UAAU,CAAC,CAMtB;AAED,YAAY,EACV,WAAW,IAAI,YAAY,EAC3B,WAAW,IAAI,YAAY,EAC3B,UAAU,IAAI,WAAW,EACzB,UAAU,IAAI,WAAW,EACzB,kBAAkB,IAAI,mBAAmB,EACzC,iBAAiB,IAAI,kBAAkB,EACvC,UAAU,IAAI,WAAW,EAC1B,MAAM,8BAA8B,CAAC"}

package/lib/cst/positions.js

@@ -0,0 +1,21 @@
+import { t as commentTriviaLabels } from "../chunks/trivia-labels.js";
+import { parseCst, parseDocCst } from "@jesscss/css-parser/cst-host";
+import { lessCstPositionsGrammar } from "../grammar/cst/positions.js";
+//#region src/cst/positions.ts
+/**
+* The line-aware Less CST entry: the `./cst` functions bound to the compiled
+* table that tracks lines and columns. Tolerant error recovery is a property of
+* the CST runner, not of the table, so `result.errors` is collected here
+* exactly as it is on `./cst` — this entry adds line/column facts and nothing
+* else. It never loads the offsets-only table.
+*/
+/** Parse Less to a CST whose spans carry line and column facts. */
+function parseLessCst(input, startRule = "Stylesheet", options) {
+	return parseCst(lessCstPositionsGrammar, input, startRule, options, commentTriviaLabels);
+}
+/** Incremental (`.edit()`-able) Less document with line and column facts. */
+function parseLessDoc(input, startRule = "Stylesheet") {
+	return parseDocCst(lessCstPositionsGrammar, input, startRule);
+}
+//#endregion
+export { commentTriviaLabels, parseLessCst, parseLessDoc };

package/lib/cst.cjs

@@ -1,14 +1,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_grammar = require("./grammar2.cjs");
-let _jesscss_css_parser_cst = require("@jesscss/css-parser/cst");
+const require_trivia_labels = require("./chunks/trivia-labels.cjs");
+let _jesscss_css_parser_cst_host = require("@jesscss/css-parser/cst-host");
+let src_grammar_cst_js = require("./grammar/cst.cjs");
 //#region src/cst.ts
+/**
+* Parse Less to a CST. Spans carry offsets only; for line/column facts import
+* the same functions from `@jesscss/less-parser/cst/positions`, which binds the
+* line-aware compiled table. This entry never loads that table.
+*/
 function parseLessCst(input, startRule = "Stylesheet", options) {
-	return (0, _jesscss_css_parser_cst.parseCst)(require_grammar.lessCstGrammar, input, startRule, options);
+	return (0, _jesscss_css_parser_cst_host.parseCst)(src_grammar_cst_js.lessCstGrammar, input, startRule, options, require_trivia_labels.commentTriviaLabels);
 }
 /** Incremental (`.edit()`-able) Less document — see `parseDocCst`. */
 function parseLessDoc(input, startRule = "Stylesheet") {
-	return (0, _jesscss_css_parser_cst.parseDocCst)(require_grammar.lessCstGrammar, input, startRule);
+	return (0, _jesscss_css_parser_cst_host.parseDocCst)(src_grammar_cst_js.lessCstGrammar, input, startRule);
 }
 //#endregion
+exports.commentTriviaLabels = require_trivia_labels.commentTriviaLabels;
 exports.parseLessCst = parseLessCst;
 exports.parseLessDoc = parseLessDoc;

package/lib/cst.d.ts

@@ -1,6 +1,12 @@
-import { type CssCstNode, type CssCstParseOptions, type CssCstParseResult, type ParseDoc } from '@jesscss/css-parser/cst';
+import { type CssCstNode, type CssCstParseOptions, type CssCstParseResult, type ParseDoc } from '@jesscss/css-parser/cst-host';
+export { commentTriviaLabels } from './trivia-labels.js';
+/**
+ * Parse Less to a CST. Spans carry offsets only; for line/column facts import
+ * the same functions from `@jesscss/less-parser/cst/positions`, which binds the
+ * line-aware compiled table. This entry never loads that table.
+ */
 export declare function parseLessCst(input: string, startRule?: string, options?: CssCstParseOptions): CssCstParseResult;
 /** Incremental (`.edit()`-able) Less document — see `parseDocCst`. */
 export declare function parseLessDoc(input: string, startRule?: string): ParseDoc<CssCstNode>;
-export type { CssCstChild as LessCstChild, CssCstError as LessCstError, CssCstLeaf as LessCstLeaf, CssCstNode as LessCstNode, CssCstParseOptions as LessCstParseOptions, CssCstParseResult as LessCstParseResult, CssCstType as LessCstType } from '@jesscss/css-parser/cst';
+export type { CssCstChild as LessCstChild, CssCstError as LessCstError, CssCstLeaf as LessCstLeaf, CssCstNode as LessCstNode, CssCstParseOptions as LessCstParseOptions, CssCstParseResult as LessCstParseResult, CssCstType as LessCstType } from '@jesscss/css-parser/cst-host';
 //# sourceMappingURL=cst.d.ts.map

package/lib/cst.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cst.d.ts","sourceRoot":"","sources":["../src/cst.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,KAAK,iBAAiB,EAAE,KAAK,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGjJ,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,SAAS,SAAe,EACxB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,iBAAiB,CAEnB;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,SAAe,GAAG,QAAQ,CAAC,UAAU,CAAC,CAE1F;AAED,YAAY,EACV,WAAW,IAAI,YAAY,EAC3B,WAAW,IAAI,YAAY,EAC3B,UAAU,IAAI,WAAW,EACzB,UAAU,IAAI,WAAW,EACzB,kBAAkB,IAAI,mBAAmB,EACzC,iBAAiB,IAAI,kBAAkB,EACvC,UAAU,IAAI,WAAW,EAC1B,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"cst.d.ts","sourceRoot":"","sources":["../src/cst.ts"],"names":[],"mappings":"AACA,OAAO,EAAyB,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,KAAK,iBAAiB,EAAE,KAAK,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAGtJ,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAEzD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,SAAS,SAAe,EACxB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,iBAAiB,CAQnB;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,SAAS,SAAe,GACvB,QAAQ,CAAC,UAAU,CAAC,CAMtB;AAED,YAAY,EACV,WAAW,IAAI,YAAY,EAC3B,WAAW,IAAI,YAAY,EAC3B,UAAU,IAAI,WAAW,EACzB,UAAU,IAAI,WAAW,EACzB,kBAAkB,IAAI,mBAAmB,EACzC,iBAAiB,IAAI,kBAAkB,EACvC,UAAU,IAAI,WAAW,EAC1B,MAAM,8BAA8B,CAAC"}

package/lib/cst.js

@@ -1,12 +1,18 @@
-import { n as lessCstGrammar } from "./grammar2.js";
-import { parseCst, parseDocCst } from "@jesscss/css-parser/cst";
+import { t as commentTriviaLabels } from "./chunks/trivia-labels.js";
+import { parseCst, parseDocCst } from "@jesscss/css-parser/cst-host";
+import { lessCstGrammar } from "./grammar/cst.js";
 //#region src/cst.ts
+/**
+* Parse Less to a CST. Spans carry offsets only; for line/column facts import
+* the same functions from `@jesscss/less-parser/cst/positions`, which binds the
+* line-aware compiled table. This entry never loads that table.
+*/
 function parseLessCst(input, startRule = "Stylesheet", options) {
-	return parseCst(lessCstGrammar, input, startRule, options);
+	return parseCst(lessCstGrammar, input, startRule, options, commentTriviaLabels);
 }
 /** Incremental (`.edit()`-able) Less document — see `parseDocCst`. */
 function parseLessDoc(input, startRule = "Stylesheet") {
 	return parseDocCst(lessCstGrammar, input, startRule);
 }
 //#endregion
-export { parseLessCst, parseLessDoc };
+export { commentTriviaLabels, parseLessCst, parseLessDoc };