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

package/README.md

@@ -62,10 +62,48 @@ Pass a different `startRule` (any capitalized grammar rule) to parse a fragment.
 | Entry | Export | Purpose |
 | --- | --- | --- |
 | `@jesscss/jess-parser` (`.`) | `parse`, `JessParseError` | Parse Jess directly to canonical AST v2 `Stylesheet`; malformed input throws `JessParseError` with an offset and expected facts. |
-| `@jesscss/jess-parser` (`.`) | `parseJessCst`, `jessGrammar` | Convenience exports for the public CST parser and canonical grammar artifact. |
 | `@jesscss/jess-parser` (`.`) | `JessCstNode`, `JessCstLeaf`, `JessCstError`, `JessCstChild`, `JessCstParseResult`, `JessCstType` (types) | CST type definitions (aliases of the shared `@jesscss/css-parser/cst` types). |
-| `@jesscss/jess-parser/cst` | `parseJessCst`, CST types | Same core-free CST parser (explicit subpath). |
-| `@jesscss/jess-parser/grammar` | `jessFactory`, `jessGrammar`, `jessAstGrammar`, `jessCstGrammar` | The single host-mode grammar source and its AST/CST compiled artifacts. |
+| `@jesscss/jess-parser/cst` | `parseJessCst`, `parseJessDoc`, CST types | Core-free parse of a Jess string to a CST. Compiled grammars are not re-exported from `.` — reach for a `/grammar` subpath so the main entry never loads a grammar build you did not ask for. |
+| `@jesscss/jess-parser/grammar` | `jessGrammar` | The compiled Jess AST grammar (a rule map). Extend it with `compose()` or drive it directly with parseman's `run`. See the variant table below. |
+
+### 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/jess-parser` (`.`) | `parse` | AST | no |
+| `@jesscss/jess-parser/positions` | `parse` | AST | yes |
+| `@jesscss/jess-parser/cst` | `parseJessCst`, `parseJessDoc` | CST | no |
+| `@jesscss/jess-parser/cst/positions` | `parseJessCst`, `parseJessDoc` | 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/jess-parser/grammar/ast` | `jessGrammar` | AST | no |
+| `@jesscss/jess-parser/grammar/ast/positions` | `jessPositionsGrammar` | AST | yes |
+| `@jesscss/jess-parser/grammar/cst` | `jessCstGrammar` | CST | no |
+| `@jesscss/jess-parser/grammar/cst/positions` | `jessCstPositionsGrammar` | CST | yes |
+
+`@jesscss/jess-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
 
@@ -83,19 +121,32 @@ Parsing `$brand: #3366ff;` yields:
 {
   "_tag": "node", "type": "StyleSheet", "grammarType": "Stylesheet", "span": { "start": 0, "end": 16 },
   "children": [
-    { "_tag": "node", "type": "DirectJessVarDeclaration", "grammarType": "DirectJessVarDeclaration", "span": { "start": 0, "end": 16 },
+    { "_tag": "node", "type": "VariableDeclaration", "grammarType": "VariableDeclaration", "span": { "start": 0, "end": 16 },
       "children": [
-        { "_tag": "leaf", "value": "$brand", "span": { "start": 0, "end": 6 } },
+        { "_tag": "leaf", "value": "$", "span": { "start": 0, "end": 1 } },
+        { "_tag": "leaf", "value": "brand", "span": { "start": 1, "end": 6 } },
         { "_tag": "leaf", "value": ":", "span": { "start": 6, "end": 7 } },
-        { "_tag": "node", "type": "DirectJessColor", "grammarType": "DirectJessColor", "span": { "start": 8, "end": 15 },
-          "children": [ { "_tag": "leaf", "value": "#3366ff", "span": { "start": 8, "end": 15 } } ] },
+        { "_tag": "node", "type": "Value", "grammarType": "Value", "span": { "start": 8, "end": 15 },
+          "children": [
+            { "_tag": "node", "type": "ValueTerm", "grammarType": "ValueTerm", "span": { "start": 8, "end": 15 },
+              "children": [
+                { "_tag": "node", "type": "ValueSpaceGroup", "grammarType": "ValueSpaceGroup", "span": { "start": 8, "end": 15 },
+                  "children": [
+                    { "_tag": "node", "type": "ValueAtom", "grammarType": "ValueAtom", "span": { "start": 8, "end": 15 },
+                      "children": [
+                        { "_tag": "node", "type": "Color", "grammarType": "Color", "span": { "start": 8, "end": 15 },
+                          "children": [ { "_tag": "leaf", "value": "#3366ff", "span": { "start": 8, "end": 15 } } ] }
+                      ] }
+                  ] }
+              ] }
+          ] },
         { "_tag": "leaf", "value": ";", "span": { "start": 15, "end": 16 } }
       ] }
   ]
 }
 ```
 
-Jess-specific grammar rules include `DirectJessVarDeclaration` (`$x: …`), `DirectJessVarReference` / `DirectJessReferenceCall` (`$x`, `$x.prop`, `$x[0]`, callable chains), `DirectJessExpression*` (inside `$(…)`), `DirectJessMixinDef`, `DirectJessMixinCall`, `DirectJessInterpolatedSimple` (`.widget-${side}`), and the `@-compose`/`@-export`/`@-from`/`@-use` import at-rules.
+Jess-specific grammar rules include `VariableDeclaration` (`$x: …`), `VariableReference` / `ReferenceCall` (`$x`, `$x.prop`, `$x[0]`, callable chains), `Expression*` (inside `$(…)`), `MixinDefinition`, `MixinCall`, `InterpolatedSimple` (`.widget-${side}`), and the `@-compose`/`@-export`/`@-from`/`@-use` import at-rules.
 
 Pass `{ collapse: true }` to request parseman's transparent-wrapper collapse while preserving source leaves and grammar ownership.
 

package/lib/chunks/parse-with.cjs

@@ -0,0 +1,193 @@
+const require_trivia_labels = require("./trivia-labels.cjs");
+let parseman = require("parseman");
+let _jesscss_core_ast = require("@jesscss/core/ast");
+//#region src/parse-error.ts
+/**
+* The public Jess parse failure lives in its own module so that both AST
+* entries — `.` and `./positions` — can export it without either one reaching
+* the other's compiled grammar table. A class declared in an entry cannot be
+* re-exported by a sibling entry without dragging that entry's imports along.
+*/
+/** Structured failure from the public direct Jess parser. */
+var JessParseError = class extends SyntaxError {
+	code = "parse/syntax-error";
+	offset;
+	expected;
+	line;
+	column;
+	endLine;
+	endColumn;
+	reason;
+	fix;
+	constructor(offset, expected, options = {}) {
+		const detail = expected.length > 0 ? ` Expected: ${expected.join(", ")}.` : "";
+		super(options.message ?? `Jess parser error.${detail}`);
+		this.name = "JessParseError";
+		this.offset = offset;
+		this.expected = expected;
+		this.line = options.line;
+		this.column = options.column;
+		this.endLine = options.endLine;
+		this.endColumn = options.endColumn;
+		this.reason = options.reason;
+		this.fix = options.fix;
+	}
+};
+//#endregion
+//#region src/parse-with.ts
+/**
+* The `parse()` body and the `$apply`/`$extend` selector policy checks, 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.
+*/
+function isStylesheet(value) {
+	return typeof value === "object" && value !== null && "type" in value && value.type === "Stylesheet" && "rules" in value && Array.isArray(value.rules);
+}
+const DEFAULT_APPLY_SELECTOR_KINDS = ["class"];
+const DEFAULT_EXTEND_SELECTOR_KINDS = ["class", "placeholder"];
+function selectorPolicyError(message) {
+	return new JessParseError(0, [message]);
+}
+function isClassSelector(simple) {
+	return simple.interp === null && typeof simple.text === "string" && simple.text.startsWith(".") && simple.text.length > 1;
+}
+/**
+* A lone parent-ref target (`&`). Admitted only on the extend path: `$extend &`
+* parses and no-op-matches at eval, mirroring Less `:extend(&)`. `$apply` stays
+* class-only — a parent-ref carries no utility class to compose.
+*
+* The parser admits `&` because it is a legitimate simple-selector SHAPE; that
+* `$extend &` can only ever no-op (a selector cannot extend itself) is a SEMANTIC
+* fact, not a parse concern. The no-op is surfaced (not rejected) as
+* diagnostics-core lint `lint/no-self-extend`; see DESIGN-DECISIONS ledger X11.
+*/
+function isBareParentRef(simple) {
+	return simple.type === "SimpleSelector" && simple.interp === null && simple.text === "&";
+}
+function isTermAllowed(term, allowed, isExtend) {
+	if (term.type === "CompoundSelector") return allowed.has("compound") || term.value.length === 1 && isSimpleAllowed(term.value[0], allowed, isExtend);
+	return isSimpleAllowed(term, allowed, isExtend);
+}
+function isSimpleAllowed(simple, allowed, isExtend) {
+	if (isExtend && isBareParentRef(simple)) return true;
+	if (simple.type === "PseudoSelector") return allowed.has("simple") || allowed.has("pseudo");
+	return allowed.has("class") && isClassSelector(simple) || allowed.has("placeholder") && (0, _jesscss_core_ast.simpleSelectorIsPlaceholder)(simple) || allowed.has("simple") || allowed.has("basic");
+}
+function isBranchAllowed(branch, allowed, isExtend) {
+	return branch.type === "ComplexSelector" || branch.type === "RelativeSelector" ? allowed.has("complex") : isTermAllowed(branch, allowed, isExtend);
+}
+function validateSelectorList(label, selector, allowedKinds) {
+	const allowed = new Set(allowedKinds);
+	if (!selector.selectors.every((item) => isBranchAllowed(item, allowed, true))) throw selectorPolicyError(`${label} selector is not allowed by allowExtendSelectors.`);
+}
+function validateApply(node, allowedKinds) {
+	const allowed = new Set(allowedKinds);
+	if (!node.selectors.every((selector) => isTermAllowed(selector, allowed, false))) throw selectorPolicyError("$apply target is not allowed by allowApplySelectors.");
+}
+function validateRuleset(node, options) {
+	for (const instruction of node.extendInstructions ?? []) validateSelectorList("$extend", instruction.target, options.allowExtendSelectors);
+	validateStatements(node.rules, options);
+}
+function validateStatements(rules, options) {
+	for (const node of rules) switch (node.type) {
+		case "Ruleset":
+			validateRuleset(node, options);
+			break;
+		case "MixinDefinition":
+		case "For":
+		case "AtRuleBlock":
+			validateStatements(node.rules, options);
+			break;
+		case "If":
+			for (const branch of node.branches) validateStatements(branch.rules, options);
+			break;
+		case "Apply":
+			validateApply(node, options.allowApplySelectors);
+			break;
+		default: break;
+	}
+}
+function validateJessOptions(document, options = {}) {
+	validateStatements(document.rules, {
+		allowApplySelectors: options.allowApplySelectors ?? DEFAULT_APPLY_SELECTOR_KINDS,
+		allowExtendSelectors: options.allowExtendSelectors ?? DEFAULT_EXTEND_SELECTOR_KINDS
+	});
+}
+/**
+* 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("Jess AST grammar is missing its public document entry.");
+	const result = (0, parseman.run)(entry, input, {
+		trivia,
+		rootTrivia: { select: require_trivia_labels.commentTriviaLabels }
+	});
+	if (!result.ok) throw new JessParseError(result.span.start, result.expected, lineOptions(input, result.span));
+	if (result.unconsumedFrom !== null) {
+		if (isStylesheet(result.value) && result.value.rules.length > 0) throw new JessParseError(result.unconsumedFrom, [], {
+			message: "Unexpected Jess input after a complete stylesheet.",
+			reason: "The parser read a complete Jess stylesheet before this point, so the remaining text sits outside every rule, declaration, and at-rule.",
+			fix: "Delete the trailing text, or remove the extra \"}\" — over-closing a nested block ends the stylesheet early.",
+			...positionAt(input, result.unconsumedFrom)
+		});
+		throw new JessParseError(result.unconsumedFrom, [], {
+			message: "Unexpected Jess syntax.",
+			reason: "The parser could not read this token as the start of a Jess rule, declaration, assignment, or at-rule.",
+			fix: "Remove the token, or rewrite it as a selector block, a \"$name: value\" assignment, or an at-rule.",
+			...positionAt(input, result.unconsumedFrom)
+		});
+	}
+	if (!isStylesheet(result.value)) throw new JessParseError(result.span.end, [], {
+		message: "Jess parser did not produce a stylesheet.",
+		reason: "The Jess 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.",
+		...positionAt(input, result.span.end)
+	});
+	const document = (0, _jesscss_core_ast.withTriviaMap)((0, _jesscss_core_ast.withSourceSpan)(result.value, result.span), (0, _jesscss_core_ast.createTriviaMapFromParseman)(input, result.rootTrivia?.index));
+	validateJessOptions(document, options);
+	return document;
+}
+//#endregion
+Object.defineProperty(exports, "JessParseError", {
+	enumerable: true,
+	get: function() {
+		return JessParseError;
+	}
+});
+Object.defineProperty(exports, "parseWith", {
+	enumerable: true,
+	get: function() {
+		return parseWith;
+	}
+});

package/lib/chunks/parse-with.js

@@ -0,0 +1,182 @@
+import { t as commentTriviaLabels } from "./trivia-labels.js";
+import { buildLineIndex, offsetToLineCol, run } from "parseman";
+import { createTriviaMapFromParseman, simpleSelectorIsPlaceholder, withSourceSpan, withTriviaMap } from "@jesscss/core/ast";
+//#region src/parse-error.ts
+/**
+* The public Jess parse failure lives in its own module so that both AST
+* entries — `.` and `./positions` — can export it without either one reaching
+* the other's compiled grammar table. A class declared in an entry cannot be
+* re-exported by a sibling entry without dragging that entry's imports along.
+*/
+/** Structured failure from the public direct Jess parser. */
+var JessParseError = class extends SyntaxError {
+	code = "parse/syntax-error";
+	offset;
+	expected;
+	line;
+	column;
+	endLine;
+	endColumn;
+	reason;
+	fix;
+	constructor(offset, expected, options = {}) {
+		const detail = expected.length > 0 ? ` Expected: ${expected.join(", ")}.` : "";
+		super(options.message ?? `Jess parser error.${detail}`);
+		this.name = "JessParseError";
+		this.offset = offset;
+		this.expected = expected;
+		this.line = options.line;
+		this.column = options.column;
+		this.endLine = options.endLine;
+		this.endColumn = options.endColumn;
+		this.reason = options.reason;
+		this.fix = options.fix;
+	}
+};
+//#endregion
+//#region src/parse-with.ts
+/**
+* The `parse()` body and the `$apply`/`$extend` selector policy checks, 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.
+*/
+function isStylesheet(value) {
+	return typeof value === "object" && value !== null && "type" in value && value.type === "Stylesheet" && "rules" in value && Array.isArray(value.rules);
+}
+const DEFAULT_APPLY_SELECTOR_KINDS = ["class"];
+const DEFAULT_EXTEND_SELECTOR_KINDS = ["class", "placeholder"];
+function selectorPolicyError(message) {
+	return new JessParseError(0, [message]);
+}
+function isClassSelector(simple) {
+	return simple.interp === null && typeof simple.text === "string" && simple.text.startsWith(".") && simple.text.length > 1;
+}
+/**
+* A lone parent-ref target (`&`). Admitted only on the extend path: `$extend &`
+* parses and no-op-matches at eval, mirroring Less `:extend(&)`. `$apply` stays
+* class-only — a parent-ref carries no utility class to compose.
+*
+* The parser admits `&` because it is a legitimate simple-selector SHAPE; that
+* `$extend &` can only ever no-op (a selector cannot extend itself) is a SEMANTIC
+* fact, not a parse concern. The no-op is surfaced (not rejected) as
+* diagnostics-core lint `lint/no-self-extend`; see DESIGN-DECISIONS ledger X11.
+*/
+function isBareParentRef(simple) {
+	return simple.type === "SimpleSelector" && simple.interp === null && simple.text === "&";
+}
+function isTermAllowed(term, allowed, isExtend) {
+	if (term.type === "CompoundSelector") return allowed.has("compound") || term.value.length === 1 && isSimpleAllowed(term.value[0], allowed, isExtend);
+	return isSimpleAllowed(term, allowed, isExtend);
+}
+function isSimpleAllowed(simple, allowed, isExtend) {
+	if (isExtend && isBareParentRef(simple)) return true;
+	if (simple.type === "PseudoSelector") return allowed.has("simple") || allowed.has("pseudo");
+	return allowed.has("class") && isClassSelector(simple) || allowed.has("placeholder") && simpleSelectorIsPlaceholder(simple) || allowed.has("simple") || allowed.has("basic");
+}
+function isBranchAllowed(branch, allowed, isExtend) {
+	return branch.type === "ComplexSelector" || branch.type === "RelativeSelector" ? allowed.has("complex") : isTermAllowed(branch, allowed, isExtend);
+}
+function validateSelectorList(label, selector, allowedKinds) {
+	const allowed = new Set(allowedKinds);
+	if (!selector.selectors.every((item) => isBranchAllowed(item, allowed, true))) throw selectorPolicyError(`${label} selector is not allowed by allowExtendSelectors.`);
+}
+function validateApply(node, allowedKinds) {
+	const allowed = new Set(allowedKinds);
+	if (!node.selectors.every((selector) => isTermAllowed(selector, allowed, false))) throw selectorPolicyError("$apply target is not allowed by allowApplySelectors.");
+}
+function validateRuleset(node, options) {
+	for (const instruction of node.extendInstructions ?? []) validateSelectorList("$extend", instruction.target, options.allowExtendSelectors);
+	validateStatements(node.rules, options);
+}
+function validateStatements(rules, options) {
+	for (const node of rules) switch (node.type) {
+		case "Ruleset":
+			validateRuleset(node, options);
+			break;
+		case "MixinDefinition":
+		case "For":
+		case "AtRuleBlock":
+			validateStatements(node.rules, options);
+			break;
+		case "If":
+			for (const branch of node.branches) validateStatements(branch.rules, options);
+			break;
+		case "Apply":
+			validateApply(node, options.allowApplySelectors);
+			break;
+		default: break;
+	}
+}
+function validateJessOptions(document, options = {}) {
+	validateStatements(document.rules, {
+		allowApplySelectors: options.allowApplySelectors ?? DEFAULT_APPLY_SELECTOR_KINDS,
+		allowExtendSelectors: options.allowExtendSelectors ?? DEFAULT_EXTEND_SELECTOR_KINDS
+	});
+}
+/**
+* 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("Jess AST grammar is missing its public document entry.");
+	const result = run(entry, input, {
+		trivia,
+		rootTrivia: { select: commentTriviaLabels }
+	});
+	if (!result.ok) throw new JessParseError(result.span.start, result.expected, lineOptions(input, result.span));
+	if (result.unconsumedFrom !== null) {
+		if (isStylesheet(result.value) && result.value.rules.length > 0) throw new JessParseError(result.unconsumedFrom, [], {
+			message: "Unexpected Jess input after a complete stylesheet.",
+			reason: "The parser read a complete Jess stylesheet before this point, so the remaining text sits outside every rule, declaration, and at-rule.",
+			fix: "Delete the trailing text, or remove the extra \"}\" — over-closing a nested block ends the stylesheet early.",
+			...positionAt(input, result.unconsumedFrom)
+		});
+		throw new JessParseError(result.unconsumedFrom, [], {
+			message: "Unexpected Jess syntax.",
+			reason: "The parser could not read this token as the start of a Jess rule, declaration, assignment, or at-rule.",
+			fix: "Remove the token, or rewrite it as a selector block, a \"$name: value\" assignment, or an at-rule.",
+			...positionAt(input, result.unconsumedFrom)
+		});
+	}
+	if (!isStylesheet(result.value)) throw new JessParseError(result.span.end, [], {
+		message: "Jess parser did not produce a stylesheet.",
+		reason: "The Jess 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.",
+		...positionAt(input, result.span.end)
+	});
+	const document = withTriviaMap(withSourceSpan(result.value, result.span), createTriviaMapFromParseman(input, result.rootTrivia?.index));
+	validateJessOptions(document, options);
+	return document;
+}
+//#endregion
+export { JessParseError 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 Jess 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 = ["comment"];
+//#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 Jess 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 = ["comment"];
+//#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 Jess 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 Jess to a CST whose spans carry line and column facts. */
+function parseJessCst(input, startRule = "Stylesheet", options) {
+	return (0, _jesscss_css_parser_cst_host.parseCst)(src_grammar_cst_positions_js.jessCstPositionsGrammar, input, startRule, options, require_trivia_labels.commentTriviaLabels);
+}
+/** Incremental (`.edit()`-able) Jess document with line and column facts. */
+function parseJessDoc(input, startRule = "Stylesheet") {
+	return (0, _jesscss_css_parser_cst_host.parseDocCst)(src_grammar_cst_positions_js.jessCstPositionsGrammar, input, startRule);
+}
+//#endregion
+exports.commentTriviaLabels = require_trivia_labels.commentTriviaLabels;
+exports.parseJessCst = parseJessCst;
+exports.parseJessDoc = parseJessDoc;

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 { jessCstPositionsGrammar } from "../grammar/cst/positions.js";
+//#region src/cst/positions.ts
+/**
+* The line-aware Jess 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 Jess to a CST whose spans carry line and column facts. */
+function parseJessCst(input, startRule = "Stylesheet", options) {
+	return parseCst(jessCstPositionsGrammar, input, startRule, options, commentTriviaLabels);
+}
+/** Incremental (`.edit()`-able) Jess document with line and column facts. */
+function parseJessDoc(input, startRule = "Stylesheet") {
+	return parseDocCst(jessCstPositionsGrammar, input, startRule);
+}
+//#endregion
+export { commentTriviaLabels, parseJessCst, parseJessDoc };

package/lib/cst.cjs

@@ -1,14 +1,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_grammar = require("./grammar.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 Jess to a CST. Spans carry offsets only; for line/column facts import
+* the same functions from `@jesscss/jess-parser/cst/positions`, which binds the
+* line-aware compiled table. This entry never loads that table.
+*/
 function parseJessCst(input, startRule = "Stylesheet", options) {
-	return (0, _jesscss_css_parser_cst.parseCst)(require_grammar.jessCstGrammar, input, startRule, options);
+	return (0, _jesscss_css_parser_cst_host.parseCst)(src_grammar_cst_js.jessCstGrammar, input, startRule, options, require_trivia_labels.commentTriviaLabels);
 }
-/** Incremental (`.edit()`-able) Jess document — mirrors `parseLessDoc`/`parseScssDoc`. */
+/** Incremental (`.edit()`-able) Jess document — see `parseDocCst`. */
 function parseJessDoc(input, startRule = "Stylesheet") {
-	return (0, _jesscss_css_parser_cst.parseDocCst)(require_grammar.jessCstGrammar, input, startRule);
+	return (0, _jesscss_css_parser_cst_host.parseDocCst)(src_grammar_cst_js.jessCstGrammar, input, startRule);
 }
 //#endregion
+exports.commentTriviaLabels = require_trivia_labels.commentTriviaLabels;
 exports.parseJessCst = parseJessCst;
 exports.parseJessDoc = parseJessDoc;

package/lib/cst.d.ts

@@ -1,5 +1,11 @@
-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 Jess to a CST. Spans carry offsets only; for line/column facts import
+ * the same functions from `@jesscss/jess-parser/cst/positions`, which binds the
+ * line-aware compiled table. This entry never loads that table.
+ */
 export declare function parseJessCst(input: string, startRule?: string, options?: CssCstParseOptions): CssCstParseResult;
-/** Incremental (`.edit()`-able) Jess document — mirrors `parseLessDoc`/`parseScssDoc`. */
+/** Incremental (`.edit()`-able) Jess document — see `parseDocCst`. */
 export declare function parseJessDoc(input: string, startRule?: string): ParseDoc<CssCstNode>;
-export type { CssCstChild as JessCstChild, CssCstError as JessCstError, CssCstLeaf as JessCstLeaf, CssCstNode as JessCstNode, CssCstParseOptions as JessCstParseOptions, CssCstParseResult as JessCstParseResult, CssCstType as JessCstType } from '@jesscss/css-parser/cst';
+export type { CssCstChild as JessCstChild, CssCstError as JessCstError, CssCstLeaf as JessCstLeaf, CssCstNode as JessCstNode, CssCstParseOptions as JessCstParseOptions, CssCstParseResult as JessCstParseResult, CssCstType as JessCstType } from '@jesscss/css-parser/cst-host';

package/lib/cst.js

@@ -1,12 +1,18 @@
-import { jessCstGrammar } from "./grammar.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 { jessCstGrammar } from "./grammar/cst.js";
 //#region src/cst.ts
+/**
+* Parse Jess to a CST. Spans carry offsets only; for line/column facts import
+* the same functions from `@jesscss/jess-parser/cst/positions`, which binds the
+* line-aware compiled table. This entry never loads that table.
+*/
 function parseJessCst(input, startRule = "Stylesheet", options) {
-	return parseCst(jessCstGrammar, input, startRule, options);
+	return parseCst(jessCstGrammar, input, startRule, options, commentTriviaLabels);
 }
-/** Incremental (`.edit()`-able) Jess document — mirrors `parseLessDoc`/`parseScssDoc`. */
+/** Incremental (`.edit()`-able) Jess document — see `parseDocCst`. */
 function parseJessDoc(input, startRule = "Stylesheet") {
 	return parseDocCst(jessCstGrammar, input, startRule);
 }
 //#endregion
-export { parseJessCst, parseJessDoc };
+export { commentTriviaLabels, parseJessCst, parseJessDoc };