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

package/lib/functional-parser.cjs

@@ -1,3034 +0,0 @@
-const require_grammar = require("./grammar.cjs");
-let _jesscss_less_parser_jess = require("@jesscss/less-parser/jess");
-let _jesscss_css_parser_jess = require("@jesscss/css-parser/jess");
-let _jesscss_core = require("@jesscss/core");
-//#region ../../../parser-thing/dist/index.js
-function union(a, b) {
-	if (a.kind === "any" || b.kind === "any") return { kind: "any" };
-	if (a.kind === "empty") return b;
-	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 firstSetOf(p, seen = /* @__PURE__ */ new Set()) {
-	if (seen.has(p)) return any();
-	seen.add(p);
-	const fs = (c) => firstSetOf(c, seen);
-	const d = p._def;
-	switch (d.tag) {
-		case "literal":
-		case "regex":
-		case "keywords": return p._meta.firstSet;
-		case "lazy": try {
-			return fs(d.thunk());
-		} catch {
-			return any();
-		}
-		case "choice": {
-			let out = empty();
-			for (const arm of d.parsers) out = union(out, fs(arm));
-			return out;
-		}
-		case "sequence": {
-			let out = empty();
-			for (const term of d.parsers) {
-				out = union(out, fs(term));
-				if (!matchesEmpty(term)) return out;
-			}
-			return out;
-		}
-		case "oneOrMore":
-		case "many":
-		case "optional":
-		case "transform":
-		case "label":
-		case "trivia":
-		case "token":
-		case "node":
-		case "grammar":
-		case "expect": return fs(d.parser);
-		case "sepBy": return fs(d.parser);
-		case "skip": return fs(d.main);
-		default: return p._meta.firstSet;
-	}
-}
-function mergeRanges(ranges) {
-	if (ranges.length === 0) return [];
-	const sorted = [...ranges].sort((a, b) => a.lo - b.lo);
-	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,
-		errors: ctx._errors?.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) {
-	if (ctx._errors && mark.errors !== void 0) ctx._errors.length = mark.errors;
-	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 firstSetSentinel(fs) {
-	if (fs.kind !== "ranges" || fs.ranges.length === 0) return null;
-	const ranges = fs.ranges;
-	return {
-		_tag: "firstSetSentinel",
-		_meta: {
-			firstSet: fs,
-			canMatchNewline: false,
-			isTrivia: false
-		},
-		_def: { tag: "unknown" },
-		parse(input, pos) {
-			const code = pos < input.length ? input.codePointAt(pos) : void 0;
-			if (code !== void 0) {
-				for (const r of ranges) if (code >= r.lo && code <= r.hi) return {
-					ok: true,
-					value: null,
-					span: {
-						start: pos,
-						end: pos
-					}
-				};
-			}
-			return {
-				ok: false,
-				expected: [],
-				span: {
-					start: pos,
-					end: pos
-				}
-			};
-		}
-	};
-}
-function deriveExpected(c) {
-	const def = c._def;
-	switch (def.tag) {
-		case "literal": return [JSON.stringify(def.value)];
-		case "regex": return [`/${def.source}/`];
-		case "keywords": return def.words.map((w) => JSON.stringify(w));
-		case "label": return [def.label];
-		case "choice": return def.parsers.flatMap(deriveExpected);
-		case "sequence": return def.parsers.length > 0 ? deriveExpected(def.parsers[0]) : [];
-		case "node":
-		case "grammar":
-		case "trivia":
-		case "token":
-		case "optional":
-		case "many":
-		case "oneOrMore":
-		case "transform":
-		case "not": return deriveExpected(def.parser);
-		case "lazy": {
-			const name = c._ruleName;
-			try {
-				return deriveExpected(def.thunk());
-			} catch {
-				return name ? [name] : [];
-			}
-		}
-		default: return [];
-	}
-}
-function choice(...args) {
-	const parsers = args.map((a) => "gate" in a ? a.combinator : a);
-	const gates = args.map((a) => "gate" in a ? a.gate : null);
-	const hasGates = gates.some((g) => g !== null);
-	const disjoint = areDisjoint(parsers.map((p) => p._meta.firstSet)) && parsers.every((p) => !matchesEmpty(p));
-	let combined = { kind: "empty" };
-	for (const p of parsers) combined = union(combined, p._meta.firstSet);
-	const meta = {
-		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 idx = code < 128 ? asciiDispatch[code] : -1;
-				if (idx < 0) {
-					for (let i = 0; i < parsers.length; i++) if (inFirstSet(code, parsers[i]._meta.firstSet)) {
-						idx = i;
-						break;
-					}
-				}
-				if (idx >= 0) {
-					const gate = gates[idx];
-					if (gate && !gate(ctx.state)) return {
-						ok: false,
-						expected: deriveExpected(parsers[idx]),
-						span: {
-							start: pos,
-							end: pos
-						}
-					};
-					const result = parsers[idx].parse(input, pos, ctx);
-					if (result.ok) return result;
-					expected.push(...result.expected);
-					return {
-						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(-1);
-	for (let i = 0; i < parsers.length; i++) {
-		const fs = parsers[i]._meta.firstSet;
-		if (fs.kind !== "ranges") continue;
-		for (const { lo, hi } of fs.ranges) for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) table[code] = i;
-	}
-	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,
-		errors: m.errors,
-		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,
-		errors: mark.errors
-	});
-	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
-	};
-	let followSentinels;
-	function parseTolerant(input, pos, ctx) {
-		followSentinels ??= parsers.map((_, i) => {
-			return firstSetSentinel(parsers.slice(i + 1).reduce((acc, p) => union(acc, firstSetOf(p)), { kind: "empty" }));
-		});
-		const values = def.valueUnused ? void 0 : [];
-		let cur = pos;
-		const inheritedSync = ctx._sync;
-		try {
-			for (let i = 0; i < parsers.length; i++) {
-				ctx._sync = followSentinels[i] ?? inheritedSync;
-				if (ctx.trivia && i > 0) {
-					const mark = saveTriviaMark(ctx);
-					let scanEnd;
-					if (needsDeferredTriviaCommit(ctx)) {
-						const scan = scanTrivia(input, cur, ctx);
-						scan.commit();
-						scanEnd = scan.end;
-					} else scanEnd = advanceTrivia(input, cur, ctx);
-					const result2 = parsers[i].parse(input, scanEnd, ctx);
-					if (!result2.ok) return result2;
-					if (result2.span.end > scanEnd) cur = result2.span.end;
-					else rollbackTrivia(ctx, mark);
-					if (values !== void 0) values.push(result2.value);
-					continue;
-				}
-				const result = parsers[i].parse(input, cur, ctx);
-				if (!result.ok) return result;
-				if (values !== void 0) values.push(result.value);
-				cur = result.span.end;
-			}
-		} finally {
-			ctx._sync = inheritedSync;
-		}
-		return {
-			ok: true,
-			value: values ?? void 0,
-			span: {
-				start: pos,
-				end: cur
-			}
-		};
-	}
-	return {
-		_tag: "sequence",
-		_meta: meta,
-		_def: def,
-		parse(input, pos, ctx) {
-			if (ctx._tolerant) return parseTolerant(input, pos, ctx);
-			const values = def.valueUnused ? void 0 : [];
-			let cur = pos;
-			for (let i = 0; i < parsers.length; i++) {
-				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 ((0, _jesscss_core.isNode)(n, _jesscss_core.N.Reference) && n.options?.type === "variable" && !n.target && typeof n.key === "string") return n;
-}
-function valueFromParseResult(r, fallback, loc) {
-	const root = r.tree;
-	if ((0, _jesscss_core.isNode)(root, _jesscss_core.N.Rules) && root.rules.length > 0) return root.rules[0];
-	if (root instanceof _jesscss_core.Node) return root;
-	return new _jesscss_core.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 _jesscss_core.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 _jesscss_core.Any(trimmed, { role: "any" }, loc);
-	const tree = valueFromParseResult(r, trimmed, loc);
-	const ref = unwrapSingleReference(tree);
-	if (ref && typeof ref.key === "string") return new _jesscss_core.Reference({ key: ref.key }, {
-		type: "variable",
-		role: "ident"
-	}, loc);
-	if ((0, _jesscss_core.isNode)(tree, _jesscss_core.N.Reference)) return new _jesscss_core.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 _jesscss_core.Reference({ key: ref.key }, {
-		type: "variable",
-		role: "ident"
-	}, loc);
-	if ((0, _jesscss_core.isNode)(expr, _jesscss_core.N.Reference)) return new _jesscss_core.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 _jesscss_core.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) + _jesscss_core.INTERPOLATION_PLACEHOLDER + source.slice(adjustedEnd);
-		offset += match.end - match.start - _jesscss_core.INTERPOLATION_PLACEHOLDER.length;
-		replacements.push(toInterpReplacement(parseScssInterpExpr(match.content, loc), loc));
-	}
-	return new _jesscss_core.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 ?? (0, _jesscss_core.sourceSpanOf)(original);
-	return new _jesscss_core.Quoted(new _jesscss_core.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 _jesscss_core.Url) return true;
-	if (extraText && extraText.trim()) return true;
-	if ((0, _jesscss_core.isNode)(prelude, _jesscss_core.N.Quoted)) return isPlainCssImportPath(prelude.valueOf());
-	return true;
-}
-function findDisallowedExtendSelector(selector, allowed) {
-	if ((0, _jesscss_core.isNode)(selector, _jesscss_core.N.SelectorList)) {
-		for (const item of selector.value) {
-			const disallowed = findDisallowedExtendSelector(item, allowed);
-			if (disallowed) return disallowed;
-		}
-		return;
-	}
-	const kinds = (0, _jesscss_core.isNode)(selector, _jesscss_core.N.BasicSelector) ? ["simple", "basic"] : (0, _jesscss_core.isNode)(selector, _jesscss_core.N.PseudoSelector) ? ["simple", "pseudo"] : (0, _jesscss_core.isNode)(selector, _jesscss_core.N.CompoundSelector) ? ["compound"] : (0, _jesscss_core.isNode)(selector, _jesscss_core.N.ComplexSelector) ? ["complex"] : ["simple"];
-	if ((0, _jesscss_core.isNode)(selector, _jesscss_core.N.CompoundSelector) && selector.value.length === 1) return findDisallowedExtendSelector(selector.value[0], allowed);
-	if ((0, _jesscss_core.isNode)(selector, _jesscss_core.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 ((0, _jesscss_core.isNode)(target, _jesscss_core.N.BasicSelector)) return target.value.startsWith("\\");
-	if ((0, _jesscss_core.isNode)(target, _jesscss_core.N.SelectorList) && target.value.length === 1) return isPlaceholderExtendTarget(target.value[0]);
-	if ((0, _jesscss_core.isNode)(target, _jesscss_core.N.CompoundSelector) && target.value.length === 1) return isPlaceholderExtendTarget(target.value[0]);
-	if ((0, _jesscss_core.isNode)(target, _jesscss_core.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 ? (0, _jesscss_core.sourceSpanOf)(selector) : void 0;
-	const nil = new _jesscss_core.Nil(void 0, void 0, location, context);
-	const amp = new _jesscss_core.Ampersand({ selectorContainer: { selector: nil } }, void 0, location, context);
-	amp.adopt(nil);
-	return amp;
-}
-function getNodeLocation(node) {
-	return (0, _jesscss_core.sourceSpanOf)(node);
-}
-function prefixAtRootSelector(selector, context) {
-	if ((0, _jesscss_core.isNode)(selector, _jesscss_core.N.SelectorList)) return new _jesscss_core.SelectorList(selector.value.map((item) => prefixAtRootSelector(item, context)), void 0, getNodeLocation(selector), context);
-	const amp = createNullParentAmpersand(context, selector);
-	if ((0, _jesscss_core.isNode)(selector, _jesscss_core.N.ComplexSelector)) return new _jesscss_core.ComplexSelector([amp, ...selector.value], void 0, getNodeLocation(selector), context);
-	return new _jesscss_core.ComplexSelector([amp, selector], void 0, getNodeLocation(selector), context);
-}
-function lowerPlainAtRootRules(rules, context) {
-	const transformRule = (node) => {
-		if ((0, _jesscss_core.isNode)(node, _jesscss_core.N.Ruleset)) {
-			const rs = node;
-			if (!(0, _jesscss_core.isNode)(rs.selector, _jesscss_core.N.Nil)) return new _jesscss_core.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, (0, _jesscss_core.sourceSpanOf)(rs), context);
-			return node;
-		}
-		if ((0, _jesscss_core.isNode)(node, _jesscss_core.N.AtRule) && node.rules) {
-			lowerPlainAtRootRules(node.rules, context);
-			return node;
-		}
-		if ((0, _jesscss_core.isNode)(node, _jesscss_core.N.If)) {
-			lowerPlainAtRootRules(node, context);
-			if (node.else) lowerPlainAtRootRules(node.else, context);
-			return node;
-		}
-		if ((0, _jesscss_core.isNode)(node, _jesscss_core.N.For)) {
-			lowerPlainAtRootRules(node, context);
-			return node;
-		}
-		if ((0, _jesscss_core.isNode)(node, _jesscss_core.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 ((0, _jesscss_core.isNode)(n, _jesscss_core.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 _jesscss_core.Reference(parts[0], { type: "variable" }, loc);
-	for (let i = 1; i < parts.length; i++) {
-		const isFinal = i === parts.length - 1;
-		current = new _jesscss_core.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 _jesscss_core.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 = (0, _jesscss_core.isNode)(argsList, _jesscss_core.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 = (0, _jesscss_core.isNode)(mapExpr, _jesscss_core.N.Reference) ? mapExpr : (0, _jesscss_core.isNode)(mapExpr, _jesscss_core.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 _jesscss_core.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 _jesscss_less_parser_jess.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 = (0, _jesscss_css_parser_jess.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 _jesscss_core.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 = (0, _jesscss_css_parser_jess.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Paren(nodeChildren(children)[0] ?? new _jesscss_core.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 _jesscss_core.Any("", {}, loc);
-		if (ls.some((l) => /^not$/i.test(l.value))) return new _jesscss_core.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 _jesscss_core.Any("", {}, loc);
-		let left = nodes[0];
-		for (let i = 1; i < nodes.length; i++) left = new _jesscss_core.Condition([
-			left,
-			op,
-			nodes[i]
-		], {}, loc);
-		return left;
-	}
-	/** A `{ … }` control-block body → Rules. */
-	_buildScssRules(children, loc) {
-		return new _jesscss_core.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 _jesscss_core.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 _jesscss_core.If({
-			condition: conditions[i],
-			rules: bodies[i].rules,
-			else: elseNode
-		}, void 0, loc);
-		return elseNode ?? new _jesscss_core.Any("", {}, loc);
-	}
-	/** A `$name` loop-binding with no value (`paramVar` — prints as `$name`). */
-	_scssParamVar(varName, loc) {
-		return new _jesscss_core.VarDeclaration({
-			name: varName,
-			value: new _jesscss_core.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 _jesscss_core.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 _jesscss_core.Sequence(iterableNodes, void 0, loc);
-		if (iterable.type === "Expression") iterable = iterable.value;
-		const decls = vars.map((v) => this._scssParamVar(v, loc));
-		return new _jesscss_core.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 _jesscss_core.Rules);
-		const exprNodes = nodes.filter((n) => n !== body);
-		const startExpr = exprNodes[0] ?? new _jesscss_core.Any("", {}, loc);
-		const endExpr = exprNodes[1] ?? new _jesscss_core.Any("", {}, loc);
-		return new _jesscss_core.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 _jesscss_core.Rules);
-		return new _jesscss_core.While({
-			condition: nodes.find((n) => n !== body) ?? new _jesscss_core.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) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Interpolated));
-		if (interp) return new _jesscss_core.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 _jesscss_core.Reference(parts[0], { type: "variable" }, loc);
-			for (let i = 1; i < parts.length; i++) {
-				const isFinal = i === parts.length - 1;
-				ref = new _jesscss_core.Reference({
-					target: ref,
-					key: parts[i]
-				}, {
-					type: isFinal ? "mixin" : "index",
-					...isFinal ? { role: "name" } : {}
-				}, loc);
-			}
-			return ref;
-		}
-		return new _jesscss_core.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 _jesscss_core.VarDeclaration({
-			name: varLeaf.value.slice(1),
-			value: nodes.find((n) => n !== void 0 && !ls.includes(n)) ?? nodes[0] ?? new _jesscss_core.Nil()
-		}, {}, loc);
-		const value = nodes[0] ?? new _jesscss_core.Any("", {}, loc);
-		if (hasSpread) return new _jesscss_core.Rest(value, void 0, loc);
-		return value;
-	}
-	_buildScssCallArgsInner(children, loc) {
-		const nodes = nodeChildren(children);
-		if (nodes.length === 0) return;
-		return new _jesscss_core.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 _jesscss_core.Rest(varName, void 0, loc);
-		if (ls.some((l) => l.value === ":") && nodes[0]) return new _jesscss_core.VarDeclaration({
-			name: varName,
-			value: nodes[0]
-		}, { paramVar: true }, loc);
-		return new _jesscss_core.Any(varName, { role: "property" }, loc);
-	}
-	_buildScssMixinParams(children, loc) {
-		return new _jesscss_core.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) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Interpolated));
-		const nameLeaf = ls.find((l) => !l.value.startsWith("@") && l.value !== "(" && l.value !== ")" && l.value !== "{" && l.value !== "}" && l.value !== ",");
-		return new _jesscss_core.Mixin({
-			name: interpName ?? nameLeaf?.value ?? "",
-			params: nodes.find((n) => n.type === "List"),
-			rules: nodes.find((n) => n instanceof _jesscss_core.Rules).rules
-		}, void 0, loc);
-	}
-	/** `using ($c, $n)` param list for `@include … using (…)`. */
-	_buildScssIncludeUsing(children, loc) {
-		return new _jesscss_core.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 _jesscss_core.Rules);
-		let contentNode;
-		if (contentRules) {
-			contentNode = new _jesscss_core.Mixin({
-				rules: contentRules.rules,
-				params: usingParams
-			}, void 0, loc);
-			contentNode.addFlags(_jesscss_core.F_VISIBLE);
-		}
-		return new _jesscss_core.Call({
-			name: nameRef ?? new _jesscss_core.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 _jesscss_core.Call({
-			name: new _jesscss_core.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) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Interpolated));
-		const nameLeaf = ls.find((l) => !l.value.startsWith("@") && l.value !== "(" && l.value !== ")" && l.value !== "{" && l.value !== "}" && l.value !== ",");
-		return new _jesscss_core.Func({
-			name: interpName ?? nameLeaf?.value ?? "",
-			params: nodes.find((n) => n.type === "List"),
-			body: nodes.find((n) => n instanceof _jesscss_core.Rules)
-		}, { returnName: "result" }, loc);
-	}
-	/** `@return <value>;` → `$result: <value>;` */
-	_buildScssReturn(children, rawChildren, loc) {
-		const items = (0, _jesscss_css_parser_jess.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 _jesscss_core.VarDeclaration({
-			name: "result",
-			value
-		}, void 0, loc);
-	}
-	_buildScssInterpBare(children, loc) {
-		return new _jesscss_core.Interpolated({
-			source: _jesscss_core.INTERPOLATION_PLACEHOLDER,
-			replacements: [toInterpReplacement(nodeChildren(children)[0] ?? new _jesscss_core.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" && (0, _jesscss_core.isNode)(c, _jesscss_core.N.Interpolated)) {
-			source += _jesscss_core.INTERPOLATION_PLACEHOLDER;
-			replacements.push(...c.replacements);
-		}
-		if (replacements.length === 0) return new _jesscss_core.Any(source, { role: "name" }, loc);
-		return new _jesscss_core.Interpolated({
-			source,
-			replacements
-		}, { role: "name" }, loc);
-	}
-	_buildScssInterpValue(raw, loc) {
-		return buildScssInterpolatedFromString((0, _jesscss_css_parser_jess.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" && (0, _jesscss_core.isNode)(c, _jesscss_core.N.Interpolated)) {
-			source += _jesscss_core.INTERPOLATION_PLACEHOLDER;
-			replacements.push(...c.replacements);
-		}
-		return new _jesscss_core.InterpolatedSelector(new _jesscss_core.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) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Collection) || (0, _jesscss_core.isNode)(n, _jesscss_core.N.Sequence) || (0, _jesscss_core.isNode)(n, _jesscss_core.N.Keyword) || (0, _jesscss_core.isNode)(n, _jesscss_core.N.Reference) || (0, _jesscss_core.isNode)(n, _jesscss_core.N.Num) || (0, _jesscss_core.isNode)(n, _jesscss_core.N.Paren) || (0, _jesscss_core.isNode)(n, _jesscss_core.N.List));
-		const collection = valueNodes.find((n) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Collection));
-		if (collection && valueNodes.length > 1) {
-			const base = valueNodes.find((n) => n !== collection);
-			if (base) d.value = new _jesscss_core.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 _jesscss_core.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 _jesscss_core.Any("", { role: "property" }, loc);
-		const valueNode = nodes[1] ?? new _jesscss_core.Any("", {}, loc);
-		return new _jesscss_core.Declaration({
-			name: toDeclKey(keyNode),
-			value: valueNode
-		}, void 0, loc);
-	}
-	_buildScssMapLiteral(children, loc) {
-		return new _jesscss_core.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 _jesscss_core.Reference({
-			target: new _jesscss_core.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) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.List));
-			return new _jesscss_core.Expression(new _jesscss_core.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 = (0, _jesscss_css_parser_jess.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 = (0, _jesscss_core.isNode)(argValue, _jesscss_core.N.List) ? argValue.value[0] : argValue;
-				const selectorText = firstArg && (0, _jesscss_core.isNode)(firstArg, _jesscss_core.N.Quoted) ? typeof firstArg.value === "string" ? firstArg.value : (0, _jesscss_core.isNode)(firstArg.value, _jesscss_core.N.Any) ? String(firstArg.value.valueOf()) : void 0 : void 0;
-				if (selectorText !== void 0 && isValidScssSelectorList(selectorText)) return new _jesscss_core.SelectorCapture(selectorText, void 0, loc);
-			}
-			const items = (0, _jesscss_css_parser_jess.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 = (0, _jesscss_core.isNode)(argValue, _jesscss_core.N.List) ? argValue : new _jesscss_core.List([argValue], void 0, loc);
-			const mapped = desugarMapLookup(new _jesscss_core.Call({
-				name: `${ident}.${fnName}`,
-				args
-			}, void 0, loc), loc);
-			if ((0, _jesscss_core.isNode)(mapped, _jesscss_core.N.Reference)) return mapped;
-			const memberType = fnName.startsWith("#") ? "mixin-ruleset" : "function";
-			const call = new _jesscss_core.Call({
-				name: makeNamespacedReference([ident, fnName.startsWith("#") ? fnName.slice(1) : fnName], memberType, loc),
-				args
-			}, void 0, loc);
-			if (memberType === "mixin-ruleset") return new _jesscss_core.Expression(call, void 0, loc);
-			return new _jesscss_core.Expression(desugarNamespacedCall(call, loc), void 0, loc);
-		}
-		return new _jesscss_core.Any(ident, { role: "ident" }, loc);
-	}
-	_buildStylesheet(children, loc) {
-		const nodes = this._flattenScssImportLists(nodeChildren(children));
-		return new _jesscss_core.Rules(this._liftStandaloneComments(nodes, loc.start, loc.end, loc), void 0, loc);
-	}
-	_flattenScssImportLists(nodes) {
-		const flat = [];
-		for (const n of nodes) if ((0, _jesscss_core.isNode)(n, _jesscss_core.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 _jesscss_core.Collection(nodeChildren(children).filter((n) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Declaration) || (0, _jesscss_core.isNode)(n, _jesscss_core.N.VarDeclaration) || n instanceof _jesscss_core.If || n instanceof _jesscss_core.For || n instanceof _jesscss_core.While), void 0, loc);
-	}
-	_buildScssDiagnostic(children, loc) {
-		return new _jesscss_core.Log({
-			level: children.filter((c) => c?._tag === "leaf").find((l) => l.value.startsWith("@"))?.value.slice(1) ?? "debug",
-			message: nodeChildren(children).find((n) => !(0, _jesscss_core.isNode)(n, _jesscss_core.N.Any) || n.options?.role !== "atkeyword") ?? nodeChildren(children)[0] ?? new _jesscss_core.Any("", {}, loc)
-		}, void 0, loc);
-	}
-	_buildScssAtRootFilter(children, loc) {
-		const nodes = nodeChildren(children);
-		const prelude = nodes.find((n) => !(n instanceof _jesscss_core.Rules)) ?? nodes[0];
-		const body = nodes.find((n) => n instanceof _jesscss_core.Rules);
-		const name = new _jesscss_core.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 _jesscss_core.AtRule({
-			name,
-			prelude,
-			rules: body.rules
-		}, void 0, loc);
-	}
-	_buildScssAtRootSelector(children, loc) {
-		const nodes = nodeChildren(children);
-		const selector = nodes.find((n) => !(n instanceof _jesscss_core.Rules));
-		const body = nodes.find((n) => n instanceof _jesscss_core.Rules);
-		const context = this._parseContext;
-		return new _jesscss_core.Ruleset({
-			selector: prefixAtRootSelector(selector, context),
-			rules: body.rules
-		}, void 0, loc);
-	}
-	_buildScssAtRootPlain(children, loc) {
-		const body = nodeChildren(children).find((n) => n instanceof _jesscss_core.Rules);
-		const context = this._parseContext;
-		const lowered = new _jesscss_core.Rules([...body.rules], void 0, loc);
-		lowerPlainAtRootRules(lowered, context);
-		if (lowered.rules.length === 0) return new _jesscss_core.Nil(void 0, void 0, loc);
-		if (lowered.rules.length === 1) return lowered.rules[0];
-		return new _jesscss_core.List(lowered.rules, { role: "scss-at-root" }, loc);
-	}
-	_buildScssWithConfigEntry(rawChildren, loc) {
-		const items = (0, _jesscss_css_parser_jess.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 _jesscss_core.VarDeclaration({
-			name,
-			value
-		}, {
-			assign: sawDefault ? "?:" : ":",
-			setDefined: sawGlobal
-		}, loc);
-	}
-	_buildScssWithConfig(children, loc) {
-		return new _jesscss_core.Collection(nodeChildren(children).filter((n) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.VarDeclaration)), void 0, loc);
-	}
-	_buildScssUseAs(children, loc) {
-		return new _jesscss_core.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) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Quoted));
-		const withConfig = nodeChildren(children).find((n) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Collection));
-		const useAs = nodeChildren(children).find((n) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Any) && n.options?.role === "ident");
-		const namespace = useAs ? String(useAs.valueOf()) : void 0;
-		const rawPath = pathNode?.valueOf() ?? "";
-		if (rawPath.startsWith("sass:")) return new _jesscss_core.JsImport({ path: quotedLike(pathNode, `#sass/${rawPath.slice(5)}`, loc) }, { namespace: namespace ?? defaultNamespaceFromPath(rawPath) }, loc);
-		if (isScriptUsePath(rawPath)) return new _jesscss_core.JsImport({ path: pathNode }, { namespace: namespace ?? defaultNamespaceFromPath(rawPath) }, loc);
-		return new _jesscss_core.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) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Quoted));
-		const withConfig = nodeChildren(children).find((n) => (0, _jesscss_core.isNode)(n, _jesscss_core.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 _jesscss_core.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 _jesscss_core.AtRule({
-			name,
-			prelude: new _jesscss_core.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 _jesscss_core.AtRule({
-			name,
-			prelude: preludeNodes.length === 1 ? preludeNodes[0] : preludeNodes.length > 0 ? new _jesscss_core.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 _jesscss_core.AtRule({
-			name,
-			prelude: new _jesscss_core.Sequence(nodeChildren(preludeChildren), void 0, loc),
-			rules: nodeChildren(bodyChildren)
-		}, void 0, loc);
-	}
-	_buildScssParen(rawChildren, loc) {
-		const inner = this._betweenParens((0, _jesscss_css_parser_jess.spannedComponents)(rawChildren));
-		const { value } = this._assembleValue(inner, loc);
-		if (value && (0, _jesscss_core.isNode)(value, _jesscss_core.N.Operation)) return new _jesscss_core.Expression(value, void 0, loc);
-		if (value && (0, _jesscss_core.isNode)(value, _jesscss_core.N.List) && value.options?.sep === "/" && value.value.length === 2) {
-			const [left, right] = value.value;
-			return new _jesscss_core.Expression(new _jesscss_core.Operation([
-				left,
-				"/",
-				right
-			], void 0, loc), void 0, loc);
-		}
-		return new _jesscss_core.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 = (0, _jesscss_css_parser_jess.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 = (0, _jesscss_css_parser_jess.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 _jesscss_core.Extend({
-			target,
-			flag: _jesscss_core.ExtendFlag.All,
-			namespace
-		}, void 0, loc);
-	}
-	_buildScssImportItem(children, raw, loc) {
-		const prelude = nodeChildren(children).find((n) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Quoted) || (0, _jesscss_core.isNode)(n, _jesscss_core.N.Url));
-		const pathSpan = (0, _jesscss_css_parser_jess.spannedComponents)(raw).find((i) => (0, _jesscss_core.isNode)(i.comp, _jesscss_core.N.Quoted) || (0, _jesscss_core.isNode)(i.comp, _jesscss_core.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 _jesscss_core.Any(extraText, { role: "ident" }, loc));
-		return new _jesscss_core.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) => (0, _jesscss_core.isNode)(n, _jesscss_core.N.Sequence));
-		const importName = new _jesscss_core.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 && (0, _jesscss_core.isNode)(extra, _jesscss_core.N.Any) ? String(extra.valueOf()).trim() : void 0;
-			const itemLoc = (0, _jesscss_core.sourceSpanOf)(seq) ?? loc;
-			if (!prelude) continue;
-			if (!isPlainCssImportPrelude(prelude, extraText) && (0, _jesscss_core.isNode)(prelude, _jesscss_core.N.Quoted)) {
-				built.push(new _jesscss_core.StyleImport({ path: prelude }, {
-					type: "import",
-					importOptions: { multiple: true }
-				}, itemLoc));
-				continue;
-			}
-			const preludeNodes = [prelude];
-			if (extraText) preludeNodes.push(new _jesscss_core.Any(extraText, { role: "ident" }, itemLoc));
-			built.push(new _jesscss_core.AtRuleStatement({
-				name: importName,
-				prelude: new _jesscss_core.Sequence(preludeNodes, void 0, itemLoc)
-			}, void 0, itemLoc));
-		}
-		if (built.length === 1) return built[0];
-		return new _jesscss_core.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 : (0, _jesscss_core.isNode)(nameNode, _jesscss_core.N.Reference) && typeof nameNode.key === "string" ? nameNode.key : "";
-		const mapped = desugarMapLookup(new _jesscss_core.Call({
-			name: stringName,
-			args: call.args
-		}, call.options, loc), loc);
-		if ((0, _jesscss_core.isNode)(mapped, _jesscss_core.N.Reference)) return mapped;
-		const desugared = desugarNamespacedCall(new _jesscss_core.Call({
-			name: stringName,
-			args: call.args
-		}, call.options, loc), loc);
-		const name = desugared.name;
-		if (stringName === "selector.parse") {
-			const firstArg = ((0, _jesscss_core.isNode)(desugared.args, _jesscss_core.N.List) ? desugared.args.value : [])[0];
-			const selectorText = firstArg && (0, _jesscss_core.isNode)(firstArg, _jesscss_core.N.Quoted) ? typeof firstArg.value === "string" ? firstArg.value : (0, _jesscss_core.isNode)(firstArg.value, _jesscss_core.N.Any) ? String(firstArg.value.valueOf()) : void 0 : void 0;
-			if (selectorText !== void 0 && isValidScssSelectorList(selectorText)) return new _jesscss_core.SelectorCapture(selectorText, void 0, loc);
-			return desugared;
-		}
-		if (typeof name === "string" && name.includes(".")) return new _jesscss_core.Expression(desugared, void 0, loc);
-		if ((0, _jesscss_core.isNode)(name, _jesscss_core.N.Reference) && name.options?.type === "function") return new _jesscss_core.Call({
-			name,
-			args: desugared.args
-		}, void 0, loc);
-		if (typeof name === "string") return new _jesscss_core.Call({
-			name: new _jesscss_core.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 _jesscss_core.Paren(inner, { delimiter: (0, _jesscss_core.isNode)(inner, _jesscss_core.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 = require_grammar.scssGrammar;
-	host.setContext(options.context);
-	return (0, _jesscss_css_parser_jess.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
-Object.defineProperty(exports, "ScssGrammar", {
-	enumerable: true,
-	get: function() {
-		return ScssGrammar;
-	}
-});
-Object.defineProperty(exports, "ScssParser", {
-	enumerable: true,
-	get: function() {
-		return ScssParser;
-	}
-});
-Object.defineProperty(exports, "parseScssFn", {
-	enumerable: true,
-	get: function() {
-		return parseScssFn;
-	}
-});