@jesscss/less-parser 2.0.0-alpha.6 → 2.0.0-alpha.7

package/lib/functional-parser.js

@@ -0,0 +1,2588 @@
+import { lessGrammar } from "./grammar.js";
+import { LexerType, SKIPPED_LABEL, groupCapture, rawCssFragments, rawCssTokens } from "@jesscss/css-parser";
+import { CssParser, buildLazyTriviaMap, runFunctionalParse, spannedComponents, toParseError } from "@jesscss/css-parser/jess";
+import { Ampersand, Any, AtRule, AtRuleStatement, Block, Call, Color, ComplexSelector, CompoundSelector, Condition, CustomDeclaration, Declaration, DefaultGuard, Dimension, Expression, Extend, ExtendFlag, For, INTERPOLATION_PLACEHOLDER, Interpolated, InterpolatedSelector, JsImport, List, Mixin, N, NESTABLE_AT_RULES, Negative, Nil, Num, Operation, Paren, QueryCondition, Quoted, Reference, Rest, Rules, Ruleset, Sequence, StyleImport, Url, VarDeclaration, isNode, isSelectorListLike, nil, selectorListItems, shouldOperateWithMathFrames } from "@jesscss/core";
+//#region src/lessTokens.ts
+const AMPERSAND_TEMPLATE_CONTENTS_REGEX = /(?:[.#-]|\d)(?:[.#\w\u0080-\uffff-]|&)*|(?:[.#\w\u0080-\uffff-]|&)*&(?:[.#\w\u0080-\uffff-]|&)*/;
+function $preBuildFragments() {
+	const fragments = rawCssFragments().map((f) => [...f]);
+	fragments.unshift(["lineComment", "\\/\\/[^\\n\\r]*"]);
+	fragments.push(["interpolated", "[@$]\\{(?:{{nmchar}}*)\\}"]);
+	return fragments;
+}
+function $preBuildTokens() {
+	const tokens = rawCssTokens();
+	/**
+	* Keyed by what to insert after
+	*
+	* @todo - Move merge utility to css-parser
+	*/
+	const merges = {
+		Assign: [{
+			name: "Ellipsis",
+			pattern: /\.\.\./,
+			categories: ["BlockMarker"]
+		}, (
+		/**
+		* Less's historical parser unfortunately allows
+		* at-keywords that are not valid in CSS. One is
+		* that Less allows at-keywords to begin with numbers.
+		* Another is that it allows an at-rule that only
+		* contains a single dash. So we capture this as
+		* a separate token.
+		*
+		* We also do this later in the token stack so that we
+		* don't accidentally grab something like
+		* @-webkit-keyframes while looking for @-.
+		*/
+		{
+			name: "AtKeywordLessExtension",
+			pattern: "@(?:-|\\d(?:{{nmchar}})*)",
+			categories: ["BlockMarker", "AtName"]
+		})],
+		PlainIdent: [
+			{
+				name: "Interpolated",
+				pattern: LexerType.NA
+			},
+			{
+				name: "LineComment",
+				pattern: "{{lineComment}}",
+				label: SKIPPED_LABEL
+			},
+			{
+				name: "PlusAssign",
+				pattern: "\\+{{whitespace}}*:",
+				categories: ["BlockMarker", "Assign"]
+			},
+			{
+				name: "UnderscoreAssign",
+				pattern: "\\+{{whitespace}}*_{{whitespace}}*:",
+				categories: ["BlockMarker", "Assign"]
+			},
+			{
+				name: "AnonMixinStart",
+				pattern: /[.#]\(/,
+				categories: ["BlockMarker"]
+			},
+			{
+				name: "GtEqAlias",
+				pattern: /=>/,
+				categories: ["CompareOperator"]
+			},
+			{
+				name: "LtEqAlias",
+				pattern: /=</,
+				categories: ["CompareOperator"]
+			},
+			{
+				name: "Extend",
+				pattern: /:extend\(/,
+				categories: ["BlockMarker"]
+			},
+			{
+				name: "VarOrProp",
+				pattern: LexerType.NA
+			},
+			{
+				name: "NestedReference",
+				pattern: ["([@$]+{{ident}}?){2,}", groupCapture],
+				start_chars_hint: ["@", "$"],
+				categories: ["VarOrProp"],
+				line_breaks: true
+			},
+			{
+				name: "PropertyReference",
+				pattern: "\\${{ident}}",
+				categories: ["VarOrProp"]
+			},
+			(
+			/** Can be used in unit function or mod operation */
+			{
+				name: "Percent",
+				pattern: /%/
+			}),
+			{
+				name: "DefaultGuardIdent",
+				pattern: /default/,
+				longer_alt: "PlainIdent",
+				categories: ["Ident"]
+			},
+			{
+				name: "DefaultGuardFunc",
+				pattern: /default(?:\(\))/
+			}
+		],
+		Ampersand: [{
+			name: "AmpersandLParen",
+			pattern: /&\(/,
+			push_mode: "AmpersandTemplate",
+			categories: [
+				"Selector",
+				"NestedRuleStart",
+				"BlockMarker"
+			]
+		}, {
+			name: "AllFlag",
+			pattern: /!all/,
+			categories: ["BlockMarker"]
+		}],
+		UrlStart: [
+			(
+			/**
+			* Keywords that we don't identify as idents
+			* should be manually added to other places where an ident is valid.
+			*/
+			{
+				name: "When",
+				pattern: /when/i,
+				longer_alt: "PlainIdent",
+				categories: ["BlockMarker"]
+			}),
+			{
+				name: "FormatFunction",
+				pattern: /%\(/,
+				categories: ["BlockMarker", "FunctionStart"]
+			},
+			{
+				name: "IfFunction",
+				pattern: /if\(/,
+				categories: ["BlockMarker", "FunctionStart"]
+			},
+			{
+				name: "BooleanFunction",
+				pattern: /boolean\(/,
+				categories: ["BlockMarker", "FunctionStart"]
+			},
+			{
+				name: "JavaScript",
+				pattern: /~?`[^`]*`/,
+				line_breaks: true
+			}
+		],
+		Signed: [
+			{
+				name: "InterpolatedIdent",
+				pattern: "(?:{{ident}}|-)?{{interpolated}}(?:{{interpolated}}|{{nmchar}})*",
+				categories: [
+					"Interpolated",
+					"Selector",
+					"Ident"
+				]
+			},
+			{
+				name: "InterpolatedCustomProperty",
+				pattern: "--{{ident}}?{{interpolated}}(?:{{interpolated}}|{{nmchar}})*",
+				categories: ["Interpolated"]
+			},
+			(
+			/**
+			* Unfortunately, there's grammatical ambiguity between
+			* interpolated props and a naked interpolated selector name,
+			* making this awkward token necessary.
+			*/
+			{
+				name: "InterpolatedSelector",
+				pattern: ["[.#]{{ident}}?{{interpolated}}(?:{{interpolated}}|{{nmchar}})*", groupCapture],
+				categories: ["Interpolated", "Selector"],
+				start_chars_hint: [".", "#"],
+				line_breaks: true
+			})
+		]
+	};
+	let defaultTokens = tokens.modes.Default.slice();
+	let tokenLength = defaultTokens.length;
+	for (let i = 0; i < tokenLength; i++) {
+		let token = defaultTokens[i];
+		const { name } = token;
+		const copyToken = () => {
+			token = structuredClone(token);
+		};
+		let alterations = true;
+		switch (name) {
+			case "Ampersand":
+				copyToken();
+				/**
+				* Captures not just ampersands, but "ampersand merges", where
+				* the intent of the author was to merge the parent selector with a token
+				* suffix or prefix.
+				*
+				* e.g.
+				*   1. &-foo
+				*   2. &(foo)
+				*   3. &1
+				*   4. .foo-&
+				*/
+				token.pattern = "(?:[.#](?:{{ident}}-)?&|&){{nmchar}}*";
+				token.start_chars_hint = [
+					"&",
+					".",
+					"#"
+				];
+				break;
+			case "DotName":
+			case "HashName":
+				copyToken();
+				token.longer_alt = "Ampersand";
+				break;
+			case "Divide":
+				copyToken();
+				token.pattern = /\.?\//;
+				break;
+			case "SingleQuoteStart":
+				copyToken();
+				token.pattern = /~?'/;
+				break;
+			case "DoubleQuoteStart":
+				copyToken();
+				token.pattern = /~?"/;
+				break;
+			default: alterations = false;
+		}
+		if (alterations) defaultTokens[i] = token;
+		const merge = merges[name];
+		if (merge) {
+			/** Insert after current token */
+			defaultTokens = defaultTokens.slice(0, i + 1).concat(merge, defaultTokens.slice(i + 1));
+			tokens.modes.Default = defaultTokens;
+			const mergeLength = merge.length;
+			tokenLength += mergeLength;
+			i += mergeLength;
+		}
+	}
+	tokens.modes.AmpersandTemplate = [
+		{
+			name: "AmpersandTemplateEnd",
+			pattern: /\)/,
+			pop_mode: true,
+			categories: ["FunctionLikeEnd"]
+		},
+		{
+			name: "AmpersandTemplateContents",
+			pattern: AMPERSAND_TEMPLATE_CONTENTS_REGEX,
+			categories: ["Selector"]
+		},
+		"SingleQuoteStart",
+		"DoubleQuoteStart",
+		"WS"
+	];
+	return tokens;
+}
+const Fragments = $preBuildFragments();
+const Tokens = $preBuildTokens();
+const lessFragments = () => Fragments;
+const lessTokens = () => Tokens;
+//#endregion
+//#region src/utils.ts
+const INTERPOLATION_REGEX = /([$@])\{([^}]+)\}/g;
+const createInterpolatedReference = (prefix, varName, location, context) => {
+	const isProperty = prefix === "$";
+	return new Reference({ key: isProperty ? new Quoted(varName, { quote: "'" }, location) : varName }, {
+		type: isProperty ? "index" : "variable",
+		role: "ident"
+	}, location);
+};
+const getInterpolatedNode = (name, location, context) => {
+	const replacements = [];
+	let source = name;
+	let result;
+	INTERPOLATION_REGEX.lastIndex = 0;
+	while ((result = INTERPOLATION_REGEX.exec(name)) !== null) {
+		const [match, prefix, varName] = result;
+		source = source.replace(match, INTERPOLATION_PLACEHOLDER);
+		replacements.push(createInterpolatedReference(prefix ?? "", varName ?? "", location, context));
+	}
+	return new Interpolated({
+		source,
+		replacements
+	}, { role: "ident" }, location);
+};
+const normalizeMixinReferenceKey = (selector) => {
+	if (isNode(selector, N.BasicSelector) || selector instanceof InterpolatedSelector) return {
+		key: selector.valueOf(),
+		rawKey: selector
+	};
+	if (isNode(selector, N.CompoundSelector)) return {
+		key: selector.value.map((node) => node.valueOf()),
+		rawKey: selector
+	};
+	if (isNode(selector, N.ComplexSelector)) {
+		const path = [];
+		let canUsePath = true;
+		for (const node of selector.value) {
+			if (isNode(node, N.BasicSelector) || node instanceof InterpolatedSelector) {
+				path.push(node.valueOf());
+				continue;
+			}
+			if (isNode(node, N.CompoundSelector)) {
+				path.push(...node.value.map((child) => child.valueOf()));
+				continue;
+			}
+			if (isNode(node, N.Combinator) && (node.value === ">" || node.value === " ")) continue;
+			canUsePath = false;
+			break;
+		}
+		if (canUsePath && path.length > 0) return {
+			key: path,
+			rawKey: selector
+		};
+	}
+	return {
+		key: selector.valueOf(),
+		rawKey: selector
+	};
+};
+const getInterpolatedOrString = (name, location, context) => {
+	const matches = [];
+	INTERPOLATION_REGEX.lastIndex = 0;
+	let result;
+	while ((result = INTERPOLATION_REGEX.exec(name)) !== null) {
+		const [fullMatch, prefix, varName] = result;
+		if (varName && prefix) matches.push({
+			fullMatch,
+			prefix,
+			varName,
+			index: result.index
+		});
+	}
+	if (matches.length > 0) {
+		let source = name;
+		const replacements = [];
+		let offset = 0;
+		for (let i = 0; i < matches.length; i++) {
+			const match = matches[i];
+			const adjustedIndex = match.index - offset;
+			const beforeMatch = source.substring(0, adjustedIndex);
+			const afterMatch = source.substring(adjustedIndex + match.fullMatch.length);
+			source = beforeMatch + INTERPOLATION_PLACEHOLDER + afterMatch;
+			offset += match.fullMatch.length - INTERPOLATION_PLACEHOLDER.length;
+			const ref = createInterpolatedReference(match.prefix, match.varName, location, context);
+			replacements.push(ref);
+		}
+		return new Interpolated({
+			source,
+			replacements
+		}, { role: "ident" }, location);
+	}
+	const atPos = name.indexOf("@", 1);
+	const dollarPos = name.indexOf("$", 1);
+	if (atPos === -1 && dollarPos === -1) if (name.startsWith("@") || name.startsWith("$")) return name.slice(1);
+	else return name;
+	const nextPos = atPos !== -1 ? atPos : dollarPos;
+	const start = name.slice(1, nextPos);
+	const end = name.slice(nextPos);
+	const type = end.startsWith("@") ? "variable" : "index";
+	const endResult = getInterpolatedOrString(end, location, context);
+	if (typeof endResult === "string") {
+		const endKey = type === "index" ? new Quoted(endResult, { quote: "'" }, location) : endResult;
+		return new Interpolated({
+			source: start + INTERPOLATION_PLACEHOLDER,
+			replacements: [new Reference({ key: endKey }, {
+				type,
+				role: "ident"
+			}, location)]
+		}, { role: "ident" });
+	} else
+ /**
+	* endResult is already an Interpolated node, so we need to handle this
+	* differently.
+	*
+	* @todo - test deep nesting
+	*/
+	return new Interpolated({
+		source: start + INTERPOLATION_PLACEHOLDER,
+		replacements: [type === "index" ? new Quoted(endResult, { quote: "'" }, location) : endResult]
+	}, { role: "ident" });
+};
+//#endregion
+//#region src/builders.ts
+const KNOWN_AT_RULE_VAR_NAME_RE = /^(?:(?:-moz-)?document|(?:-[a-z]+-)?keyframes|(?:-ms-)?viewport|import|media|supports|layer|container|scope|page|font-face|starting-style|property|counter-style|color-profile|font-palette-values|namespace)$/i;
+function spanToLocation(span) {
+	return {
+		start: span.start,
+		end: span.end
+	};
+}
+function nodeChildren(children) {
+	return children.filter((c) => c._tag === "node");
+}
+var LessGrammar = class LessGrammar extends CssParser {
+	/** Math mode governing when arithmetic operates / when `/` divides. Less default. */
+	mathMode = "parens-division";
+	/** Bare ident/keyword token in value or guard position. */
+	_lessKeyword(text, loc) {
+		return this._valueKeyword(text, loc);
+	}
+	_isKeywordLike(node) {
+		return !!node && typeof node === "object" && (node.type === "Keyword" || node.type === "Any");
+	}
+	_isEmptyKeywordLike(node) {
+		return !node || this._isKeywordLike(node) && !String(node.value ?? "").trim();
+	}
+	buildNode(type, span, children, _state, _rawChildren, fields, triviaLog = []) {
+		const loc = spanToLocation(span);
+		const raw = _rawChildren;
+		switch (type) {
+			case "VarDeclaration": return this._buildVarDeclaration(children, raw, loc);
+			case "Reference": return this._buildReference(children, loc);
+			case "LessAmpersand": return this._buildAmpersand(children, loc);
+			case "ComplexSelector": return this._buildComplexSelector(raw, loc);
+			case "SelectorList": return this._buildSelectorList(raw, loc);
+			case "Ruleset": return this._buildRuleset(children, raw, loc);
+			case "Declaration":
+				this._warnDeprecatedValue(span);
+				return this._buildLessDeclaration(raw, loc);
+			case "CustomDeclaration":
+				this._warnCustomPropVars(span);
+				return this._buildLessCustomDecl(children, loc);
+			case "Block": return this._buildLessCustomBlock(children, loc);
+			case "AtRuleBlock":
+				this._warnAtRulePreludeVars(span);
+				return this._buildAtRuleBlock(children, loc);
+			case "QueryAtRuleBlock":
+				this._warnAtRulePreludeVars(span);
+				return this._buildLessQueryAtRuleBlock(children, raw, loc);
+			case "NamedColor": return this._buildNamedColor(children, loc);
+			case "Comparison": return this._buildComparison(raw, loc);
+			case "GuardDefault": return new DefaultGuard("default()", {}, loc);
+			case "GuardInParens": return this._buildGuardInParens(children, loc);
+			case "GuardTerm": return this._buildGuardTerm(raw, loc);
+			case "GuardAnd": return this._buildGuardJoin(children, loc, "and");
+			case "GuardOr": return this._buildGuardJoin(children, loc, "or");
+			case "Guard": return this._buildGuard(children, loc);
+			case "CondArgTerm": return this._buildCondArgTerm(raw, loc);
+			case "CondArgAnd": return this._buildCondArgJoin(children, loc, "and");
+			case "CondArgOr": return this._buildCondArgJoin(children, loc, "or");
+			case "UnicodeRange": return this._lessKeyword(this._source.slice(span.start, span.end), loc);
+			case "PseudoSelector": return this._buildLessPseudo(type, span, children, _state, raw, fields, triviaLog, loc);
+			case "InterpolatedSelector": return this._buildInterpolatedSelector(children, loc);
+			case "VarCall": return this._buildVarCall(children, raw, loc);
+			case "MixinCall": return this._buildMixinCall(children, raw, loc);
+			case "Rest": return this._buildRest(children, loc);
+			case "NamedArg": return this._buildNamedArg(raw, loc);
+			case "MixinArgs": return this._buildMixinArgs(raw, loc);
+			case "AnonymousMixinDefinition": return this._buildAnonMixin(children, loc);
+			case "DetachedRuleset": return this._buildDetachedRuleset(children, loc);
+			case "For": return this._buildEachFor(children, loc);
+			case "FormatCall": return this._buildFormatCall(raw, loc);
+			case "MixinOrQualifiedRule": return this._buildMixinOrQualified(children, loc);
+			case "Negative": return new Negative(this._negativeOperand(children), void 0, loc);
+			case "OperationTop": return this._buildOperation(children, loc, this.mathMode === "always");
+			case "EscapedValue": return this._buildEscapedValue(children, loc);
+			case "InterpValue": return this._buildInterpValue(raw, loc);
+			case "NsAccessor": return this._buildNsAccessor(children, loc);
+			case "AtRuleStatement": return this._buildAtRuleStatement(children, loc);
+			case "ExtendTarget": return this._buildExtendTarget(children, raw, loc);
+			case "ExtendPseudo": return this._buildExtendPseudo(children, loc);
+			case "ExtendStatement": return this._buildExtendStatement(children, raw, loc);
+			default: return super.buildNode(type, span, children, _state, raw, fields, triviaLog);
+		}
+	}
+	/**
+	* The operand of a `Negative` (`-value`). The grammar emits the leading `-`
+	* as a leaf followed by the operand, which may itself be a node or a bare
+	* string terminal (e.g. `-@color` → `var(--color)`'s inner `-color-accent`).
+	* Prefer a node child; otherwise take the operand leaf's text so `Negative`
+	* coerces it to the canonical node form rather than receiving `undefined`.
+	*/
+	_negativeOperand(children) {
+		const node = nodeChildren(children)[0];
+		if (node) return node;
+		return children.find((c) => c._tag === "leaf" && c.value !== "-")?.value ?? "";
+	}
+	_buildVarDeclaration(children, rawChildren, loc) {
+		const items = spannedComponents(rawChildren);
+		const rawName = typeof items[0]?.comp === "string" ? items[0].comp : "";
+		const name = rawName.startsWith("@") ? rawName.slice(1) : rawName;
+		if (/^-?\d/.test(name)) this._warn(`Variable name "@${name}" starts with a digit; digit-leading variable names are deprecated.`, "digit-leading-variable");
+		const colonIdx = items.findIndex((i) => i.comp === ":");
+		if (items[colonIdx + 1]?.comp === "{") {
+			const ruleNodes = nodeChildren(children);
+			const openBrace = items[colonIdx + 1];
+			const closeBrace = items[items.length - 1].comp === "}" ? items[items.length - 1] : void 0;
+			if (ruleNodes.length === 0 && closeBrace) {
+				if (this._source.slice(openBrace.span.end, closeBrace.span.start).trim() !== "") {
+					const rawBlock = this._source.slice(openBrace.span.start, closeBrace.span.end);
+					return new VarDeclaration({
+						name: (name || void 0) ?? name,
+						value: new Quoted(rawBlock, {}, loc)
+					}, {}, loc);
+				}
+			}
+			const mixin = new Mixin({ rules: ruleNodes }, {}, loc);
+			return new VarDeclaration({
+				name: (name || void 0) ?? name,
+				value: mixin
+			}, {}, loc);
+		}
+		let end = items.length;
+		let bangIdx = -1;
+		for (let i = colonIdx + 1; i < items.length; i++) {
+			const c = items[i].comp;
+			if (c === "!") {
+				end = i;
+				bangIdx = i;
+				break;
+			}
+			if (c === "important" || c === ";") {
+				end = i;
+				break;
+			}
+		}
+		const valItems = items.slice(colonIdx + 1, end);
+		if (valItems.length) {
+			const vText = this._source.slice(valItems[0].span.start, valItems[valItems.length - 1].span.end);
+			if (/(?:^|[\s,])\.-?[_a-zA-Z]/.test(vText)) this._warn(`Unquoted selector capture in variable "@${name}" is deprecated; wrap the value in quotes or ~"...".`, "unquoted-selector-capture");
+		}
+		const nsRef = this._tryParseNamespaceRef(valItems, loc);
+		let { value: rawValue } = nsRef ? { value: nsRef } : this._assembleLessValue(valItems, loc);
+		if (!nsRef && valItems.length > 0) {
+			const lastSpan = valItems[valItems.length - 1].span;
+			const afterVal = this._source.slice(lastSpan.end);
+			const rv = rawValue;
+			const rvKey = rv?.key;
+			const isEmptyKey = rvKey === "" || rvKey === void 0 || rvKey && typeof rvKey === "object" && rvKey.type === "Quoted" && (rvKey.value === "" || rvKey.valueOf?.() === "");
+			const grammarPartialAccessor = rv && rv.type === "Reference" && rv.target !== void 0 && isEmptyKey;
+			const accMatch = /^\s*\[([^\]]+)\]/.exec(afterVal);
+			if (accMatch) {
+				const accText = accMatch[1].trim();
+				const accessorKey = this._decodeAccessorKey(accText, loc);
+				const accessorRefOptions = typeof accessorKey === "number" ? { type: "index" } : {};
+				if (grammarPartialAccessor) rawValue = new Reference({
+					target: rv.target,
+					key: accessorKey
+				}, accessorRefOptions, loc);
+				else rawValue = new Reference({
+					target: rawValue,
+					key: accessorKey
+				}, accessorRefOptions, loc);
+				const afterAcc = afterVal.slice(accMatch[0].length);
+				if (/^\s*\(\s*\)/.test(afterAcc)) rawValue = new Call({ name: rawValue }, {}, loc);
+			}
+		}
+		const value = typeof rawValue === "string" && rawValue ? this._lessKeyword(rawValue, loc) : rawValue;
+		let important;
+		if (bangIdx >= 0) {
+			const bang = items[bangIdx];
+			const kw = items[bangIdx + 1];
+			const impEnd = kw && typeof kw.comp === "string" && kw.comp.toLowerCase() === "important" ? kw.span.end : bang.span.end;
+			important = this._source.slice(bang.span.start, impEnd);
+		}
+		return new VarDeclaration({
+			name: (name || void 0) ?? name,
+			value,
+			important
+		}, {}, loc);
+	}
+	/**
+	* Build a Less variable reference and its accessor/call chain. Faithful 1:1
+	* port of the Chevrotain `varReference` + `lookupOrCall` productions
+	* (productions/values.ts, productions/guards.ts): a `@var` base glued to a
+	* left-folded chain of `[index]` accessors and `(call)`s. The grammar's
+	* noTrivia() guarantees the chain is adjacent (no whitespace between segments).
+	*/
+	_buildReference(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const varName = ls[0]?.value ?? "";
+		const isVar = varName.startsWith("@");
+		let base = varName.startsWith("$") ? new Reference({ key: new Quoted(varName.slice(1), { quote: "'" }, loc) }, { type: "index" }, loc) : new Reference(isVar ? varName.slice(1) : varName, isVar ? { type: "variable" } : {}, loc);
+		let i = 1;
+		while (i < ls.length) {
+			const tok = ls[i].value;
+			if (tok === "[") if (ls[i + 1]?.value === "]") {
+				base = new Reference({
+					target: base,
+					key: -1
+				}, { type: "index" }, loc);
+				i += 2;
+			} else {
+				base = this._applyReferenceAccessor(base, ls[i + 1].value, loc);
+				i += 3;
+			}
+			else if (tok === "(") {
+				const payload = { name: base };
+				if (ls[i + 1]?.value === ")") i += 2;
+				else {
+					const args = this._buildRefCallArgs(ls[i + 1].value, loc);
+					if (args) payload.args = args;
+					i += 3;
+				}
+				base = new Call(payload, {}, loc);
+			} else break;
+		}
+		return base;
+	}
+	/**
+	* Build a namespace INDEXED-accessor value: a `.`/`#` selector-path head glued to
+	* a `[accessor]` (and any further `[accessor]`/`(call)` chain), e.g.
+	* `#ns.options[val1]`. The grammar (NsAccessor) captures this as ONE value operand
+	* so it survives arithmetic folding; here we reassemble it into the mixin-ruleset
+	* name Reference + accessor chain — the SAME shape the declaration-value
+	* _assembleSegment path produces for a lone `#ns.options[val1]`. Call-headed forms
+	* (`.mixin()`, `.mixin()[k]`) do NOT reach here (they keep the GluedParen path).
+	* Leaves: [ headText, '[', key?, ']', '(', content?, ')' … ].
+	*/
+	_buildNsAccessor(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const headText = (ls[0]?.value ?? "").trim();
+		const pathSegs = headText.match(/[#.][^#.>+~\s]*/g) ?? [headText];
+		const nameKey = pathSegs.length === 1 ? pathSegs[0] : pathSegs;
+		const rawKey = pathSegs.length > 1 ? pathSegs.join("") : void 0;
+		let base = new Reference({
+			key: nameKey,
+			...rawKey ? { rawKey } : {}
+		}, {
+			type: "mixin-ruleset",
+			role: "name"
+		}, loc);
+		let i = 1;
+		while (i < ls.length) {
+			const tok = ls[i].value;
+			if (tok === "[") if (ls[i + 1]?.value === "]") {
+				base = new Reference({
+					target: base,
+					key: -1
+				}, { type: "index" }, loc);
+				i += 2;
+			} else {
+				base = this._applyReferenceAccessor(base, ls[i + 1].value, loc);
+				i += 3;
+			}
+			else if (tok === "(") {
+				const payload = { name: base };
+				if (ls[i + 1]?.value === ")") i += 2;
+				else {
+					const args = this._buildRefCallArgs(ls[i + 1].value, loc);
+					if (args) payload.args = args;
+					i += 3;
+				}
+				base = new Call(payload, {}, loc);
+			} else break;
+		}
+		return base;
+	}
+	/**
+	* Apply one `[key]` accessor to `base`, reproducing lookupOrCall's key logic:
+	* type is `variable` when the key token starts with `@`, else `index`; the key
+	* text runs through getInterpolatedOrString (handling `$@x`/`@{x}` interpolation),
+	* and index keys are wrapped in a Quoted.
+	*/
+	_applyReferenceAccessor(base, keyStr, loc) {
+		const type = keyStr.startsWith("@") ? "variable" : "index";
+		let result = getInterpolatedOrString(keyStr, loc);
+		if (type === "index") result = new Quoted(result, { quote: "'" }, loc);
+		return new Reference({
+			target: base,
+			key: result
+		}, { type }, loc);
+	}
+	/**
+	* Build mixin-call args for a `(…)` segment in a reference chain from the raw
+	* captured content. Comma-separated values become a List; an empty segment
+	* yields null (no args). Sub-structure here is intentionally shallow — the
+	* accessor-chain call form is rare and no consumer inspects nested arg shape.
+	*/
+	_buildRefCallArgs(content, loc) {
+		const trimmed = content.trim();
+		if (!trimmed) return null;
+		return new List(trimmed.split(",").map((p) => p.trim()).filter(Boolean).map((p) => p.startsWith("@") ? new Reference(p.slice(1), { type: "variable" }, loc) : this._lessKeyword(p, loc)), void 0, loc);
+	}
+	_buildNamedColor(children, loc) {
+		return new Color({ node: children.filter((c) => c._tag === "leaf")[0]?.value ?? "" }, {}, loc);
+	}
+	_normalizeCompareOp(op) {
+		switch (op) {
+			case "=>":
+			case ">=": return ">=";
+			case "=<":
+			case "<=": return "<=";
+			case ">": return ">";
+			case "<": return "<";
+			default: return "=";
+		}
+	}
+	/** A guard comparison operator leaf (`=`, `<`, `>=`, `=<`, `=~`, …). */
+	_isCompareOpLeaf(text) {
+		return />=|<=|=>|=<|=~|[<>=]/.test(text);
+	}
+	/**
+	* Split a guard term's ordered components into `left [op right]`. A bare-keyword
+	* operand (`foo`, `true`) is a leaf string — not a node — so `nodeChildren`
+	* alone drops it; walk the ordered stream so string operands become real
+	* keyword nodes (their guard truthiness is decided at eval by `Condition`).
+	*/
+	_guardComparison(raw, loc) {
+		const items = spannedComponents(raw);
+		let op;
+		const operands = [];
+		for (const it of items) if (typeof it.comp === "string") {
+			if (this._isCompareOpLeaf(it.comp)) {
+				op = this._normalizeCompareOp(it.comp);
+				continue;
+			}
+			operands.push(this._lessKeyword(it.comp, loc));
+		} else operands.push(it.comp);
+		const left = this._maybeDefaultGuard(operands[0] ?? this._lessKeyword("", loc), loc);
+		const right = operands[1] !== void 0 ? this._maybeDefaultGuard(operands[1], loc) : void 0;
+		return {
+			left,
+			op,
+			right
+		};
+	}
+	_buildComparison(raw, loc) {
+		const { left, op, right } = this._guardComparison(raw, loc);
+		if (op && right) return new Condition([
+			left,
+			op,
+			right
+		], {}, loc);
+		return new Condition([left], {}, loc);
+	}
+	/**
+	* Coerce a `_assembleValue` result — a single Component or a raw space-group
+	* array — into ONE Node, so it can be a Condition operand. A single string
+	* becomes a keyword; a space-group array becomes a `Sequence` (the same coercion
+	* the List serializer applies to a raw group).
+	*/
+	_condOperandNode(comps, loc) {
+		const { value } = this._assembleValue(comps, loc);
+		if (Array.isArray(value)) return new Sequence(value.map((c) => typeof c === "string" ? this._lessKeyword(c, loc) : c), void 0, loc);
+		if (typeof value === "string") return this._lessKeyword(value, loc);
+		return value;
+	}
+	/**
+	* `CondArgTerm` — a name-independent condition-argument term: optional leading
+	* `not`, a bounded value operand, and an optional `<op> right` comparison. Builds
+	* a `Condition` (comparison → `[left, op, right]`; bare `not` → `{negate:true}`)
+	* or, when neither a `not` nor a `compareOp` is present, the plain operand value
+	* (byte-identical to an ordinary value arg). Multi-token operands (`1px solid`)
+	* survive as a `Sequence`, unlike the single-operand guard path.
+	*/
+	_buildCondArgTerm(raw, loc) {
+		const items = spannedComponents(raw);
+		const hasNot = items.length > 0 && items[0].comp === "not";
+		const rest = hasNot ? items.slice(1) : items;
+		const opIdx = rest.findIndex((it) => typeof it.comp === "string" && this._isCompareOpLeaf(it.comp));
+		let term;
+		if (opIdx >= 0) term = new Condition([
+			this._condOperandNode(rest.slice(0, opIdx), loc),
+			this._normalizeCompareOp(rest[opIdx].comp),
+			this._condOperandNode(rest.slice(opIdx + 1), loc)
+		], {}, loc);
+		else term = this._condOperandNode(rest, loc);
+		if (hasNot) return new Condition([term], { negate: true }, loc);
+		return term;
+	}
+	/**
+	* Fold a left-associative `and`/`or` chain of condition-arg terms into Conditions.
+	*
+	* Less accepts a bare `and`/`or` join in value-position condition args (`if(@a > 5
+	* and @b < 2, …)`) — verified against less@4.6.7 (`if`/`boolean` route their arg
+	* through `condition()` with no `needsParens`, so bare comparisons split on `and`/
+	* `or`). We keep accepting the bare form for Less parity, but NORMALIZE the AST so
+	* each join operand is `Paren`-wrapped: `@a > 5 and @b < 2` builds the SAME tree as
+	* the explicitly-parenthesised `(@a > 5) and (@b < 2)`. This is a structural
+	* normalisation only — `Paren(Condition)` evaluates to the same boolean as the bare
+	* `Condition`, so rendered CSS is byte-identical. A single unjoined operand (one
+	* node) is untouched (no synthetic Paren).
+	*/
+	_buildCondArgJoin(children, loc, op) {
+		const nodes = nodeChildren(children);
+		if (nodes.length === 0) return this._lessKeyword("", loc);
+		if (nodes.length === 1) return nodes[0];
+		const wrap = (n) => n.type === "Paren" ? n : new Paren(n, {}, loc);
+		let left = wrap(nodes[0]);
+		for (let i = 1; i < nodes.length; i++) left = new Condition([
+			left,
+			op,
+			wrap(nodes[i])
+		], {}, loc);
+		return left;
+	}
+	/** Coerce a default() call/reference into a DefaultGuard, mirroring isDefaultGuardCall. */
+	_maybeDefaultGuard(node, loc) {
+		const n = node;
+		if (n?.type === "Call") {
+			const name = n.name;
+			const nameStr = String(typeof name === "object" && name !== null && "valueOf" in name ? name.valueOf() : name ?? "");
+			if (nameStr === "default" || nameStr === "??") return new DefaultGuard("default()", {}, loc);
+		}
+		return node;
+	}
+	/** guardInParens: `(` guardOr `)` → Paren, or a bare default() → Paren(DefaultGuard). */
+	_buildGuardInParens(children, loc) {
+		let inner = nodeChildren(children)[0] ?? this._lessKeyword("", loc);
+		inner = this._maybeDefaultGuard(inner, loc);
+		const innerAny = inner;
+		if (innerAny?.type === "Paren" && innerAny.value?.type === "DefaultGuard") return inner;
+		return new Paren(inner, {}, loc);
+	}
+	/** A single guard term: optional `not`, then a paren-guard or a comparison/value. */
+	_buildGuardTerm(raw, loc) {
+		const hasNot = spannedComponents(raw).some((i) => typeof i.comp === "string" && i.comp === "not");
+		const rest = raw.filter((rc) => !(rc._tag === "leaf" && rc.value === "not"));
+		const nodes = nodeChildren(rest);
+		let term;
+		if (nodes.length >= 1 && nodes[0].type === "Paren") term = nodes[0];
+		else {
+			const { left, op, right } = this._guardComparison(rest, loc);
+			term = op && right ? new Condition([
+				left,
+				op,
+				right
+			], {}, loc) : left;
+		}
+		if (hasNot) return new Condition([term], { negate: true }, loc);
+		return term;
+	}
+	/** Fold a left-associative chain of terms joined by `and` / `or`. */
+	_buildGuardJoin(children, loc, op) {
+		const nodes = nodeChildren(children);
+		if (nodes.length === 0) return this._lessKeyword("", loc);
+		let left = nodes[0];
+		for (let i = 1; i < nodes.length; i++) left = new Condition([
+			left,
+			op,
+			nodes[i]
+		], {}, loc);
+		return left;
+	}
+	/** guard: `when` guardOr — returns the single guardOr child. */
+	_buildGuard(children, loc) {
+		return nodeChildren(children)[0] ?? this._lessKeyword("", loc);
+	}
+	/**
+	* Deprecated Less `%(format, args…)` string formatting, LOWERED at build time.
+	*
+	* Jess already has full string interpolation, so `%()` is redundant Less-4 legacy —
+	* we emit a `percent-format` deprecation warning and, when the format is a string
+	* literal, splice its `%[sda]` directives into the canonical `Interpolated` node
+	* (the same one `@{var}` string interpolation builds), wrapped in a `Quoted` that
+	* preserves the literal's quote char / escaped flag:
+	*   - `%s`  → bare interpolation slot (a Quoted arg inserts with its quotes stripped);
+	*   - `%d`/`%a` → identical bare slot (d/a are the same in Less);
+	*   - `%S`/`%D`/`%A` → the arg WRAPPED in `escape(…)` (URL-encode);
+	*   - `%%` → a literal `%`.
+	* A dynamic (non-literal) format (`%(hello)`, `%(e("…"), …)`) can't be lowered at
+	* parse time, so it falls back to a best-effort runtime `%` Call with the same warning.
+	*/
+	_buildFormatCall(raw, loc) {
+		this._warn("%() string formatting is deprecated — use string interpolation", "percent-format");
+		const argList = this._assembleArgs(this._betweenParens(spannedComponents(raw)), loc);
+		const args = argList.value ?? [];
+		const format = args[0];
+		const rest = args.slice(1);
+		if (format instanceof Quoted && typeof format.value === "string") {
+			const { source, replacements } = this._lowerFormatString(format.value, rest, loc);
+			return new Quoted(new Interpolated({
+				source,
+				replacements
+			}, { role: "ident" }, loc), {
+				quote: format.quote,
+				escaped: format.escaped
+			}, loc);
+		}
+		return new Call({
+			name: new Reference("%", {
+				type: "function",
+				fallbackValue: true
+			}, loc),
+			args: argList
+		}, { silentFail: true }, loc);
+	}
+	/**
+	* Turn a printf-style format string into an `Interpolated` source + replacements.
+	* `%[sda]` → one `INTERPOLATION_PLACEHOLDER` slot consuming the next positional arg
+	* (uppercase → wrapped in `escape(…)` to URL-encode); `%%` → a literal `%`.
+	*/
+	_lowerFormatString(formatText, restArgs, loc) {
+		let source = "";
+		const replacements = [];
+		let argIndex = 0;
+		for (let i = 0; i < formatText.length; i++) {
+			const ch = formatText[i];
+			if (ch !== "%") {
+				source += ch;
+				continue;
+			}
+			const next = formatText[i + 1];
+			if (next === "%") {
+				source += "%";
+				i++;
+				continue;
+			}
+			if (next && /[sda]/i.test(next)) {
+				const arg = restArgs[argIndex++];
+				if (arg) {
+					source += INTERPOLATION_PLACEHOLDER;
+					if (/[A-Z]/.test(next)) {
+						const escapeRef = new Reference("escape", {
+							type: "function",
+							fallbackValue: true
+						}, loc);
+						const escapeArgs = new List([arg], {}, loc);
+						replacements.push(new Call({
+							name: escapeRef,
+							args: escapeArgs
+						}, { silentFail: true }, loc));
+					} else replacements.push(arg);
+				} else source += ch + next;
+				i++;
+				continue;
+			}
+			source += ch;
+		}
+		return {
+			source,
+			replacements
+		};
+	}
+	_buildInterpolatedSelector(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const replacements = [];
+		let source = "";
+		for (const l of ls) if (l.value.startsWith("@{")) {
+			const varName = l.value.slice(2, -1);
+			replacements.push(new Reference(varName, { role: "ident" }, loc));
+			source += INTERPOLATION_PLACEHOLDER;
+		} else source += l.value;
+		return new InterpolatedSelector(new Interpolated({
+			source,
+			replacements
+		}, { role: "ident" }, loc), {}, loc);
+	}
+	_buildLessPseudo(type, span, children, state, raw, fields, triviaLog, loc) {
+		const pseudo = super.buildNode(type, span, children, state, raw, fields, triviaLog);
+		let pseudoArg = pseudo.arg;
+		if (pseudoArg === void 0) {
+			const open = children.findIndex((c) => c._tag === "leaf" && c.value === "(");
+			if (open >= 0) {
+				const inner = children[open + 1];
+				const isClose = inner?._tag === "leaf" && inner.value === ")";
+				if (inner !== void 0 && !isClose) {
+					const recovered = typeof inner === "string" ? this._lessKeyword(inner, loc) : inner._tag === "leaf" ? this._lessKeyword(inner.value, loc) : inner;
+					pseudo.arg = recovered;
+					pseudoArg = recovered;
+				}
+			}
+		}
+		if (Array.isArray(pseudoArg)) pseudo.arg = pseudoArg.map((item) => typeof item === "string" && item !== " " ? this._lessKeyword(item, loc) : item);
+		return pseudo;
+	}
+	_buildLessDeclaration(raw, loc) {
+		const items = spannedComponents(raw);
+		const decl = this._buildDeclaration(raw, loc);
+		const colonIdx = items.findIndex((i) => i.comp === ":");
+		const merge = colonIdx > 0 ? items[colonIdx - 1]?.comp : void 0;
+		const assign = merge === "+_" ? "+_:" : merge === "+" ? "+,:" : ":";
+		const d = decl;
+		d._options = {
+			...d._options ?? {},
+			assign
+		};
+		if (typeof d.name === "string" && d.name) {
+			const nameStr = d.name;
+			decl.name = nameStr.includes("@{") || nameStr.includes("${") ? getInterpolatedNode(nameStr, loc) : nameStr;
+		}
+		const dvRaw = decl.value;
+		if (dvRaw && typeof dvRaw === "object" && dvRaw.type === "Operation") {
+			const f = dvRaw;
+			if (shouldOperateWithMathFrames({
+				mathMode: this.mathMode,
+				parenFrames: [],
+				calcFrames: 0
+			}, f.operator, f.left, f.right)) decl.value = new Expression(dvRaw, { parens: true }, loc);
+			return decl;
+		}
+		const dvList = decl.value;
+		if (dvList && dvList.type === "List" && dvList.options?.sep === "/" && this.mathMode === "always") {
+			const items = dvList.value;
+			if (items.length >= 2 && items.every((it) => this._isDivisionLike(it))) {
+				let op = items[0];
+				for (let i = 1; i < items.length; i++) op = new Operation([
+					op,
+					"/",
+					items[i]
+				], void 0, loc);
+				const f = op;
+				decl.value = shouldOperateWithMathFrames({
+					mathMode: this.mathMode,
+					parenFrames: [],
+					calcFrames: 0
+				}, f.operator, f.left, f.right) ? new Expression(op, { parens: true }, loc) : op;
+				return decl;
+			}
+		}
+		const dv = decl.value;
+		const dvIsArray = Array.isArray(dv);
+		const dvHasNode = dvIsArray && dv.some((p) => !!p && typeof p === "object" && "type" in p);
+		if (dvIsArray && dvHasNode) {
+			const src = this._source.slice(loc.start, loc.end);
+			const colonPos = src.indexOf(":");
+			const rawVal = colonPos >= 0 ? src.slice(colonPos + 1).trim().replace(/;\s*$/, "").trim() : src;
+			if (/^progid:/i.test(rawVal)) decl.value = this._buildLegacyMSFilter(rawVal, loc);
+		}
+		return decl;
+	}
+	/**
+	* Port of `processLegacyMSFilterToken` (lessRecursiveParser.ts): a `progid:…`
+	* filter value string → Interpolated(role=any) with `@var` runs templated out,
+	* or a plain Keyword when the run has no variables.
+	*/
+	_buildLegacyMSFilter(source, loc) {
+		source = source.replace(/\s*=\s*/g, "=");
+		const varRe = /@([_a-zA-Z\xA0-￿][-_a-zA-Z0-9\xA0-￿]*)/g;
+		const matches = [...source.matchAll(varRe)];
+		if (matches.length === 0) return this._lessKeyword(source, loc);
+		return new Interpolated({
+			source: source.replace(varRe, (_full, _name, offset, fullSource) => {
+				const key = fullSource.slice(0, offset).match(/([A-Za-z]+)=$/)?.[1];
+				if (key && /colorstr$/i.test(key)) return `"${INTERPOLATION_PLACEHOLDER}"`;
+				return INTERPOLATION_PLACEHOLDER;
+			}),
+			replacements: matches.map((match) => createInterpolatedReference("@", match[1], loc))
+		}, { role: "any" }, loc);
+	}
+	_buildAmpersand(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		if (!ls.some((l) => l.value === "(")) {
+			const image = ls[0]?.value ?? "&";
+			return new Ampersand(this._ampersandTemplateValue(image), {}, loc);
+		}
+		const trimmed = (ls.find((l) => l.value !== "&" && l.value !== "(" && l.value !== ")")?.value ?? "").trim();
+		return new Ampersand(trimmed === "nil" ? "" : trimmed.replace(/^(['"])([\s\S]*)\1$/, "$2"), {}, loc);
+	}
+	/** The append value of a `&`-led ampersand token: the suffix after `&` (`&-bar` →
+	* `-bar`, `&1` → `1`), or undefined for a bare `&`. */
+	_ampersandTemplateValue(image) {
+		return image === "&" ? void 0 : image.slice(1) || void 0;
+	}
+	/**
+	* A single extend target inside `extend( … )`: a complex selector plus its
+	* optional `all` / `!all` flag (selectors.ts `complexSelector`'s OPTION2 flag).
+	* Produced as an `Extend` carrier the surrounding pseudo/statement groups.
+	*/
+	_buildExtendTarget(_children, raw, loc) {
+		const comps = spannedComponents(raw);
+		const isFlag = (c) => typeof c === "string" && /^!?all$/.test(c);
+		const flag = comps.some((c) => isFlag(c.comp)) ? ExtendFlag.All : ExtendFlag.Exact;
+		const targetComp = comps.find((c) => !isFlag(c.comp))?.comp;
+		return new Extend({
+			target: typeof targetComp === "string" ? targetComp : targetComp ?? "&",
+			flag
+		}, {}, loc);
+	}
+	/**
+	* `:extend( … )` pseudo form (selectors.ts `extend`): groups its ExtendTarget
+	* children. Targets sharing one flag collapse to a single Extend whose target is
+	* a SelectorList (or the lone selector); mixed flags stay as one Extend each,
+	* returned in a List. Mirrors mergeExtends' target-and-flag grouping.
+	*/
+	_buildExtendPseudo(children, loc) {
+		const targets = nodeChildren(children).filter((n) => n.type === "Extend");
+		const firstFlag = targets[0].flag;
+		if (targets.every((t) => t.flag === firstFlag)) return new Extend({
+			target: targets.length === 1 ? targets[0].target : this._makeSelectorList(targets.map((t) => t.target), loc),
+			flag: firstFlag
+		}, {}, loc);
+		return new List(targets.map((t) => new Extend({
+			target: t.target,
+			flag: t.flag
+		}, {}, loc)), {}, loc);
+	}
+	/**
+	* `&:extend( … );` (or bare `:extend( … );`) statement form (selectors.ts
+	* `ampersandExtend`). The ExtendPseudo child already carries the grouped
+	* Extend(s); the leading `&` is just the statement marker.
+	*/
+	_buildExtendStatement(children, _raw, _loc) {
+		return nodeChildren(children).find((n) => n.type === "Extend" || n.type === "List");
+	}
+	/**
+	* Decode a single `[key]` accessor into its Less lookup-key AST — the ONE shared
+	* decoder for every accessor-chain builder path (var-decl value, declaration value,
+	* at-rule prelude, namespace ref). Accepts either a raw authored key STRING (the
+	* text inside the brackets, e.g. `@@foo`, `$@x`, `bar`, ``), or a SquareParen `Paren`
+	* node whose inner content the grammar already parsed (a raw string or a `@var`
+	* Reference). Returns the key exactly as the reference lookupOrCall production would:
+	*
+	*   `[]`        → -1        (index, empty)
+	*   `[@@name]`  → Reference{type:variable,key:name}   (dynamic variable lookup)
+	*   `[$@name]` / `[@$name]` → Quoted(Interpolated(@name))  (dynamic property lookup)
+	*   `[@name]`   → 'name'    (static variable lookup; bare string key)
+	*   `[$name]`   → Quoted('name')   (property lookup; `$` marker dropped)
+	*   `[name]`    → Quoted('name')   (index)
+	*
+	* Exactly one `@`/`$` marker is the lookup marker and is never kept.
+	*/
+	_decodeAccessorKey(rawTextOrNode, loc) {
+		let rawText;
+		let innerVal;
+		if (typeof rawTextOrNode === "string") rawText = rawTextOrNode.trim();
+		else {
+			innerVal = rawTextOrNode.node ?? rawTextOrNode.value;
+			if (!innerVal || this._isEmptyKeywordLike(innerVal)) return -1;
+			if (typeof innerVal === "string") rawText = innerVal.trim();
+			else if (typeof innerVal === "object" && innerVal.type === "Reference" && typeof innerVal.key === "string") rawText = "@" + innerVal.key;
+			else if (this._isKeywordLike(innerVal) && typeof innerVal.value === "string") rawText = innerVal.value.trim();
+		}
+		if (rawText === void 0 || rawText === "") {
+			if (rawText === "") return -1;
+			return innerVal?.key ?? innerVal;
+		}
+		if (rawText.startsWith("@@")) return new Reference(rawText.slice(2), { type: "variable" }, loc);
+		if (rawText.startsWith("$@") || rawText.startsWith("@$")) return new Quoted(new Interpolated({
+			source: INTERPOLATION_PLACEHOLDER,
+			replacements: [new Reference(rawText.slice(2), { role: "ident" }, loc)]
+		}, { role: "ident" }, loc), {}, loc);
+		if (rawText.startsWith("@")) return rawText.slice(1);
+		return new Quoted(rawText.replace(/^\$/, ""), {}, loc);
+	}
+	_assembleSegment(seg, loc) {
+		const result = super._assembleSegment(seg, loc);
+		const isNsNameEarly = (c) => typeof c === "string" && /^[#.]-?[_a-zA-Z]/.test(c.trim());
+		if (!Array.isArray(result)) {
+			if (isNsNameEarly(result)) {
+				const segs = result.trim().match(/[#.][^#.]*/g) ?? [result.trim()];
+				const nameKey = segs.length === 1 ? segs[0] : segs;
+				const rawKey = segs.length > 1 ? segs.join("") : void 0;
+				return new Reference({
+					key: nameKey,
+					...rawKey ? { rawKey } : {}
+				}, {
+					type: "mixin-ruleset",
+					role: "name"
+				}, loc);
+			}
+			return result;
+		}
+		if (result.length < 2) return result;
+		const comps = result;
+		const isNsName = (c) => typeof c === "string" && /^[#.]-?[_a-zA-Z€-￿]/.test(c.trim());
+		const isSquareParen = (c) => !!c && typeof c === "object" && c.type === "Paren" && c._options?.delimiter === "square";
+		const isRoundParen = (c) => !!c && typeof c === "object" && c.type === "Paren" && c._options?.delimiter !== "square";
+		if (!isNsName(comps[0])) return comps;
+		const splitNsToken = (s) => s.match(/[#.][^#.]*/g) ?? [s];
+		let i = 0;
+		const pathSegs = [];
+		while (i < comps.length && isNsName(comps[i])) {
+			pathSegs.push(...splitNsToken(comps[i].trim()));
+			i++;
+		}
+		const rawPathText = pathSegs.join("");
+		const nameKey = pathSegs.length === 1 ? pathSegs[0] : pathSegs;
+		const rawKey = pathSegs.length > 1 ? rawPathText : void 0;
+		let base = new Reference({
+			key: nameKey,
+			...rawKey ? { rawKey } : {}
+		}, {
+			type: "mixin-ruleset",
+			role: "name"
+		}, loc);
+		if (i >= comps.length || !isSquareParen(comps[i]) && !isRoundParen(comps[i])) return i === comps.length ? base : comps;
+		while (i < comps.length) {
+			const item = comps[i];
+			if (isSquareParen(item)) {
+				const innerKey = this._decodeAccessorKey(item, loc);
+				const accType = typeof innerKey === "string" || innerKey != null && typeof innerKey === "object" && innerKey.type === "Reference" ? "variable" : "index";
+				base = new Reference({
+					target: base,
+					key: innerKey
+				}, { type: accType }, loc);
+				i++;
+			} else if (isRoundParen(item)) {
+				const innerContent = item.value ?? item.node;
+				const argsNode = this._isEmptyKeywordLike(innerContent) ? null : this._parenToArgs(item, loc);
+				const callPayload = { name: base };
+				if (argsNode) callPayload.args = argsNode;
+				base = new Call(callPayload, {}, loc);
+				i++;
+			} else break;
+		}
+		return i === comps.length ? base : comps;
+	}
+	_buildEscapedValue(children, loc) {
+		const inner = nodeChildren(children)[0];
+		if (!inner) return this._lessKeyword("", loc);
+		if (inner instanceof Quoted) return new Quoted(inner.value, {
+			quote: inner.quote,
+			escaped: true
+		}, loc);
+		const n = inner;
+		n._options = {
+			...n._options ?? {},
+			escaped: true
+		};
+		return inner;
+	}
+	_buildInterpValue(raw, loc) {
+		const result = getInterpolatedOrString(spannedComponents(raw).map((i) => typeof i.comp === "string" ? i.comp : "").join(""), loc);
+		if (typeof result === "string") return this._lessKeyword(result, loc);
+		return result;
+	}
+	/**
+	* A quoted string value. Unlike plain CSS, Less interpolates `@{var}` / `${prop}`
+	* inside quoted (and escaped `~"…"`) strings and inside `@import` paths. When the
+	* raw content holds an interpolation, split it into an `Interpolated` value the same
+	* way the reference parser's `processStringInterpolation` does (source with
+	* INTERPOLATION_PLACEHOLDER, `@var`/`$prop` references in `replacements`); otherwise
+	* fall through to the plain CSS builder (bare-string value).
+	*/
+	/**
+	* The Less `Url` grammar tokenizes the inner string as bare leaves (no child
+	* node), so the css base builder wraps a quoted url body in a raw-string
+	* `Quoted` — which never interpolates `@{var}`/`${prop}`. Less 4.x DOES resolve
+	* interpolation inside a QUOTED url body (`url("@{base}/@{i}.svg")`), the same as
+	* any other quoted string, so route the quoted inner through the same
+	* interpolation-aware construction `_buildQuoted` uses. Unquoted url bodies stay
+	* verbatim (Less 4.x leaves `url(@{x})` literal), as does a quoted body with no
+	* interpolation.
+	*/
+	_buildUrl(children, loc) {
+		if (nodeChildren(children)[0]) return super._buildUrl(children, loc);
+		const inner = children.filter((c) => c._tag === "leaf").filter((l) => !/^url\($/i.test(l.value) && l.value !== ")").map((l) => l.value).join("").trim();
+		const quote = inner[0];
+		if ((quote === "\"" || quote === "'") && inner.at(-1) === quote) {
+			const body = inner.slice(1, -1);
+			if (body.includes("@{") || body.includes("${")) return new Url(new Quoted(this._buildStringInterpolation(body, loc), { quote }, loc), void 0, loc);
+		}
+		return super._buildUrl(children, loc);
+	}
+	_buildQuoted(children, loc) {
+		const text = children.filter((c) => c._tag === "leaf").map((l) => l.value).join("");
+		const inner = text.slice(1, -1);
+		if (inner.includes("@{") || inner.includes("${")) return new Quoted(this._buildStringInterpolation(inner, loc), { quote: text[0] }, loc);
+		return super._buildQuoted(children, loc);
+	}
+	/**
+	* Build an escaped `~'…'` Quoted (at-rule prelude position), interpolating any
+	* `@{var}` / `${prop}` in its body the same way `_buildQuoted` does — so
+	* `~'@{a} / @{b}'` renders its substituted values instead of literal text.
+	*/
+	_buildEscapedQuoted(inner, quote, loc) {
+		return new Quoted(inner.includes("@{") || inner.includes("${") ? this._buildStringInterpolation(inner, loc) : inner, {
+			quote,
+			escaped: true
+		}, loc);
+	}
+	/**
+	* Split a quoted-string body on `@{…}` / `${…}` interpolations into an
+	* `Interpolated` (source + reference replacements). Port of the reference parser's
+	* `processStringInterpolation`/`findInterpolations` (productions/values.ts): brace
+	* matching is nesting-aware, and a nested-interpolated name resolves through a
+	* variable Reference wrapped in an Expression.
+	*/
+	_buildStringInterpolation(value, loc) {
+		const matches = this._findInterpolations(value);
+		const replacements = [];
+		let source = value;
+		let offset = 0;
+		for (const match of matches) {
+			const adjustedStart = match.start - offset;
+			const adjustedEnd = match.end - offset;
+			source = source.slice(0, adjustedStart) + INTERPOLATION_PLACEHOLDER + source.slice(adjustedEnd);
+			offset += match.end - match.start - INTERPOLATION_PLACEHOLDER.length;
+			if (match.content.includes("@{") || match.content.includes("${")) {
+				const nestedRef = new Reference({ key: this._buildStringInterpolation(match.content, loc) }, {
+					type: "variable",
+					role: "ident"
+				}, loc);
+				replacements.push(new Expression(nestedRef, void 0, loc));
+			} else replacements.push(createInterpolatedReference(match.prefix, match.content, loc));
+		}
+		return new Interpolated({
+			source,
+			replacements
+		}, { role: "ident" }, loc);
+	}
+	/**
+	* Locate `@{…}` / `${…}` interpolation runs in a string, counting nested braces so
+	* `@{@{x}}` and `@{fn(a, b)}` are matched whole. Returns start/end/prefix/content.
+	*/
+	_findInterpolations(value) {
+		const matches = [];
+		let i = 0;
+		while (i < value.length) if ((value[i] === "@" || value[i] === "$") && value[i + 1] === "{") {
+			const prefix = value[i];
+			const start = i;
+			i += 2;
+			let braceCount = 1;
+			const contentStart = i;
+			while (i < value.length && braceCount > 0) {
+				if (value[i] === "{") braceCount++;
+				else if (value[i] === "}") braceCount--;
+				i++;
+			}
+			if (braceCount === 0) matches.push({
+				start,
+				end: i,
+				prefix,
+				content: value.slice(contentStart, i - 1)
+			});
+		} else i++;
+		return matches;
+	}
+	_buildCall(rawChildren, loc) {
+		const call = super._buildCall(rawChildren, loc);
+		const key = typeof call.name === "string" ? call.name : "";
+		this._checkMixedArgDelimiters(call.args, "function", loc);
+		const loweredArgs = this._lowerSemiArgs(call.args, loc);
+		return new Call({
+			name: new Reference(key, {
+				type: "function",
+				fallbackValue: true
+			}, loc),
+			args: loweredArgs
+		}, { silentFail: true }, loc);
+	}
+	_buildLessCustomDecl(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const propNameText = ls[0]?.value ?? "";
+		const name = propNameText.includes("@") || propNameText.includes("$") ? getInterpolatedNode(propNameText, loc) : propNameText;
+		const valueNodes = nodeChildren(children);
+		if (valueNodes.length > 0) return new CustomDeclaration({
+			name,
+			value: valueNodes.length === 1 ? valueNodes[0] : valueNodes
+		}, void 0, loc);
+		const valueText = ls.slice(2).filter((l) => l.value !== ";").map((l) => l.value).join("").trim();
+		return new CustomDeclaration({
+			name,
+			value: this._lessKeyword(valueText, loc)
+		}, void 0, loc);
+	}
+	/**
+	* `--foo: { color: @a; }` — a curly-brace custom-property value whose body
+	* opportunistically structured as a declaration list (customCurlyBlock in the
+	* grammar), so nested `@var`/calls evaluate normally instead of staying opaque
+	* text. Wrapped in a Block(type: 'curly') so `{`/`}` re-render around it.
+	*/
+	_buildLessCustomBlock(children, loc) {
+		return new Block(new Sequence(nodeChildren(children), void 0, loc), { type: "curly" }, loc);
+	}
+	_warnDeprecatedValue(span) {
+		const text = this._source.slice(span.start, span.end);
+		if (/\d\s*\.\//.test(text)) this._warn("The ./ operator is deprecated and will be removed.", "dot-slash-operator");
+	}
+	_warnCustomPropVars(span) {
+		const text = this._source.slice(span.start, span.end);
+		const colon = text.indexOf(":");
+		const value = colon >= 0 ? text.slice(colon + 1) : text;
+		const at = value.match(/@[a-zA-Z][\w-]*/);
+		if (at && !value.includes("@{")) this._warn(`"${at[0]}" in custom property values is treated as literal text. Use @{${at[0].slice(1)}} for interpolation.`, "variable-in-unknown-value");
+		const dollar = value.match(/\$[a-zA-Z][\w-]*/);
+		if (dollar && !value.includes("${")) this._warn(`"${dollar[0]}" in custom property values is treated as literal text. Use \${${dollar[0].slice(1)}} for interpolation.`, "property-in-unknown-value");
+	}
+	_warnAtRulePreludeVars(span) {
+		const text = this._source.slice(span.start, span.end);
+		const varName = this._firstTopLevelBareAtVar(text);
+		if (varName !== null) this._warn(`A bare "@${varName}" in an at-rule prelude is deprecated. Use @{${varName}} interpolation instead.`, "variable-in-at-rule-prelude");
+	}
+	/**
+	* The first bare `@ident` reference in an at-rule prelude that is deprecated
+	* under Less 4.x PR #4462 (`variable-in-at-rule-prelude`), or null when there
+	* is none. A bare `@var` in a *structural* (top-level) prelude position still
+	* resolves but is deprecated in favour of `@{var}` interpolation; the scan
+	* therefore ignores, mirroring `hasTopLevelBareVariable` / `warnBareAtRuleVariable`:
+	*   - the leading at-rule name itself (`@media`, `@-moz-document`, …);
+	*   - `@{ident}` interpolation — the supported migration target;
+	*   - a `@var` inside `(...)` — a declaration/feature value (e.g. the `@size`
+	*     in `@media (min-width: @size)`), which stays valid;
+	*   - `@`/`(` characters inside string literals, which are not structural.
+	*/
+	_firstTopLevelBareAtVar(text) {
+		let depth = 0;
+		let i = /^\s*@-?[\w-]+/.exec(text)?.[0].length ?? 0;
+		for (; i < text.length; i++) {
+			const c = text[i];
+			if (c === "\"" || c === "'") {
+				i++;
+				while (i < text.length && text[i] !== c) i++;
+				continue;
+			}
+			if (c === "@") {
+				if (text[i + 1] === "{") {
+					i += 2;
+					while (i < text.length && text[i] !== "}") i++;
+					continue;
+				}
+				if (depth === 0) {
+					const m = /^@(-?[a-zA-Z\x80-￿][\w-]*)/.exec(text.slice(i));
+					if (m) return m[1];
+				}
+				continue;
+			}
+			if (c === "{") break;
+			if (c === "(") depth++;
+			else if (c === ")" && depth > 0) depth--;
+		}
+		return null;
+	}
+	_buildMixinCall(children, raw, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const markImportant = ls.some((l) => l.value === "!");
+		const nameParts = [];
+		for (const l of ls) {
+			if (l.value === "(" || l.value === ";" || l.value === "!") break;
+			nameParts.push(l.value);
+		}
+		const name = nameParts.join("");
+		const argsList = nodeChildren(children).find((n) => n.type === "List");
+		const hasArgs = argsList && argsList.value?.length;
+		if (argsList === void 0) this._warn("Calling a mixin without parentheses is deprecated", "mixin-call-no-parens");
+		else {
+			const src = this._source.slice(loc.start, loc.end);
+			if (/^\S+\s+\(/.test(src)) this._warn("Whitespace between a mixin name and parentheses is deprecated", "mixin-call-whitespace");
+		}
+		return new Call({
+			name: new Reference({ key: name }, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, loc),
+			args: hasArgs ? this._convertArgsForCall(argsList, loc) : void 0
+		}, { markImportant }, loc);
+	}
+	/**
+	* `@name(...)` (no `:`) → a detached-ruleset variable CALL. Faithful port of
+	* `varDeclarationOrCall`'s LParen branch (selectors.ts): build a `Reference`
+	* over the var name (`type: 'variable', role: 'name'`), wrap in a `Call` with
+	* the (optional) args, and wrap THAT in an `Expression` (a top-level variable
+	* call is an expression, not a parenthesized one). `!important` sets
+	* `markImportant` on the Call, mirroring the production.
+	*/
+	_buildVarCall(children, raw, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const markImportant = ls.some((l) => l.value === "!");
+		const rawName = ls.find((l) => l.value.startsWith("@"))?.value ?? "";
+		const name = rawName.startsWith("@") ? rawName.slice(1) : rawName;
+		const nameRef = new Reference({ key: this._lessKeyword(name, loc) }, {
+			type: "variable",
+			role: "name"
+		}, loc);
+		const argsList = nodeChildren(children).find((n) => n.type === "List");
+		const hasArgs = argsList && argsList.value?.length;
+		if (!hasArgs && KNOWN_AT_RULE_VAR_NAME_RE.test(name)) this._warn("Using known at-rule names as variables is deprecated", "at-rule-variable");
+		return new Expression(new Call({
+			name: nameRef,
+			args: hasArgs ? this._convertArgsForCall(argsList, loc) : void 0
+		}, markImportant ? { markImportant: true } : void 0, loc), void 0, loc);
+	}
+	/** `...` or `@name...` variadic arg → `Rest`. Definition-shape (string name); a
+	* CALL turns it into `Rest(Reference)` via `_convertArgsForCall`. */
+	_buildRest(raw, loc) {
+		const nameItem = spannedComponents(raw).find((i) => typeof i.comp === "string" && i.comp.startsWith("@"));
+		return new Rest(nameItem ? String(nameItem.comp).slice(1) : "", {}, loc);
+	}
+	/** `@name: value` named arg/param → `VarDeclaration`. The value is assembled by the
+	* shared value builder (`_assembleValue`) — the same machinery as a declaration
+	* value, so trivia and Keyword-ification are handled and no manual trimming is
+	* needed. Named args flow through function calls too; the runtime decides whether
+	* the target accepts them. */
+	_buildNamedArg(raw, loc) {
+		const items = spannedComponents(raw);
+		const colonIdx = items.findIndex((i) => i.comp === ":");
+		const nameItem = items.find((i) => typeof i.comp === "string" && i.comp.startsWith("@"));
+		const name = String(nameItem?.comp ?? "").slice(1);
+		const valueItems = colonIdx >= 0 ? items.slice(colonIdx + 1) : [];
+		const { value } = this._assembleValue(valueItems, loc);
+		let paramValue;
+		if (typeof value === "string") paramValue = this._valueKeyword(value, loc);
+		else if (Array.isArray(value)) paramValue = new Sequence(value.map((c) => this._argComponent(c, loc)), void 0, loc);
+		else paramValue = value;
+		return new VarDeclaration({
+			name,
+			value: paramValue
+		}, {}, loc);
+	}
+	/** Mixin-call args are assembled by the SAME builder as function-call args
+	* (`_assembleArgs` via `_betweenParens`) — identical comma/semicolon and value
+	* handling. Named args are `VarDeclaration`s and variadic args `Rest`, which pass
+	* through as single components. A bare `@name` is a `Reference` (the call shape);
+	* the mixin-DEFINITION builder reinterprets a lone `@name` as a param. */
+	_buildMixinArgs(raw, loc) {
+		const inner = this._betweenParens(spannedComponents(raw));
+		const args = this._assembleArgs(inner, loc);
+		this._checkMixedArgDelimiters(args, "mixin", loc);
+		return this._lowerSemiArgs(args, loc);
+	}
+	/** Less forbids mixing the COMMA and SEMICOLON argument separators: once a
+	* semicolon separates args, a comma is a value-list separator, so a semicolon-group
+	* may not hold 2+ named params (`@a: 1, @b: 2`). `_assembleArgs` renders such a group
+	* as a List of ≥2 VarDeclarations. (This is purely about the `,` vs `;` argument
+	* separators — a `/` inside a value is unrelated and never checked.) Applies to BOTH
+	* mixin and function calls (args are unified). */
+	_checkMixedArgDelimiters(args, kind, loc) {
+		const list = args;
+		if (list?.type !== "List" || list.options?.sep !== ";" || !Array.isArray(list.value)) return;
+		for (const el of list.value) {
+			const group = el;
+			if (group?.type === "List" && Array.isArray(group.value) && group.value.filter((n) => n?.type === "VarDeclaration").length >= 2) {
+				this._error(`Cannot mix ; and , as delimiter types in ${kind} arguments`, loc.start);
+				break;
+			}
+		}
+	}
+	/**
+	* Lower Less `;`-separated call args to the unified Jess representation: the outer
+	* args `List{ sep: ';' }` becomes comma-separated, and each element that is itself
+	* a comma-`List` (a `;`-group that held a comma-list) is wrapped in an escaped
+	* `Paren` — the same shape Jess authors write as `~(1, 2)`. So
+	* `.mixin(1, 2; 3, 4)` and Jess `mixin(~(1, 2), ~(3, 4))` converge on one AST.
+	*
+	* The escaped `Paren` evaluates to its inner value STRIPPED (paren.ts §escaped),
+	* so `~(1, 2)` binds/renders identically to the bare list `1, 2` — representation
+	* only, semantics unchanged. Scalar (non-List) elements pass through untouched.
+	*
+	* MUST run AFTER `_checkMixedArgDelimiters` (which inspects the `;`-List).
+	*/
+	_lowerSemiArgs(args, loc) {
+		const list = args;
+		if (!list || list.type !== "List" || list.options?.sep !== ";" || !Array.isArray(list.value)) return args;
+		return new List(list.value.map((el) => {
+			if (el?.type === "List") return new Paren(el, { escaped: true }, loc);
+			return el;
+		}), void 0, loc);
+	}
+	/**
+	* Mixin-DEFINITION param conversion. With combinator-composed args a bare `@name`
+	* value parses as a `Reference{variable}` (the CALL shape); in a DEFINITION it is a
+	* param, so convert it to `VarDeclaration(name, Nil)`. Named params (`@a: 1`),
+	* variadic (`Rest`) and pattern-match values stay as-is. Returns a NEW List (the
+	* def/call split must not mutate a shared node).
+	*/
+	_convertArgsForDefinition(argsList, loc) {
+		if (!argsList || argsList.type !== "List") return argsList;
+		const list = argsList;
+		const value = list.value;
+		if (!value || value.length === 0) return argsList;
+		let changed = false;
+		const converted = value.map((node) => {
+			if (node.type === "Reference" && node.options?.type === "variable") {
+				const key = node.key;
+				const name = typeof key === "string" ? key : String(key?.valueOf?.() ?? "");
+				changed = true;
+				return new VarDeclaration({
+					name,
+					value: new Nil("", {}, loc)
+				}, {}, loc);
+			}
+			return node;
+		});
+		if (!changed) return argsList;
+		return new List(converted, list.options, loc);
+	}
+	/**
+	* Mixin-CALL argument conversion (reference `convertArgsForCall`, root.ts).
+	* `_buildMixinArgs` builds bare `@name` args as definition-style VarDeclarations
+	* (Nil value) — correct for a DEFINITION param, but in a CALL a bare `@name` is a
+	* variable being PASSED, i.e. a `Reference{type:variable}`. Named args (`@a: 1`)
+	* and value args stay as-is; a `Rest('name')` becomes `Rest(Reference{variable})`.
+	* Returns a NEW List (the def/call split must not mutate a shared node).
+	*/
+	_convertArgsForCall(argsList, loc) {
+		if (!argsList || argsList.type !== "List") return argsList;
+		const list = argsList;
+		const value = list.value;
+		if (!value || value.length === 0) return argsList;
+		let changed = false;
+		const converted = value.map((node) => {
+			if (node.type === "VarDeclaration") {
+				const decl = node;
+				const val = decl.value;
+				if (!val || val.type === "Nil") {
+					const key = decl.name.valueOf();
+					changed = true;
+					return new Reference({ key }, { type: "variable" }, loc);
+				}
+				return node;
+			}
+			if (node.type === "Rest") {
+				const restVal = node.value;
+				if (typeof restVal === "string") {
+					changed = true;
+					return new Rest(new Reference({ key: restVal }, { type: "variable" }, loc), {}, loc);
+				}
+				return node;
+			}
+			return node;
+		});
+		if (!changed) return argsList;
+		return new List(converted, list.options, loc);
+	}
+	_buildAnonMixin(children, loc) {
+		const nodes = nodeChildren(children);
+		const argsList = nodes.find((n) => n.type === "List");
+		const rules = nodes.filter((n) => n !== argsList);
+		const defParams = this._convertArgsForDefinition(argsList, loc);
+		return new Mixin({
+			params: defParams?.value?.length ? defParams : void 0,
+			rules
+		}, void 0, loc);
+	}
+	/**
+	* `each(<iterable>, { … })` → a `For` control node (the $for shape), not a Call.
+	* The value(s) before the comma are the iterable; the callback block's body becomes
+	* the loop rules. A literal block callback carries no captured params here, so the
+	* pattern defaults to the Less `[value, key, index]` triple.
+	*/
+	/** A bare detached ruleset `{ … }` in value / argument position → a Mixin holding
+	* its rules (same shape `@var: { … }` produces in `_buildVarDeclaration`). */
+	_buildDetachedRuleset(children, loc) {
+		return new Mixin({ rules: nodeChildren(children) }, {}, loc);
+	}
+	_buildEachFor(children, loc) {
+		const nodes = nodeChildren(children);
+		const callback = nodes.find((n) => n.type === "Mixin");
+		const iterableNodes = nodes.filter((n) => n !== callback);
+		const paramsList = (callback?.params)?.type === "List" ? callback.params : void 0;
+		const ruleNodes = callback?.rules ?? [];
+		const iterable = iterableNodes.length === 1 ? iterableNodes[0] : new List(iterableNodes, void 0, loc);
+		return new For({
+			pattern: this._eachPattern(paramsList, loc),
+			iterable: {
+				kind: "node",
+				value: iterable
+			},
+			rules: ruleNodes
+		}, void 0, loc);
+	}
+	_eachPattern(paramsList, loc) {
+		const params = (paramsList?.value ?? []).filter((p) => p?.type === "VarDeclaration");
+		if (params.length === 1) return {
+			kind: "single",
+			value: params[0]
+		};
+		if (params.length >= 2) return {
+			kind: "tuple",
+			values: [params[0], ...params.slice(1)]
+		};
+		const paramVar = (name) => new VarDeclaration({
+			name,
+			value: this._lessKeyword("", loc)
+		}, { paramVar: true }, loc);
+		return {
+			kind: "tuple",
+			values: [
+				paramVar("value"),
+				paramVar("key"),
+				paramVar("index")
+			]
+		};
+	}
+	_buildMixinOrQualified(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const nodes = nodeChildren(children);
+		const hasBlock = ls.some((l) => l.value === "{");
+		const markImportant = ls.some((l) => l.value === "!");
+		const nameParts = [];
+		for (const l of ls) {
+			if (l.value === "(" || l.value === "{" || l.value === "}" || l.value === ";" || l.value === ")" || l.value === "!") break;
+			nameParts.push(l.value);
+		}
+		const name = nameParts.join("");
+		const argsList = nodes.find((n) => n.type === "List");
+		const guard = nodes.find((n) => n.type === "Paren" || n.type === "Condition" || n.type === "DefaultGuard");
+		const hasExplicitParens = argsList !== void 0;
+		if (hasBlock) {
+			const rawRuleNodes = nodes.filter((n) => n !== argsList && n !== guard);
+			const braceIdx = this._source.indexOf("{", loc.start);
+			const bodyStart = braceIdx >= 0 ? braceIdx + 1 : loc.start;
+			const closeIdx = this._source.lastIndexOf("}", loc.end - 1);
+			const bodyEnd = closeIdx >= bodyStart ? closeIdx : loc.end;
+			const ruleNodes = this._liftStandaloneComments(rawRuleNodes, bodyStart, bodyEnd, loc);
+			if (hasExplicitParens) {
+				const hasDefault = (guard !== void 0 ? guard.toTrimmedString?.() ?? "" : "").includes("default");
+				const defParams = this._convertArgsForDefinition(argsList, loc);
+				return new Mixin({
+					name,
+					params: defParams?.value?.length ? defParams : void 0,
+					rules: ruleNodes,
+					guard
+				}, { hasDefault: !!hasDefault }, loc);
+			}
+			const { cleanedSelector, extractedExtends } = this._extractExtendsFromSelectorText(name || "&", loc);
+			const finalRules = extractedExtends.length > 0 ? [...extractedExtends, ...ruleNodes] : ruleNodes;
+			return new Ruleset({
+				selector: cleanedSelector || "&",
+				rules: finalRules,
+				guard
+			}, void 0, loc);
+		}
+		const combinatorValues = new Set([
+			">",
+			"+",
+			"~"
+		]);
+		const selectorTokens = nameParts.filter((p) => !combinatorValues.has(p.trim()) && p.trim() !== "");
+		const hasComplexPath = selectorTokens.length > 1;
+		const refKey = hasComplexPath ? selectorTokens : name;
+		const rawKey = hasComplexPath ? new ComplexSelector(nameParts, void 0, loc) : void 0;
+		const ref = name.startsWith(".") || name.startsWith("#") ? new Reference({
+			key: refKey,
+			...rawKey ? { rawKey } : {}
+		}, {
+			type: "mixin-ruleset",
+			role: "name"
+		}, loc) : new Reference({ key: refKey }, {
+			type: "function",
+			silentFail: true,
+			fallbackValue: true
+		}, loc);
+		const hasArgs2 = argsList && argsList.value?.length;
+		const hasSemi = ls.some((l) => l.value === ";");
+		if (hasSemi && !hasExplicitParens) this._warn("Calling a mixin without parentheses is deprecated", "mixin-call-no-parens");
+		else if (hasSemi && hasExplicitParens) {
+			const src = this._source.slice(loc.start, loc.end);
+			if (/^\S+\s+\(/.test(src)) this._warn("Whitespace between a mixin name and parentheses is deprecated", "mixin-call-whitespace");
+		}
+		return new Call({
+			name: ref,
+			args: hasArgs2 ? this._convertArgsForCall(argsList, loc) : void 0
+		}, { markImportant }, loc);
+	}
+	_extractExtendsFromSelectorText(selectorText, _loc) {
+		return {
+			cleanedSelector: selectorText,
+			extractedExtends: []
+		};
+	}
+	_selectorHasNestedExtend(sel) {
+		if (!sel || typeof sel === "string") return false;
+		if (sel.type === "PseudoSelector") {
+			const arg = sel.arg;
+			return arg ? this._treeHasExtend(arg) : false;
+		}
+		if (sel instanceof CompoundSelector || sel instanceof ComplexSelector) return sel.value.some((p) => this._selectorHasNestedExtend(p));
+		if (isSelectorListLike(sel)) return selectorListItems(sel).some((p) => this._selectorHasNestedExtend(p));
+		return false;
+	}
+	_treeHasExtend(node) {
+		if (node instanceof Extend) return true;
+		if (node instanceof CompoundSelector || node instanceof ComplexSelector) return node.value.some((p) => this._treeHasExtend(p));
+		if (isSelectorListLike(node)) return selectorListItems(node).some((p) => this._treeHasExtend(p));
+		return false;
+	}
+	/**
+	* A guarded ruleset (`sel when …`) is parsed by the shared CSS builder, which
+	* has no `when` concept, so the Guard CST child folds into the body as the
+	* first rule — always a Paren/Condition/DefaultGuard. Lift it into the
+	* ruleset's `guard` field (rebuilt through the canonical Ruleset ctor so the
+	* guard is adopted) so it gates output instead of rendering as a `{ true }`
+	* body. Non-guarded rulesets never begin their body with one of these node
+	* types, so the leading-node check is unambiguous.
+	*/
+	_liftRulesetGuard(base, loc) {
+		const rules = base.rules;
+		if (!Array.isArray(rules) || rules.length === 0) return base;
+		const first = rules[0];
+		if (first?.type !== "Paren" && first?.type !== "Condition" && first?.type !== "DefaultGuard") return base;
+		return new Ruleset({
+			selector: base.selector,
+			rules: rules.slice(1),
+			guard: first
+		}, void 0, loc);
+	}
+	_buildRuleset(children, rawChildren, loc) {
+		let base = super._buildRuleset(children, rawChildren, loc);
+		const selector = base.selector;
+		if (!selector) return base;
+		base = this._liftRulesetGuard(base, loc);
+		if (typeof selector === "string") return base;
+		if (this._selectorHasNestedExtend(selector)) this._error(":extend() is not allowed inside a pseudo-class selector", loc.start);
+		const baseRules = Array.isArray(base.rules) ? base.rules : [];
+		const baseGuard = base.guard;
+		const withGuard = (rs) => {
+			if (baseGuard !== void 0) rs.guard = baseGuard;
+			return rs;
+		};
+		const extendKey = (e) => {
+			const ext = e;
+			return `${String(ext.target?.valueOf?.() ?? ext.target)}:${ext.flag}`;
+		};
+		if (!isSelectorListLike(selector)) {
+			const { cleanedSelector, extractedExtends } = this._extractExtendsFromSelector(selector, loc);
+			if (extractedExtends.length === 0) return base;
+			return withGuard(new Ruleset({
+				selector: cleanedSelector,
+				rules: [...extractedExtends, ...baseRules]
+			}, void 0, loc));
+		}
+		const perSelector = [];
+		let anyExtends = false;
+		for (const item of selectorListItems(selector)) {
+			const { cleanedSelector: cs, extractedExtends: ee } = this._extractExtendsFromSelector(item, loc);
+			perSelector.push({
+				clean: cs,
+				extends: ee
+			});
+			if (ee.length > 0) anyExtends = true;
+		}
+		if (!anyExtends) return base;
+		const allExtendKeys = perSelector.map((s) => s.extends.map(extendKey).sort().join("|"));
+		if (allExtendKeys.every((k) => k === allExtendKeys[0])) {
+			const uniqueExtends = perSelector[0].extends;
+			const cleanedItems = perSelector.map((s) => s.clean).filter((c) => c !== void 0);
+			return withGuard(new Ruleset({
+				selector: cleanedItems.length === 1 ? cleanedItems[0] : this._makeSelectorList(cleanedItems, loc),
+				rules: [...uniqueExtends, ...baseRules]
+			}, void 0, loc));
+		}
+		const wrapperRules = [];
+		const cleanedItems = [];
+		for (const { clean, extends: exts } of perSelector) {
+			for (const ext of exts) {
+				const extNode = ext;
+				wrapperRules.push(new Extend({
+					target: extNode.target,
+					flag: extNode.flag,
+					selector: clean
+				}, {}, loc));
+			}
+			if (clean !== void 0) cleanedItems.push(clean);
+		}
+		const combinedSel = cleanedItems.length === 1 ? cleanedItems[0] : this._makeSelectorList(cleanedItems, loc);
+		wrapperRules.push(withGuard(new Ruleset({
+			selector: combinedSel,
+			rules: baseRules
+		}, void 0, loc)));
+		return new Rules(wrapperRules, void 0, loc);
+	}
+	_extractExtendsFromSelector(selector, loc) {
+		if (!selector || typeof selector === "string") return {
+			cleanedSelector: selector,
+			extractedExtends: []
+		};
+		if (selector instanceof CompoundSelector) {
+			const extractedExtends = [];
+			const newParts = [];
+			for (const part of selector.value) if (part instanceof Extend) extractedExtends.push(part);
+			else if (part instanceof List) for (const item of part.value ?? []) if (item instanceof Extend) extractedExtends.push(item);
+			else newParts.push(item);
+			else newParts.push(part);
+			if (extractedExtends.length === 0) return {
+				cleanedSelector: selector,
+				extractedExtends: []
+			};
+			return {
+				cleanedSelector: newParts.length === 0 ? "&" : newParts.length === 1 ? newParts[0] : new CompoundSelector(newParts, void 0, loc),
+				extractedExtends
+			};
+		}
+		if (selector instanceof ComplexSelector) {
+			const allExtends = [];
+			const newParts = [];
+			for (const part of selector.value) if (part instanceof Extend) allExtends.push(part);
+			else if (part instanceof List) for (const item of part.value ?? []) if (item instanceof Extend) allExtends.push(item);
+			else newParts.push(item);
+			else if (part instanceof CompoundSelector) {
+				const { cleanedSelector: cs, extractedExtends: ee } = this._extractExtendsFromSelector(part, loc);
+				allExtends.push(...ee);
+				if (cs !== void 0) newParts.push(cs);
+			} else newParts.push(part);
+			if (allExtends.length === 0) return {
+				cleanedSelector: selector,
+				extractedExtends: []
+			};
+			return {
+				cleanedSelector: newParts.length === 1 ? newParts[0] : new ComplexSelector(newParts, void 0, loc),
+				extractedExtends: allExtends
+			};
+		}
+		if (isSelectorListLike(selector)) {
+			const allExtends = [];
+			const cleanedItems = [];
+			let changed = false;
+			for (const item of selectorListItems(selector)) {
+				const { cleanedSelector: cs, extractedExtends: ee } = this._extractExtendsFromSelector(item, loc);
+				allExtends.push(...ee);
+				if (ee.length > 0) changed = true;
+				if (cs !== void 0) cleanedItems.push(cs);
+			}
+			if (!changed) return {
+				cleanedSelector: selector,
+				extractedExtends: []
+			};
+			return {
+				cleanedSelector: cleanedItems.length === 1 ? cleanedItems[0] : this._makeSelectorList(cleanedItems, loc),
+				extractedExtends: allExtends
+			};
+		}
+		return {
+			cleanedSelector: selector,
+			extractedExtends: []
+		};
+	}
+	static _isCssUrl(url, opts) {
+		if (opts.includes("inline") || opts.includes("less")) return false;
+		return url.endsWith(".css") || url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//");
+	}
+	_buildImportAtRuleFromPrelude(children, raw, loc, name) {
+		const preludeText = this._source.slice(loc.start, loc.end);
+		const optMatch = /^\s*\(([^)]+)\)/.exec(preludeText.replace(/^@import\s*/, ""));
+		const opts = optMatch ? optMatch[1].split(",").map((s) => s.trim()) : [];
+		const builtNodes = nodeChildren(children);
+		const urlNode = builtNodes.find((n) => n.type === "Url");
+		const quotedNode = builtNodes.find((n) => n.type === "Quoted");
+		let pathNode;
+		if (quotedNode) pathNode = new Quoted(quotedNode.value, { quote: quotedNode.quote ?? "\"" }, loc);
+		else {
+			const _qm = preludeText.match(/(['"])([^'"]+)\1/);
+			if (_qm) {
+				const quote = _qm[1] === "'" ? "'" : "\"";
+				const innerNode = _qm[2];
+				pathNode = new Quoted(innerNode, { quote }, loc);
+			}
+		}
+		let mediaNode;
+		{
+			let rest = preludeText.replace(/^@-?[_a-zA-Z][-_a-zA-Z0-9]*\s*/, "");
+			rest = rest.replace(/^\([^)]*\)\s*/, "");
+			rest = urlNode ? rest.replace(/url\(\s*(['"])[^'"]*\1\s*\)\s*/i, "") : rest.replace(/(['"])[^'"]*\1\s*/, "");
+			rest = rest.replace(/\bas\s+[^\s;(]+\s*/g, "");
+			rest = rest.replace(/;\s*$/, "").trim();
+			if (rest) mediaNode = this._buildAtRulePrelude(rest, loc);
+		}
+		const pathMatch2 = /['"]([^'"]+)['"]/.exec(preludeText);
+		const pathStr = pathMatch2 ? pathMatch2[1] : "";
+		const isCssImport = pathStr ? LessGrammar._isCssUrl(pathStr, opts) : false;
+		if (!opts.includes("inline") && (isCssImport || opts.includes("css"))) {
+			const preludeItems = [];
+			const pathPrelude = urlNode ?? pathNode;
+			if (pathPrelude) preludeItems.push(pathPrelude);
+			if (mediaNode) preludeItems.push(mediaNode);
+			let prelude;
+			if (preludeItems.length === 1) prelude = preludeItems[0];
+			else {
+				const joined = preludeItems.map((item) => item.toTrimmedString()).join(" ");
+				prelude = preludeItems.every((item) => item.structuralStaticFlag()) ? new Any(joined, void 0, loc) : joined;
+			}
+			return new AtRuleStatement({
+				name,
+				prelude
+			}, void 0, loc);
+		}
+		const isForward = name === "@-export";
+		const importType = isForward ? "compose" : "import";
+		const importOpts = { once: !opts.includes("multiple") };
+		if (opts.includes("reference")) importOpts.reference = true;
+		if (opts.includes("multiple")) importOpts.multiple = true;
+		if (opts.includes("optional")) importOpts.optional = true;
+		if (opts.includes("inline")) importOpts.inline = true;
+		if (opts.includes("less")) importOpts.type = "less";
+		if (mediaNode) importOpts.postlude = mediaNode;
+		if (isForward) importOpts.forward = true;
+		const namespace = /\bas\s+([^\s;(]+)/.exec(preludeText)?.[1];
+		const styleImportOptions = {
+			type: importType,
+			importOptions: importOpts
+		};
+		if (namespace) styleImportOptions.namespace = namespace;
+		return new StyleImport({ path: pathNode ?? urlNode }, styleImportOptions, loc);
+	}
+	_buildAtRuleBlock(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const nameLf = ls[0];
+		const name = nameLf?.value ?? "";
+		if ([
+			"@import",
+			"@-import",
+			"@-export"
+		].includes(name)) return this._buildImportAtRuleFromPrelude(children, ls, loc, name);
+		if (["@use", "@-use"].includes(name)) return this._buildUseAtRuleFromPrelude(children, loc, name);
+		const nameSpan = nameLf?.span;
+		const braceStart = ls.find((l) => l.value === "{")?.span?.start;
+		let rawPreludeText;
+		if (nameSpan && typeof braceStart === "number") {
+			const sliced = this._source.slice(nameSpan.end, braceStart).trim();
+			rawPreludeText = sliced.length > 0 ? sliced : void 0;
+		} else rawPreludeText = ls.slice(1).find((l) => l.value !== "{" && l.value !== "}")?.value.trim();
+		return this._buildAtRuleFromParts(name, rawPreludeText, nodeChildren(children), loc);
+	}
+	/**
+	* Shared AtRule assembly used by both the flat `AtRuleBlock` builder and the
+	* structured, committed `QueryAtRuleBlock` builder. `preludeText` is the raw
+	* prelude source (already `{`/`}` stripped); routing it through
+	* `_buildAtRulePrelude` keeps the emitted AST identical regardless of which
+	* grammar rule matched.
+	*/
+	_buildAtRuleFromParts(name, preludeText, ruleNodes, loc) {
+		const nestableOpts = NESTABLE_AT_RULES.includes(name) ? { nestable: true } : void 0;
+		return new AtRule({
+			name,
+			prelude: preludeText ? this._buildAtRulePrelude(preludeText, loc) : void 0,
+			rules: ruleNodes
+		}, nestableOpts, loc);
+	}
+	/**
+	* Builder for the structured, committed `@media`/`@container`/`@supports`
+	* query block. The grammar rule parses the prelude with real query structure
+	* (so a stray/unbalanced bracket is rejected instead of swallowed) and commits
+	* on `expect('{')`, but the AST is reconstructed from the prelude source text
+	* via the shared `_buildAtRuleFromParts` path — so well-formed queries emit the
+	* exact same AtRule the flat `AtRuleBlock` builder would.
+	*/
+	_buildLessQueryAtRuleBlock(children, raw, loc) {
+		const name = children.filter((c) => c._tag === "leaf")[0]?.value ?? "";
+		const comps = spannedComponents(raw);
+		const keywordEnd = comps[0]?.span.end ?? loc.start;
+		const braceStart = comps.find((c) => c.comp === "{")?.span.start ?? loc.end;
+		const preludeText = this._source.slice(keywordEnd, braceStart).trim();
+		const bodyNodes = comps.filter((c) => typeof c.comp !== "string" && c.span.start >= braceStart).map((c) => c.comp);
+		return this._buildAtRuleFromParts(name, preludeText || void 0, bodyNodes, loc);
+	}
+	_buildAtRulePrelude(text, loc) {
+		const singleVarRe = /^@(-?[_a-zA-Z\x80-￿][-_a-zA-Z0-9\x80-￿]*)$/;
+		const MEDIA_KEYWORDS = new Set([
+			"and",
+			"or",
+			"not",
+			"only",
+			"all",
+			"print",
+			"screen",
+			"speech"
+		]);
+		const COMPARISON_OPS = new Set([
+			">",
+			"<",
+			">=",
+			"<=",
+			"=",
+			"!="
+		]);
+		const escapedStrRe = /^~(['"])([\s\S]*)\1$/;
+		const buildWord = (w) => {
+			const es = escapedStrRe.exec(w);
+			if (es) return this._buildEscapedQuoted(es[2], es[1], loc);
+			const mv = singleVarRe.exec(w);
+			if (mv) return new Reference(mv[1], {
+				type: "index",
+				role: "ident"
+			}, loc);
+			if (MEDIA_KEYWORDS.has(w.toLowerCase())) return this._lessKeyword(w, loc);
+			if (COMPARISON_OPS.has(w)) return w;
+			return this._lessKeyword(w, loc);
+		};
+		const varAccRe = /^@(-?[_a-zA-Z\x80-￿][-_a-zA-Z0-9\x80-￿]*)\[([^\]]*)\]$/;
+		const buildAccessor = (varName, accInner) => {
+			const varBase = new Reference({ key: varName }, {}, loc);
+			const inner = accInner.trim();
+			let accKey;
+			let accType;
+			if (inner === "") {
+				accKey = -1;
+				accType = "index";
+			} else if (inner.startsWith("@")) {
+				accKey = inner.slice(1);
+				accType = "variable";
+			} else {
+				accKey = new Quoted(inner, {}, loc);
+				accType = "index";
+			}
+			return new Reference({
+				target: varBase,
+				key: accKey
+			}, { type: accType }, loc);
+		};
+		const prodOps = new Set(["*", "/"]);
+		const buildFeatureValue = (raw) => {
+			const propVal = raw.trim();
+			if (escapedStrRe.test(propVal) || singleVarRe.test(propVal)) return buildWord(propVal);
+			const vam = varAccRe.exec(propVal);
+			if (vam) return buildAccessor(vam[1], vam[2] ?? "");
+			const paren = /^\(([\s\S]*)\)$/.exec(propVal);
+			if (paren) {
+				const op = buildMathExpr(paren[1].trim());
+				if (op) return new Expression(op, { parens: true }, loc);
+			}
+			const ratio = /^(\d+(?:\.\d+)?)\s*\/\s*(\d+(?:\.\d+)?)$/.exec(propVal);
+			if (ratio) return this._lessKeyword(`${ratio[1]} / ${ratio[2]}`, loc);
+			return this._lessKeyword(propVal, loc);
+		};
+		const buildMathExpr = (expr) => {
+			const parts = expr.split(/\s+/).filter(Boolean);
+			if (parts.length < 3 || parts.length % 2 === 0) return;
+			const buildOperand = (t) => {
+				const es = escapedStrRe.exec(t);
+				if (es) return this._buildEscapedQuoted(es[2], es[1], loc);
+				const mv = singleVarRe.exec(t);
+				if (mv) return new Reference(mv[1], {
+					type: "index",
+					role: "ident"
+				}, loc);
+				const va = varAccRe.exec(t);
+				if (va) return buildAccessor(va[1], va[2] ?? "");
+				const dim = /^([+-]?(?:\d*\.\d+|\d+))([_a-zA-Z%][-_a-zA-Z0-9%]*)?$/.exec(t);
+				if (dim) return dim[2] ? new Dimension({
+					number: parseFloat(dim[1]),
+					unit: dim[2]
+				}, void 0, loc) : new Num(parseFloat(dim[1]), void 0, loc);
+			};
+			const nodes = parts.map((p, i) => i % 2 === 0 ? buildOperand(p) : /^[-+*/]$/.test(p) ? p : void 0);
+			if (nodes.some((n) => n === void 0)) return;
+			const foldPass = (matchOp) => {
+				for (let i = 1; i < nodes.length - 1; i += 2) {
+					const op = nodes[i];
+					if (matchOp(op)) {
+						const left = nodes[i - 1];
+						const right = nodes[i + 1];
+						const combined = new Operation([
+							left,
+							op,
+							right
+						], void 0, loc);
+						nodes.splice(i - 1, 3, combined);
+						return true;
+					}
+				}
+				return false;
+			};
+			while (foldPass((op) => prodOps.has(op)));
+			while (foldPass((op) => op === "+" || op === "-"));
+			return nodes.length === 1 ? nodes[0] : void 0;
+		};
+		const buildParen = (inner) => {
+			const trimmed = inner.trim();
+			const colonIdx = trimmed.indexOf(":");
+			if (colonIdx > 0 && !/[><=!]/.test(trimmed.slice(0, colonIdx))) {
+				const propName = trimmed.slice(0, colonIdx).trim();
+				const valueNode = buildFeatureValue(trimmed.slice(colonIdx + 1).trim());
+				if (propName.startsWith("--")) return new Paren(new QueryCondition([this._lessKeyword(`${propName}:`, loc), valueNode], void 0, loc), void 0, loc);
+				return new Paren(new Declaration({
+					name: propName,
+					value: valueNode
+				}, void 0, loc), void 0, loc);
+			}
+			return new Paren(new QueryCondition(trimmed.replace(/\(\s+/g, "(").replace(/\s+\)/g, ")").replace(/\s*(<=|>=|!=|[<>=])\s*/g, " $1 ").trim().split(/\s+/).filter(Boolean).map((w) => buildWord(w)), void 0, loc), void 0, loc);
+		};
+		const tokenize = (t) => {
+			const tokens = [];
+			let i = 0;
+			while (i < t.length) if (t[i] === "(") {
+				let depth = 1;
+				let j = i + 1;
+				while (j < t.length && depth > 0) {
+					if (t[j] === "(") depth++;
+					else if (t[j] === ")") depth--;
+					j++;
+				}
+				tokens.push(buildParen(t.slice(i + 1, j - 1)));
+				i = j;
+			} else if (t[i] === "\"" || t[i] === "'" || t[i] === "~" && (t[i + 1] === "\"" || t[i + 1] === "'")) {
+				const start = i;
+				if (t[i] === "~") i++;
+				const quote = t[i];
+				i++;
+				while (i < t.length && t[i] !== quote) i++;
+				i = Math.min(i + 1, t.length);
+				tokens.push(buildWord(t.slice(start, i)));
+			} else if (/\s/.test(t[i])) i++;
+			else {
+				let j = i;
+				while (j < t.length && !/\s/.test(t[j]) && t[j] !== "(") j++;
+				tokens.push(buildWord(t.slice(i, j)));
+				i = j;
+			}
+			return tokens;
+		};
+		const splitCommas = (t) => {
+			const parts = [];
+			let depth = 0;
+			let start = 0;
+			for (let i = 0; i < t.length; i++) if (t[i] === "(") depth++;
+			else if (t[i] === ")") depth--;
+			else if (t[i] === "," && depth === 0) {
+				parts.push(t.slice(start, i).trim());
+				start = i + 1;
+			}
+			parts.push(t.slice(start).trim());
+			return parts.filter(Boolean);
+		};
+		const nsMediaRe = /^([#.][^(\[,\s]*)(\([^)]*\))?(\[[^\]]*\])?$/;
+		const buildItem = (t) => {
+			const trimmed = t.trim();
+			const mv = singleVarRe.exec(trimmed);
+			if (mv) return new QueryCondition([new Reference(mv[1], {
+				type: "index",
+				role: "ident"
+			}, loc)], void 0, loc);
+			const vam = /^@(-?[_a-zA-Z\x80-￿][-_a-zA-Z0-9\x80-￿]*)(\[([^\]]*)\])$/.exec(trimmed);
+			if (vam) {
+				const varBase = new Reference({ key: vam[1] }, {}, loc);
+				const accInner = (vam[3] ?? "").trim();
+				let accKey;
+				let accType;
+				if (accInner === "") {
+					accKey = -1;
+					accType = "index";
+				} else if (accInner.startsWith("@")) {
+					accKey = accInner.slice(1);
+					accType = "variable";
+				} else {
+					accKey = new Quoted(accInner, {}, loc);
+					accType = "index";
+				}
+				return new Expression(new Reference({
+					target: varBase,
+					key: accKey
+				}, { type: accType }, loc), void 0, loc);
+			}
+			const nsm = nsMediaRe.exec(trimmed);
+			if (nsm) {
+				const nsPath = nsm[1];
+				const argsText = nsm[2];
+				const accText = nsm[3];
+				const segments = nsPath.match(/[#.][^#.]*/g) ?? [nsPath];
+				const nameKey = segments.length === 1 ? segments[0] : segments;
+				const rawKey = segments.length > 1 ? nsPath : void 0;
+				let base = new Reference({
+					key: nameKey,
+					...rawKey ? { rawKey } : {}
+				}, {
+					type: "mixin-ruleset",
+					role: "name"
+				}, loc);
+				if (argsText) {
+					const argsInner = argsText.slice(1, -1).trim();
+					let argsNode = null;
+					if (argsInner) {
+						const argRefMatch = /^([.#][^\[\]()\s]+)(\[([^\]]*)\])?$/.exec(argsInner);
+						if (argRefMatch) {
+							let argBase = new Reference({ key: argRefMatch[1] }, { role: "name" }, loc);
+							if (argRefMatch[2] !== void 0) {
+								const argAcc = argRefMatch[3] ?? "";
+								argBase = new Reference({
+									target: argBase,
+									key: argAcc === "" ? -1 : argAcc
+								}, {}, loc);
+							}
+							argsNode = new List([argBase], void 0, loc);
+						}
+					}
+					const callPayload = { name: base };
+					if (argsNode) callPayload.args = argsNode;
+					base = new Call(callPayload, {}, loc);
+				}
+				if (accText) {
+					const inner = accText.slice(1, -1).trim();
+					const key = inner.startsWith("@") ? inner.slice(1) : inner === "" ? -1 : inner;
+					base = new Reference({
+						target: base,
+						key
+					}, { type: "variable" }, loc);
+				}
+				return new Expression(base, void 0, loc);
+			}
+			const tokens = tokenize(t);
+			const nameMatch = /^(@?-?[_a-zA-Z\x80-\uffff][-_a-zA-Z0-9\x80-\uffff]*)\s+(?:\(|not(?![-\w]))/i.exec(trimmed);
+			return new QueryCondition(tokens, !!nameMatch && tokens.length > 1 && ![
+				"not",
+				"and",
+				"or",
+				"only"
+			].includes(nameMatch[1].replace(/^@/, "").toLowerCase()) ? { leadingContainerName: true } : void 0, loc);
+		};
+		const commaItems = splitCommas(text);
+		if (commaItems.length === 1) return buildItem(commaItems[0]);
+		return new List(commaItems.map(buildItem), void 0, loc);
+	}
+	_buildAtRuleStatement(children, loc) {
+		const ls = children.filter((c) => c._tag === "leaf");
+		const name = ls[0]?.value ?? "";
+		if ([
+			"@import",
+			"@-import",
+			"@-export"
+		].includes(name)) return this._buildImportAtRuleFromPrelude(children, ls, loc, name);
+		if (["@use", "@-use"].includes(name)) return this._buildUseAtRuleFromPrelude(children, loc, name);
+		return super._buildAtRuleStatement(children, loc);
+	}
+	_buildUseAtRuleFromPrelude(children, loc, name) {
+		const preludeText = this._source.slice(loc.start, loc.end);
+		const quotedNode = nodeChildren(children).find((n) => n.type === "Quoted");
+		let rawPath = "";
+		let pathNode;
+		if (quotedNode) {
+			const quote = quotedNode.quote ?? "\"";
+			const innerVal = quotedNode.value;
+			const inner = typeof innerVal === "string" ? innerVal : innerVal?.value ?? String(innerVal?.valueOf?.() ?? "");
+			rawPath = inner;
+			pathNode = new Quoted(inner, { quote }, loc);
+		} else {
+			const qm = /(['"])((?:[^'"\\]|\\.)*)\1/.exec(preludeText);
+			if (qm) {
+				const quote = qm[1] === "'" ? "'" : "\"";
+				const inner = qm[2];
+				rawPath = inner;
+				pathNode = new Quoted(inner, { quote }, loc);
+			}
+		}
+		const explicitNs = /\bas\s+([^\s;]+)/.exec(preludeText)?.[1];
+		if (/\.[cm]?[jt]sx?$/.test(rawPath) || rawPath.startsWith("#")) {
+			let ns = explicitNs;
+			if (!ns) ns = (rawPath.split("/").pop() ?? "").replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_$]/g, "_");
+			return new JsImport({ path: pathNode }, { namespace: ns }, loc);
+		}
+		return new AtRule({
+			name,
+			prelude: pathNode,
+			rules: []
+		}, void 0, loc);
+	}
+	_parenToArgs(paren, loc) {
+		const inner = paren.value ?? paren.node;
+		if (!inner) return null;
+		const items = [];
+		const isSeq = inner && typeof inner === "object" && inner.type === "Sequence";
+		if (isSeq || Array.isArray(inner)) {
+			const seqItems = (isSeq ? inner.value ?? [] : inner).map((it) => typeof it === "string" ? this._lessKeyword(it.trim(), loc) : it);
+			let j = 0;
+			while (j < seqItems.length) {
+				const item = seqItems[j];
+				if (item.type === "Reference" && j + 2 < seqItems.length && seqItems[j + 1]?.value === ":") {
+					const nameAny = item.key ?? "";
+					const valNode = seqItems[j + 2];
+					const vd = new VarDeclaration({
+						name: nameAny,
+						value: this._isKeywordLike(valNode) ? this._lessKeyword(String(valNode.value ?? "").trim(), loc) : this._lessKeyword(String(valNode.value ?? ""), loc)
+					}, {}, loc);
+					items.push(vd);
+					j += 3;
+				} else {
+					items.push(item);
+					j++;
+				}
+			}
+		} else if (inner && inner.type === "List") for (const it of inner.value ?? []) items.push(it);
+		else if (inner) {
+			if (!this._isEmptyKeywordLike(inner)) items.push(inner);
+		}
+		if (items.length === 0) return null;
+		return new List(items, void 0, loc);
+	}
+	_tryParseNamespaceRef(valItems, loc) {
+		const isSel = (s) => typeof s === "string" && /^[#.]-?[_a-zA-Z\u0080-\uffff]/.test(s.trim());
+		const isCombinator = (s) => typeof s === "string" && /^[>+~|]$|^\|\|$/.test(String(s).trim());
+		const isJessNodeVal = (x) => !!x && typeof x === "object" && "type" in x;
+		const first = valItems[0]?.comp;
+		const isVarRef = (x) => !!x && typeof x === "object" && x.type === "Reference";
+		if (!isSel(first) && !isVarRef(first)) return null;
+		if (isVarRef(first) && valItems.length < 2) return null;
+		const hasSquareAfterVar = isVarRef(first) && valItems.slice(1).some((vi) => isJessNodeVal(vi.comp) && vi.comp.type === "Paren" && vi.comp._options?.delimiter === "square");
+		if (isVarRef(first) && !hasSquareAfterVar) return null;
+		let i = 0;
+		let base = null;
+		let pendingSegments = [];
+		let hasMidCall = false;
+		const flushPendingAsRef = () => {
+			const k = pendingSegments.length === 1 ? pendingSegments[0] : pendingSegments;
+			pendingSegments = [];
+			if (base === null) return new Reference({ key: k }, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, loc);
+			return new Reference({
+				target: base,
+				key: k
+			}, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, loc);
+		};
+		while (i < valItems.length) {
+			const c = valItems[i].comp;
+			if (isVarRef(c) && base === null && pendingSegments.length === 0) {
+				const rv = c;
+				base = rv.target !== void 0 && (rv.key === "" || rv.key === void 0 || rv.key && typeof rv.key === "object" && rv.key.type === "Quoted" && !String(rv.key.value ?? "").trim()) ? rv.target : c;
+				i++;
+			} else if (isSel(c)) {
+				const seg = c.trim();
+				const splitSeg = seg.match(/[#.][^#.]*/g) ?? [seg];
+				for (const s of splitSeg) pendingSegments.push(s);
+				i++;
+			} else if (isCombinator(c) && i + 1 < valItems.length && isSel(valItems[i + 1]?.comp)) i++;
+			else if (isJessNodeVal(c) && c.type === "Paren" && c._options?.delimiter === "square") {
+				if (pendingSegments.length > 0) base = flushPendingAsRef();
+				if (base === null) break;
+				const innerKey = this._decodeAccessorKey(c, loc);
+				base = new Reference({
+					target: base,
+					key: innerKey
+				}, { type: typeof innerKey === "number" ? "index" : "variable" }, loc);
+				i++;
+			} else if (isJessNodeVal(c) && c.type === "Paren") {
+				if (pendingSegments.length === 0 && base === null) break;
+				if (pendingSegments.length > 0) base = flushPendingAsRef();
+				const argsNode = this._parenToArgs(c, loc);
+				const callPayload = { name: base };
+				if (argsNode) callPayload.args = argsNode;
+				base = new Call(callPayload, {}, loc);
+				hasMidCall = true;
+				i++;
+			} else break;
+		}
+		if (i !== valItems.length) return null;
+		if (pendingSegments.length === 0 && base === null) return null;
+		if (pendingSegments.length > 0) base = flushPendingAsRef();
+		if (valItems.length > 0) {
+			const lastSpan = valItems[valItems.length - 1].span;
+			let afterVal = this._source.slice(lastSpan.end).trimStart();
+			if (!hasMidCall && afterVal.startsWith("(")) {
+				const closeIdx = afterVal.indexOf(")", 1);
+				if (closeIdx > 0) {
+					const callInner = afterVal.slice(1, closeIdx).trim();
+					afterVal = afterVal.slice(closeIdx + 1).trimStart();
+					let argsNode = null;
+					if (callInner) {
+						const argRefMatch = /^([.#][^\[\]()\s]+)(\[([^\]]*)\])?$/.exec(callInner);
+						if (argRefMatch) {
+							const argSel = argRefMatch[1];
+							const argAccContent = argRefMatch[3];
+							let argBase = new Reference({ key: argSel }, { role: "name" }, loc);
+							if (argRefMatch[2] !== void 0) {
+								const argAccKey = argAccContent === void 0 || argAccContent === "" ? -1 : argAccContent.startsWith("@") ? argAccContent.slice(1) : argAccContent;
+								argBase = new Reference({
+									target: argBase,
+									key: argAccKey
+								}, {}, loc);
+							}
+							argsNode = new List([argBase], void 0, loc);
+						}
+					}
+					const callPayload = { name: base };
+					if (argsNode) callPayload.args = argsNode;
+					base = new Call(callPayload, {}, loc);
+				}
+			}
+			const accMatch = /^\[([^\]]*)\]/.exec(afterVal);
+			if (accMatch) {
+				const accText = accMatch[1].trim();
+				let accessorKey;
+				if (accText === "") accessorKey = -1;
+				else if (accText.startsWith("@")) accessorKey = accText.slice(1);
+				else accessorKey = new Quoted(accText, {}, loc);
+				base = new Reference({
+					target: base,
+					key: accessorKey
+				}, {}, loc);
+				const afterAcc = afterVal.slice(accMatch[0].length).trimStart();
+				if (/^\(\s*\)/.test(afterAcc)) base = new Call({ name: base }, {}, loc);
+			} else if (!hasMidCall) {
+				if (/^\(\s*\)/.exec(afterVal)) base = new Call({ name: base }, {}, loc);
+			}
+		}
+		return base;
+	}
+	_assembleLessValue(valItems, loc) {
+		const parts = [];
+		for (const item of valItems) {
+			const c = item.comp;
+			if (typeof c === "string") {
+				if (c.trim()) parts.push(this._lessKeyword(c.trim(), loc));
+			} else parts.push(c);
+		}
+		if (parts.length === 0) return { value: "" };
+		if (parts.length === 1) return { value: parts[0] };
+		return { value: parts };
+	}
+};
+//#endregion
+//#region src/functional-parser.ts
+var BuilderHost = class extends LessGrammar {
+	/**
+	* The TreeContext threaded in by the caller (the plugin's per-file context),
+	* held for the duration of one parse. Currently a pass-through: it's carried
+	* back out in the result so a caller can hand one context in and read it back.
+	* Grammar rules (e.g. a future `@compose`/`@use` rule) can read/mutate it —
+	* e.g. set `context.opts.strict` — and the mutation is visible to the caller
+	* since it's the same object.
+	*/
+	context;
+	setSource(src) {
+		this._source = src;
+	}
+	resetWarnings() {
+		this._warnings = [];
+		this._errors = [];
+		this._liftedCommentRanges = [];
+	}
+	getWarnings() {
+		return this._warnings.slice();
+	}
+	getErrors() {
+		return this._errors.slice();
+	}
+	/** `ctx.build` host: every structural `node(type, …)` builds through this,
+	* reusing LessGrammar's (Less + inherited 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 parseLessFn(input, rule = "Stylesheet", mathMode = "parens-division", context) {
+	host.mathMode = context?.options?.mathMode ?? mathMode;
+	host.context = context;
+	const g = lessGrammar;
+	const result = runFunctionalParse(input, g[rule], host, { trivia: g.rw });
+	const threaded = host.context;
+	host.context = void 0;
+	return {
+		...result,
+		context: threaded
+	};
+}
+/**
+* Index of the first backtick in CODE position (i.e. real inline JS), or -1.
+* Skips `//` line comments, `/* … *​/` block comments, and quoted strings so a
+* backtick inside a comment/string (common in Less doc comments) is not
+* mistaken for inline JavaScript.
+*/
+function firstInlineJsBacktick(text) {
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i];
+		if (c === "`") return i;
+		if (c === "/" && text[i + 1] === "/") {
+			const nl = text.indexOf("\n", i + 2);
+			if (nl === -1) return -1;
+			i = nl;
+		} else if (c === "/" && text[i + 1] === "*") {
+			const end = text.indexOf("*/", i + 2);
+			if (end === -1) return -1;
+			i = end + 1;
+		} else if (c === "\"" || c === "'") {
+			i++;
+			while (i < text.length && text[i] !== c) {
+				if (text[i] === "\\") i++;
+				i++;
+			}
+		}
+	}
+	return -1;
+}
+/** Functional Less parser — call .parse(text) to get a Jess AST. */
+var LessParser = class {
+	_mathMode;
+	constructor(config) {
+		this._mathMode = config?.mathMode ?? "parens-division";
+	}
+	parse = (text, rule = "Stylesheet", options) => {
+		const backtick = firstInlineJsBacktick(text);
+		if (backtick !== -1) return {
+			tree: nil(),
+			errors: [toParseError("Inline JavaScript using backticks is not supported. Use @use / @-use to import a script module instead.", backtick, text)],
+			warnings: [],
+			trivia: buildLazyTriviaMap([], text),
+			liftedCommentRanges: [],
+			context: options?.context
+		};
+		return parseLessFn(text, rule, this._mathMode, options?.context);
+	};
+};
+//#endregion
+export { getInterpolatedNode as a, Fragments as c, lessTokens as d, createInterpolatedReference as i, Tokens as l, parseLessFn as n, getInterpolatedOrString as o, LessGrammar as r, normalizeMixinReferenceKey as s, LessParser as t, lessFragments as u };