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

package/lib/functional-parser.cjs

@@ -0,0 +1,2654 @@
+const require_grammar = require("./grammar.cjs");
+let _jesscss_css_parser = require("@jesscss/css-parser");
+let _jesscss_css_parser_jess = require("@jesscss/css-parser/jess");
+let _jesscss_core = require("@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 = (0, _jesscss_css_parser.rawCssFragments)().map((f) => [...f]);
+	fragments.unshift(["lineComment", "\\/\\/[^\\n\\r]*"]);
+	fragments.push(["interpolated", "[@$]\\{(?:{{nmchar}}*)\\}"]);
+	return fragments;
+}
+function $preBuildTokens() {
+	const tokens = (0, _jesscss_css_parser.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: _jesscss_css_parser.LexerType.NA
+			},
+			{
+				name: "LineComment",
+				pattern: "{{lineComment}}",
+				label: _jesscss_css_parser.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: _jesscss_css_parser.LexerType.NA
+			},
+			{
+				name: "NestedReference",
+				pattern: ["([@$]+{{ident}}?){2,}", _jesscss_css_parser.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}})*", _jesscss_css_parser.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 _jesscss_core.Reference({ key: isProperty ? new _jesscss_core.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, _jesscss_core.INTERPOLATION_PLACEHOLDER);
+		replacements.push(createInterpolatedReference(prefix ?? "", varName ?? "", location, context));
+	}
+	return new _jesscss_core.Interpolated({
+		source,
+		replacements
+	}, { role: "ident" }, location);
+};
+const normalizeMixinReferenceKey = (selector) => {
+	if ((0, _jesscss_core.isNode)(selector, _jesscss_core.N.BasicSelector) || selector instanceof _jesscss_core.InterpolatedSelector) return {
+		key: selector.valueOf(),
+		rawKey: selector
+	};
+	if ((0, _jesscss_core.isNode)(selector, _jesscss_core.N.CompoundSelector)) return {
+		key: selector.value.map((node) => node.valueOf()),
+		rawKey: selector
+	};
+	if ((0, _jesscss_core.isNode)(selector, _jesscss_core.N.ComplexSelector)) {
+		const path = [];
+		let canUsePath = true;
+		for (const node of selector.value) {
+			if ((0, _jesscss_core.isNode)(node, _jesscss_core.N.BasicSelector) || node instanceof _jesscss_core.InterpolatedSelector) {
+				path.push(node.valueOf());
+				continue;
+			}
+			if ((0, _jesscss_core.isNode)(node, _jesscss_core.N.CompoundSelector)) {
+				path.push(...node.value.map((child) => child.valueOf()));
+				continue;
+			}
+			if ((0, _jesscss_core.isNode)(node, _jesscss_core.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 + _jesscss_core.INTERPOLATION_PLACEHOLDER + afterMatch;
+			offset += match.fullMatch.length - _jesscss_core.INTERPOLATION_PLACEHOLDER.length;
+			const ref = createInterpolatedReference(match.prefix, match.varName, location, context);
+			replacements.push(ref);
+		}
+		return new _jesscss_core.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 _jesscss_core.Quoted(endResult, { quote: "'" }, location) : endResult;
+		return new _jesscss_core.Interpolated({
+			source: start + _jesscss_core.INTERPOLATION_PLACEHOLDER,
+			replacements: [new _jesscss_core.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 _jesscss_core.Interpolated({
+		source: start + _jesscss_core.INTERPOLATION_PLACEHOLDER,
+		replacements: [type === "index" ? new _jesscss_core.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 _jesscss_css_parser_jess.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 _jesscss_core.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 _jesscss_core.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 = (0, _jesscss_css_parser_jess.spannedComponents)(rawChildren);
+		const rawName = typeof items[0]?.comp === "string" ? items[0].comp : "";
+		const name = rawName.startsWith("@") ? rawName.slice(1) : rawName;
+		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 _jesscss_core.VarDeclaration({
+						name: (name || void 0) ?? name,
+						value: new _jesscss_core.Quoted(rawBlock, {}, loc)
+					}, {}, loc);
+				}
+			}
+			const mixin = new _jesscss_core.Mixin({ rules: ruleNodes }, {}, loc);
+			return new _jesscss_core.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 > 0 && valItems[valItems.length - 1].comp === ",") valItems.pop();
+		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 _jesscss_core.Reference({
+					target: rv.target,
+					key: accessorKey
+				}, accessorRefOptions, loc);
+				else rawValue = new _jesscss_core.Reference({
+					target: rawValue,
+					key: accessorKey
+				}, accessorRefOptions, loc);
+				const afterAcc = afterVal.slice(accMatch[0].length);
+				if (/^\s*\(\s*\)/.test(afterAcc)) rawValue = new _jesscss_core.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 _jesscss_core.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 _jesscss_core.Reference({ key: new _jesscss_core.Quoted(varName.slice(1), { quote: "'" }, loc) }, { type: "index" }, loc) : new _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Quoted(result, { quote: "'" }, loc);
+		return new _jesscss_core.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 _jesscss_core.List(trimmed.split(",").map((p) => p.trim()).filter(Boolean).map((p) => p.startsWith("@") ? new _jesscss_core.Reference(p.slice(1), { type: "variable" }, loc) : this._lessKeyword(p, loc)), void 0, loc);
+	}
+	_buildNamedColor(children, loc) {
+		return new _jesscss_core.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 = (0, _jesscss_css_parser_jess.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 _jesscss_core.Condition([
+			left,
+			op,
+			right
+		], {}, loc);
+		return new _jesscss_core.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 _jesscss_core.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 = (0, _jesscss_css_parser_jess.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Paren(n, {}, loc);
+		let left = wrap(nodes[0]);
+		for (let i = 1; i < nodes.length; i++) left = new _jesscss_core.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 _jesscss_core.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 _jesscss_core.Paren(inner, {}, loc);
+	}
+	/** A single guard term: optional `not`, then a paren-guard or a comparison/value. */
+	_buildGuardTerm(raw, loc) {
+		const hasNot = (0, _jesscss_css_parser_jess.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 _jesscss_core.Condition([
+				left,
+				op,
+				right
+			], {}, loc) : left;
+		}
+		if (hasNot) return new _jesscss_core.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 _jesscss_core.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((0, _jesscss_css_parser_jess.spannedComponents)(raw)), loc);
+		const args = argList.value ?? [];
+		const format = args[0];
+		const rest = args.slice(1);
+		if (format instanceof _jesscss_core.Quoted && typeof format.value === "string") {
+			const { source, replacements } = this._lowerFormatString(format.value, rest, loc);
+			return new _jesscss_core.Quoted(new _jesscss_core.Interpolated({
+				source,
+				replacements
+			}, { role: "ident" }, loc), {
+				quote: format.quote,
+				escaped: format.escaped
+			}, loc);
+		}
+		return new _jesscss_core.Call({
+			name: new _jesscss_core.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 += _jesscss_core.INTERPOLATION_PLACEHOLDER;
+					if (/[A-Z]/.test(next)) {
+						const escapeRef = new _jesscss_core.Reference("escape", {
+							type: "function",
+							fallbackValue: true
+						}, loc);
+						const escapeArgs = new _jesscss_core.List([arg], {}, loc);
+						replacements.push(new _jesscss_core.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 _jesscss_core.Reference(varName, { role: "ident" }, loc));
+			source += _jesscss_core.INTERPOLATION_PLACEHOLDER;
+		} else source += l.value;
+		return new _jesscss_core.InterpolatedSelector(new _jesscss_core.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 = (0, _jesscss_css_parser_jess.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 ((0, _jesscss_core.shouldOperateWithMathFrames)({
+				mathMode: this.mathMode,
+				parenFrames: [],
+				calcFrames: 0
+			}, f.operator, f.left, f.right)) decl.value = new _jesscss_core.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 _jesscss_core.Operation([
+					op,
+					"/",
+					items[i]
+				], void 0, loc);
+				const f = op;
+				decl.value = (0, _jesscss_core.shouldOperateWithMathFrames)({
+					mathMode: this.mathMode,
+					parenFrames: [],
+					calcFrames: 0
+				}, f.operator, f.left, f.right) ? new _jesscss_core.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 _jesscss_core.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 `"${_jesscss_core.INTERPOLATION_PLACEHOLDER}"`;
+				return _jesscss_core.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 _jesscss_core.Ampersand(this._ampersandTemplateValue(image), {}, loc);
+		}
+		const trimmed = (ls.find((l) => l.value !== "&" && l.value !== "(" && l.value !== ")")?.value ?? "").trim();
+		return new _jesscss_core.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 = (0, _jesscss_css_parser_jess.spannedComponents)(raw);
+		const isFlag = (c) => typeof c === "string" && /^!?all$/.test(c);
+		const flag = comps.some((c) => isFlag(c.comp)) ? _jesscss_core.ExtendFlag.All : _jesscss_core.ExtendFlag.Exact;
+		const targetComp = comps.find((c) => !isFlag(c.comp))?.comp;
+		return new _jesscss_core.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 _jesscss_core.Extend({
+			target: targets.length === 1 ? targets[0].target : this._makeSelectorList(targets.map((t) => t.target), loc),
+			flag: firstFlag
+		}, {}, loc);
+		return new _jesscss_core.List(targets.map((t) => new _jesscss_core.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 _jesscss_core.Reference(rawText.slice(2), { type: "variable" }, loc);
+		if (rawText.startsWith("$@") || rawText.startsWith("@$")) return new _jesscss_core.Quoted(new _jesscss_core.Interpolated({
+			source: _jesscss_core.INTERPOLATION_PLACEHOLDER,
+			replacements: [new _jesscss_core.Reference(rawText.slice(2), { role: "ident" }, loc)]
+		}, { role: "ident" }, loc), {}, loc);
+		if (rawText.startsWith("@")) return rawText.slice(1);
+		return new _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Quoted) return new _jesscss_core.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((0, _jesscss_css_parser_jess.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 _jesscss_core.Url(new _jesscss_core.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 _jesscss_core.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 _jesscss_core.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) + _jesscss_core.INTERPOLATION_PLACEHOLDER + source.slice(adjustedEnd);
+			offset += match.end - match.start - _jesscss_core.INTERPOLATION_PLACEHOLDER.length;
+			if (match.content.includes("@{") || match.content.includes("${")) {
+				const nestedRef = new _jesscss_core.Reference({ key: this._buildStringInterpolation(match.content, loc) }, {
+					type: "variable",
+					role: "ident"
+				}, loc);
+				replacements.push(new _jesscss_core.Expression(nestedRef, void 0, loc));
+			} else replacements.push(createInterpolatedReference(match.prefix, match.content, loc));
+		}
+		return new _jesscss_core.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 _jesscss_core.Call({
+			name: new _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Block(new _jesscss_core.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 _jesscss_core.Call({
+			name: new _jesscss_core.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 _jesscss_core.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 _jesscss_core.Expression(new _jesscss_core.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 = (0, _jesscss_css_parser_jess.spannedComponents)(raw).find((i) => typeof i.comp === "string" && i.comp.startsWith("@"));
+		return new _jesscss_core.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 = (0, _jesscss_css_parser_jess.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 _jesscss_core.Sequence(value.map((c) => this._argComponent(c, loc)), void 0, loc);
+		else paramValue = value;
+		return new _jesscss_core.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((0, _jesscss_css_parser_jess.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 _jesscss_core.List(list.value.map((el) => {
+			if (el?.type === "List") return new _jesscss_core.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 _jesscss_core.VarDeclaration({
+					name,
+					value: new _jesscss_core.Nil("", {}, loc)
+				}, {}, loc);
+			}
+			return node;
+		});
+		if (!changed) return argsList;
+		return new _jesscss_core.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 _jesscss_core.Reference({ key }, { type: "variable" }, loc);
+				}
+				return node;
+			}
+			if (node.type === "Rest") {
+				const restVal = node.value;
+				if (typeof restVal === "string") {
+					changed = true;
+					return new _jesscss_core.Rest(new _jesscss_core.Reference({ key: restVal }, { type: "variable" }, loc), {}, loc);
+				}
+				return node;
+			}
+			return node;
+		});
+		if (!changed) return argsList;
+		return new _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.List(iterableNodes, void 0, loc);
+		return new _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.ComplexSelector(nameParts, void 0, loc) : void 0;
+		const ref = name.startsWith(".") || name.startsWith("#") ? new _jesscss_core.Reference({
+			key: refKey,
+			...rawKey ? { rawKey } : {}
+		}, {
+			type: "mixin-ruleset",
+			role: "name"
+		}, loc) : new _jesscss_core.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 _jesscss_core.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 _jesscss_core.CompoundSelector || sel instanceof _jesscss_core.ComplexSelector) return sel.value.some((p) => this._selectorHasNestedExtend(p));
+		if ((0, _jesscss_core.isSelectorListLike)(sel)) return (0, _jesscss_core.selectorListItems)(sel).some((p) => this._selectorHasNestedExtend(p));
+		return false;
+	}
+	_treeHasExtend(node) {
+		if (node instanceof _jesscss_core.Extend) return true;
+		if (node instanceof _jesscss_core.CompoundSelector || node instanceof _jesscss_core.ComplexSelector) return node.value.some((p) => this._treeHasExtend(p));
+		if ((0, _jesscss_core.isSelectorListLike)(node)) return (0, _jesscss_core.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 _jesscss_core.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 (!(0, _jesscss_core.isSelectorListLike)(selector)) {
+			const { cleanedSelector, extractedExtends } = this._extractExtendsFromSelector(selector, loc);
+			if (extractedExtends.length === 0) return base;
+			return withGuard(new _jesscss_core.Ruleset({
+				selector: cleanedSelector,
+				rules: [...extractedExtends, ...baseRules]
+			}, void 0, loc));
+		}
+		const perSelector = [];
+		let anyExtends = false;
+		for (const item of (0, _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Ruleset({
+			selector: combinedSel,
+			rules: baseRules
+		}, void 0, loc)));
+		return new _jesscss_core.Rules(wrapperRules, void 0, loc);
+	}
+	_extractExtendsFromSelector(selector, loc) {
+		if (!selector || typeof selector === "string") return {
+			cleanedSelector: selector,
+			extractedExtends: []
+		};
+		if (selector instanceof _jesscss_core.CompoundSelector) {
+			const extractedExtends = [];
+			const newParts = [];
+			for (const part of selector.value) if (part instanceof _jesscss_core.Extend) extractedExtends.push(part);
+			else if (part instanceof _jesscss_core.List) for (const item of part.value ?? []) if (item instanceof _jesscss_core.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 _jesscss_core.CompoundSelector(newParts, void 0, loc),
+				extractedExtends
+			};
+		}
+		if (selector instanceof _jesscss_core.ComplexSelector) {
+			const allExtends = [];
+			const newParts = [];
+			for (const part of selector.value) if (part instanceof _jesscss_core.Extend) allExtends.push(part);
+			else if (part instanceof _jesscss_core.List) for (const item of part.value ?? []) if (item instanceof _jesscss_core.Extend) allExtends.push(item);
+			else newParts.push(item);
+			else if (part instanceof _jesscss_core.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 _jesscss_core.ComplexSelector(newParts, void 0, loc),
+				extractedExtends: allExtends
+			};
+		}
+		if ((0, _jesscss_core.isSelectorListLike)(selector)) {
+			const allExtends = [];
+			const cleanedItems = [];
+			let changed = false;
+			for (const item of (0, _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Any(joined, void 0, loc) : joined;
+			}
+			return new _jesscss_core.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 _jesscss_core.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 = _jesscss_core.NESTABLE_AT_RULES.includes(name) ? { nestable: true } : void 0;
+		return new _jesscss_core.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 = (0, _jesscss_css_parser_jess.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Quoted(inner, {}, loc);
+				accType = "index";
+			}
+			return new _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Dimension({
+					number: parseFloat(dim[1]),
+					unit: dim[2]
+				}, void 0, loc) : new _jesscss_core.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 _jesscss_core.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 _jesscss_core.Paren(new _jesscss_core.QueryCondition([this._lessKeyword(`${propName}:`, loc), valueNode], void 0, loc), void 0, loc);
+				return new _jesscss_core.Paren(new _jesscss_core.Declaration({
+					name: propName,
+					value: valueNode
+				}, void 0, loc), void 0, loc);
+			}
+			return new _jesscss_core.Paren(new _jesscss_core.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 _jesscss_core.QueryCondition([new _jesscss_core.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 _jesscss_core.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 _jesscss_core.Quoted(accInner, {}, loc);
+					accType = "index";
+				}
+				return new _jesscss_core.Expression(new _jesscss_core.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 _jesscss_core.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 _jesscss_core.Reference({ key: argRefMatch[1] }, { role: "name" }, loc);
+							if (argRefMatch[2] !== void 0) {
+								const argAcc = argRefMatch[3] ?? "";
+								argBase = new _jesscss_core.Reference({
+									target: argBase,
+									key: argAcc === "" ? -1 : argAcc
+								}, {}, loc);
+							}
+							argsNode = new _jesscss_core.List([argBase], void 0, loc);
+						}
+					}
+					const callPayload = { name: base };
+					if (argsNode) callPayload.args = argsNode;
+					base = new _jesscss_core.Call(callPayload, {}, loc);
+				}
+				if (accText) {
+					const inner = accText.slice(1, -1).trim();
+					const key = inner.startsWith("@") ? inner.slice(1) : inner === "" ? -1 : inner;
+					base = new _jesscss_core.Reference({
+						target: base,
+						key
+					}, { type: "variable" }, loc);
+				}
+				return new _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Quoted(inner, { quote }, loc);
+		} else {
+			const qm = /(['"])((?:[^'"\\]|\\.)*)\1/.exec(preludeText);
+			if (qm) {
+				const quote = qm[1] === "'" ? "'" : "\"";
+				const inner = qm[2];
+				rawPath = inner;
+				pathNode = new _jesscss_core.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 _jesscss_core.JsImport({ path: pathNode }, { namespace: ns }, loc);
+		}
+		return new _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Reference({ key: k }, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, loc);
+			return new _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.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 _jesscss_core.Reference({
+									target: argBase,
+									key: argAccKey
+								}, {}, loc);
+							}
+							argsNode = new _jesscss_core.List([argBase], void 0, loc);
+						}
+					}
+					const callPayload = { name: base };
+					if (argsNode) callPayload.args = argsNode;
+					base = new _jesscss_core.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 _jesscss_core.Quoted(accText, {}, loc);
+				base = new _jesscss_core.Reference({
+					target: base,
+					key: accessorKey
+				}, {}, loc);
+				const afterAcc = afterVal.slice(accMatch[0].length).trimStart();
+				if (/^\(\s*\)/.test(afterAcc)) base = new _jesscss_core.Call({ name: base }, {}, loc);
+			} else if (!hasMidCall) {
+				if (/^\(\s*\)/.exec(afterVal)) base = new _jesscss_core.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 = require_grammar.lessGrammar;
+	const result = (0, _jesscss_css_parser_jess.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: (0, _jesscss_core.nil)(),
+			errors: [(0, _jesscss_css_parser_jess.toParseError)("Inline JavaScript using backticks is not supported. Use @use / @-use to import a script module instead.", backtick, text)],
+			warnings: [],
+			trivia: (0, _jesscss_css_parser_jess.buildLazyTriviaMap)([], text),
+			liftedCommentRanges: [],
+			context: options?.context
+		};
+		return parseLessFn(text, rule, this._mathMode, options?.context);
+	};
+};
+//#endregion
+Object.defineProperty(exports, "Fragments", {
+	enumerable: true,
+	get: function() {
+		return Fragments;
+	}
+});
+Object.defineProperty(exports, "LessGrammar", {
+	enumerable: true,
+	get: function() {
+		return LessGrammar;
+	}
+});
+Object.defineProperty(exports, "LessParser", {
+	enumerable: true,
+	get: function() {
+		return LessParser;
+	}
+});
+Object.defineProperty(exports, "Tokens", {
+	enumerable: true,
+	get: function() {
+		return Tokens;
+	}
+});
+Object.defineProperty(exports, "createInterpolatedReference", {
+	enumerable: true,
+	get: function() {
+		return createInterpolatedReference;
+	}
+});
+Object.defineProperty(exports, "getInterpolatedNode", {
+	enumerable: true,
+	get: function() {
+		return getInterpolatedNode;
+	}
+});
+Object.defineProperty(exports, "getInterpolatedOrString", {
+	enumerable: true,
+	get: function() {
+		return getInterpolatedOrString;
+	}
+});
+Object.defineProperty(exports, "lessFragments", {
+	enumerable: true,
+	get: function() {
+		return lessFragments;
+	}
+});
+Object.defineProperty(exports, "lessTokens", {
+	enumerable: true,
+	get: function() {
+		return lessTokens;
+	}
+});
+Object.defineProperty(exports, "normalizeMixinReferenceKey", {
+	enumerable: true,
+	get: function() {
+		return normalizeMixinReferenceKey;
+	}
+});
+Object.defineProperty(exports, "parseLessFn", {
+	enumerable: true,
+	get: function() {
+		return parseLessFn;
+	}
+});