@jesscss/scss-parser 2.0.0-alpha.7 → 2.0.0-alpha.8

package/README.md

@@ -1,8 +1,25 @@
 # @jesscss/scss-parser
 
-A [SCSS/Sass](https://sass-lang.com/) parser built on [parseman](https://www.npmjs.com/package/parseman). The grammar is the CSS grammar plus an SCSS delta: `scssGrammar = compose([cssGrammar, <SCSS delta>])`, layered on the shared CSS base in `@jesscss/css-parser`.
+An SCSS grammar for Jess, layered on the CSS base parser — **experimental, and not the focus of the Less alpha.**
 
-The goal is **parse coverage**: not every Sass/SCSS feature is necessarily *evaluated*, but the surface syntax should parse. This is the earliest-stage of the four Jess parsers (`2.0.0-alpha.1`).
+> **Status: experimental / roadmap.** Part of [Jess](https://github.com/jesscss/jess), which *is* Less.js v5. Only `.less` rendering ships today. SCSS is **not a goal of this phase** — this parser is early and exists to seed the future **"Sass+"** dialect (roadmap milestone #2, after Less.js). Don't rely on it for production; prefer [`@jesscss/css-parser`](https://www.npmjs.com/package/@jesscss/css-parser) / [`@jesscss/less-parser`](https://www.npmjs.com/package/@jesscss/less-parser). [Report bugs](https://github.com/jesscss/jess/issues); docs live at [jesscss.github.io](https://jesscss.github.io/).
+
+## What it is
+
+The SCSS grammar is the shared CSS grammar plus an SCSS delta:
+`scssGrammar = compose([cssGrammar, <SCSS delta>])`, layered on the spec-aligned
+CSS base in `@jesscss/css-parser` and 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).
+
+The current goal is **parse coverage**: the surface `$`-variable / SCSS syntax
+should parse into a tree, but not every Sass/SCSS feature is necessarily
+*evaluated*. This is the least-mature of the Jess parsers (the `.jess` parser
+trails it), and the seed for the roadmap "Sass+" dialect rather than a shipped
+Sass replacement. The language roadmap is ordered: **Now Less.js → Next Sass+ →
+Final `.jess`.**
 
 Two ways to use it:
 
@@ -129,4 +146,4 @@ type BuildHost = (
 
 ## Part of Jess
 
-This package is developed as part of [Jess](https://github.com/jesscss/jess). The core-coupled `.` entry integrates with `@jesscss/core`; the `./cst` and `./grammar` entries are usable on their own. SCSS is the least-mature of the Jess dialects — prefer `@jesscss/css-parser` / `@jesscss/less-parser` for production use.
+This package is developed as part of [Jess](https://github.com/jesscss/jess), the Less.js v5 rewrite. SCSS is the least-mature Jess dialect and is not the focus of the Less alpha — it seeds the roadmap "Sass+" dialect. For production use, prefer `@jesscss/css-parser` / `@jesscss/less-parser`. Licensed MIT.

package/lib/functional-parser.cjs

@@ -2,7 +2,7 @@ const require_grammar = require("./grammar.cjs");
 let _jesscss_less_parser_jess = require("@jesscss/less-parser/jess");
 let _jesscss_css_parser_jess = require("@jesscss/css-parser/jess");
 let _jesscss_core = require("@jesscss/core");
-//#region ../../node_modules/.pnpm/parseman@0.25.0/node_modules/parseman/dist/index.js
+//#region ../../../parser-thing/dist/index.js
 function union(a, b) {
 	if (a.kind === "any" || b.kind === "any") return { kind: "any" };
 	if (a.kind === "empty") return b;
@@ -88,6 +88,48 @@ function sequenceFirstSet(parsers) {
 	}
 	return fs;
 }
+function firstSetOf(p, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(p)) return any();
+	seen.add(p);
+	const fs = (c) => firstSetOf(c, seen);
+	const d = p._def;
+	switch (d.tag) {
+		case "literal":
+		case "regex":
+		case "keywords": return p._meta.firstSet;
+		case "lazy": try {
+			return fs(d.thunk());
+		} catch {
+			return any();
+		}
+		case "choice": {
+			let out = empty();
+			for (const arm of d.parsers) out = union(out, fs(arm));
+			return out;
+		}
+		case "sequence": {
+			let out = empty();
+			for (const term of d.parsers) {
+				out = union(out, fs(term));
+				if (!matchesEmpty(term)) return out;
+			}
+			return out;
+		}
+		case "oneOrMore":
+		case "many":
+		case "optional":
+		case "transform":
+		case "label":
+		case "trivia":
+		case "token":
+		case "node":
+		case "grammar":
+		case "expect": return fs(d.parser);
+		case "sepBy": return fs(d.parser);
+		case "skip": return fs(d.main);
+		default: return p._meta.firstSet;
+	}
+}
 function mergeRanges(ranges) {
 	if (ranges.length === 0) return [];
 	const sorted = [...ranges].sort((a, b) => a.lo - b.lo);
@@ -178,7 +220,8 @@ function saveCstMark(ctx) {
 		raw: cstRawLen(ctx),
 		tlog: cstTlLen(ctx),
 		leaves: cstLeavesLen(ctx),
-		fields: ctx._fields?.length ?? 0
+		fields: ctx._fields?.length ?? 0,
+		errors: ctx._errors?.length ?? 0
 	};
 }
 function rollbackBufList(b, keyMulti, keySingle, len) {
@@ -194,6 +237,7 @@ function rollbackBufList(b, keyMulti, keySingle, len) {
 	if (len === 0) b[keySingle] = void 0;
 }
 function rollbackCstCapture(ctx, mark) {
+	if (ctx._errors && mark.errors !== void 0) ctx._errors.length = mark.errors;
 	const b = ctx._cstBuf;
 	if (b) {
 		rollbackBufList(b, "raw", "rawSingle", mark.raw);
@@ -757,11 +801,74 @@ function firstSetFromRegex(source) {
 		canMatchNewline: firstCanBeNewline(ast)
 	};
 }
+function firstSetSentinel(fs) {
+	if (fs.kind !== "ranges" || fs.ranges.length === 0) return null;
+	const ranges = fs.ranges;
+	return {
+		_tag: "firstSetSentinel",
+		_meta: {
+			firstSet: fs,
+			canMatchNewline: false,
+			isTrivia: false
+		},
+		_def: { tag: "unknown" },
+		parse(input, pos) {
+			const code = pos < input.length ? input.codePointAt(pos) : void 0;
+			if (code !== void 0) {
+				for (const r of ranges) if (code >= r.lo && code <= r.hi) return {
+					ok: true,
+					value: null,
+					span: {
+						start: pos,
+						end: pos
+					}
+				};
+			}
+			return {
+				ok: false,
+				expected: [],
+				span: {
+					start: pos,
+					end: pos
+				}
+			};
+		}
+	};
+}
+function deriveExpected(c) {
+	const def = c._def;
+	switch (def.tag) {
+		case "literal": return [JSON.stringify(def.value)];
+		case "regex": return [`/${def.source}/`];
+		case "keywords": return def.words.map((w) => JSON.stringify(w));
+		case "label": return [def.label];
+		case "choice": return def.parsers.flatMap(deriveExpected);
+		case "sequence": return def.parsers.length > 0 ? deriveExpected(def.parsers[0]) : [];
+		case "node":
+		case "grammar":
+		case "trivia":
+		case "token":
+		case "optional":
+		case "many":
+		case "oneOrMore":
+		case "transform":
+		case "not": return deriveExpected(def.parser);
+		case "lazy": {
+			const name = c._ruleName;
+			try {
+				return deriveExpected(def.thunk());
+			} catch {
+				return name ? [name] : [];
+			}
+		}
+		default: return [];
+	}
+}
 function choice(...args) {
 	const parsers = args.map((a) => "gate" in a ? a.combinator : a);
 	const gates = args.map((a) => "gate" in a ? a.gate : null);
 	const hasGates = gates.some((g) => g !== null);
-	const disjoint = !hasGates && areDisjoint(parsers.map((p) => p._meta.firstSet));
+	const disjoint = areDisjoint(parsers.map((p) => p._meta.firstSet)) && parsers.every((p) => !matchesEmpty(p));
 	let combined = { kind: "empty" };
 	for (const p of parsers) combined = union(combined, p._meta.firstSet);
 	const meta = {
@@ -798,15 +905,24 @@ function choice(...args) {
 			const expected = [];
 			if (disjoint && pos < input.length) {
 				const code = input.codePointAt(pos);
-				let parser2 = code < 128 ? asciiDispatch?.[code] ?? null : null;
-				if (!parser2) {
-					for (const p of parsers) if (inFirstSet(code, p._meta.firstSet)) {
-						parser2 = p;
+				let idx = code < 128 ? asciiDispatch[code] : -1;
+				if (idx < 0) {
+					for (let i = 0; i < parsers.length; i++) if (inFirstSet(code, parsers[i]._meta.firstSet)) {
+						idx = i;
 						break;
 					}
 				}
-				if (parser2) {
-					const result = parser2.parse(input, pos, ctx);
+				if (idx >= 0) {
+					const gate = gates[idx];
+					if (gate && !gate(ctx.state)) return {
+						ok: false,
+						expected: deriveExpected(parsers[idx]),
+						span: {
+							start: pos,
+							end: pos
+						}
+					};
+					const result = parsers[idx].parse(input, pos, ctx);
 					if (result.ok) return result;
 					expected.push(...result.expected);
 					return {
@@ -1026,11 +1142,11 @@ function areDisjoint(sets) {
 	return true;
 }
 function buildAsciiDispatch(parsers) {
-	const table = Array(128).fill(null);
-	for (const parser2 of parsers) {
-		const fs = parser2._meta.firstSet;
+	const table = Array(128).fill(-1);
+	for (let i = 0; i < parsers.length; i++) {
+		const fs = parsers[i]._meta.firstSet;
 		if (fs.kind !== "ranges") continue;
-		for (const { lo, hi } of fs.ranges) for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) table[code] = parser2;
+		for (const { lo, hi } of fs.ranges) for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) table[code] = i;
 	}
 	return table;
 }
@@ -1201,6 +1317,7 @@ function saveTriviaMark(ctx) {
 		tlog: m.tlog,
 		leaves: m.leaves,
 		fields: m.fields,
+		errors: m.errors,
 		log: ctx._triviaLog ? ctx._triviaLog.length : 0
 	};
 }
@@ -1209,7 +1326,8 @@ function rollbackTrivia(ctx, mark) {
 		raw: mark.raw,
 		tlog: mark.tlog,
 		leaves: mark.leaves,
-		fields: mark.fields
+		fields: mark.fields,
+		errors: mark.errors
 	});
 	if (ctx._triviaLog) ctx._triviaLog.length = mark.log;
 }
@@ -1474,11 +1592,55 @@ function sequence(...parsers) {
 		tag: "sequence",
 		parsers
 	};
+	let followSentinels;
+	function parseTolerant(input, pos, ctx) {
+		followSentinels ??= parsers.map((_, i) => {
+			return firstSetSentinel(parsers.slice(i + 1).reduce((acc, p) => union(acc, firstSetOf(p)), { kind: "empty" }));
+		});
+		const values = def.valueUnused ? void 0 : [];
+		let cur = pos;
+		const inheritedSync = ctx._sync;
+		try {
+			for (let i = 0; i < parsers.length; i++) {
+				ctx._sync = followSentinels[i] ?? inheritedSync;
+				if (ctx.trivia && i > 0) {
+					const mark = saveTriviaMark(ctx);
+					let scanEnd;
+					if (needsDeferredTriviaCommit(ctx)) {
+						const scan = scanTrivia(input, cur, ctx);
+						scan.commit();
+						scanEnd = scan.end;
+					} else scanEnd = advanceTrivia(input, cur, ctx);
+					const result2 = parsers[i].parse(input, scanEnd, ctx);
+					if (!result2.ok) return result2;
+					if (result2.span.end > scanEnd) cur = result2.span.end;
+					else rollbackTrivia(ctx, mark);
+					if (values !== void 0) values.push(result2.value);
+					continue;
+				}
+				const result = parsers[i].parse(input, cur, ctx);
+				if (!result.ok) return result;
+				if (values !== void 0) values.push(result.value);
+				cur = result.span.end;
+			}
+		} finally {
+			ctx._sync = inheritedSync;
+		}
+		return {
+			ok: true,
+			value: values ?? void 0,
+			span: {
+				start: pos,
+				end: cur
+			}
+		};
+	}
 	return {
 		_tag: "sequence",
 		_meta: meta,
 		_def: def,
 		parse(input, pos, ctx) {
+			if (ctx._tolerant) return parseTolerant(input, pos, ctx);
 			const values = def.valueUnused ? void 0 : [];
 			let cur = pos;
 			for (let i = 0; i < parsers.length; i++) {

package/lib/functional-parser.js

@@ -2,7 +2,7 @@ import { scssGrammar } from "./grammar.js";
 import { LessGrammar } from "@jesscss/less-parser/jess";
 import { runFunctionalParse, spannedComponents } from "@jesscss/css-parser/jess";
 import { Ampersand, Any, AtRule, AtRuleStatement, Call, Collection, ComplexSelector, Condition, Declaration, Expression, Extend, ExtendFlag, F_VISIBLE, For, Func, INTERPOLATION_PLACEHOLDER, If, Interpolated, InterpolatedSelector, JsImport, List, Log, Mixin, N, Nil, Node, Operation, Paren, Quoted, Reference, Rest, Rules, Ruleset, SelectorCapture, SelectorList, Sequence, StyleImport, Url, VarDeclaration, While, isNode, sourceSpanOf } from "@jesscss/core";
-//#region ../../node_modules/.pnpm/parseman@0.25.0/node_modules/parseman/dist/index.js
+//#region ../../../parser-thing/dist/index.js
 function union(a, b) {
 	if (a.kind === "any" || b.kind === "any") return { kind: "any" };
 	if (a.kind === "empty") return b;
@@ -88,6 +88,48 @@ function sequenceFirstSet(parsers) {
 	}
 	return fs;
 }
+function firstSetOf(p, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(p)) return any();
+	seen.add(p);
+	const fs = (c) => firstSetOf(c, seen);
+	const d = p._def;
+	switch (d.tag) {
+		case "literal":
+		case "regex":
+		case "keywords": return p._meta.firstSet;
+		case "lazy": try {
+			return fs(d.thunk());
+		} catch {
+			return any();
+		}
+		case "choice": {
+			let out = empty();
+			for (const arm of d.parsers) out = union(out, fs(arm));
+			return out;
+		}
+		case "sequence": {
+			let out = empty();
+			for (const term of d.parsers) {
+				out = union(out, fs(term));
+				if (!matchesEmpty(term)) return out;
+			}
+			return out;
+		}
+		case "oneOrMore":
+		case "many":
+		case "optional":
+		case "transform":
+		case "label":
+		case "trivia":
+		case "token":
+		case "node":
+		case "grammar":
+		case "expect": return fs(d.parser);
+		case "sepBy": return fs(d.parser);
+		case "skip": return fs(d.main);
+		default: return p._meta.firstSet;
+	}
+}
 function mergeRanges(ranges) {
 	if (ranges.length === 0) return [];
 	const sorted = [...ranges].sort((a, b) => a.lo - b.lo);
@@ -178,7 +220,8 @@ function saveCstMark(ctx) {
 		raw: cstRawLen(ctx),
 		tlog: cstTlLen(ctx),
 		leaves: cstLeavesLen(ctx),
-		fields: ctx._fields?.length ?? 0
+		fields: ctx._fields?.length ?? 0,
+		errors: ctx._errors?.length ?? 0
 	};
 }
 function rollbackBufList(b, keyMulti, keySingle, len) {
@@ -194,6 +237,7 @@ function rollbackBufList(b, keyMulti, keySingle, len) {
 	if (len === 0) b[keySingle] = void 0;
 }
 function rollbackCstCapture(ctx, mark) {
+	if (ctx._errors && mark.errors !== void 0) ctx._errors.length = mark.errors;
 	const b = ctx._cstBuf;
 	if (b) {
 		rollbackBufList(b, "raw", "rawSingle", mark.raw);
@@ -757,11 +801,74 @@ function firstSetFromRegex(source) {
 		canMatchNewline: firstCanBeNewline(ast)
 	};
 }
+function firstSetSentinel(fs) {
+	if (fs.kind !== "ranges" || fs.ranges.length === 0) return null;
+	const ranges = fs.ranges;
+	return {
+		_tag: "firstSetSentinel",
+		_meta: {
+			firstSet: fs,
+			canMatchNewline: false,
+			isTrivia: false
+		},
+		_def: { tag: "unknown" },
+		parse(input, pos) {
+			const code = pos < input.length ? input.codePointAt(pos) : void 0;
+			if (code !== void 0) {
+				for (const r of ranges) if (code >= r.lo && code <= r.hi) return {
+					ok: true,
+					value: null,
+					span: {
+						start: pos,
+						end: pos
+					}
+				};
+			}
+			return {
+				ok: false,
+				expected: [],
+				span: {
+					start: pos,
+					end: pos
+				}
+			};
+		}
+	};
+}
+function deriveExpected(c) {
+	const def = c._def;
+	switch (def.tag) {
+		case "literal": return [JSON.stringify(def.value)];
+		case "regex": return [`/${def.source}/`];
+		case "keywords": return def.words.map((w) => JSON.stringify(w));
+		case "label": return [def.label];
+		case "choice": return def.parsers.flatMap(deriveExpected);
+		case "sequence": return def.parsers.length > 0 ? deriveExpected(def.parsers[0]) : [];
+		case "node":
+		case "grammar":
+		case "trivia":
+		case "token":
+		case "optional":
+		case "many":
+		case "oneOrMore":
+		case "transform":
+		case "not": return deriveExpected(def.parser);
+		case "lazy": {
+			const name = c._ruleName;
+			try {
+				return deriveExpected(def.thunk());
+			} catch {
+				return name ? [name] : [];
+			}
+		}
+		default: return [];
+	}
+}
 function choice(...args) {
 	const parsers = args.map((a) => "gate" in a ? a.combinator : a);
 	const gates = args.map((a) => "gate" in a ? a.gate : null);
 	const hasGates = gates.some((g) => g !== null);
-	const disjoint = !hasGates && areDisjoint(parsers.map((p) => p._meta.firstSet));
+	const disjoint = areDisjoint(parsers.map((p) => p._meta.firstSet)) && parsers.every((p) => !matchesEmpty(p));
 	let combined = { kind: "empty" };
 	for (const p of parsers) combined = union(combined, p._meta.firstSet);
 	const meta = {
@@ -798,15 +905,24 @@ function choice(...args) {
 			const expected = [];
 			if (disjoint && pos < input.length) {
 				const code = input.codePointAt(pos);
-				let parser2 = code < 128 ? asciiDispatch?.[code] ?? null : null;
-				if (!parser2) {
-					for (const p of parsers) if (inFirstSet(code, p._meta.firstSet)) {
-						parser2 = p;
+				let idx = code < 128 ? asciiDispatch[code] : -1;
+				if (idx < 0) {
+					for (let i = 0; i < parsers.length; i++) if (inFirstSet(code, parsers[i]._meta.firstSet)) {
+						idx = i;
 						break;
 					}
 				}
-				if (parser2) {
-					const result = parser2.parse(input, pos, ctx);
+				if (idx >= 0) {
+					const gate = gates[idx];
+					if (gate && !gate(ctx.state)) return {
+						ok: false,
+						expected: deriveExpected(parsers[idx]),
+						span: {
+							start: pos,
+							end: pos
+						}
+					};
+					const result = parsers[idx].parse(input, pos, ctx);
 					if (result.ok) return result;
 					expected.push(...result.expected);
 					return {
@@ -1026,11 +1142,11 @@ function areDisjoint(sets) {
 	return true;
 }
 function buildAsciiDispatch(parsers) {
-	const table = Array(128).fill(null);
-	for (const parser2 of parsers) {
-		const fs = parser2._meta.firstSet;
+	const table = Array(128).fill(-1);
+	for (let i = 0; i < parsers.length; i++) {
+		const fs = parsers[i]._meta.firstSet;
 		if (fs.kind !== "ranges") continue;
-		for (const { lo, hi } of fs.ranges) for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) table[code] = parser2;
+		for (const { lo, hi } of fs.ranges) for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) table[code] = i;
 	}
 	return table;
 }
@@ -1201,6 +1317,7 @@ function saveTriviaMark(ctx) {
 		tlog: m.tlog,
 		leaves: m.leaves,
 		fields: m.fields,
+		errors: m.errors,
 		log: ctx._triviaLog ? ctx._triviaLog.length : 0
 	};
 }
@@ -1209,7 +1326,8 @@ function rollbackTrivia(ctx, mark) {
 		raw: mark.raw,
 		tlog: mark.tlog,
 		leaves: mark.leaves,
-		fields: mark.fields
+		fields: mark.fields,
+		errors: mark.errors
 	});
 	if (ctx._triviaLog) ctx._triviaLog.length = mark.log;
 }
@@ -1474,11 +1592,55 @@ function sequence(...parsers) {
 		tag: "sequence",
 		parsers
 	};
+	let followSentinels;
+	function parseTolerant(input, pos, ctx) {
+		followSentinels ??= parsers.map((_, i) => {
+			return firstSetSentinel(parsers.slice(i + 1).reduce((acc, p) => union(acc, firstSetOf(p)), { kind: "empty" }));
+		});
+		const values = def.valueUnused ? void 0 : [];
+		let cur = pos;
+		const inheritedSync = ctx._sync;
+		try {
+			for (let i = 0; i < parsers.length; i++) {
+				ctx._sync = followSentinels[i] ?? inheritedSync;
+				if (ctx.trivia && i > 0) {
+					const mark = saveTriviaMark(ctx);
+					let scanEnd;
+					if (needsDeferredTriviaCommit(ctx)) {
+						const scan = scanTrivia(input, cur, ctx);
+						scan.commit();
+						scanEnd = scan.end;
+					} else scanEnd = advanceTrivia(input, cur, ctx);
+					const result2 = parsers[i].parse(input, scanEnd, ctx);
+					if (!result2.ok) return result2;
+					if (result2.span.end > scanEnd) cur = result2.span.end;
+					else rollbackTrivia(ctx, mark);
+					if (values !== void 0) values.push(result2.value);
+					continue;
+				}
+				const result = parsers[i].parse(input, cur, ctx);
+				if (!result.ok) return result;
+				if (values !== void 0) values.push(result.value);
+				cur = result.span.end;
+			}
+		} finally {
+			ctx._sync = inheritedSync;
+		}
+		return {
+			ok: true,
+			value: values ?? void 0,
+			span: {
+				start: pos,
+				end: cur
+			}
+		};
+	}
 	return {
 		_tag: "sequence",
 		_meta: meta,
 		_def: def,
 		parse(input, pos, ctx) {
+			if (ctx._tolerant) return parseTolerant(input, pos, ctx);
 			const values = def.valueUnused ? void 0 : [];
 			let cur = pos;
 			for (let i = 0; i < parsers.length; i++) {