@jesscss/scss-parser 2.0.0-alpha.7

package/lib/functional-parser.js

@@ -0,0 +1,2855 @@
+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
+function union(a, b) {
+	if (a.kind === "any" || b.kind === "any") return { kind: "any" };
+	if (a.kind === "empty") return b;
+	if (b.kind === "empty") return a;
+	return {
+		kind: "ranges",
+		ranges: mergeRanges([...a.ranges, ...b.ranges])
+	};
+}
+function intersects(a, b) {
+	if (a.kind === "any" || b.kind === "any") return true;
+	if (a.kind === "empty" || b.kind === "empty") return false;
+	for (const ra of a.ranges) for (const rb of b.ranges) if (ra.lo <= rb.hi && rb.lo <= ra.hi) return true;
+	return false;
+}
+function fromChar(code) {
+	return {
+		kind: "ranges",
+		ranges: [{
+			lo: code,
+			hi: code
+		}]
+	};
+}
+function fromRange(lo, hi) {
+	return {
+		kind: "ranges",
+		ranges: [{
+			lo,
+			hi
+		}]
+	};
+}
+function any() {
+	return { kind: "any" };
+}
+function empty() {
+	return { kind: "empty" };
+}
+function matchesEmpty(p, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(p)) return true;
+	seen.add(p);
+	const me = (c) => matchesEmpty(c, seen);
+	const d = p._def;
+	switch (d.tag) {
+		case "literal": return d.value.length === 0;
+		case "keywords": return false;
+		case "regex": try {
+			const m = new RegExp(d.source).exec("");
+			return m != null && m[0] === "";
+		} catch {
+			return true;
+		}
+		case "many":
+		case "optional":
+		case "not": return true;
+		case "oneOrMore": return me(d.parser);
+		case "sequence": return d.parsers.every(me);
+		case "choice": return d.parsers.some(me);
+		case "transform":
+		case "label":
+		case "trivia":
+		case "token":
+		case "expect":
+		case "withCtx":
+		case "node":
+		case "grammar":
+		case "recover": return me(d.parser);
+		case "skip": return me(d.main);
+		case "lazy": try {
+			return me(d.thunk());
+		} catch {
+			return true;
+		}
+		default: return true;
+	}
+}
+function sequenceFirstSet(parsers) {
+	let fs = empty();
+	for (const p of parsers) {
+		fs = union(fs, p._meta.firstSet);
+		if (!matchesEmpty(p)) return fs;
+	}
+	return fs;
+}
+function mergeRanges(ranges) {
+	if (ranges.length === 0) return [];
+	const sorted = [...ranges].sort((a, b) => a.lo - b.lo);
+	const out = [{
+		lo: sorted[0].lo,
+		hi: sorted[0].hi
+	}];
+	for (let i = 1; i < sorted.length; i++) {
+		const top = out[out.length - 1];
+		const cur = sorted[i];
+		if (cur.lo <= top.hi + 1) {
+			if (cur.hi > top.hi) top.hi = cur.hi;
+		} else out.push({
+			lo: cur.lo,
+			hi: cur.hi
+		});
+	}
+	return out;
+}
+function failAt(ctx, expected, pos) {
+	const r = {
+		ok: false,
+		expected,
+		span: {
+			start: pos,
+			end: pos
+		}
+	};
+	const probe = ctx._probe;
+	if (probe !== void 0 && pos <= probe.offset) {
+		const best = probe.best;
+		if (best === null || pos > best.span.start) probe.best = r;
+		else if (pos === best.span.start) probe.best = {
+			...best,
+			expected: [...best.expected, ...expected]
+		};
+	}
+	return r;
+}
+function cstCaptureActive(ctx) {
+	return ctx._cstBuf !== void 0 || ctx._cstLeaves !== void 0;
+}
+function pushCstLeaf(ctx, leaf) {
+	pushCstChild(ctx, leaf, leaf);
+}
+function pushCstChild(ctx, built, rawEntry) {
+	const b = ctx._cstBuf;
+	if (b) {
+		if (b.ch) b.ch.push(built);
+		else if (b.single !== void 0) {
+			b.ch = [b.single, built];
+			b.single = void 0;
+		} else b.single = built;
+		if (b.raw) b.raw.push(rawEntry);
+		else if (b.rawSingle !== void 0) {
+			b.raw = [b.rawSingle, rawEntry];
+			b.rawSingle = void 0;
+		} else b.rawSingle = rawEntry;
+		return;
+	}
+	if (ctx._cstChildren) ctx._cstChildren.push(built);
+	else if (ctx._cstLeaves) ctx._cstLeaves.push(built);
+	if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry);
+}
+function cstRawLen(ctx) {
+	const b = ctx._cstBuf;
+	if (b) {
+		if (b.raw) return b.raw.length;
+		return b.rawSingle !== void 0 ? 1 : 0;
+	}
+	return ctx._cstRawChildren?.length ?? 0;
+}
+function cstLeavesLen(ctx) {
+	const b = ctx._cstBuf;
+	if (b) {
+		if (b.ch) return b.ch.length;
+		return b.single !== void 0 ? 1 : 0;
+	}
+	return ctx._cstLeaves?.length ?? 0;
+}
+function cstTlLen(ctx) {
+	const b = ctx._cstBuf;
+	if (b) return b.tl?.length ?? 0;
+	return ctx._cstTriviaLog?.length ?? 0;
+}
+function saveCstMark(ctx) {
+	return {
+		raw: cstRawLen(ctx),
+		tlog: cstTlLen(ctx),
+		leaves: cstLeavesLen(ctx),
+		fields: ctx._fields?.length ?? 0
+	};
+}
+function rollbackBufList(b, keyMulti, keySingle, len) {
+	const arr = b[keyMulti];
+	if (arr) {
+		if (len === 0) b[keyMulti] = void 0;
+		else if (len === 1) {
+			b[keySingle] = arr[0];
+			b[keyMulti] = void 0;
+		} else arr.length = len;
+		return;
+	}
+	if (len === 0) b[keySingle] = void 0;
+}
+function rollbackCstCapture(ctx, mark) {
+	const b = ctx._cstBuf;
+	if (b) {
+		rollbackBufList(b, "raw", "rawSingle", mark.raw);
+		rollbackBufList(b, "ch", "single", mark.leaves);
+		if (b.tl) if (mark.tlog === 0) b.tl = void 0;
+		else b.tl.length = mark.tlog;
+		if (ctx._fields) ctx._fields.length = mark.fields;
+		return;
+	}
+	if (ctx._cstRawChildren) ctx._cstRawChildren.length = mark.raw;
+	if (ctx._cstTriviaLog) ctx._cstTriviaLog.length = mark.tlog;
+	if (ctx._cstLeaves) ctx._cstLeaves.length = mark.leaves;
+	if (ctx._fields) ctx._fields.length = mark.fields;
+}
+function pushCstTriviaEntry(ctx, start, end, kindIndex) {
+	const insertIdx = cstRawLen(ctx);
+	const b = ctx._cstBuf;
+	const withKind = ctx.triviaKindLabels !== void 0 && kindIndex !== void 0;
+	if (b) {
+		if (!b.tl) b.tl = withKind ? [
+			start,
+			end,
+			insertIdx,
+			kindIndex
+		] : [
+			start,
+			end,
+			insertIdx
+		];
+		else if (withKind) b.tl.push(start, end, insertIdx, kindIndex);
+		else b.tl.push(start, end, insertIdx);
+		return;
+	}
+	if (ctx._cstTriviaLog) if (withKind) ctx._cstTriviaLog.push(start, end, insertIdx, kindIndex);
+	else ctx._cstTriviaLog.push(start, end, insertIdx);
+}
+function pushTriviaLogEntry(ctx, start, end, kindIndex) {
+	if (!ctx._triviaLog) return;
+	if (ctx.triviaKindLabels !== void 0 && kindIndex !== void 0) ctx._triviaLog.push(start, end, kindIndex);
+	else ctx._triviaLog.push(start, end);
+}
+function asciiFoldEq(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		let ca = a.charCodeAt(i);
+		let cb = b.charCodeAt(i);
+		if (ca >= 65 && ca <= 90) ca += 32;
+		if (cb >= 65 && cb <= 90) cb += 32;
+		if (ca !== cb) return false;
+	}
+	return true;
+}
+function literal(value, opts = {}) {
+	const caseInsensitive = opts.caseInsensitive ?? false;
+	const firstSet2 = value.length > 0 ? fromChar(value.codePointAt(0)) : empty();
+	const meta = {
+		firstSet: firstSet2,
+		canMatchNewline: value.includes("\n"),
+		isTrivia: false
+	};
+	if (caseInsensitive) {
+		const upper = value.toUpperCase();
+		const lower = value.toLowerCase();
+		const firstUpper = upper.codePointAt(0);
+		const firstLower = lower.codePointAt(0);
+		meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? firstLower === firstUpper ? {
+			kind: "ranges",
+			ranges: [{
+				lo: firstLower,
+				hi: firstLower
+			}]
+		} : {
+			kind: "ranges",
+			ranges: [{
+				lo: firstLower,
+				hi: firstLower
+			}, {
+				lo: firstUpper,
+				hi: firstUpper
+			}]
+		} : firstSet2;
+	}
+	const expected = [JSON.stringify(value)];
+	const parse2 = !caseInsensitive && value.length === 1 ? (() => {
+		const code = value.charCodeAt(0);
+		return function parse3(input, pos, ctx) {
+			if (input.charCodeAt(pos) === code) {
+				const span = {
+					start: pos,
+					end: pos + 1
+				};
+				if (cstCaptureActive(ctx)) pushCstLeaf(ctx, {
+					_tag: "leaf",
+					value,
+					span
+				});
+				return {
+					ok: true,
+					value,
+					span
+				};
+			}
+			return failAt(ctx, expected, pos);
+		};
+	})() : function parse3(input, pos, ctx) {
+		const end = pos + value.length;
+		if (end > input.length) return failAt(ctx, expected, pos);
+		const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
+		if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
+			const span = {
+				start: pos,
+				end
+			};
+			if (cstCaptureActive(ctx)) pushCstLeaf(ctx, {
+				_tag: "leaf",
+				value: matchedValue,
+				span
+			});
+			return {
+				ok: true,
+				value: matchedValue,
+				span
+			};
+		}
+		return failAt(ctx, expected, pos);
+	};
+	return {
+		_tag: "literal",
+		_meta: meta,
+		_def: {
+			tag: "literal",
+			value,
+			caseInsensitive
+		},
+		parse: parse2
+	};
+}
+var CLASS_ESCAPES = {
+	t: 9,
+	n: 10,
+	r: 13,
+	f: 12,
+	v: 11,
+	"0": 0
+};
+var SPACE_RANGES = [
+	[9, 13],
+	[32, 32],
+	[160, 160],
+	[5760, 5760],
+	[8192, 8202],
+	[8232, 8232],
+	[8233, 8233],
+	[8239, 8239],
+	[8287, 8287],
+	[12288, 12288],
+	[65279, 65279]
+];
+function shorthandRanges(ch) {
+	if (ch === "d") return [[48, 57]];
+	if (ch === "s") return SPACE_RANGES;
+	return [
+		[48, 57],
+		[65, 90],
+		[97, 122],
+		[95, 95]
+	];
+}
+function readUnicodeEscape(body, i) {
+	if (body[i] !== "\\" || body[i + 1] !== "u") return null;
+	const hex = body.slice(i + 2, i + 6);
+	if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
+	return {
+		cp: Number.parseInt(hex, 16),
+		next: i + 6
+	};
+}
+function parseClassRanges(body) {
+	const ranges = [];
+	let i = 0;
+	const readAtom = () => {
+		const ch = body[i];
+		if (ch === void 0) return null;
+		if (ch === "\\") {
+			const uni = readUnicodeEscape(body, i);
+			if (uni) {
+				i = uni.next;
+				return { cp: uni.cp };
+			}
+			const e = body[i + 1];
+			if (e === void 0) return null;
+			i += 2;
+			if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e] };
+			if (e === "d" || e === "w" || e === "s") return { set: shorthandRanges(e) };
+			if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
+			return { cp: e.codePointAt(0) };
+		}
+		i += ch.length;
+		return { cp: ch.codePointAt(0) };
+	};
+	while (i < body.length) {
+		const lo = readAtom();
+		if (lo === null) return null;
+		if ("set" in lo) {
+			ranges.push(...lo.set);
+			continue;
+		}
+		if (body[i] === "-" && body[i + 1] !== void 0 && body[i + 1] !== "]") {
+			i += 1;
+			const hi = readAtom();
+			if (hi === null || "set" in hi) return null;
+			ranges.push([lo.cp, hi.cp]);
+		} else ranges.push([lo.cp, lo.cp]);
+	}
+	return ranges.length ? ranges : null;
+}
+var firstSetAnalyzer = null;
+function registerRegexAnalyzer(analyzer) {
+	firstSetAnalyzer = analyzer;
+}
+var permissiveFirstSet = () => ({
+	firstSet: any(),
+	canMatchNewline: true
+});
+var SCAN_BAIL_AT = 64;
+function inRanges(cp, ranges) {
+	for (let i = 0; i < ranges.length; i++) {
+		const [lo, hi] = ranges[i];
+		if (cp >= lo && cp <= hi) return true;
+	}
+	return false;
+}
+function readClassRanges(body) {
+	if (body.startsWith("^")) return null;
+	return parseClassRanges(body);
+}
+function shortScanner(source, flags) {
+	if (/[imsuvy]/.test(flags)) return null;
+	let ranges = null;
+	let quant = "";
+	if (source[0] === "[") {
+		let end = 1;
+		while (end < source.length && source[end] !== "]") if (source[end] === "\\") end += 2;
+		else end++;
+		if (source[end] !== "]") return null;
+		ranges = readClassRanges(source.slice(1, end));
+		quant = source.slice(end + 1);
+	} else if (source[0] === "\\" && (source[1] === "d" || source[1] === "w" || source[1] === "s")) {
+		ranges = shorthandRanges(source[1]);
+		quant = source.slice(2);
+	}
+	if (!ranges || quant !== "+" && quant !== "*") return null;
+	const minOne = quant === "+";
+	return (input, pos) => {
+		let end = pos;
+		while (end < input.length && inRanges(input.charCodeAt(end), ranges)) {
+			end++;
+			if (end - pos >= SCAN_BAIL_AT) return void 0;
+		}
+		return minOne && end === pos ? null : end;
+	};
+}
+function regex(pattern, flags = "") {
+	const source = typeof pattern === "string" ? pattern : pattern.source;
+	const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
+	const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
+	const scan = shortScanner(source, resolvedFlags);
+	const { firstSet: firstSet2, canMatchNewline } = (firstSetAnalyzer ?? permissiveFirstSet)(source);
+	return {
+		_tag: "regex",
+		_meta: {
+			firstSet: firstSet2,
+			canMatchNewline,
+			isTrivia: false
+		},
+		_def: {
+			tag: "regex",
+			source,
+			flags: resolvedFlags
+		},
+		parse(input, pos, ctx) {
+			const scanEnd = scan?.(input, pos);
+			if (scanEnd !== void 0) {
+				if (scanEnd === null) return failAt(ctx, [`/${source}/`], pos);
+				const value = input.slice(pos, scanEnd);
+				const span2 = {
+					start: pos,
+					end: scanEnd
+				};
+				if (cstCaptureActive(ctx)) pushCstLeaf(ctx, {
+					_tag: "leaf",
+					value,
+					span: span2
+				});
+				return {
+					ok: true,
+					value,
+					span: span2
+				};
+			}
+			anchored.lastIndex = pos;
+			const m = anchored.exec(input);
+			if (m === null) return failAt(ctx, [`/${source}/`], pos);
+			const span = {
+				start: pos,
+				end: pos + m[0].length
+			};
+			if (cstCaptureActive(ctx)) pushCstLeaf(ctx, {
+				_tag: "leaf",
+				value: m[0],
+				span
+			});
+			return {
+				ok: true,
+				value: m[0],
+				span
+			};
+		}
+	};
+}
+var ANY = { t: "any" };
+var EMPTY2 = { t: "empty" };
+function charNode(set, nl) {
+	return {
+		t: "char",
+		set,
+		nl
+	};
+}
+function rangesToSet(ranges) {
+	let fs = empty();
+	for (const [lo, hi] of ranges) fs = union(fs, fromRange(lo, hi));
+	return fs;
+}
+function rangesHaveNewline(ranges) {
+	return ranges.some(([lo, hi]) => lo <= 10 && 10 <= hi);
+}
+var BAIL = /* @__PURE__ */ Symbol("regex-bail");
+function parseRegex(src) {
+	let i = 0;
+	const parseAlt = () => {
+		const arms = [parseSeq()];
+		while (src[i] === "|") {
+			i++;
+			arms.push(parseSeq());
+		}
+		return arms.length === 1 ? arms[0] : {
+			t: "alt",
+			arms
+		};
+	};
+	const parseSeq = () => {
+		const parts = [];
+		while (i < src.length) {
+			const ch = src[i];
+			if (ch === "|" || ch === ")") break;
+			parts.push(parseQuantified());
+		}
+		if (parts.length === 0) return EMPTY2;
+		return parts.length === 1 ? parts[0] : {
+			t: "seq",
+			parts
+		};
+	};
+	const parseQuantified = () => {
+		const atom = parseAtom();
+		const ch = src[i];
+		let min = null;
+		if (ch === "*") {
+			min = 0;
+			i++;
+		} else if (ch === "+") {
+			min = 1;
+			i++;
+		} else if (ch === "?") {
+			min = 0;
+			i++;
+		} else if (ch === "{") min = parseBraceQuantifier();
+		if (min === null) return atom;
+		if (src[i] === "?") i++;
+		return {
+			t: "rep",
+			node: atom,
+			min
+		};
+	};
+	const parseBraceQuantifier = () => {
+		const close = src.indexOf("}", i);
+		if (close === -1) return null;
+		const m = /^(\d+)(?:,(\d*))?$/.exec(src.slice(i + 1, close));
+		if (!m) return null;
+		i = close + 1;
+		return Number.parseInt(m[1], 10);
+	};
+	const parseAtom = () => {
+		const ch = src[i];
+		switch (ch) {
+			case "(": return parseGroup();
+			case "[": return parseClass();
+			case ".":
+				i++;
+				return charNode(any(), false);
+			case "\\": return parseEscape();
+			case "^":
+			case "$":
+				i++;
+				return EMPTY2;
+			case "{":
+				i++;
+				return charNode(fromRange(123, 123), false);
+			default:
+				i += ch.length;
+				return charNode(fromRange(ch.codePointAt(0), ch.codePointAt(0)), ch === "\n");
+		}
+	};
+	const parseGroup = () => {
+		i++;
+		let lookaround = false;
+		if (src[i] === "?") {
+			const c1 = src[i + 1];
+			if (c1 === ":") i += 2;
+			else if (c1 === "=" || c1 === "!") {
+				i += 2;
+				lookaround = true;
+			} else if (c1 === "<") {
+				const c2 = src[i + 2];
+				if (c2 === "=" || c2 === "!") {
+					i += 3;
+					lookaround = true;
+				} else {
+					const gt = src.indexOf(">", i);
+					if (gt === -1) throw BAIL;
+					i = gt + 1;
+				}
+			} else throw BAIL;
+		}
+		const inner = parseAlt();
+		if (src[i] !== ")") throw BAIL;
+		i++;
+		return lookaround ? EMPTY2 : inner;
+	};
+	const parseClass = () => {
+		let k = i + 1;
+		const negated = src[k] === "^";
+		if (negated) k++;
+		let body = "";
+		while (k < src.length && src[k] !== "]") if (src[k] === "\\") {
+			body += src[k] + (src[k + 1] ?? "");
+			k += 2;
+		} else {
+			body += src[k];
+			k++;
+		}
+		if (src[k] !== "]") throw BAIL;
+		i = k + 1;
+		if (negated) return charNode(any(), true);
+		const ranges = parseClassRanges(body);
+		if (!ranges) return charNode(any(), true);
+		return charNode(rangesToSet(ranges), rangesHaveNewline(ranges));
+	};
+	const parseEscape = () => {
+		const e = src[i + 1];
+		if (e === void 0) throw BAIL;
+		if (e === "u" && /^[0-9a-fA-F]{4}$/.test(src.slice(i + 2, i + 6))) {
+			const cp = Number.parseInt(src.slice(i + 2, i + 6), 16);
+			i += 6;
+			return charNode(fromRange(cp, cp), cp === 10);
+		}
+		if (e === "x" && /^[0-9a-fA-F]{2}$/.test(src.slice(i + 2, i + 4))) {
+			const cp = Number.parseInt(src.slice(i + 2, i + 4), 16);
+			i += 4;
+			return charNode(fromRange(cp, cp), cp === 10);
+		}
+		i += 2;
+		switch (e) {
+			case "d": return charNode(rangesToSet(shorthandRanges("d")), false);
+			case "w": return charNode(rangesToSet(shorthandRanges("w")), false);
+			case "s": return charNode(rangesToSet(shorthandRanges("s")), true);
+			case "D":
+			case "W":
+			case "S": return charNode(any(), true);
+			case "b":
+			case "B": return EMPTY2;
+			case "n": return charNode(fromRange(10, 10), true);
+			case "r": return charNode(fromRange(13, 13), false);
+			case "t": return charNode(fromRange(9, 9), false);
+			case "f": return charNode(fromRange(12, 12), false);
+			case "v": return charNode(fromRange(11, 11), false);
+			case "0": return charNode(fromRange(0, 0), false);
+			default:
+				if (e >= "1" && e <= "9") return ANY;
+				return charNode(fromRange(e.codePointAt(0), e.codePointAt(0)), e === "\n");
+		}
+	};
+	const node2 = parseAlt();
+	if (i < src.length) throw BAIL;
+	return node2;
+}
+function nullable(n) {
+	switch (n.t) {
+		case "char": return false;
+		case "any": return true;
+		case "empty": return true;
+		case "seq": return n.parts.every(nullable);
+		case "alt": return n.arms.some(nullable);
+		case "rep": return n.min === 0 || nullable(n.node);
+	}
+}
+function firstSet(n) {
+	switch (n.t) {
+		case "char": return n.set;
+		case "any": return any();
+		case "empty": return empty();
+		case "rep": return firstSet(n.node);
+		case "alt": {
+			let fs = empty();
+			for (const arm of n.arms) fs = union(fs, firstSet(arm));
+			return fs;
+		}
+		case "seq": {
+			let fs = empty();
+			for (const part of n.parts) {
+				fs = union(fs, firstSet(part));
+				if (!nullable(part)) break;
+			}
+			return fs;
+		}
+	}
+}
+function firstCanBeNewline(n) {
+	switch (n.t) {
+		case "char": return n.nl;
+		case "any": return true;
+		case "empty": return false;
+		case "rep": return firstCanBeNewline(n.node);
+		case "alt": return n.arms.some(firstCanBeNewline);
+		case "seq":
+			for (const part of n.parts) {
+				if (firstCanBeNewline(part)) return true;
+				if (!nullable(part)) break;
+			}
+			return false;
+	}
+}
+function firstSetFromRegex(source) {
+	let ast;
+	try {
+		ast = parseRegex(source);
+	} catch {
+		return {
+			firstSet: any(),
+			canMatchNewline: true
+		};
+	}
+	if (nullable(ast)) return {
+		firstSet: any(),
+		canMatchNewline: true
+	};
+	return {
+		firstSet: firstSet(ast),
+		canMatchNewline: firstCanBeNewline(ast)
+	};
+}
+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));
+	let combined = { kind: "empty" };
+	for (const p of parsers) combined = union(combined, p._meta.firstSet);
+	const meta = {
+		firstSet: combined,
+		canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+		isTrivia: false,
+		disjoint
+	};
+	const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
+	const autoNot = !disjoint && !hasGates && strategy?.tag === "firstMatch" ? computeAutoNot(parsers) : parsers.map(() => null);
+	let greedyLitMap = null;
+	let sortedParsers = null;
+	const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
+	if (strategy?.tag === "greedyClassify") {
+		greedyLitMap = /* @__PURE__ */ new Map();
+		for (let i = 0; i < parsers.length; i++) {
+			if (i === strategy.superIndex) continue;
+			const litVal = getCoreLiteralValue(parsers[i]);
+			if (litVal !== null) greedyLitMap.set(litVal, i);
+		}
+	} else if (strategy?.tag === "literalsLongestFirst") sortedParsers = strategy.sortedIndices.map((i) => parsers[i]);
+	return {
+		_tag: "choice",
+		_meta: meta,
+		_def: {
+			tag: "choice",
+			parsers,
+			gates,
+			disjoint,
+			strategy: strategy ?? { tag: "firstMatch" },
+			autoNot
+		},
+		parse(input, pos, ctx) {
+			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;
+						break;
+					}
+				}
+				if (parser2) {
+					const result = parser2.parse(input, pos, ctx);
+					if (result.ok) return result;
+					expected.push(...result.expected);
+					return {
+						ok: false,
+						expected,
+						span: {
+							start: pos,
+							end: pos
+						}
+					};
+				}
+				return {
+					ok: false,
+					expected: parsers.flatMap((p) => {
+						const r = p.parse(input, pos, ctx);
+						return r.ok ? [] : r.expected;
+					}),
+					span: {
+						start: pos,
+						end: pos
+					}
+				};
+			}
+			if (strategy?.tag === "greedyClassify") {
+				const superResult = parsers[strategy.superIndex].parse(input, pos, ctx);
+				if (!superResult.ok) return superResult;
+				const end = superResult.span.end;
+				const litIdx = greedyLitMap.get(input.slice(pos, end));
+				if (litIdx !== void 0) {
+					const litVal = getCoreLiteralValue(parsers[litIdx]);
+					return {
+						ok: true,
+						value: applyTransforms(parsers[litIdx], litVal, {
+							start: pos,
+							end
+						}),
+						span: {
+							start: pos,
+							end
+						}
+					};
+				}
+				return superResult;
+			}
+			if (strategy?.tag === "literalsLongestFirst") {
+				for (const p of sortedParsers) {
+					const r = p.parse(input, pos, ctx);
+					if (r.ok) return r;
+					expected.push(...r.expected);
+				}
+				return {
+					ok: false,
+					expected,
+					span: {
+						start: pos,
+						end: pos
+					}
+				};
+			}
+			for (let i = 0; i < parsers.length; i++) {
+				if (gates[i] && !gates[i](ctx.state)) continue;
+				const mark = saveCstMark(ctx);
+				const logLen = ctx._triviaLog?.length;
+				const result = parsers[i].parse(input, pos, ctx);
+				if (!result.ok) {
+					rollbackCstCapture(ctx, mark);
+					if (logLen !== void 0 && ctx._triviaLog) ctx._triviaLog.length = logLen;
+					expected.push(...result.expected);
+					continue;
+				}
+				const checks = autoNot[i];
+				if (checks && autoNotFires(input, result.span.end, checks)) {
+					rollbackCstCapture(ctx, mark);
+					if (logLen !== void 0 && ctx._triviaLog) ctx._triviaLog.length = logLen;
+					continue;
+				}
+				return result;
+			}
+			return {
+				ok: false,
+				expected,
+				span: {
+					start: pos,
+					end: pos
+				}
+			};
+		}
+	};
+}
+function detectStrategy(parsers) {
+	const regexIndices = [];
+	const literalIndices = [];
+	for (let i = 0; i < parsers.length; i++) if (getCoreRegexDef(parsers[i]) !== null) regexIndices.push(i);
+	else if (getCoreLiteralValue(parsers[i]) !== null) literalIndices.push(i);
+	if (regexIndices.length === 1 && literalIndices.length === parsers.length - 1 && literalIndices.length > 0) {
+		const superIndex = regexIndices[0];
+		const regexDef = getCoreRegexDef(parsers[superIndex]);
+		const flags = "y" + regexDef.flags.replace(/[gy]/g, "");
+		const re = new RegExp(regexDef.source, flags);
+		if (literalIndices.every((i) => {
+			const litVal = getCoreLiteralValue(parsers[i]);
+			re.lastIndex = 0;
+			const m = re.exec(litVal);
+			return m !== null && m[0] === litVal;
+		})) return {
+			tag: "greedyClassify",
+			superIndex
+		};
+	}
+	if (parsers.length === literalIndices.length) return {
+		tag: "literalsLongestFirst",
+		sortedIndices: [...literalIndices].sort((a, b) => getCoreLiteralValue(parsers[b]).length - getCoreLiteralValue(parsers[a]).length)
+	};
+	return { tag: "firstMatch" };
+}
+function computeAutoNot(parsers) {
+	return parsers.map((p, i) => {
+		const litVal = getCoreLiteralValue(p);
+		if (litVal === null) return null;
+		const checks = [];
+		for (let j = i + 1; j < parsers.length; j++) {
+			const other = parsers[j];
+			const otherLit = getCoreLiteralValue(other);
+			if (otherLit !== null && otherLit.startsWith(litVal) && otherLit.length > litVal.length) {
+				checks.push({
+					kind: "startsWith",
+					value: otherLit.slice(litVal.length)
+				});
+				continue;
+			}
+			const regexDef = getCoreRegexDef(other);
+			if (regexDef !== null) {
+				const contSet = continuationFirstSet(litVal, regexDef.source, regexDef.flags);
+				if (contSet !== null) checks.push({
+					kind: "firstSet",
+					set: contSet
+				});
+			}
+		}
+		return checks.length > 0 ? checks : null;
+	});
+}
+function autoNotFires(input, end, checks) {
+	for (const check of checks) if (check.kind === "firstSet") {
+		if (inFirstSet(end < input.length ? input.codePointAt(end) ?? -1 : -1, check.set)) return true;
+	} else if (input.startsWith(check.value, end)) return true;
+	return false;
+}
+function getCoreLiteralValue(p) {
+	const def = p._def;
+	if (def.tag === "literal" && !def.caseInsensitive) return def.value;
+	if (def.tag === "transform") return getCoreLiteralValue(def.parser);
+	return null;
+}
+function getCoreRegexDef(p) {
+	const def = p._def;
+	if (def.tag === "regex") return {
+		source: def.source,
+		flags: def.flags
+	};
+	if (def.tag === "transform") return getCoreRegexDef(def.parser);
+	if (def.tag === "label") return getCoreRegexDef(def.parser);
+	return null;
+}
+function applyTransforms(p, value, span) {
+	const def = p._def;
+	if (def.tag === "transform") {
+		const inner = applyTransforms(def.parser, value, span);
+		return def.fn(inner, span);
+	}
+	return value;
+}
+function continuationFirstSet(lit, source, flags) {
+	const re = new RegExp(source, "y" + flags.replace(/[gy]/g, ""));
+	re.lastIndex = 0;
+	const base = re.exec(lit);
+	if (!base || base[0] !== lit) return null;
+	const contCodes = [];
+	for (let code = 1; code < 128; code++) {
+		re.lastIndex = 0;
+		const m = re.exec(lit + String.fromCharCode(code));
+		if (m && m[0].length > lit.length) contCodes.push(code);
+	}
+	if (contCodes.length === 0) return null;
+	return codesToFirstSet(contCodes);
+}
+function codesToFirstSet(codes) {
+	codes.sort((a, b) => a - b);
+	const ranges = [];
+	let lo = codes[0], hi = codes[0];
+	for (let i = 1; i < codes.length; i++) if (codes[i] === hi + 1) hi = codes[i];
+	else {
+		ranges.push({
+			lo,
+			hi
+		});
+		lo = hi = codes[i];
+	}
+	ranges.push({
+		lo,
+		hi
+	});
+	return {
+		kind: "ranges",
+		ranges
+	};
+}
+function inFirstSet(code, fs) {
+	if (fs.kind === "any") return true;
+	if (fs.kind === "empty") return false;
+	for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+	return false;
+}
+function areDisjoint(sets) {
+	if (sets.some((s) => s.kind === "any")) return false;
+	for (let i = 0; i < sets.length; i++) for (let j = i + 1; j < sets.length; j++) if (intersects(sets[i], sets[j])) return false;
+	return true;
+}
+function buildAsciiDispatch(parsers) {
+	const table = Array(128).fill(null);
+	for (const parser2 of parsers) {
+		const fs = parser2._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;
+	}
+	return table;
+}
+function unwrapTrivia(p) {
+	let cur = p;
+	while (cur._def.tag === "trivia") cur = cur._def.parser;
+	return cur;
+}
+function peelLabel(p) {
+	if (p._def.tag === "label") return {
+		label: p._def.label,
+		parser: p._def.parser
+	};
+	return null;
+}
+function analyzeLabeledTrivia(trivia2) {
+	let core = unwrapTrivia(trivia2);
+	let minRepeats = 1;
+	if (core._def.tag === "oneOrMore") {
+		core = core._def.parser;
+		minRepeats = 1;
+	} else if (core._def.tag === "many") {
+		core = core._def.parser;
+		minRepeats = 0;
+	}
+	const arms = [];
+	if (core._def.tag === "choice") for (let i = 0; i < core._def.parsers.length; i++) {
+		const peeled = peelLabel(core._def.parsers[i]);
+		if (!peeled) return null;
+		arms.push({
+			label: peeled.label,
+			kindIndex: i,
+			parser: peeled.parser
+		});
+	}
+	else {
+		const peeled = peelLabel(core);
+		if (!peeled) return null;
+		arms.push({
+			label: peeled.label,
+			kindIndex: 0,
+			parser: peeled.parser
+		});
+	}
+	return {
+		labels: arms.map((a) => a.label),
+		arms,
+		minRepeats
+	};
+}
+function matchArmAt(input, pos, arm) {
+	const r = arm.parse(input, pos, { trackLines: false });
+	if (!r.ok || r.span.end <= pos) return null;
+	return { end: r.span.end };
+}
+function scanLabeledTriviaChunks(input, cur, spec) {
+	const chunks = [];
+	let pos = cur;
+	while (pos < input.length) {
+		let matched = null;
+		for (const arm of spec.arms) {
+			const m = matchArmAt(input, pos, arm.parser);
+			if (m) {
+				matched = {
+					end: m.end,
+					kindIndex: arm.kindIndex
+				};
+				break;
+			}
+		}
+		if (!matched) break;
+		chunks.push({
+			start: pos,
+			end: matched.end,
+			kindIndex: matched.kindIndex
+		});
+		pos = matched.end;
+	}
+	if (chunks.length < spec.minRepeats) return {
+		end: cur,
+		chunks: []
+	};
+	return {
+		end: pos,
+		chunks
+	};
+}
+function scanFastWsCommentsChunks(input, cur, wsKind, commentKind) {
+	const chunks = [];
+	let pos = cur;
+	while (pos < input.length) {
+		const c = input.charCodeAt(pos);
+		if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {
+			const start = pos;
+			pos++;
+			while (pos < input.length) {
+				const c2 = input.charCodeAt(pos);
+				if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) pos++;
+				else break;
+			}
+			chunks.push({
+				start,
+				end: pos,
+				kindIndex: wsKind
+			});
+			continue;
+		}
+		if (c === 47 && input.charCodeAt(pos + 1) === 42) {
+			let j = pos + 2;
+			while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++;
+			if (j + 1 < input.length && input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47) {
+				const start = pos;
+				pos = j + 2;
+				chunks.push({
+					start,
+					end: pos,
+					kindIndex: commentKind
+				});
+				continue;
+			}
+			break;
+		}
+		break;
+	}
+	return {
+		end: pos,
+		chunks
+	};
+}
+function tryFastLabeledScan(input, cur, trivia2) {
+	const spec = analyzeLabeledTrivia(trivia2);
+	if (!spec || spec.arms.length !== 2) return null;
+	const wsArm = spec.arms.find((a) => {
+		const src = getCoreRegexDef(a.parser)?.source;
+		return src != null && !src.includes("\\*");
+	});
+	const commentArm = spec.arms.find((a) => {
+		const src = getCoreRegexDef(a.parser)?.source;
+		return src != null && src.includes("\\*");
+	});
+	if (!wsArm || !commentArm) return null;
+	const { chunks } = scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex);
+	if (chunks.length < spec.minRepeats) return {
+		end: cur,
+		chunks: []
+	};
+	return scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex);
+}
+function recordTriviaChunks(ctx, chunks) {
+	const kinds = ctx.triviaKindLabels;
+	const mask = ctx._triviaCaptureMask;
+	for (const ch of chunks) {
+		pushTriviaLogEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : void 0);
+		if (ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0)) {
+			if (mask === void 0 || kinds === void 0 || (mask & 1 << ch.kindIndex) !== 0) pushCstTriviaEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : void 0);
+		}
+	}
+}
+var NOOP_COMMIT = () => {};
+var fastTriviaCache = /* @__PURE__ */ new WeakMap();
+function needsDeferredTriviaCommit(ctx) {
+	return ctx._triviaLog !== void 0 || ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0;
+}
+function saveTriviaMark(ctx) {
+	const m = saveCstMark(ctx);
+	return {
+		raw: m.raw,
+		tlog: m.tlog,
+		leaves: m.leaves,
+		fields: m.fields,
+		log: ctx._triviaLog ? ctx._triviaLog.length : 0
+	};
+}
+function rollbackTrivia(ctx, mark) {
+	rollbackCstCapture(ctx, {
+		raw: mark.raw,
+		tlog: mark.tlog,
+		leaves: mark.leaves,
+		fields: mark.fields
+	});
+	if (ctx._triviaLog) ctx._triviaLog.length = mark.log;
+}
+function scanWithLabels(input, cur, ctx) {
+	const triviaP = ctx.trivia;
+	const spec = analyzeLabeledTrivia(triviaP);
+	if (!spec) return {
+		end: cur,
+		commit: NOOP_COMMIT
+	};
+	const { end, chunks } = tryFastLabeledScan(input, cur, triviaP) ?? scanLabeledTriviaChunks(input, cur, spec);
+	if (end === cur) return {
+		end: cur,
+		commit: NOOP_COMMIT
+	};
+	return {
+		end,
+		commit: () => recordTriviaChunks(ctx, chunks)
+	};
+}
+function advanceTrivia(input, cur, ctx) {
+	const triviaP = ctx.trivia;
+	if (!triviaP) return cur;
+	const fast = fastTriviaScanner(triviaP);
+	if (fast) return fast(input, cur);
+	if (ctx.triviaKindLabels) return scanWithLabels(input, cur, ctx).end;
+	const tr = triviaP.parse(input, cur, {
+		trackLines: ctx.trackLines,
+		state: ctx.state
+	});
+	return tr.ok && tr.span.end > cur ? tr.span.end : cur;
+}
+function scanTrivia(input, cur, ctx) {
+	const triviaP = ctx.trivia;
+	if (!triviaP) return {
+		end: cur,
+		commit: NOOP_COMMIT
+	};
+	const log = ctx._triviaLog;
+	const captureTl = ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0);
+	const fast = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null;
+	if (fast && log === void 0 && !captureTl) return {
+		end: fast(input, cur),
+		commit: NOOP_COMMIT
+	};
+	if (ctx.triviaKindLabels && (log !== void 0 || captureTl)) return scanWithLabels(input, cur, ctx);
+	if (log !== void 0 || captureTl) {
+		const tr2 = triviaP.parse(input, cur, {
+			trackLines: log !== void 0 ? false : ctx.trackLines,
+			state: ctx.state
+		});
+		if (!tr2.ok || tr2.span.end === cur) return {
+			end: cur,
+			commit: NOOP_COMMIT
+		};
+		const end = tr2.span.end;
+		return {
+			end,
+			commit: () => {
+				pushTriviaLogEntry(ctx, cur, end);
+				if (captureTl) pushCstTriviaEntry(ctx, cur, end);
+			}
+		};
+	}
+	const tr = triviaP.parse(input, cur, {
+		trackLines: ctx.trackLines,
+		state: ctx.state
+	});
+	return {
+		end: tr.ok ? tr.span.end : cur,
+		commit: NOOP_COMMIT
+	};
+}
+function fastTriviaScanner(trivia2) {
+	const cached = fastTriviaCache.get(trivia2);
+	if (cached !== void 0) return cached;
+	const scanner = buildFastTriviaScanner(trivia2);
+	fastTriviaCache.set(trivia2, scanner);
+	return scanner;
+}
+function buildFastTriviaScanner(trivia2) {
+	const core = trivia2._def.tag === "trivia" ? trivia2._def.parser : trivia2;
+	const direct = regexTriviaScanner(core);
+	if (direct) return direct;
+	const repeat = core._def.tag === "oneOrMore" || core._def.tag === "many" && core._def.min >= 1 ? core._def.parser : null;
+	if (!repeat) return null;
+	const one = regexTriviaScanner(repeat);
+	if (one) return loopScanner([one]);
+	if (repeat._def.tag !== "choice") return null;
+	const arms = repeat._def.parsers.map(regexTriviaScanner);
+	if (arms.some((s) => s === null)) return null;
+	return loopScanner(arms);
+}
+function loopScanner(arms) {
+	return (input, cur) => {
+		let pos = cur;
+		scan: while (pos < input.length) {
+			for (const arm of arms) {
+				const end = arm(input, pos);
+				if (end > pos) {
+					pos = end;
+					continue scan;
+				}
+			}
+			break;
+		}
+		return pos;
+	};
+}
+function regexTriviaScanner(parser2) {
+	if (parser2._def.tag !== "regex" || parser2._def.flags) return null;
+	const source = parser2._def.source;
+	return classRunSource(source) ?? altStarSource(source) ?? (blockCommentSource(source) ? scanBlockComment : null);
+}
+function inRanges2(cp, ranges) {
+	for (let i = 0; i < ranges.length; i++) {
+		const r = ranges[i];
+		if (cp >= r[0] && cp <= r[1]) return true;
+	}
+	return false;
+}
+function classScanner(classBody) {
+	const ranges = parseClassRanges(classBody);
+	if (!ranges) return null;
+	return (input, cur) => {
+		let pos = cur;
+		while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
+		return pos;
+	};
+}
+function lineCommentScanner(commentCode) {
+	return (input, cur) => {
+		if (input.charCodeAt(cur) !== commentCode) return cur;
+		let pos = cur + 1;
+		while (pos < input.length) {
+			const cc = input.charCodeAt(pos);
+			if (cc === 10 || cc === 13) break;
+			pos++;
+		}
+		return pos;
+	};
+}
+function classRunSource(source) {
+	const m = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]$/.exec(source);
+	return m ? classScanner(m[1]) : null;
+}
+function classifyTriviaArm(arm) {
+	const cls = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]?$/.exec(arm);
+	if (cls) {
+		const ranges = parseClassRanges(cls[1]);
+		return ranges ? {
+			kind: "class",
+			ranges
+		} : null;
+	}
+	const lc = /^(\\?.)\[\^\\n\\r\]\*$/.exec(arm);
+	if (lc) {
+		const marker = lc[1];
+		return {
+			kind: "comment",
+			code: (marker.length === 2 ? marker[1] : marker[0]).charCodeAt(0)
+		};
+	}
+	return null;
+}
+function armScanner(arm) {
+	if (arm.kind === "comment") return lineCommentScanner(arm.code);
+	const ranges = arm.ranges;
+	return (input, cur) => {
+		let pos = cur;
+		while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
+		return pos;
+	};
+}
+function fusedTriviaScanner(ranges, commentCodes) {
+	const c0 = commentCodes[0];
+	const single = commentCodes.length === 1;
+	return (input, cur) => {
+		let pos = cur;
+		const len = input.length;
+		for (;;) {
+			const c = input.charCodeAt(pos);
+			if (pos < len && inRanges2(c, ranges)) {
+				pos++;
+				continue;
+			}
+			if (single ? c === c0 : commentCodes.includes(c)) {
+				pos++;
+				while (pos < len) {
+					const cc = input.charCodeAt(pos);
+					if (cc === 10 || cc === 13) break;
+					pos++;
+				}
+				continue;
+			}
+			break;
+		}
+		return pos;
+	};
+}
+function splitTopLevelAlts(body) {
+	const arms = [];
+	let inClass = false;
+	let start = 0;
+	for (let i = 0; i < body.length; i++) {
+		const c = body[i];
+		if (c === "\\") {
+			i++;
+			continue;
+		}
+		if (inClass) {
+			if (c === "]") inClass = false;
+			continue;
+		}
+		if (c === "[") inClass = true;
+		else if (c === "(") return null;
+		else if (c === "|") {
+			arms.push(body.slice(start, i));
+			start = i + 1;
+		}
+	}
+	arms.push(body.slice(start));
+	return arms;
+}
+function altStarSource(source) {
+	const m = /^\(\?:(.*)\)[*+]$/.exec(source);
+	if (!m) return null;
+	const armSrcs = splitTopLevelAlts(m[1]);
+	if (!armSrcs || armSrcs.length < 2) return null;
+	const arms = [];
+	for (const src of armSrcs) {
+		const arm = classifyTriviaArm(src);
+		if (!arm) return null;
+		arms.push(arm);
+	}
+	const ranges = [];
+	const commentCodes = [];
+	for (const arm of arms) if (arm.kind === "class") ranges.push(...arm.ranges);
+	else commentCodes.push(arm.code);
+	if (commentCodes.some((code) => inRanges2(code, ranges))) return loopScanner(arms.map(armScanner));
+	if (commentCodes.length === 0) return armScanner({
+		kind: "class",
+		ranges
+	});
+	return fusedTriviaScanner(ranges, commentCodes);
+}
+function blockCommentSource(source) {
+	return source === "\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/" || source === "\\/\\*[^]*?\\*\\/";
+}
+function scanBlockComment(input, cur) {
+	if (input.charCodeAt(cur) !== 47 || input.charCodeAt(cur + 1) !== 42) return cur;
+	const close = input.indexOf("*/", cur + 2);
+	return close === -1 ? cur : close + 2;
+}
+function sequence(...parsers) {
+	const meta = {
+		firstSet: sequenceFirstSet(parsers),
+		canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+		isTrivia: false
+	};
+	const def = {
+		tag: "sequence",
+		parsers
+	};
+	return {
+		_tag: "sequence",
+		_meta: meta,
+		_def: def,
+		parse(input, pos, ctx) {
+			const values = def.valueUnused ? void 0 : [];
+			let cur = pos;
+			for (let i = 0; i < parsers.length; i++) {
+				if (ctx.trivia && i > 0) {
+					let scanEnd;
+					let mark = saveTriviaMark(ctx);
+					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;
+			}
+			return {
+				ok: true,
+				value: values ?? void 0,
+				span: {
+					start: pos,
+					end: cur
+				}
+			};
+		}
+	};
+}
+function optional(combinator) {
+	const meta = {
+		firstSet: combinator._meta.firstSet,
+		canMatchNewline: combinator._meta.canMatchNewline,
+		isTrivia: false
+	};
+	const firstSetSkippable = !matchesEmpty(combinator);
+	return {
+		_tag: "optional",
+		_meta: meta,
+		_def: {
+			tag: "optional",
+			parser: combinator
+		},
+		parse(input, pos, ctx) {
+			if (firstSetSkippable && ctx._probe === void 0 && !startsFirstSet(combinator, input, pos)) return {
+				ok: true,
+				value: null,
+				span: {
+					start: pos,
+					end: pos
+				}
+			};
+			const mark = saveTriviaMark(ctx);
+			const result = combinator.parse(input, pos, ctx);
+			if (result.ok) return result;
+			rollbackTrivia(ctx, mark);
+			return {
+				ok: true,
+				value: null,
+				span: {
+					start: pos,
+					end: pos
+				}
+			};
+		}
+	};
+}
+function startsFirstSet(combinator, input, pos) {
+	const fs = combinator._meta.firstSet;
+	if (fs.kind === "any") return true;
+	if (fs.kind === "empty") return false;
+	const code = input.codePointAt(pos);
+	if (code === void 0) return false;
+	for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+	return false;
+}
+new Set("()[]{}*+?|^$.".split(""));
+[
+	`  if (_cap && _e > _pos) {`,
+	`    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,
+	`    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,
+	`  }`
+].join("\n");
+var { isFinite } = Number;
+registerRegexAnalyzer(firstSetFromRegex);
+//#endregion
+//#region src/interp.ts
+/**
+* SCSS `#{…}` interpolation helpers for the functional grammar builders.
+* Mirrors productions/helpers.ts (Chevrotain) without the nested parser bootstrap.
+*/
+let parseScssFnLazy;
+/** Wired from grammar.ts after `parseScssFn` is defined (breaks circular import). */
+function setParseScssFnForInterp(fn) {
+	parseScssFnLazy = fn;
+}
+function findScssInterpolationSpans(value) {
+	const matches = [];
+	let i = 0;
+	while (i < value.length) if (value[i] === "#" && value[i + 1] === "{") {
+		const start = i;
+		i += 2;
+		let depth = 1;
+		const contentStart = i;
+		while (i < value.length && depth > 0) {
+			const ch = value[i];
+			if (ch === "{") depth++;
+			else if (ch === "}") depth--;
+			i++;
+		}
+		if (depth === 0) matches.push({
+			start,
+			end: i,
+			content: value.slice(contentStart, i - 1)
+		});
+	} else i++;
+	return matches;
+}
+function unwrapSingleReference(n) {
+	if (isNode(n, N.Reference) && n.options?.type === "variable" && !n.target && typeof n.key === "string") return n;
+}
+function valueFromParseResult(r, fallback, loc) {
+	const root = r.tree;
+	if (isNode(root, N.Rules) && root.rules.length > 0) return root.rules[0];
+	if (root instanceof Node) return root;
+	return new Any(fallback, { role: "any" }, loc);
+}
+/** Parse a `#{…}` inner expression via the functional value grammar. */
+function parseScssInterpExpr(expr, loc) {
+	const trimmed = expr.trim();
+	if (!trimmed) return new Any("", { role: "any" }, loc);
+	if (!parseScssFnLazy) throw new Error("parseScssFn not wired for interpolation (setParseScssFnForInterp)");
+	const r = parseScssFnLazy(trimmed, "valueList");
+	if (r.errors.length) return new Any(trimmed, { role: "any" }, loc);
+	const tree = valueFromParseResult(r, trimmed, loc);
+	const ref = unwrapSingleReference(tree);
+	if (ref && typeof ref.key === "string") return new Reference({ key: ref.key }, {
+		type: "variable",
+		role: "ident"
+	}, loc);
+	if (isNode(tree, N.Reference)) return new Expression(tree, void 0, loc);
+	return tree;
+}
+/**
+* Validate a `selector.parse("…")` argument through the functional selector
+* grammar. Returns `true` when the text is a well-formed selector list. Used to
+* gate lifting a `selector.*` call into a `SelectorCapture`; the capture keeps the
+* lean string payload (`SelectorCapture` supports a bare-string `SelectorLike`).
+*/
+function isValidScssSelectorList(selectorText) {
+	const trimmed = selectorText.trim();
+	if (!trimmed) return false;
+	if (!parseScssFnLazy) throw new Error("parseScssFn not wired for interpolation (setParseScssFnForInterp)");
+	return parseScssFnLazy(trimmed, "SelectorList").errors.length === 0;
+}
+/** Turn a parsed expression into an interpolation replacement (name/ident slots). */
+function toInterpReplacement(expr, loc) {
+	const ref = unwrapSingleReference(expr);
+	if (ref && typeof ref.key === "string") return new Reference({ key: ref.key }, {
+		type: "variable",
+		role: "ident"
+	}, loc);
+	if (isNode(expr, N.Reference)) return new Expression(expr, void 0, loc);
+	return expr;
+}
+/** Build an `Interpolated` node from a string containing `#{…}` runs. */
+function buildScssInterpolatedFromString(value, loc, role) {
+	const matches = findScssInterpolationSpans(value);
+	if (matches.length === 0) return new Any(value, { role }, loc);
+	const replacements = [];
+	let source = value;
+	let offset = 0;
+	for (const match of matches) {
+		const adjustedStart = match.start - offset;
+		const adjustedEnd = match.end - offset;
+		source = source.slice(0, adjustedStart) + INTERPOLATION_PLACEHOLDER + source.slice(adjustedEnd);
+		offset += match.end - match.start - INTERPOLATION_PLACEHOLDER.length;
+		replacements.push(toInterpReplacement(parseScssInterpExpr(match.content, loc), loc));
+	}
+	return new Interpolated({
+		source,
+		replacements
+	}, { role }, loc);
+}
+//#endregion
+//#region src/scss-atrule-helpers.ts
+/**
+* Shared helpers for SCSS module-system at-rules in the functional parser.
+*/
+function isScriptUsePath(path) {
+	return path.endsWith(".js") || path.endsWith(".ts") || path.endsWith(".json");
+}
+function defaultNamespaceFromPath(path) {
+	if (path.startsWith("sass:")) return path.slice(5).split("/").filter(Boolean).pop();
+	const base = path.split("/").filter(Boolean).pop();
+	if (!base) return;
+	return base.replace(/\.(scss|sass|css|jess|js|ts|json)$/i, "") || void 0;
+}
+function quotedLike(original, nextValue, loc) {
+	const quote = original.options?.quote ?? "\"";
+	const escaped = original.options?.escaped;
+	const nodeLoc = loc ?? sourceSpanOf(original);
+	return new Quoted(new Any(nextValue, { role: "any" }), {
+		quote,
+		escaped
+	}, nodeLoc);
+}
+/**
+* Detect the CSS `@import` ordering violations Sass parse-rejects (`error/wrong_order/*`).
+* The full media-query-list / `supports()` grammar is out of scope for the
+* scanned prelude, so this catches the clearly-invalid, low-false-positive
+* shapes on the raw prelude text (everything after `@import`, minus the path):
+*
+*   1. A bare media feature `(x: y)` (NOT a `fn(...)` call — hence the
+*      no-ident-before-`(` guard) followed by anything other than `and` / `or` /
+*      `,` / `;` / end. Catches `"a" (b: c) supports(d: e)`, `"a" (b: c) d`,
+*      `"a" (b: c) d(e)`.
+*   2. A comma directly followed by a function call `ident(` — a new import item
+*      can never be `supports(...)` or an unknown function. Catches
+*      `"a" b, supports(c: d)`, `"a" b, c(d)`, and `"a", url(b)`.
+*
+* Not caught (documented as remaining): a string after a comma in media context
+* (`"a" b, "c"` — indistinguishable from a valid plain-import continuation without
+* modelling media-vs-plain state) and `supports()` value-syntax errors
+* (`supports(--a:)`).
+*/
+function checkImportPreludeOrder(preludeText, recordError) {
+	const text = preludeText;
+	if (/(?<![-\w])\([^()]*:[^()]*\)\s*(?!and(?![-\w])|or(?![-\w])|[,;{})])\S/i.test(text) || /,\s*[a-zA-Z][-\w]*\s*\(/.test(text)) recordError("Invalid @import: a media-query list must not follow a media feature without `and`/`or`, and a comma-separated @import item must be a URL or string (not `supports(…)` or another function).");
+}
+function isPlainCssImportPath(rawPath) {
+	return /\.css(?:$|[?#])/i.test(rawPath) || /^[a-z]+:\/\//i.test(rawPath) || rawPath.startsWith("//");
+}
+function isPlainCssImportPrelude(prelude, extraText) {
+	if (prelude instanceof Url) return true;
+	if (extraText && extraText.trim()) return true;
+	if (isNode(prelude, N.Quoted)) return isPlainCssImportPath(prelude.valueOf());
+	return true;
+}
+function findDisallowedExtendSelector(selector, allowed) {
+	if (isNode(selector, N.SelectorList)) {
+		for (const item of selector.value) {
+			const disallowed = findDisallowedExtendSelector(item, allowed);
+			if (disallowed) return disallowed;
+		}
+		return;
+	}
+	const kinds = isNode(selector, N.BasicSelector) ? ["simple", "basic"] : isNode(selector, N.PseudoSelector) ? ["simple", "pseudo"] : isNode(selector, N.CompoundSelector) ? ["compound"] : isNode(selector, N.ComplexSelector) ? ["complex"] : ["simple"];
+	if (isNode(selector, N.CompoundSelector) && selector.value.length === 1) return findDisallowedExtendSelector(selector.value[0], allowed);
+	if (isNode(selector, N.ComplexSelector) && selector.value.length === 1) return findDisallowedExtendSelector(selector.value[0], allowed);
+	if (kinds.some((k) => allowed.includes(k))) return;
+	return {
+		kind: kinds[0],
+		selector
+	};
+}
+function validateExtendTarget(target, allowed, recordError) {
+	if (!allowed) return;
+	const disallowed = findDisallowedExtendSelector(target, allowed);
+	if (!disallowed) return;
+	recordError(`@extend only allows ${allowed.length === 1 ? `${allowed[0]} value` : allowed.join(", ")}, but found ${disallowed.kind} selector "${disallowed.selector.valueOf()}".`);
+}
+function checkForwardPreludeErrors(preludeExtra, recordError) {
+	if (!preludeExtra?.trim()) return;
+	const text = preludeExtra.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n\r]*/g, " ").replace(/\s+/g, " ").trim();
+	if (/\bas\s+\S+-\*/.test(text)) recordError("@forward with \"as <prefix>-*\" prefixing is not supported in Jess and will never be. Use explicit namespacing instead.");
+	if (/\b(show|hide)\b/.test(text)) recordError("@forward with \"show\"/\"hide\" lists is not supported in Jess and will never be. Visibility control belongs to the module itself.");
+}
+function isPlaceholderExtendTarget(target) {
+	if (typeof target === "string") return target.startsWith("\\");
+	if (isNode(target, N.BasicSelector)) return target.value.startsWith("\\");
+	if (isNode(target, N.SelectorList) && target.value.length === 1) return isPlaceholderExtendTarget(target.value[0]);
+	if (isNode(target, N.CompoundSelector) && target.value.length === 1) return isPlaceholderExtendTarget(target.value[0]);
+	if (isNode(target, N.ComplexSelector) && target.value.length === 1) return isPlaceholderExtendTarget(target.value[0]);
+	return false;
+}
+//#endregion
+//#region src/scss-atroot-helpers.ts
+function createNullParentAmpersand(context, selector) {
+	const location = selector ? sourceSpanOf(selector) : void 0;
+	const nil = new Nil(void 0, void 0, location, context);
+	const amp = new Ampersand({ selectorContainer: { selector: nil } }, void 0, location, context);
+	amp.adopt(nil);
+	return amp;
+}
+function getNodeLocation(node) {
+	return sourceSpanOf(node);
+}
+function prefixAtRootSelector(selector, context) {
+	if (isNode(selector, N.SelectorList)) return new SelectorList(selector.value.map((item) => prefixAtRootSelector(item, context)), void 0, getNodeLocation(selector), context);
+	const amp = createNullParentAmpersand(context, selector);
+	if (isNode(selector, N.ComplexSelector)) return new ComplexSelector([amp, ...selector.value], void 0, getNodeLocation(selector), context);
+	return new ComplexSelector([amp, selector], void 0, getNodeLocation(selector), context);
+}
+function lowerPlainAtRootRules(rules, context) {
+	const transformRule = (node) => {
+		if (isNode(node, N.Ruleset)) {
+			const rs = node;
+			if (!isNode(rs.selector, N.Nil)) return new Ruleset({
+				selector: prefixAtRootSelector(rs.selector, context),
+				rules: rs.rules,
+				...rs.guard !== void 0 && { guard: rs.guard },
+				...rs.selectorBeforeExtend !== void 0 && { selectorBeforeExtend: rs.selectorBeforeExtend }
+			}, rs.options, sourceSpanOf(rs), context);
+			return node;
+		}
+		if (isNode(node, N.AtRule) && node.rules) {
+			lowerPlainAtRootRules(node.rules, context);
+			return node;
+		}
+		if (isNode(node, N.If)) {
+			lowerPlainAtRootRules(node, context);
+			if (node.else) lowerPlainAtRootRules(node.else, context);
+			return node;
+		}
+		if (isNode(node, N.For)) {
+			lowerPlainAtRootRules(node, context);
+			return node;
+		}
+		if (isNode(node, N.While)) {
+			lowerPlainAtRootRules(node, context);
+			return node;
+		}
+		return node;
+	};
+	for (let i = 0; i < rules.rules.length; i++) rules.rules[i] = transformRule(rules.rules[i]);
+}
+//#endregion
+//#region src/scss-value-helpers.ts
+/**
+* SCSS value desugaring helpers for the functional grammar builders.
+* Ports productions/helpers.ts without the Chevrotain parser bootstrap.
+*/
+function unwrapSingleSequence(n) {
+	if (isNode(n, N.Sequence) && n.value.length === 1) return n.value[0];
+	return n;
+}
+function toDeclKey(node) {
+	return String(node.valueOf());
+}
+function isValidIdentifierKey(key) {
+	return /^[a-zA-Z_-][a-zA-Z0-9_-]*$/.test(key);
+}
+function makeNamespacedReference(parts, finalType, loc) {
+	let current = new Reference(parts[0], { type: "variable" }, loc);
+	for (let i = 1; i < parts.length; i++) {
+		const isFinal = i === parts.length - 1;
+		current = new Reference({
+			target: current,
+			key: parts[i]
+		}, { type: isFinal ? finalType : "index" }, loc);
+	}
+	return current;
+}
+function desugarNamespacedCall(call, loc) {
+	const { name, args } = call;
+	if (typeof name !== "string") return call;
+	if (!name.includes(".")) return call;
+	if (name === "map.get") return call;
+	const parts = name.split(".").filter(Boolean);
+	if (parts.length < 2) return call;
+	return new Call({
+		name: makeNamespacedReference(parts, "function", loc),
+		args
+	}, call.options, loc);
+}
+function desugarMapLookup(call, loc) {
+	const { name, args: argsList } = call;
+	if (typeof name !== "string") return call;
+	if (name !== "map-get" && name !== "map.get") return call;
+	const args = isNode(argsList, N.List) ? argsList.value : [];
+	if (args.length < 2) return call;
+	const mapExpr = unwrapSingleSequence(args[0]);
+	const keyArgs = args.slice(1).map((a) => unwrapSingleSequence(a));
+	const initialTarget = isNode(mapExpr, N.Reference) ? mapExpr : isNode(mapExpr, N.Call) ? mapExpr : void 0;
+	if (!initialTarget) return call;
+	let currentTarget = initialTarget;
+	for (const keyNode of keyArgs) {
+		const keyStr = toDeclKey(keyNode);
+		const useDeclaration = isValidIdentifierKey(keyStr);
+		currentTarget = new Reference({
+			target: currentTarget,
+			key: useDeclaration ? keyStr : keyNode
+		}, { type: useDeclaration ? "declaration" : "index" }, loc);
+	}
+	return currentTarget;
+}
+//#endregion
+//#region src/builders.ts
+/**
+* ScssGrammar — Parséman-based SCSS parser, extending LessGrammar.
+*
+* Adds SCSS-specific grammar on top of Less (which in turn extends CSS):
+*   - Variable declarations: $var: value [!default|!global];  →  VarDeclaration
+*   - Variable references:   $var                             →  Reference
+*   - Line comments:         // ...  (added to rw trivia)
+*
+* Inherits from LessGrammar:
+*   - Nested rulesets, & ampersand, relative selectors
+*   - anyDeclaration entry point
+*   - atRuleBody, declarationList, Stylesheet overrides
+*   - Less merge operators on Declaration (harmless for SCSS)
+*
+* Chevrotain note: in the Chevrotain architecture, ScssRecursiveParser
+* extends CssRecursiveParser independently of LessRecursiveParser.
+* Here we take the Parséman inheritance chain
+* CssParser → LessGrammar → ScssGrammar to maximise code reuse.
+*/
+function spanToLocation(span) {
+	return {
+		start: span.start,
+		end: span.end
+	};
+}
+function nodeChildren(children) {
+	return children.filter((c) => c != null && c._tag === "node");
+}
+var ScssGrammar = class extends LessGrammar {
+	rw = regex(/(?:[ \t\n\r\f]+|\/\/[^\n\r]*|\/\*(?:[^*]|\*(?!\/))*\*\/)+/);
+	_trivia = this.rw;
+	_parseContext;
+	setContext(context) {
+		this._parseContext = context;
+	}
+	scssVar = regex(/\$-?[_a-zA-Z-￿][-_a-zA-Z0-9-￿]*/);
+	VarDeclaration = (g) => sequence(g.scssVar, literal(":"), g.valueList, optional(choice(literal("!default"), literal("!global"))), optional(literal(";")));
+	Reference = (g) => g.scssVar;
+	buildNode(type, span, children, _state, _rawChildren, fields, triviaLog = []) {
+		const loc = spanToLocation(span);
+		switch (type) {
+			case "VarDeclaration": return this._buildScssVarDeclaration(_rawChildren, loc);
+			case "NsVarDeclaration": return this._buildScssNsVarDeclaration(_rawChildren, loc);
+			case "Reference": return this._buildScssReference(children, loc);
+			case "ScssComparison": return this._buildScssComparison(children, loc);
+			case "ScssCondInParens": return this._buildScssCondInParens(children, loc);
+			case "ScssCondTerm": return this._buildScssCondTerm(children, loc);
+			case "ScssCondAnd": return this._buildScssCondJoin(children, loc, "and");
+			case "ScssCondOr": return this._buildScssCondJoin(children, loc, "or");
+			case "ScssRules": return this._buildScssRules(children, loc);
+			case "ScssIf": return this._buildScssIf(children, loc);
+			case "ScssEach": return this._buildScssEach(children, loc);
+			case "ScssFor": return this._buildScssFor(children, loc);
+			case "ScssWhile": return this._buildScssWhile(children, loc);
+			case "ScssCallArg": return this._buildScssCallArg(children, loc);
+			case "ScssCallArgsInner": return this._buildScssCallArgsInner(children, loc);
+			case "ScssMixinParam": return this._buildScssMixinParam(children, loc);
+			case "ScssMixinParams": return this._buildScssMixinParams(children, loc);
+			case "ScssMixinName": return this._buildScssMixinName(children, loc);
+			case "ScssDeclBody": return this._buildScssRules(children, loc);
+			case "ScssMixin": return this._buildScssMixin(children, loc);
+			case "ScssIncludeUsing": return this._buildScssIncludeUsing(children, loc);
+			case "ScssInclude": return this._buildScssInclude(children, loc);
+			case "ScssContent": return this._buildScssContent(children, loc);
+			case "ScssFunction": return this._buildScssFunction(children, loc);
+			case "ScssReturn": return this._buildScssReturn(children, _rawChildren, loc);
+			case "ScssInterpBare": return this._buildScssInterpBare(children, loc);
+			case "ScssInterpolatedName": return this._buildScssInterpolatedName(children, loc);
+			case "InterpValue": return this._buildScssInterpValue(_rawChildren, loc);
+			case "InterpolatedSelector": return this._buildScssInterpolatedSelector(children, loc);
+			case "Declaration": return this._buildScssDeclaration(children, loc, () => super.buildNode(type, span, children, _state, _rawChildren, fields, triviaLog));
+			case "CustomDeclaration": return this._buildScssCustomDeclaration(children, loc, () => super.buildNode(type, span, children, _state, _rawChildren, fields, triviaLog));
+			case "Quoted": return this._buildQuoted(children, loc);
+			case "ScssMapPair": return this._buildScssMapPair(children, loc);
+			case "ScssMapLiteral": return this._buildScssMapLiteral(children, loc);
+			case "ScssIdentValue": return this._buildScssIdentValue(children, _rawChildren, loc);
+			case "ScssWithConfigEntry": return this._buildScssWithConfigEntry(_rawChildren, loc);
+			case "ScssWithConfig": return this._buildScssWithConfig(children, loc);
+			case "ScssUseAs": return this._buildScssUseAs(children, loc);
+			case "ScssUse": return this._buildScssUse(children, loc);
+			case "ScssForward": return this._buildScssForward(children, _rawChildren, loc);
+			case "ScssPlaceholderSelector": return this._buildScssPlaceholderSelector(children, loc);
+			case "ScssPlaceholderRuleset": return this._buildRuleset(children, _rawChildren, loc);
+			case "ScssExtendTarget": return this._buildScssExtendTarget(children, _rawChildren, loc);
+			case "ScssExtend": return this._buildScssExtend(children, _rawChildren, loc);
+			case "ScssImportItem": return this._buildScssImportItem(children, _rawChildren, loc);
+			case "ScssImportAtRule": return this._buildScssImportAtRule(children, loc);
+			case "ScssNestedProps": return this._buildScssNestedProps(children, loc);
+			case "ScssDiagnostic": return this._buildScssDiagnostic(children, loc);
+			case "ScssAtRootFilter": return this._buildScssAtRootFilter(children, loc);
+			case "ScssAtRootSelector": return this._buildScssAtRootSelector(children, loc);
+			case "ScssAtRootPlain": return this._buildScssAtRootPlain(children, loc);
+			case "ScssScopeBlock": return this._buildScssPermissiveAtRule(children, loc);
+			case "ScssLayerBlock": return this._buildScssLayerBlock(children, loc);
+			case "Call": return this._buildCall(_rawChildren, loc);
+			case "SquareParen": return this._buildSquareParen(_rawChildren, loc);
+			case "Paren": return this._buildScssParen(_rawChildren, loc);
+			default: return super.buildNode(type, span, children, _state, _rawChildren, fields, triviaLog);
+		}
+	}
+	_buildScssVarDeclaration(rawChildren, loc) {
+		const items = spannedComponents(rawChildren);
+		const rawName = typeof items[0]?.comp === "string" ? items[0].comp : "";
+		const name = rawName.startsWith("$") ? rawName.slice(1) : rawName;
+		const colonIdx = items.findIndex((i) => i.comp === ":");
+		let end = items.length;
+		for (let i = colonIdx + 1; i < items.length; i++) {
+			const c = items[i].comp;
+			if (c === "!" || c === "!default" || c === "!global" || c === ";") {
+				end = i;
+				break;
+			}
+		}
+		const { value } = this._assembleValue(items.slice(colonIdx + 1, end), loc);
+		return new VarDeclaration({
+			name,
+			value,
+			important: items.some((i) => i.comp === "!" || i.comp === "!default" || i.comp === "!global") || void 0
+		}, {}, loc);
+	}
+	/**
+	* `ns.$member: value [!default|!global];` — a namespaced variable ASSIGNMENT.
+	* Built as a `VarDeclaration` whose name carries the namespace (`ns.member`);
+	* `!default` → conditional-assign, `!global` → `setDefined`. Mirrors the
+	* member-read shape (`Reference{ target, key }`) on the write side while
+	* staying within the `string | Interpolated` declaration-name contract.
+	*/
+	_buildScssNsVarDeclaration(rawChildren, loc) {
+		const items = spannedComponents(rawChildren);
+		const ns = typeof items[0]?.comp === "string" ? items[0].comp : "";
+		const memberItem = items.find((i) => typeof i.comp === "string" && i.comp.startsWith("$"));
+		const memberRaw = typeof memberItem?.comp === "string" ? memberItem.comp : "";
+		const member = memberRaw.startsWith("$") ? memberRaw.slice(1) : memberRaw;
+		const colonIdx = items.findIndex((i) => i.comp === ":");
+		let end = items.length;
+		for (let i = colonIdx + 1; i < items.length; i++) {
+			const c = items[i].comp;
+			if (c === "!" || c === "!default" || c === "!global" || c === ";") {
+				end = i;
+				break;
+			}
+		}
+		const { value } = this._assembleValue(items.slice(colonIdx + 1, end), loc);
+		const sawDefault = items.slice(end).some((i) => i.comp === "!default");
+		const sawGlobal = items.slice(end).some((i) => i.comp === "!global");
+		return new VarDeclaration({
+			name: `${ns}.${member}`,
+			value
+		}, {
+			assign: sawDefault ? "?:" : ":",
+			setDefined: sawGlobal
+		}, loc);
+	}
+	_buildScssReference(children, loc) {
+		const varName = children.filter((c) => c._tag === "leaf")[0]?.value ?? "";
+		return new Reference(varName.startsWith("$") ? varName.slice(1) : varName, { type: "variable" }, loc);
+	}
+	/**
+	* `left [op right]` → Condition, or a bare operand when there is no operator.
+	* `!=` desugars to `=` + negate (matches the Chevrotain scssComparison).
+	*/
+	_buildScssComparison(children, loc) {
+		const nodes = nodeChildren(children);
+		const ls = children.filter((c) => c._tag === "leaf");
+		const left = nodes[0] ?? new Any("", {}, loc);
+		const opLeaf = ls.find((l) => /^(?:==|!=|>=|<=|=|>|<)$/.test(l.value));
+		if (!opLeaf || !nodes[1]) return left;
+		let op = opLeaf.value;
+		let negate = false;
+		if (op === "!=") {
+			op = "=";
+			negate = true;
+		} else if (op === "==") op = "=";
+		return new Condition([
+			left,
+			op,
+			nodes[1]
+		], negate ? { negate: true } : {}, loc);
+	}
+	/**
+	* Every condition term is wrapped in a Paren, matching the Chevrotain
+	* `scssConditionInParens` production (both the `( … )` group and the bare
+	* comparison / value branch wrap their result in a single Paren).
+	*/
+	_buildScssCondInParens(children, loc) {
+		return new Paren(nodeChildren(children)[0] ?? new Any("", {}, loc), {}, loc);
+	}
+	/** Optional leading `not` negates the term. */
+	_buildScssCondTerm(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const inner = nodeChildren(children)[0] ?? new Any("", {}, loc);
+		if (ls.some((l) => /^not$/i.test(l.value))) return new Condition([inner], { negate: true }, loc);
+		return inner;
+	}
+	/** Fold a left-associative `and` / `or` chain of terms into Conditions. */
+	_buildScssCondJoin(children, loc, op) {
+		const nodes = nodeChildren(children);
+		if (nodes.length === 0) return new Any("", {}, loc);
+		let left = nodes[0];
+		for (let i = 1; i < nodes.length; i++) left = new Condition([
+			left,
+			op,
+			nodes[i]
+		], {}, loc);
+		return left;
+	}
+	/** A `{ … }` control-block body → Rules. */
+	_buildScssRules(children, loc) {
+		return new Rules(this._flattenScssImportLists(nodeChildren(children)), void 0, loc);
+	}
+	/**
+	* `@if cond { … } (@else if cond { … })* (@else { … })?` → nested `If` chain.
+	* Children arrive as alternating condition / Rules nodes, with an optional
+	* trailing bare Rules (the final `@else`). Fold from the last branch inward.
+	*/
+	_buildScssIf(children, loc) {
+		const nodes = nodeChildren(children);
+		const conditions = [];
+		const bodies = [];
+		let elseBranch;
+		let pendingCond;
+		for (const n of nodes) if (n instanceof Rules) if (pendingCond !== void 0) {
+			conditions.push(pendingCond);
+			bodies.push(n);
+			pendingCond = void 0;
+		} else elseBranch = n;
+		else pendingCond = n;
+		let elseNode = elseBranch;
+		for (let i = conditions.length - 1; i >= 0; i--) elseNode = new If({
+			condition: conditions[i],
+			rules: bodies[i].rules,
+			else: elseNode
+		}, void 0, loc);
+		return elseNode ?? new Any("", {}, loc);
+	}
+	/** A `$name` loop-binding with no value (`paramVar` — prints as `$name`). */
+	_scssParamVar(varName, loc) {
+		return new VarDeclaration({
+			name: varName,
+			value: new Nil()
+		}, { paramVar: true }, loc);
+	}
+	/**
+	* `@each $a[, $b …] in <expr> { … }` → `For` with a node iterable.
+	* Normalizes to Jess `$for ($a of …)` / `$for ([$a, $b] of …)`.
+	*/
+	_buildScssEach(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const nodes = nodeChildren(children);
+		const body = nodes.find((n) => n instanceof Rules);
+		const vars = [];
+		let pastEach = false;
+		for (const l of ls) {
+			if (/^@each/i.test(l.value)) {
+				pastEach = true;
+				continue;
+			}
+			if (pastEach && l.value === "in") break;
+			if (pastEach && l.value.startsWith("$")) vars.push(l.value.slice(1));
+		}
+		const iterableNodes = nodes.filter((n) => n !== body);
+		let iterable = iterableNodes.length === 1 ? iterableNodes[0] : new Sequence(iterableNodes, void 0, loc);
+		if (iterable.type === "Expression") iterable = iterable.value;
+		const decls = vars.map((v) => this._scssParamVar(v, loc));
+		return new For({
+			pattern: decls.length === 1 ? {
+				kind: "single",
+				value: decls[0]
+			} : {
+				kind: "tuple",
+				values: decls
+			},
+			iterable: {
+				kind: "node",
+				value: iterable
+			},
+			rules: body.rules
+		}, void 0, loc);
+	}
+	/**
+	* `@for $i from <start> (to|through) <end> { … }` → `For` with a range iterable.
+	* `through` is inclusive end; `to` is exclusive (`includeEnd: false`).
+	*/
+	_buildScssFor(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const nodes = nodeChildren(children);
+		const includeEnd = ls.some((l) => l.value === "through");
+		const varLeaf = ls.find((l) => l.value.startsWith("$"));
+		const varDecl = this._scssParamVar(varLeaf?.value.slice(1) ?? "", loc);
+		const body = nodes.find((n) => n instanceof Rules);
+		const exprNodes = nodes.filter((n) => n !== body);
+		const startExpr = exprNodes[0] ?? new Any("", {}, loc);
+		const endExpr = exprNodes[1] ?? new Any("", {}, loc);
+		return new For({
+			pattern: {
+				kind: "single",
+				value: varDecl
+			},
+			iterable: {
+				kind: "range",
+				start: startExpr,
+				end: endExpr,
+				includeStart: true,
+				includeEnd
+			},
+			rules: body.rules
+		}, void 0, loc);
+	}
+	/** `@while <cond> { … }` → `While`. */
+	_buildScssWhile(children, loc) {
+		const nodes = nodeChildren(children);
+		const body = nodes.find((n) => n instanceof Rules);
+		return new While({
+			condition: nodes.find((n) => n !== body) ?? new Any("", {}, loc),
+			rules: body.rules
+		}, void 0, loc);
+	}
+	/** Build a module-qualified or plain mixin `Reference`. */
+	_buildScssMixinName(children, loc) {
+		const interp = nodeChildren(children).find((n) => isNode(n, N.Interpolated));
+		if (interp) return new Reference({ key: interp }, {
+			type: "mixin",
+			role: "name"
+		}, loc);
+		const parts = children.filter((c) => c._tag === "leaf").map((l) => l.value).filter((v) => v !== ".");
+		if (parts.length >= 2) {
+			let ref = new Reference(parts[0], { type: "variable" }, loc);
+			for (let i = 1; i < parts.length; i++) {
+				const isFinal = i === parts.length - 1;
+				ref = new Reference({
+					target: ref,
+					key: parts[i]
+				}, {
+					type: isFinal ? "mixin" : "index",
+					...isFinal ? { role: "name" } : {}
+				}, loc);
+			}
+			return ref;
+		}
+		return new Reference({ key: parts[0] ?? "" }, {
+			type: "mixin",
+			role: "name"
+		}, loc);
+	}
+	/** `$x: val` keyword arg, `val...` spread, or plain value. */
+	_buildScssCallArg(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const nodes = nodeChildren(children);
+		const varLeaf = ls.find((l) => l.value.startsWith("$") && l.value !== "$");
+		const hasColon = ls.some((l) => l.value === ":");
+		const hasSpread = ls.some((l) => l.value === "...");
+		if (varLeaf && hasColon) return new VarDeclaration({
+			name: varLeaf.value.slice(1),
+			value: nodes.find((n) => n !== void 0 && !ls.includes(n)) ?? nodes[0] ?? new Nil()
+		}, {}, loc);
+		const value = nodes[0] ?? new Any("", {}, loc);
+		if (hasSpread) return new Rest(value, void 0, loc);
+		return value;
+	}
+	_buildScssCallArgsInner(children, loc) {
+		const nodes = nodeChildren(children);
+		if (nodes.length === 0) return;
+		return new List(nodes, void 0, loc);
+	}
+	/** Mixin param: `...$rest`, `$rest...`, `$a: default`, or bare `$a`. */
+	_buildScssMixinParam(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const nodes = nodeChildren(children);
+		const varName = ls.find((l) => l.value.startsWith("$"))?.value.slice(1) ?? "";
+		const hasPrefixEllipsis = ls[0]?.value === "...";
+		const hasSuffixEllipsis = ls.some((l) => l.value === "..." && ls.indexOf(l) > 0);
+		if (hasPrefixEllipsis || hasSuffixEllipsis) return new Rest(varName, void 0, loc);
+		if (ls.some((l) => l.value === ":") && nodes[0]) return new VarDeclaration({
+			name: varName,
+			value: nodes[0]
+		}, { paramVar: true }, loc);
+		return new Any(varName, { role: "property" }, loc);
+	}
+	_buildScssMixinParams(children, loc) {
+		return new List(nodeChildren(children), void 0, loc);
+	}
+	/** `@mixin name($params) { … }` → `Mixin` (inner vars default to private). */
+	_buildScssMixin(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const nodes = nodeChildren(children);
+		const interpName = nodes.find((n) => isNode(n, N.Interpolated));
+		const nameLeaf = ls.find((l) => !l.value.startsWith("@") && l.value !== "(" && l.value !== ")" && l.value !== "{" && l.value !== "}" && l.value !== ",");
+		return new Mixin({
+			name: interpName ?? nameLeaf?.value ?? "",
+			params: nodes.find((n) => n.type === "List"),
+			rules: nodes.find((n) => n instanceof Rules).rules
+		}, void 0, loc);
+	}
+	/** `using ($c, $n)` param list for `@include … using (…)`. */
+	_buildScssIncludeUsing(children, loc) {
+		return new List(children.filter((c) => c._tag === "leaf").filter((l) => l.value.startsWith("$")).map((l) => this._scssParamVar(l.value.slice(1), loc)), void 0, loc);
+	}
+	/**
+	* `@include name(args) [using (…)] [ { … } ];` → `Call(Reference(type=mixin))`.
+	* An optional content block becomes an anonymous visible `Mixin` on the call.
+	*/
+	_buildScssInclude(children, loc) {
+		const ls = children.filter((c) => c?._tag === "leaf");
+		const nodes = nodeChildren(children);
+		const nameRef = nodes.find((n) => n.type === "Reference");
+		const lists = nodes.filter((n) => n.type === "List");
+		const hasUsing = ls.some((l) => l.value === "using");
+		let args;
+		let usingParams;
+		if (lists.length === 2) {
+			args = lists[0];
+			usingParams = lists[1];
+		} else if (lists.length === 1) if (hasUsing) usingParams = lists[0];
+		else args = lists[0];
+		const contentRules = nodes.find((n) => n instanceof Rules);
+		let contentNode;
+		if (contentRules) {
+			contentNode = new Mixin({
+				rules: contentRules.rules,
+				params: usingParams
+			}, void 0, loc);
+			contentNode.addFlags(F_VISIBLE);
+		}
+		return new Call({
+			name: nameRef ?? new Reference({ key: "" }, {
+				type: "mixin",
+				role: "name"
+			}, loc),
+			args,
+			contentNode
+		}, void 0, loc);
+	}
+	/** `@content[(args)];` → `Call(Reference('content', type=mixin))`. */
+	_buildScssContent(children, loc) {
+		const args = nodeChildren(children).find((n) => n.type === "List");
+		return new Call({
+			name: new Reference({ key: "content" }, {
+				type: "mixin",
+				role: "name"
+			}, loc),
+			args
+		}, void 0, loc);
+	}
+	/** `@function name($params) { … }` → `Func` with `returnName: 'result'`. */
+	_buildScssFunction(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const nodes = nodeChildren(children);
+		const interpName = nodes.find((n) => isNode(n, N.Interpolated));
+		const nameLeaf = ls.find((l) => !l.value.startsWith("@") && l.value !== "(" && l.value !== ")" && l.value !== "{" && l.value !== "}" && l.value !== ",");
+		return new Func({
+			name: interpName ?? nameLeaf?.value ?? "",
+			params: nodes.find((n) => n.type === "List"),
+			body: nodes.find((n) => n instanceof Rules)
+		}, { returnName: "result" }, loc);
+	}
+	/** `@return <value>;` → `$result: <value>;` */
+	_buildScssReturn(children, rawChildren, loc) {
+		const items = spannedComponents(rawChildren);
+		const semiIdx = items.findIndex((i) => i.comp === ";");
+		const valueItems = items.filter((i, idx) => idx > 0 && i.comp !== "@return" && (semiIdx < 0 || idx < semiIdx));
+		const { value } = this._assembleValue(valueItems, loc);
+		return new VarDeclaration({
+			name: "result",
+			value
+		}, void 0, loc);
+	}
+	_buildScssInterpBare(children, loc) {
+		return new Interpolated({
+			source: INTERPOLATION_PLACEHOLDER,
+			replacements: [toInterpReplacement(nodeChildren(children)[0] ?? new Any("", {}, loc), loc)]
+		}, { role: "any" }, loc);
+	}
+	/** `foo-#{$bar}` name segments → Interpolated(role=name) or plain Any. */
+	_buildScssInterpolatedName(children, loc) {
+		let source = "";
+		const replacements = [];
+		for (const c of children) if (c._tag === "leaf") {
+			const v = c.value;
+			if (v === "#{" || v === "}" || v === ".") continue;
+			source += v;
+		} else if (c._tag === "node" && isNode(c, N.Interpolated)) {
+			source += INTERPOLATION_PLACEHOLDER;
+			replacements.push(...c.replacements);
+		}
+		if (replacements.length === 0) return new Any(source, { role: "name" }, loc);
+		return new Interpolated({
+			source,
+			replacements
+		}, { role: "name" }, loc);
+	}
+	_buildScssInterpValue(raw, loc) {
+		return buildScssInterpolatedFromString(spannedComponents(raw).map((i) => typeof i.comp === "string" ? i.comp : "").join(""), loc, "ident");
+	}
+	_buildScssInterpolatedSelector(children, loc) {
+		let source = "";
+		const replacements = [];
+		for (const c of children) if (c._tag === "leaf") {
+			const v = c.value;
+			if (v === "#{" || v === "}") continue;
+			source += v;
+		} else if (c._tag === "node" && isNode(c, N.Interpolated)) {
+			source += INTERPOLATION_PLACEHOLDER;
+			replacements.push(...c.replacements);
+		}
+		return new InterpolatedSelector(new Interpolated({
+			source,
+			replacements
+		}, { role: "ident" }, loc), {}, loc);
+	}
+	_scssInterpDeclName(name, loc) {
+		if (typeof name !== "string") return name;
+		if (name.includes("#{")) return buildScssInterpolatedFromString(name, loc, "property");
+		return name;
+	}
+	_buildScssDeclaration(children, loc, buildLess) {
+		const decl = buildLess();
+		const d = decl;
+		if (d.name !== void 0) d.name = this._scssInterpDeclName(d.name, loc);
+		const valueNodes = nodeChildren(children).filter((n) => isNode(n, N.Collection) || isNode(n, N.Sequence) || isNode(n, N.Keyword) || isNode(n, N.Reference) || isNode(n, N.Num) || isNode(n, N.Paren) || isNode(n, N.List));
+		const collection = valueNodes.find((n) => isNode(n, N.Collection));
+		if (collection && valueNodes.length > 1) {
+			const base = valueNodes.find((n) => n !== collection);
+			if (base) d.value = new Sequence([base, collection], void 0, loc);
+		} else if (collection) d.value = collection;
+		return decl;
+	}
+	_buildScssCustomDeclaration(children, loc, buildLess) {
+		const decl = buildLess();
+		const d = decl;
+		if (d.name !== void 0) d.name = this._scssInterpDeclName(d.name, loc);
+		return decl;
+	}
+	_buildQuoted(children, loc) {
+		const text = children.filter((c) => c._tag === "leaf").map((l) => l.value).join("");
+		const inner = text.slice(1, -1);
+		const quote = text[0];
+		if (inner.includes("#{")) return new Quoted(buildScssInterpolatedFromString(inner, loc, "any"), { quote }, loc);
+		return super._buildQuoted(children, loc);
+	}
+	/** `("k": v, …)` pair inside a map literal. */
+	_buildScssMapPair(children, loc) {
+		const nodes = nodeChildren(children);
+		const keyNode = nodes[0] ?? new Any("", { role: "property" }, loc);
+		const valueNode = nodes[1] ?? new Any("", {}, loc);
+		return new Declaration({
+			name: toDeclKey(keyNode),
+			value: valueNode
+		}, void 0, loc);
+	}
+	_buildScssMapLiteral(children, loc) {
+		return new Collection(nodeChildren(children), void 0, loc);
+	}
+	/** `ns.$var`, `ns.fn(…)`, `ns.\#foo(…)`, or a plain ident. */
+	_buildScssIdentValue(children, raw, loc) {
+		const ls = children.filter((c) => c?._tag === "leaf");
+		const ident = ls.find((l) => !l.value.startsWith(".") && l.value !== "(" && l.value !== ")" && l.value !== "\\")?.value ?? "";
+		const varLeaf = ls.find((l) => l.value.startsWith("$"));
+		const dotLeaf = ls.find((l) => l.value.startsWith(".") && !l.value.startsWith("$"));
+		const hashLeaf = ls.find((l) => l.value.startsWith("#"));
+		const hasCall = ls.some((l) => l.value === "(");
+		const hasEscape = ls.some((l) => l.value === "\\");
+		if (varLeaf && dotLeaf) return new Reference({
+			target: new Reference(ident, { type: "variable" }, loc),
+			key: varLeaf.value.slice(1)
+		}, { type: "variable" }, loc);
+		if (hasEscape && hashLeaf && hasCall) {
+			const key = hashLeaf.value.slice(1);
+			const args = nodeChildren(children).find((n) => isNode(n, N.List));
+			return new Expression(new Call({
+				name: makeNamespacedReference([ident, key], "mixin-ruleset", loc),
+				args
+			}, void 0, loc), void 0, loc);
+		}
+		if (dotLeaf && hasCall) {
+			const fnName = dotLeaf.value.slice(1);
+			if (ident === "selector" && fnName === "parse") {
+				const items = spannedComponents(raw);
+				const open = items.findIndex((i) => i.comp === "(");
+				let close = items.length;
+				for (let i = items.length - 1; i >= 0; i--) if (items[i].comp === ")") {
+					close = i;
+					break;
+				}
+				const { value: argValue } = this._assembleValue(items.slice(open + 1, close), loc);
+				const firstArg = isNode(argValue, N.List) ? argValue.value[0] : argValue;
+				const selectorText = firstArg && isNode(firstArg, N.Quoted) ? typeof firstArg.value === "string" ? firstArg.value : isNode(firstArg.value, N.Any) ? String(firstArg.value.valueOf()) : void 0 : void 0;
+				if (selectorText !== void 0 && isValidScssSelectorList(selectorText)) return new SelectorCapture(selectorText, void 0, loc);
+			}
+			const items = spannedComponents(raw);
+			const open = items.findIndex((i) => i.comp === "(");
+			let close = items.length;
+			for (let i = items.length - 1; i >= 0; i--) if (items[i].comp === ")") {
+				close = i;
+				break;
+			}
+			const { value: argValue } = this._assembleValue(items.slice(open + 1, close), loc);
+			let args;
+			if (argValue !== void 0) args = isNode(argValue, N.List) ? argValue : new List([argValue], void 0, loc);
+			const mapped = desugarMapLookup(new Call({
+				name: `${ident}.${fnName}`,
+				args
+			}, void 0, loc), loc);
+			if (isNode(mapped, N.Reference)) return mapped;
+			const memberType = fnName.startsWith("#") ? "mixin-ruleset" : "function";
+			const call = new Call({
+				name: makeNamespacedReference([ident, fnName.startsWith("#") ? fnName.slice(1) : fnName], memberType, loc),
+				args
+			}, void 0, loc);
+			if (memberType === "mixin-ruleset") return new Expression(call, void 0, loc);
+			return new Expression(desugarNamespacedCall(call, loc), void 0, loc);
+		}
+		return new Any(ident, { role: "ident" }, loc);
+	}
+	_buildStylesheet(children, loc) {
+		const nodes = this._flattenScssImportLists(nodeChildren(children));
+		return new Rules(this._liftStandaloneComments(nodes, loc.start, loc.end, loc), void 0, loc);
+	}
+	_flattenScssImportLists(nodes) {
+		const flat = [];
+		for (const n of nodes) if (isNode(n, N.List) && (n.options?.role === "scss-imports" || n.options?.role === "scss-at-root")) flat.push(...n.value);
+		else flat.push(n);
+		return flat;
+	}
+	_buildScssNestedProps(children, loc) {
+		return new Collection(nodeChildren(children).filter((n) => isNode(n, N.Declaration) || isNode(n, N.VarDeclaration) || n instanceof If || n instanceof For || n instanceof While), void 0, loc);
+	}
+	_buildScssDiagnostic(children, loc) {
+		return new Log({
+			level: children.filter((c) => c?._tag === "leaf").find((l) => l.value.startsWith("@"))?.value.slice(1) ?? "debug",
+			message: nodeChildren(children).find((n) => !isNode(n, N.Any) || n.options?.role !== "atkeyword") ?? nodeChildren(children)[0] ?? new Any("", {}, loc)
+		}, void 0, loc);
+	}
+	_buildScssAtRootFilter(children, loc) {
+		const nodes = nodeChildren(children);
+		const prelude = nodes.find((n) => !(n instanceof Rules)) ?? nodes[0];
+		const body = nodes.find((n) => n instanceof Rules);
+		const name = new Any("@at-root", { role: "atkeyword" }, loc);
+		this._error("@at-root prelude/filter forms are not yet supported in Jess. Write the hoisted rules directly instead.", loc.start, loc.end);
+		return new AtRule({
+			name,
+			prelude,
+			rules: body.rules
+		}, void 0, loc);
+	}
+	_buildScssAtRootSelector(children, loc) {
+		const nodes = nodeChildren(children);
+		const selector = nodes.find((n) => !(n instanceof Rules));
+		const body = nodes.find((n) => n instanceof Rules);
+		const context = this._parseContext;
+		return new Ruleset({
+			selector: prefixAtRootSelector(selector, context),
+			rules: body.rules
+		}, void 0, loc);
+	}
+	_buildScssAtRootPlain(children, loc) {
+		const body = nodeChildren(children).find((n) => n instanceof Rules);
+		const context = this._parseContext;
+		const lowered = new Rules([...body.rules], void 0, loc);
+		lowerPlainAtRootRules(lowered, context);
+		if (lowered.rules.length === 0) return new Nil(void 0, void 0, loc);
+		if (lowered.rules.length === 1) return lowered.rules[0];
+		return new List(lowered.rules, { role: "scss-at-root" }, loc);
+	}
+	_buildScssWithConfigEntry(rawChildren, loc) {
+		const items = spannedComponents(rawChildren);
+		const rawName = typeof items[0]?.comp === "string" ? items[0].comp : "";
+		const name = rawName.startsWith("$") ? rawName.slice(1) : rawName;
+		const colonIdx = items.findIndex((i) => i.comp === ":");
+		let end = items.length;
+		for (let i = colonIdx + 1; i < items.length; i++) {
+			const c = items[i].comp;
+			if (c === "!" || c === "!default" || c === "!global" || c === "," || c === ")") {
+				end = i;
+				break;
+			}
+		}
+		const { value } = this._assembleValue(items.slice(colonIdx + 1, end), loc);
+		const sawDefault = items.slice(end).some((i) => i.comp === "!default");
+		const sawGlobal = items.slice(end).some((i) => i.comp === "!global");
+		return new VarDeclaration({
+			name,
+			value
+		}, {
+			assign: sawDefault ? "?:" : ":",
+			setDefined: sawGlobal
+		}, loc);
+	}
+	_buildScssWithConfig(children, loc) {
+		return new Collection(nodeChildren(children).filter((n) => isNode(n, N.VarDeclaration)), void 0, loc);
+	}
+	_buildScssUseAs(children, loc) {
+		return new Any(children.filter((c) => c?._tag === "leaf").find((l) => l.value !== "as")?.value ?? "", { role: "ident" }, loc);
+	}
+	_buildScssUse(children, loc) {
+		const pathNode = nodeChildren(children).find((n) => isNode(n, N.Quoted));
+		const withConfig = nodeChildren(children).find((n) => isNode(n, N.Collection));
+		const useAs = nodeChildren(children).find((n) => isNode(n, N.Any) && n.options?.role === "ident");
+		const namespace = useAs ? String(useAs.valueOf()) : void 0;
+		const rawPath = pathNode?.valueOf() ?? "";
+		if (rawPath.startsWith("sass:")) return new JsImport({ path: quotedLike(pathNode, `#sass/${rawPath.slice(5)}`, loc) }, { namespace: namespace ?? defaultNamespaceFromPath(rawPath) }, loc);
+		if (isScriptUsePath(rawPath)) return new JsImport({ path: pathNode }, { namespace: namespace ?? defaultNamespaceFromPath(rawPath) }, loc);
+		return new StyleImport({
+			path: pathNode,
+			with: withConfig ? {
+				node: withConfig,
+				type: "set"
+			} : void 0
+		}, {
+			type: "compose",
+			namespace,
+			importOptions: {}
+		}, loc);
+	}
+	_buildScssForward(children, _raw, loc) {
+		const pathNode = nodeChildren(children).find((n) => isNode(n, N.Quoted));
+		const withConfig = nodeChildren(children).find((n) => isNode(n, N.Collection));
+		const preludeText = this._source.slice(loc.start, loc.end);
+		const pathMatch = /(['"])([^'"]+)\1/.exec(preludeText);
+		checkForwardPreludeErrors((pathMatch ? preludeText.slice(preludeText.indexOf(pathMatch[0]) + pathMatch[0].length) : "").replace(/\bwith\s*\([^)]*\)\s*;?\s*$/, "").replace(/;\s*$/, "").trim(), (msg) => this._error(msg, loc.start, loc.end));
+		return new StyleImport({
+			path: pathNode,
+			with: withConfig ? {
+				node: withConfig,
+				type: "set"
+			} : void 0
+		}, {
+			type: "compose",
+			importOptions: { forward: true }
+		}, loc);
+	}
+	_buildScssPlaceholderSelector(children, loc) {
+		const name = `\\${(children.filter((c) => c?._tag === "leaf")[0]?.value ?? "").slice(1)}`;
+		return this._makeBasicSelector(name, loc);
+	}
+	_buildScssPermissiveAtRule(children, loc) {
+		const name = children.filter((c) => c?._tag === "leaf")[0]?.value ?? "";
+		const braceIdx = children.findIndex((c) => c._tag === "leaf" && c.value === "{");
+		const preludeChildren = braceIdx >= 0 ? children.slice(1, braceIdx) : children.slice(1);
+		const bodyChildren = braceIdx >= 0 ? children.slice(braceIdx + 1) : [];
+		return new AtRule({
+			name,
+			prelude: new Sequence(nodeChildren(preludeChildren), void 0, loc),
+			rules: nodeChildren(bodyChildren)
+		}, void 0, loc);
+	}
+	_buildScssLayerBlock(children, loc) {
+		const name = children.filter((c) => c?._tag === "leaf")[0]?.value ?? "";
+		const braceIdx = children.findIndex((c) => c._tag === "leaf" && c.value === "{");
+		const preludeChildren = braceIdx >= 0 ? children.slice(1, braceIdx) : children.slice(1);
+		const bodyChildren = braceIdx >= 0 ? children.slice(braceIdx + 1) : [];
+		const preludeNodes = nodeChildren(preludeChildren);
+		return new AtRule({
+			name,
+			prelude: preludeNodes.length === 1 ? preludeNodes[0] : preludeNodes.length > 0 ? new Sequence(preludeNodes, void 0, loc) : void 0,
+			rules: nodeChildren(bodyChildren)
+		}, void 0, loc);
+	}
+	_buildQueryAtRuleBlock(children, loc) {
+		const name = children.filter((c) => c?._tag === "leaf")[0]?.value ?? "";
+		const braceIdx = children.findIndex((c) => c._tag === "leaf" && c.value === "{");
+		const preludeChildren = braceIdx >= 0 ? children.slice(1, braceIdx) : children.slice(1);
+		const bodyChildren = braceIdx >= 0 ? children.slice(braceIdx + 1) : [];
+		return new AtRule({
+			name,
+			prelude: new Sequence(nodeChildren(preludeChildren), void 0, loc),
+			rules: nodeChildren(bodyChildren)
+		}, void 0, loc);
+	}
+	_buildScssParen(rawChildren, loc) {
+		const inner = this._betweenParens(spannedComponents(rawChildren));
+		const { value } = this._assembleValue(inner, loc);
+		if (value && isNode(value, N.Operation)) return new Expression(value, void 0, loc);
+		if (value && isNode(value, N.List) && value.options?.sep === "/" && value.value.length === 2) {
+			const [left, right] = value.value;
+			return new Expression(new Operation([
+				left,
+				"/",
+				right
+			], void 0, loc), void 0, loc);
+		}
+		return new Paren(value, void 0, loc);
+	}
+	_buildScssExtendTarget(children, raw, loc) {
+		for (const c of children) if (typeof c === "string") return c;
+		const placeholderLeaf = children.find((c) => c?._tag === "leaf" && typeof c.value === "string" && c.value.startsWith("%"));
+		if (placeholderLeaf) return `\\${placeholderLeaf.value.slice(1)}`;
+		const items = nodeChildren(children);
+		if (items.length === 1) return items[0];
+		if (items.length > 1) return this._makeSelectorList(items, loc);
+		const spanItems = spannedComponents(raw).filter((i) => i.comp !== ",");
+		if (spanItems.length === 1 && typeof spanItems[0].comp === "string") {
+			const sel = spanItems[0].comp;
+			return sel.startsWith("%") ? `\\${sel.slice(1)}` : sel;
+		}
+		return items[0];
+	}
+	_scssExtendTargetFrom(children, raw, _loc) {
+		for (const c of children) {
+			if (typeof c === "string") return c;
+			if (c != null && typeof c === "object" && "_tag" in c && c._tag === "node") {
+				const n = c;
+				if ([
+					"SelectorList",
+					"BasicSelector",
+					"CompoundSelector",
+					"ComplexSelector"
+				].includes(n.type)) return n;
+			}
+		}
+		const items = spannedComponents(raw).filter((i) => i.comp !== "@extend" && i.comp !== ";" && i.comp !== "!optional");
+		if (items.length === 1 && typeof items[0].comp === "string") {
+			const sel = items[0].comp;
+			if (sel.startsWith("%")) return `\\${sel.slice(1)}`;
+			return sel;
+		}
+		return nodeChildren(children)[0];
+	}
+	_buildScssExtend(children, raw, loc) {
+		const target = this._scssExtendTargetFrom(children, raw, loc);
+		validateExtendTarget(target, this._parseContext?.opts?.allowExtendSelectors, (msg) => this._error(msg, loc.start, loc.end));
+		const prelude = this._source.slice(loc.start, loc.end);
+		const namespace = /@extend\s+%/.test(prelude) || isPlaceholderExtendTarget(target) ? "*" : void 0;
+		return new Extend({
+			target,
+			flag: ExtendFlag.All,
+			namespace
+		}, void 0, loc);
+	}
+	_buildScssImportItem(children, raw, loc) {
+		const prelude = nodeChildren(children).find((n) => isNode(n, N.Quoted) || isNode(n, N.Url));
+		const pathSpan = spannedComponents(raw).find((i) => isNode(i.comp, N.Quoted) || isNode(i.comp, N.Url) || typeof i.comp === "string" && (i.comp.startsWith("\"") || i.comp.startsWith("'") || i.comp.startsWith("url")));
+		let extraText;
+		if (pathSpan) {
+			const tail = raw.filter((c) => c._tag === "leaf" && c.value !== "@import").map((c) => c.value).join("");
+			const pathText = typeof pathSpan.comp === "string" ? pathSpan.comp : "";
+			const idx = tail.indexOf(pathText);
+			if (idx >= 0) extraText = tail.slice(idx + pathText.length).replace(/^[\s,]+/, "").replace(/[,;]\s*$/, "").trim() || void 0;
+		}
+		const seqItems = [];
+		if (prelude) seqItems.push(prelude);
+		if (extraText) seqItems.push(new Any(extraText, { role: "ident" }, loc));
+		return new Sequence(seqItems, void 0, loc);
+	}
+	_buildScssImportAtRule(children, loc) {
+		checkImportPreludeOrder(this._source.slice(loc.start, loc.end).replace(/^@import\b/i, "").replace(/;\s*$/, ""), (msg) => this._error(msg, loc.start, loc.end));
+		const items = nodeChildren(children).filter((n) => isNode(n, N.Sequence));
+		const importName = new Any("@import", { role: "atkeyword" }, loc);
+		const built = [];
+		for (const item of items) {
+			const seq = item;
+			const prelude = seq.value[0];
+			const extra = seq.value[1];
+			const extraText = extra && isNode(extra, N.Any) ? String(extra.valueOf()).trim() : void 0;
+			const itemLoc = sourceSpanOf(seq) ?? loc;
+			if (!prelude) continue;
+			if (!isPlainCssImportPrelude(prelude, extraText) && isNode(prelude, N.Quoted)) {
+				built.push(new StyleImport({ path: prelude }, {
+					type: "import",
+					importOptions: { multiple: true }
+				}, itemLoc));
+				continue;
+			}
+			const preludeNodes = [prelude];
+			if (extraText) preludeNodes.push(new Any(extraText, { role: "ident" }, itemLoc));
+			built.push(new AtRuleStatement({
+				name: importName,
+				prelude: new Sequence(preludeNodes, void 0, itemLoc)
+			}, void 0, itemLoc));
+		}
+		if (built.length === 1) return built[0];
+		return new List(built, { role: "scss-imports" }, loc);
+	}
+	_buildCall(rawChildren, loc) {
+		const call = super._buildCall(rawChildren, loc);
+		const nameNode = call.name;
+		const stringName = typeof nameNode === "string" ? nameNode : isNode(nameNode, N.Reference) && typeof nameNode.key === "string" ? nameNode.key : "";
+		const mapped = desugarMapLookup(new Call({
+			name: stringName,
+			args: call.args
+		}, call.options, loc), loc);
+		if (isNode(mapped, N.Reference)) return mapped;
+		const desugared = desugarNamespacedCall(new Call({
+			name: stringName,
+			args: call.args
+		}, call.options, loc), loc);
+		const name = desugared.name;
+		if (stringName === "selector.parse") {
+			const firstArg = (isNode(desugared.args, N.List) ? desugared.args.value : [])[0];
+			const selectorText = firstArg && isNode(firstArg, N.Quoted) ? typeof firstArg.value === "string" ? firstArg.value : isNode(firstArg.value, N.Any) ? String(firstArg.value.valueOf()) : void 0 : void 0;
+			if (selectorText !== void 0 && isValidScssSelectorList(selectorText)) return new SelectorCapture(selectorText, void 0, loc);
+			return desugared;
+		}
+		if (typeof name === "string" && name.includes(".")) return new Expression(desugared, void 0, loc);
+		if (isNode(name, N.Reference) && name.options?.type === "function") return new Call({
+			name,
+			args: desugared.args
+		}, void 0, loc);
+		if (typeof name === "string") return new Call({
+			name: new Reference({ key: name }, {
+				type: "function",
+				fallbackValue: true
+			}, loc),
+			args: desugared.args
+		}, void 0, loc);
+		return desugared;
+	}
+	_buildSquareParen(rawChildren, loc) {
+		const inner = super._buildSquareParen(rawChildren, loc).value;
+		return new Paren(inner, { delimiter: isNode(inner, N.Any) && inner.options?.role === "ident" ? "square" : "paren" }, loc);
+	}
+};
+//#endregion
+//#region src/functional-parser.ts
+var BuilderHost = class extends ScssGrammar {
+	setSource(src) {
+		this._source = src;
+	}
+	resetWarnings() {
+		this._warnings = [];
+		this._errors = [];
+		this._liftedCommentRanges = [];
+	}
+	getWarnings() {
+		return this._warnings.slice();
+	}
+	getErrors() {
+		return this._errors.slice();
+	}
+	setContext(context) {
+		this._parseContext = context;
+	}
+	/** `ctx.build` host: every structural `node(type, …)` builds through this,
+	* reusing ScssGrammar's (SCSS + inherited Less/CSS) `buildNode` verbatim. */
+	captureTriviaForNode(type) {
+		return type === "CompoundSelector";
+	}
+	build(type, children, fields, span, rawChildren, triviaLog) {
+		return this.buildNode(type, {
+			start: span.start,
+			end: span.end
+		}, children, void 0, rawChildren, fields, triviaLog);
+	}
+};
+const host = new BuilderHost();
+function parseScssFn(input, rule = "Stylesheet", options = {}) {
+	const g = scssGrammar;
+	host.setContext(options.context);
+	return runFunctionalParse(input, g[rule], host, { trivia: g.rw });
+}
+setParseScssFnForInterp(parseScssFn);
+const EMPTY_LEXER_RESULT = {
+	tokens: [],
+	errors: [],
+	groups: {}
+};
+function toParseResult(result) {
+	return {
+		tree: result.tree,
+		errors: result.errors,
+		warnings: result.warnings,
+		trivia: result.trivia,
+		lexerResult: EMPTY_LEXER_RESULT
+	};
+}
+/**
+* Functional SCSS parser — the default `Parser` export. Wraps `parseScssFn` and
+* returns the same `IParseResult` shape as the legacy Chevrotain parser (with an
+* empty `lexerResult`; the functional grammar does not tokenize separately).
+*/
+var ScssParser = class {
+	constructor(_config = {}) {}
+	parse(text, rule = "Stylesheet", options) {
+		return toParseResult(parseScssFn(text, rule, { context: options?.context }));
+	}
+	suggest(_text, _init) {
+		return [];
+	}
+};
+//#endregion
+export { parseScssFn as n, ScssGrammar as r, ScssParser as t };