@jesscss/scss-parser 2.0.0-alpha.11 → 2.0.0-alpha.12

package/README.md

@@ -12,9 +12,12 @@ An SCSS grammar for Jess, layered on the CSS base parser — **experimental, and
 
 ## What it is
 
-The SCSS grammar is the shared CSS grammar plus an SCSS delta:
-`scssGrammar = compose([cssFactory, <SCSS delta>])`, layered on the spec-aligned
-CSS base in `@jesscss/css-parser` and built on
+The SCSS grammar extends the spec-aligned CSS base in `@jesscss/css-parser`:
+unchanged CSS structure remains CSS-owned, and SCSS changes only the smallest
+child, value slot, or reference its syntax requires. Parseman currently compiles
+the CSS and SCSS host factories from shared recognition artifacts rather than
+literally composing a terminal CSS grammar 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)
@@ -83,9 +86,49 @@ Pass a different `startRule` (any capitalized grammar rule) to parse a fragment.
 | --- | --- | --- |
 | `@jesscss/scss-parser/cst` | `parseScssCst` | Core-free parse of an SCSS string to a CST. |
 | `@jesscss/scss-parser/cst` | `ScssCstNode`, `ScssCstLeaf`, `ScssCstError`, `ScssCstChild`, `ScssCstParseResult`, `ScssCstType` (types) | CST type definitions (aliases of the shared `@jesscss/css-parser/cst` types). |
-| `@jesscss/scss-parser/grammar` | `scssGrammar` | The compiled SCSS grammar (a rule map). Extend it with `compose()` or drive it directly with parseman's `run`. |
+| `@jesscss/scss-parser/grammar` | `scssGrammar` | The compiled SCSS AST grammar (a rule map). Extend it with `compose()` or drive it directly with parseman's `run`. See the variant table below. |
 | `@jesscss/scss-parser` (`.`) | `parse` | Parse SCSS 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/scss-parser` (`.`) | `parse` | AST | no |
+| `@jesscss/scss-parser/positions` | `parse` | AST | yes |
+| `@jesscss/scss-parser/cst` | `parseScssCst`, `parseScssDoc` | CST | no |
+| `@jesscss/scss-parser/cst/positions` | `parseScssCst`, `parseScssDoc` | 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/scss-parser/grammar/ast` | `scssGrammar` | AST | no |
+| `@jesscss/scss-parser/grammar/ast/positions` | `scssPositionsGrammar` | AST | yes |
+| `@jesscss/scss-parser/grammar/cst` | `scssCstGrammar` | CST | no |
+| `@jesscss/scss-parser/grammar/cst/positions` | `scssCstPositionsGrammar` | CST | yes |
+
+`@jesscss/scss-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:
@@ -105,7 +148,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": ";" }
       ] },
@@ -127,9 +170,9 @@ Parsing `$c: red;\n.foo { color: $c; }` yields (abridged):
 }
 ```
 
-Note the SCSS-specific nodes: `$c: …` becomes a `VarDeclaration`, `$c` in value position becomes a `Reference`, selectors parse through `InterpolatedSelector` (so `#{…}` interpolation is captured in place), and the color keyword `red` parses as `NamedColor`.
+Note the SCSS-specific nodes: `$c: …` becomes a `VarDeclaration`, `$c` in value position becomes a `Reference`, selectors parse through `InterpolatedSelector` (so `#{…}` interpolation is captured in place), and the color keyword `red` parses as a plain `Keyword` — the same node every dialect uses (NamedColor→Keyword convergence).
 
-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.
 
 ## Extending with your own builders
 
@@ -139,7 +182,7 @@ The grammar is decoupled from the tree it builds. Every capitalized rule is a pa
 import { run } from 'parseman'
 import { scssGrammar } from '@jesscss/scss-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(scssGrammar.Stylesheet, '$c: red; .foo { color: $c; }', {
   build: myHost,
@@ -154,7 +197,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,147 @@
+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 SCSS 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 SCSS parser. */
+var ScssParseError = 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 ?? `SCSS parser error.${detail}`);
+		this.name = "ScssParseError";
+		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;
+	}
+};
+/**
+* A media/layer/supports postlude belongs to the plain CSS `@import` form only.
+*
+* Once the parser has decided an `@import` is compile-time — a Sass partial
+* rather than a `.css` file or a URL — a trailing query has nothing left to
+* describe: the partial's rules are spliced into this document, not linked as a
+* separate CSS resource.
+*/
+var ScssImportPostludeError = class extends SyntaxError {
+	code = "parse/import-postlude-on-compile-time-import";
+	offset;
+	endOffset;
+	reason = "A media, layer, or supports query is only valid on a plain CSS @import.";
+	fix = "Drop the query, or wrap the import in an explicit @media/@supports/@layer block.";
+	constructor(offset, endOffset) {
+		super("A compile-time @import cannot carry a media query.");
+		this.name = "ScssImportPostludeError";
+		this.offset = offset;
+		this.endOffset = endOffset;
+	}
+};
+//#endregion
+//#region src/parse-with.ts
+/**
+* The `parse()` body, 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);
+}
+/**
+* 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) {
+	const entry = grammar.Stylesheet;
+	const trivia = grammar.whitespace;
+	if (entry === void 0 || trivia === void 0) throw new TypeError("SCSS 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 ScssParseError(result.span.start, result.expected, lineOptions(input, result.span));
+	if (result.unconsumedFrom !== null) {
+		if (isStylesheet(result.value) && result.value.rules.length > 0) throw new ScssParseError(result.unconsumedFrom, [], {
+			message: "Unexpected SCSS input after a complete stylesheet.",
+			reason: "The parser read a complete SCSS 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 ScssParseError(result.unconsumedFrom, [], {
+			message: "Unexpected SCSS syntax.",
+			reason: "The parser could not read this token as the start of an SCSS rule, declaration, or at-rule.",
+			fix: "Remove the token, or rewrite it as a selector block, a \"$name: value\" assignment, or an at-rule such as @mixin or @include.",
+			...positionAt(input, result.unconsumedFrom)
+		});
+	}
+	if (!isStylesheet(result.value)) throw new ScssParseError(result.span.end, [], {
+		message: "SCSS parser did not produce a stylesheet.",
+		reason: "The SCSS 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)
+	});
+	return (0, _jesscss_core_ast.withTriviaMap)((0, _jesscss_core_ast.withSourceSpan)(result.value, result.span), (0, _jesscss_core_ast.createTriviaMapFromParseman)(input, result.rootTrivia?.index));
+}
+//#endregion
+Object.defineProperty(exports, "ScssImportPostludeError", {
+	enumerable: true,
+	get: function() {
+		return ScssImportPostludeError;
+	}
+});
+Object.defineProperty(exports, "ScssParseError", {
+	enumerable: true,
+	get: function() {
+		return ScssParseError;
+	}
+});
+Object.defineProperty(exports, "parseWith", {
+	enumerable: true,
+	get: function() {
+		return parseWith;
+	}
+});

package/lib/chunks/parse-with.js

@@ -0,0 +1,130 @@
+import { t as commentTriviaLabels } from "./trivia-labels.js";
+import { buildLineIndex, offsetToLineCol, run } from "parseman";
+import { createTriviaMapFromParseman, withSourceSpan, withTriviaMap } from "@jesscss/core/ast";
+//#region src/parse-error.ts
+/**
+* The public SCSS 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 SCSS parser. */
+var ScssParseError = 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 ?? `SCSS parser error.${detail}`);
+		this.name = "ScssParseError";
+		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;
+	}
+};
+/**
+* A media/layer/supports postlude belongs to the plain CSS `@import` form only.
+*
+* Once the parser has decided an `@import` is compile-time — a Sass partial
+* rather than a `.css` file or a URL — a trailing query has nothing left to
+* describe: the partial's rules are spliced into this document, not linked as a
+* separate CSS resource.
+*/
+var ScssImportPostludeError = class extends SyntaxError {
+	code = "parse/import-postlude-on-compile-time-import";
+	offset;
+	endOffset;
+	reason = "A media, layer, or supports query is only valid on a plain CSS @import.";
+	fix = "Drop the query, or wrap the import in an explicit @media/@supports/@layer block.";
+	constructor(offset, endOffset) {
+		super("A compile-time @import cannot carry a media query.");
+		this.name = "ScssImportPostludeError";
+		this.offset = offset;
+		this.endOffset = endOffset;
+	}
+};
+//#endregion
+//#region src/parse-with.ts
+/**
+* The `parse()` body, 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);
+}
+/**
+* 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) {
+	const entry = grammar.Stylesheet;
+	const trivia = grammar.whitespace;
+	if (entry === void 0 || trivia === void 0) throw new TypeError("SCSS AST grammar is missing its public document entry.");
+	const result = run(entry, input, {
+		trivia,
+		rootTrivia: { select: commentTriviaLabels }
+	});
+	if (!result.ok) throw new ScssParseError(result.span.start, result.expected, lineOptions(input, result.span));
+	if (result.unconsumedFrom !== null) {
+		if (isStylesheet(result.value) && result.value.rules.length > 0) throw new ScssParseError(result.unconsumedFrom, [], {
+			message: "Unexpected SCSS input after a complete stylesheet.",
+			reason: "The parser read a complete SCSS 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 ScssParseError(result.unconsumedFrom, [], {
+			message: "Unexpected SCSS syntax.",
+			reason: "The parser could not read this token as the start of an SCSS rule, declaration, or at-rule.",
+			fix: "Remove the token, or rewrite it as a selector block, a \"$name: value\" assignment, or an at-rule such as @mixin or @include.",
+			...positionAt(input, result.unconsumedFrom)
+		});
+	}
+	if (!isStylesheet(result.value)) throw new ScssParseError(result.span.end, [], {
+		message: "SCSS parser did not produce a stylesheet.",
+		reason: "The SCSS 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)
+	});
+	return withTriviaMap(withSourceSpan(result.value, result.span), createTriviaMapFromParseman(input, result.rootTrivia?.index));
+}
+//#endregion
+export { ScssImportPostludeError as n, ScssParseError as r, parseWith as t };

package/lib/chunks/trivia-labels.cjs

@@ -0,0 +1,18 @@
+//#region src/trivia-labels.ts
+/**
+* Root-trivia label selection for the SCSS 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 SCSS 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 SCSS 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 SCSS to a CST whose spans carry line and column facts. */
+function parseScssCst(input, startRule = "Stylesheet", options) {
+	return (0, _jesscss_css_parser_cst_host.parseCst)(src_grammar_cst_positions_js.scssCstPositionsGrammar, input, startRule, options, require_trivia_labels.commentTriviaLabels);
+}
+/** Incremental (`.edit()`-able) SCSS document with line and column facts. */
+function parseScssDoc(input, startRule = "Stylesheet") {
+	return (0, _jesscss_css_parser_cst_host.parseDocCst)(src_grammar_cst_positions_js.scssCstPositionsGrammar, input, startRule);
+}
+//#endregion
+exports.commentTriviaLabels = require_trivia_labels.commentTriviaLabels;
+exports.parseScssCst = parseScssCst;
+exports.parseScssDoc = parseScssDoc;

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

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 SCSS to a CST. Spans carry offsets only; for line/column facts import
+* the same functions from `@jesscss/scss-parser/cst/positions`, which binds the
+* line-aware compiled table. This entry never loads that table.
+*/
 function parseScssCst(input, startRule = "Stylesheet", options) {
-	return (0, _jesscss_css_parser_cst.parseCst)(require_grammar.scssCstGrammar, input, startRule, options);
+	return (0, _jesscss_css_parser_cst_host.parseCst)(src_grammar_cst_js.scssCstGrammar, input, startRule, options, require_trivia_labels.commentTriviaLabels);
 }
 /** Incremental (`.edit()`-able) SCSS document — see `parseDocCst`. */
 function parseScssDoc(input, startRule = "Stylesheet") {
-	return (0, _jesscss_css_parser_cst.parseDocCst)(require_grammar.scssCstGrammar, input, startRule);
+	return (0, _jesscss_css_parser_cst_host.parseDocCst)(src_grammar_cst_js.scssCstGrammar, input, startRule);
 }
 //#endregion
+exports.commentTriviaLabels = require_trivia_labels.commentTriviaLabels;
 exports.parseScssCst = parseScssCst;
 exports.parseScssDoc = parseScssDoc;

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 SCSS to a CST. Spans carry offsets only; for line/column facts import
+ * the same functions from `@jesscss/scss-parser/cst/positions`, which binds the
+ * line-aware compiled table. This entry never loads that table.
+ */
 export declare function parseScssCst(input: string, startRule?: string, options?: CssCstParseOptions): CssCstParseResult;
 /** Incremental (`.edit()`-able) SCSS document — see `parseDocCst`. */
 export declare function parseScssDoc(input: string, startRule?: string): ParseDoc<CssCstNode>;
-export type { CssCstChild as ScssCstChild, CssCstError as ScssCstError, CssCstLeaf as ScssCstLeaf, CssCstNode as ScssCstNode, CssCstParseOptions as ScssCstParseOptions, CssCstParseResult as ScssCstParseResult, CssCstType as ScssCstType } from '@jesscss/css-parser/cst';
+export type { CssCstChild as ScssCstChild, CssCstError as ScssCstError, CssCstLeaf as ScssCstLeaf, CssCstNode as ScssCstNode, CssCstParseOptions as ScssCstParseOptions, CssCstParseResult as ScssCstParseResult, CssCstType as ScssCstType } from '@jesscss/css-parser/cst-host';

package/lib/cst.js

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