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

package/lib/jess.js

@@ -0,0 +1,3962 @@
+import { a as getInterpolatedNode, d as lessTokens, i as createInterpolatedReference, n as parseLessFn, o as getInterpolatedOrString, r as LessGrammar, s as normalizeMixinReferenceKey, t as LessParser, u as lessFragments } from "./functional-parser.js";
+import { createLexerDefinition } from "@jesscss/css-parser";
+import { CssRecursiveParser, productions } from "@jesscss/css-parser/jess";
+import { Ampersand, Any, AtRuleStatement, AttributeSelector, BasicSelector, Block, Bool, Call, Collection, Combinator, ComplexSelector, CompoundSelector, Condition, Declaration, DefaultGuard, Dimension, Expression, Extend, For, INTERPOLATION_PLACEHOLDER, Interpolated, InterpolatedSelector, JsImport, Keyword, List, Mixin, N, Negative, Nil, Node, Num, Operation, Paren, QueryCondition, Quoted, Reference, Rest, Rules, Ruleset, Selector, SelectorCapture, SelectorList, Sequence, StyleImport, Url, VarDeclaration, isNode, nil, shouldOperateWithMathFrames } from "@jesscss/core";
+import { Lexer, NoViableAltException, tokenMatcher } from "chevrotain";
+import { all } from "known-css-properties";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/productions/root.ts
+const cssMain = productions.main;
+const cssDeclaration = productions.declaration;
+productions.mediaTypeQuery;
+function extendWithSelector$1(node, selector, context) {
+	return new Extend({
+		selector,
+		target: node.target,
+		namespace: node.namespace,
+		flag: node.flag
+	}, void 0, node.location, context);
+}
+function prependRules(rules, nodes, context) {
+	const out = new Rules([...nodes, ...rules.rules], rules.options, rules.location.length ? rules.location : void 0, context);
+	out._location = rules._location;
+	return out;
+}
+function getParenFrames$2(ctx) {
+	return ctx?.parenFrames ?? [];
+}
+function getCalcFrames(ctx) {
+	return ctx?.calcFrames ?? 0;
+}
+function guardContainsDefaultCall(node) {
+	if (!node) return false;
+	const isNodeLike = (value) => {
+		return Boolean(value && typeof value === "object" && "type" in value && typeof value.type === "string" && "valueOf" in value && typeof value.valueOf === "function");
+	};
+	const queue = [node];
+	const seen = /* @__PURE__ */ new Set();
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (!current || seen.has(current) || !isNodeLike(current)) continue;
+		seen.add(current);
+		if (current.type === "DefaultGuard") return true;
+		if (isNode(current, N.Call)) {
+			const callName = current.name;
+			const callNameStr = String(typeof callName === "object" && callName !== null && "valueOf" in callName ? callName.valueOf() : callName ?? "");
+			if (callNameStr === "default" || callNameStr === "??") return true;
+			if (callName instanceof Reference) {
+				const key = callName.key;
+				const keyStr = String(typeof key === "object" && key !== null && "valueOf" in key ? key.valueOf() : key ?? "");
+				if (keyStr === "default" || keyStr === "??") return true;
+			}
+		}
+		if ("data" in current) {
+			const value = current.data;
+			if (Array.isArray(value)) queue.push(...value);
+			else if (value && typeof value === "object") queue.push(...Object.values(value));
+		}
+	}
+	return false;
+}
+function loc(node) {
+	const location = node.location;
+	return location.length === 6 ? location : void 0;
+}
+function wrapAtRulePreludeExpression(node, ctx) {
+	if (!this.wrapOuterExpressions || ctx?.atRulePreludeBareVariableAs !== "index") return node;
+	if (node instanceof Expression) return node;
+	if (isNode(node, N.Reference) && !node.target && typeof node.key === "string") return node;
+	return new Expression(node, void 0, loc(node), this.context);
+}
+function wrapOuterExpressionIfNeeded(node, ctx) {
+	if (!this.wrapOuterExpressions) return node;
+	if (!ctx?.wrapInExpression) return node;
+	if (node instanceof Expression) return node;
+	if (isNode(node, N.Operation)) {
+		if (shouldOperateWithMathFrames({
+			mathMode: this.mathMode ?? "parens-division",
+			parenFrames: getParenFrames$2(ctx),
+			calcFrames: getCalcFrames(ctx)
+		}, node.operator, node.left, node.right)) return new Expression(node, { parens: true }, loc(node), this.context);
+	}
+	return node;
+}
+function isEscapedString($, T) {
+	const next = $.LA(1);
+	return next.image.startsWith("~") && ($.matchToken(next, T.QuoteStart) || $.matchToken(next, T.DoubleQuoteStart) || $.matchToken(next, T.SingleQuoteStart));
+}
+function startsLessMediaQueryReference($, T) {
+	if ($.isType(T.AtName) || $.isType(T.PropertyReference) || $.isType(T.NestedReference) || $.isType(T.DotName) || $.isType(T.HashName) || $.isType(T.InterpolatedIdent) || $.isType(T.InterpolatedSelector)) return true;
+	if (!$.isType(T.ColorIdentStart)) return false;
+	const tt2 = $.LA(2).tokenType;
+	return tt2 === T.Gt || tt2 === T.DotName || tt2 === T.HashName || tt2 === T.InterpolatedSelector || $.noSep(1) && (tt2 === T.LParen || tt2 === T.LSquare || tt2 === T.HashName || tt2 === T.DotName);
+}
+function startsCustomValue($, T) {
+	return $.isType(T.LParen) || $.isType(T.FunctionStart) || $.isType(T.FunctionalPseudoClass) || $.isType(T.LSquare) || $.isType(T.LCurly) || $.isType(T.SingleQuoteStart) || $.isType(T.DoubleQuoteStart) || $.isType(T.Value) || $.isType(T.PlainIdent) || $.isType(T.AtKeyword) || $.isType(T.PropertyReference) || $.isType(T.CustomProperty) || $.isType(T.Dimension) || $.isType(T.Number) || $.isType(T.Color) || $.isType(T.UnicodeRange) || $.isType(T.Colon) || $.isType(T.Comma) || $.isType(T.Important) || $.isType(T.Unknown);
+}
+function isVariableLike($, T) {
+	let token = $.LA(2);
+	let isColon = token.tokenType === T.Colon;
+	let isParen = token.tokenType === T.LParen;
+	let postToken = $.LA(3);
+	if (!$.trivia) return false;
+	if (!isColon && !isParen) return false;
+	if (isParen && $.matchToken($.LA(1), T.AtName) && $.LA(1).tokenType !== T.AtKeyword) {
+		if (postToken.tokenType === T.RParen) {
+			$.warnDeprecation("Using known at-rule names as variables is deprecated", $.LA(1), "at-rule-variable");
+			return true;
+		}
+		return false;
+	}
+	return !$.trivia.has(token.startOffset, "before") || isColon && $.trivia.has(postToken.startOffset, "before");
+}
+const { isArray: isArray$1 } = Array;
+/**
+* Groups extends by target (using valueOf()) and flag.
+* Returns an array of grouped Extend nodes where extends with the same target and flag
+* are combined into a single Extend node with a SelectorList of all matching value.
+*
+* @todo Group complex value into selector lists
+*/
+function groupExtendsByTargetAndFlag(extendNodes) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const ext of extendNodes) {
+		const { target, flag = 1 } = ext;
+		const key = `${target.valueOf()}|${flag}`;
+		let group = groups.get(key);
+		if (!group) groups.set(key, ext);
+		else if (isArray$1(group)) group.push(ext);
+		else groups.set(key, [group, ext]);
+	}
+	return Array.from(groups.values());
+}
+/** Charset moved within `main` (explained in that rule) */
+function stylesheet(T) {
+	const $ = this;
+	return (options = {}) => {
+		let context;
+		if (options.context) context = $.context = options.context;
+		else context = $.context;
+		let charset;
+		if (!$.looseMode) $.OPTION(() => {
+			charset = $.CONSUME(T.Charset);
+		});
+		let root = $.SUBRULE($.main, { ARGS: [{ isRoot: true }] });
+		if (charset && isNode(root, N.Rules)) {
+			let charsetLoc = $.getLocationInfo(charset);
+			root = new Rules([new Any(charset.image, { role: "charset" }, charsetLoc, context), ...root.rules], root.options, root.location.length ? root.location : void 0, context);
+			let rootLoc = root.location;
+			rootLoc[0] = charsetLoc[0];
+			rootLoc[1] = charsetLoc[1];
+			rootLoc[2] = charsetLoc[2];
+		}
+		return root;
+	};
+}
+/**
+* Starts with a colon, with these conditions
+*  1. It is not preceded by a space or
+*  2. If it is preceded by a space, then it is
+*     followed by a space.
+*/
+function main(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const isAmpersandExtendStart = () => $.LA(1).tokenType === T.Ampersand && $.LA(2).tokenType === T.Extend;
+		const isMixinOrQualifiedStart = () => {
+			const next = $.LA(1).tokenType;
+			return next === T.DotName || next === T.HashName || next === T.ColorIdentStart;
+		};
+		const isCustomPropertyStart = () => $.isType(T.InterpolatedCustomProperty) || $.isType(T.CustomProperty);
+		const isAtRuleStart = () => $.matchToken($.LA(1), T.AtName);
+		const shouldTryQualifiedRule = () => !isCustomPropertyStart() && !isMixinOrQualifiedStart() && !isAtRuleStart() && $.shouldTryQualifiedRuleInDeclarationList();
+		const ruleAlt = (ctx = {}) => {
+			let isVariable = isVariableLike($, T);
+			return [
+				{ ALT: () => $.SUBRULE($.functionCall, { ARGS: [ctx] }) },
+				{
+					GATE: isAmpersandExtendStart,
+					ALT: () => $.SUBRULE2($.ampersandExtend, { ARGS: [ctx] })
+				},
+				{
+					GATE: isMixinOrQualifiedStart,
+					ALT: () => $.SUBRULE3($.mixinOrQualifiedRule, { ARGS: [ctx] })
+				},
+				{
+					GATE: () => isVariable,
+					ALT: () => $.SUBRULE4($.varDeclarationOrCall, { ARGS: [ctx] })
+				},
+				{
+					GATE: () => !isVariable && isAtRuleStart(),
+					ALT: () => $.SUBRULE5($.atRule, { ARGS: [ctx] })
+				},
+				{
+					GATE: isCustomPropertyStart,
+					ALT: () => $.SUBRULE7($.declaration, { ARGS: [ctx] })
+				},
+				{
+					GATE: shouldTryQualifiedRule,
+					ALT: () => $.SUBRULE6($.qualifiedRule, { ARGS: [ctx] })
+				},
+				(
+				/**
+				* Historically, Less allows `@charset` anywhere,
+				* to avoid outputting it in the wrong place.
+				* Ideally, this would result in an error if, say,
+				* the `@charset` was defined at the bottom of the file,
+				* but that wasn't the solution made.
+				* @see https://github.com/less/less.js/issues/2126
+				*/
+				{
+					GATE: () => $.looseMode,
+					ALT: () => $.CONSUME(T.Charset)
+				}),
+				{ ALT: () => $.CONSUME(T.Semi) }
+			];
+		};
+		let RECORDING_PHASE = $.RECORDING_PHASE;
+		let context;
+		let rules;
+		if (!RECORDING_PHASE) {
+			context = $.context;
+			rules = [];
+		}
+		let requiredSemi = false;
+		let lastRule;
+		/**
+		* In this production rule, semi-colons are not required
+		* but this is repurposed by declarationList and by Less / Sass,
+		* so that's why this gate is here.
+		*/
+		$.MANY({
+			GATE: () => {
+				const next = $.LA(1);
+				if ($.isType(T.RCurly) || next.tokenType.name === "EOF") return false;
+				return !requiredSemi || requiredSemi && ($.isType(T.Semi) || $.isTypeAt(0, T.Semi));
+			},
+			DEF: () => {
+				const localAlt = ruleAlt(ctx);
+				let value = $.OR(localAlt);
+				if (!RECORDING_PHASE) {
+					/** @todo - When do we not have a value? */
+					if (value) if (!(value instanceof Node)) {
+						/** This is a semi-colon or charset token */
+						let tok = value;
+						if (tok.image.includes("@charset")) rules.push(new Any(tok.image, { role: "charset" }, $.getLocationInfo(tok), context));
+						else if (lastRule) lastRule.options.semi = true;
+						else rules.push(new Any(";", { role: "semi" }, $.getLocationInfo($.LA(1)), context));
+					} else {
+						requiredSemi = !!value.requiredSemi;
+						rules.push(value);
+						lastRule = value;
+					}
+				}
+			}
+		});
+		if (RECORDING_PHASE) return;
+		if (ctx.extendNodes && ctx.extendNodes.length > 0) {
+			const filteredRules = rules.filter((r) => !(r instanceof Nil));
+			rules = [...ctx.extendNodes, ...filteredRules];
+			ctx.extendNodes = void 0;
+		}
+		return $.getRulesWithComments(rules, $.getLocationInfo($.LA(1)));
+	};
+}
+function declarationList(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const isMixinOrQualifiedStart = () => {
+			const next = $.LA(1).tokenType;
+			return next === T.DotName || next === T.HashName || next === T.ColorIdentStart;
+		};
+		const isCustomPropertyStart = () => $.isType(T.InterpolatedCustomProperty) || $.isType(T.CustomProperty);
+		const isAtRuleStart = () => $.matchToken($.LA(1), T.AtName);
+		const isAmpersandExtendStart = () => $.LA(1).tokenType === T.Ampersand && $.LA(2).tokenType === T.Extend;
+		const shouldTryQualifiedRule = () => !isCustomPropertyStart() && !isMixinOrQualifiedStart() && !isAtRuleStart() && $.shouldTryQualifiedRuleInDeclarationList();
+		const ruleAlt = (ctx = {}) => {
+			const isVariable = isVariableLike($, T);
+			return [
+				{
+					GATE: isMixinOrQualifiedStart,
+					ALT: () => {
+						return $.SUBRULE($.mixinOrQualifiedRule, { ARGS: [{
+							...ctx,
+							inner: true
+						}] });
+					}
+				},
+				{
+					GATE: () => isVariable,
+					ALT: () => $.SUBRULE2($.varDeclarationOrCall, { ARGS: [ctx] })
+				},
+				{
+					GATE: () => !isVariable && isAtRuleStart(),
+					ALT: () => $.SUBRULE3($.innerAtRule, { ARGS: [ctx] })
+				},
+				{
+					GATE: isAmpersandExtendStart,
+					ALT: () => $.SUBRULE4($.ampersandExtend, { ARGS: [ctx] })
+				},
+				{
+					GATE: () => $.check(T.FunctionStart),
+					ALT: () => {
+						const fnCall = $.SUBRULE5($.functionCall, { ARGS: [ctx] });
+						if (fnCall instanceof Call) fnCall.requiredSemi = false;
+						return fnCall;
+					}
+				},
+				{
+					GATE: isCustomPropertyStart,
+					ALT: () => $.SUBRULE8($.declaration, { ARGS: [ctx] })
+				},
+				{
+					GATE: shouldTryQualifiedRule,
+					ALT: () => {
+						return $.SUBRULE6($.qualifiedRule, { ARGS: [{
+							...ctx,
+							inner: true
+						}] });
+					}
+				},
+				{ ALT: () => {
+					return $.SUBRULE7($.declaration, { ARGS: [ctx] });
+				} },
+				{ ALT: () => $.CONSUME(T.Semi) }
+			];
+		};
+		return cssMain.call($, T, ruleAlt)(ctx);
+	};
+}
+function declaration(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const normalizeLessAssignToken = (assign) => {
+			if (assign.tokenType === T.PlusAssign) return {
+				...assign,
+				image: "+,:"
+			};
+			if (assign.tokenType === T.UnderscoreAssign) return {
+				...assign,
+				image: "+_:"
+			};
+			return assign;
+		};
+		const customPropertyAlt = (consumeName, occurrence) => ({ ALT: () => {
+			let nodes;
+			if (!$.RECORDING_PHASE) nodes = [];
+			const name = consumeName();
+			const assign = normalizeLessAssignToken(occurrence === 2 ? $.CONSUME2(T.Assign) : $.CONSUME3(T.Assign));
+			$.startRule();
+			while (startsCustomValue($, T)) {
+				const val = occurrence === 2 ? $.SUBRULE2($.customValue, { ARGS: [{
+					...ctx,
+					inCustomPropertyValue: true
+				}] }) : $.SUBRULE3($.customValue, { ARGS: [{
+					...ctx,
+					inCustomPropertyValue: true
+				}] });
+				if (!$.RECORDING_PHASE) nodes.push(val);
+			}
+			if (!$.RECORDING_PHASE) {
+				const location = $.endRule();
+				let nameNode;
+				const nameValue = name.image;
+				if (nameValue.includes("@") || nameValue.includes("$")) nameNode = getInterpolatedNode(nameValue, $.getLocationInfo(name), $.context);
+				else nameNode = new Any(name.image, { role: "property" }, $.getLocationInfo(name), $.context);
+				const value = new Sequence(nodes, void 0, location, $.context);
+				return [
+					nameNode,
+					assign,
+					value
+				];
+			}
+		} });
+		const ruleAlt = (ctx = {}) => [
+			{ ALT: () => {
+				let name;
+				$.OR2([{ ALT: () => {
+					name = $.CONSUME(T.Ident);
+				} }, {
+					GATE: () => $.legacyMode,
+					ALT: () => name = $.CONSUME(T.LegacyPropIdent)
+				}]);
+				const assign = normalizeLessAssignToken($.CONSUME(T.Assign));
+				let value;
+				if ($.looseMode) {
+					$.OPTION2({
+						GATE: () => !($.isType(T.Semi) || $.isType(T.RCurly)),
+						DEF: () => {
+							value = $.SUBRULE($.valueList, { ARGS: [ctx] });
+						}
+					});
+					if (!$.RECORDING_PHASE && !value) value = new Sequence([], void 0, void 0, $.context);
+				} else value = $.SUBRULE($.valueList, { ARGS: [ctx] });
+				let important;
+				$.OPTION(() => {
+					important = $.CONSUME(T.Important);
+				});
+				if (!$.RECORDING_PHASE) {
+					let nameNode;
+					const nameValue = name.image;
+					if (nameValue.includes("@") || nameValue.includes("$")) nameNode = getInterpolatedNode(nameValue, $.getLocationInfo(name), $.context);
+					else nameNode = new Any(name.image, { role: "property" }, $.getLocationInfo(name), $.context);
+					return [
+						nameNode,
+						assign,
+						value,
+						important
+					];
+				}
+			} },
+			customPropertyAlt(() => $.CONSUME(T.InterpolatedCustomProperty), 2),
+			customPropertyAlt(() => $.CONSUME(T.CustomProperty), 3)
+		];
+		return cssDeclaration.call($, T, ruleAlt)(ctx);
+	};
+}
+function mediaInParens(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		$.CONSUME(T.LParen);
+		const node = $.OR([
+			{
+				GATE: () => $.startsMediaCondition(T),
+				ALT: () => $.SUBRULE($.mediaCondition, { ARGS: [ctx] })
+			},
+			{
+				GATE: () => isEscapedString($, T),
+				ALT: () => $.SUBRULE($.string, { ARGS: [ctx] })
+			},
+			{
+				GATE: () => $.isType(T.PropertyReference) || $.isType(T.NestedReference) || $.isType(T.AtName) || $.isType(T.HashName) || $.isType(T.DotName) || $.isType(T.ColorIdentStart) || $.isType(T.InterpolatedSelector),
+				ALT: () => {
+					const node = $.SUBRULE2($.valueReference, { ARGS: [{
+						...ctx,
+						requireAccessorsAfterMixinCall: true
+					}] });
+					return wrapAtRulePreludeExpression.call($, node, ctx);
+				}
+			},
+			{ ALT: () => $.SUBRULE($.mediaFeature, { ARGS: [ctx] }) }
+		]);
+		$.CONSUME(T.RParen);
+		if (RECORDING_PHASE) return;
+		return new Paren(node, void 0, $.endRule(), $.context);
+	};
+}
+function mediaQuery(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const preludeCtx = {
+			...ctx,
+			atRulePreludeBareVariableAs: "index"
+		};
+		return $.OR2([
+			{
+				GATE: () => $.startsMediaCondition(T),
+				ALT: () => $.SUBRULE($.mediaConditionWithoutOr, { ARGS: [preludeCtx] })
+			},
+			{
+				GATE: () => isEscapedString($, T),
+				ALT: () => $.SUBRULE($.lessMediaQueryFromString, { ARGS: [preludeCtx] })
+			},
+			{
+				GATE: () => startsLessMediaQueryReference($, T),
+				ALT: () => $.SUBRULE2($.lessMediaQueryFromReference, { ARGS: [preludeCtx] })
+			},
+			{ ALT: () => $.SUBRULE7($.mediaTypeQuery, { ARGS: [preludeCtx] }) }
+		]);
+	};
+}
+function mediaCondition(T) {
+	const $ = this;
+	return (ctx = {}) => $.SUBRULE($.mediaConditionWithoutOr, { ARGS: [ctx] });
+}
+function lessMediaQueryFromString(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const first = $.SUBRULE($.string, { ARGS: [ctx] });
+		return $.SUBRULE($.lessMediaQueryTail, { ARGS: [{
+			...ctx,
+			startValue: first
+		}] });
+	};
+}
+function lessMediaQueryFromReference(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const first = $.SUBRULE($.valueReference, { ARGS: [{
+			...ctx,
+			requireAccessorsAfterMixinCall: true
+		}] });
+		return $.SUBRULE2($.lessMediaQueryTail, { ARGS: [{
+			...ctx,
+			startValue: wrapAtRulePreludeExpression.call($, first, ctx)
+		}] });
+	};
+}
+function lessMediaQueryTail(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		let nodes;
+		if (!RECORDING_PHASE) nodes = [ctx.startValue];
+		$.MANY({
+			GATE: () => $.isType(T.And),
+			DEF: () => {
+				const andToken = $.CONSUME(T.And);
+				const next = $.OR([
+					{
+						GATE: () => isEscapedString($, T),
+						ALT: () => $.SUBRULE2($.string, { ARGS: [ctx] })
+					},
+					{
+						GATE: () => startsLessMediaQueryReference($, T),
+						ALT: () => {
+							const next = $.SUBRULE2($.valueReference, { ARGS: [{
+								...ctx,
+								requireAccessorsAfterMixinCall: true
+							}] });
+							return wrapAtRulePreludeExpression.call($, next, ctx);
+						}
+					},
+					{
+						GATE: () => $.startsMediaCondition(T),
+						ALT: () => $.SUBRULE2($.mediaConditionWithoutOr, { ARGS: [ctx] })
+					},
+					{ ALT: () => $.SUBRULE2($.mediaType, { ARGS: [ctx] }) }
+				]);
+				if (!RECORDING_PHASE) {
+					nodes.push(new Keyword(andToken.image, void 0, $.getLocationInfo(andToken), $.context));
+					nodes.push(next);
+				}
+			}
+		});
+		if (RECORDING_PHASE) return;
+		const location = $.endRule();
+		if (nodes.length === 1) return nodes[0];
+		return new QueryCondition(nodes, void 0, location, $.context);
+	};
+}
+function mediaConditionWithoutOr(T) {
+	const $ = this;
+	return (ctx = {}) => $.OR([{ ALT: () => $.SUBRULE($.mediaNot, { ARGS: [ctx] }) }, { ALT: () => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		let nodes;
+		if (!RECORDING_PHASE) nodes = [];
+		const node = $.SUBRULE($.mediaInParens, { ARGS: [ctx] });
+		if (!RECORDING_PHASE) nodes.push(node);
+		$.MANY({
+			GATE: () => $.isType(T.And),
+			DEF: () => {
+				const rule = $.SUBRULE($.mediaAnd, { ARGS: [ctx] });
+				if (!RECORDING_PHASE) nodes.push(...rule);
+			}
+		});
+		if (RECORDING_PHASE) return;
+		if (nodes.length === 1) {
+			$.endRule();
+			return nodes[0];
+		}
+		return new QueryCondition(nodes, void 0, $.endRule(), $.context);
+	} }]);
+}
+function mediaFeature(T) {
+	const $ = this;
+	function createFeatureIdentNode(token, role) {
+		const location = $.getLocationInfo(token);
+		const resolved = getInterpolatedOrString(token.image, location, $.context);
+		if (typeof resolved === "string") return new Any(resolved, { role }, location, $.context);
+		return resolved;
+	}
+	return (ctx = {}) => $.OR([{
+		GATE: () => {
+			return $.isType(T.InterpolatedIdent) || $.isType(T.Ident);
+		},
+		ALT: () => {
+			const RECORDING_PHASE = $.RECORDING_PHASE;
+			$.startRule();
+			let rule;
+			const ident = $.LA(1).tokenType === T.InterpolatedIdent ? $.CONSUME(T.InterpolatedIdent) : $.CONSUME(T.Ident);
+			$.OPTION(() => {
+				rule = $.OR2([
+					{ ALT: () => {
+						$.CONSUME(T.Colon);
+						const value = $.SUBRULE($.mfValue, { ARGS: [ctx] });
+						if (!RECORDING_PHASE) {
+							const location = $.endRule();
+							const featureName = createFeatureIdentNode(ident, "property");
+							return new Declaration({
+								name: featureName instanceof Any ? String(featureName.valueOf()) : featureName,
+								value
+							}, void 0, location, $.context);
+						}
+					} },
+					{
+						GATE: () => ($.isTypeAt(1, T.MfLt) || $.isTypeAt(1, T.MfGt)) && ($.isTypeAt(2, T.Ident) || $.isTypeAt(2, T.InterpolatedIdent)),
+						ALT: () => {
+							const seq = $.SUBRULE($.mediaRange, { ARGS: [ctx] });
+							if (!RECORDING_PHASE) {
+								const [startOffset, startLine, startColumn] = $.endRule();
+								seq.value.unshift(createFeatureIdentNode(ident, "ident"));
+								seq.location.start = startOffset;
+								seq.location[1] = startLine;
+								seq.location[2] = startColumn;
+								return new QueryCondition(seq.value, void 0, seq.location, $.context);
+							}
+							return seq;
+						}
+					},
+					{
+						GATE: () => $.isTypeAt(1, T.MfLt) || $.isTypeAt(1, T.MfGt) || $.LA(1).tokenType === T.Eq,
+						ALT: () => {
+							const op = $.SUBRULE($.mfComparison, { ARGS: [ctx] });
+							const value = $.SUBRULE($.mfNonIdentifierValue, { ARGS: [ctx] });
+							if (!RECORDING_PHASE) {
+								const location = $.endRule();
+								return new QueryCondition([
+									createFeatureIdentNode(ident, "ident"),
+									new Any(op.image, { role: "operator" }, $.getLocationInfo(op), $.context),
+									value
+								], void 0, location, $.context);
+							}
+						}
+					}
+				]);
+			});
+			if (!RECORDING_PHASE && !rule) {
+				const location = $.endRule();
+				return new QueryCondition([createFeatureIdentNode(ident, "ident")], void 0, location, $.context);
+			}
+			return rule;
+		}
+	}, { ALT: () => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		const left = $.SUBRULE2($.mfNonIdentifierValue, { ARGS: [{ ...ctx }] });
+		return $.OR3([{
+			GATE: () => {
+				const tt2 = $.LA(2).tokenType;
+				if (!(($.isTypeAt(1, T.MfLt) || $.isTypeAt(1, T.MfGt) || $.LA(1).tokenType === T.Eq) && (tt2 === T.Ident || tt2 === T.InterpolatedIdent))) return false;
+				if ($.isTypeAt(3, T.MfLt) || $.isTypeAt(3, T.MfGt)) return false;
+				return true;
+			},
+			ALT: () => {
+				const op = $.SUBRULE2($.mfComparison, { ARGS: [{ ...ctx }] });
+				const value = $.LA(1).tokenType === T.Ident ? $.CONSUME2(T.Ident) : $.CONSUME2(T.InterpolatedIdent);
+				if (!RECORDING_PHASE) {
+					const location = $.endRule();
+					return new QueryCondition([
+						left,
+						new Any(op.image, { role: "operator" }, $.getLocationInfo(op), $.context),
+						createFeatureIdentNode(value, "ident")
+					], void 0, location, $.context);
+				}
+			}
+		}, { ALT: () => {
+			const seq = $.SUBRULE2($.mediaRange, { ARGS: [{ ...ctx }] });
+			if (!RECORDING_PHASE) {
+				const [startOffset, startLine, startColumn] = $.endRule();
+				seq.value.unshift(left);
+				seq.location.start = startOffset;
+				seq.location[1] = startLine;
+				seq.location[2] = startColumn;
+				return new QueryCondition(seq.value, void 0, seq.location, $.context);
+			}
+			return seq;
+		} }]);
+	} }]);
+}
+function mfValue(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		/**
+		* Like the original Less Parser, we're
+		* going to allow any value expression,
+		* and it's up to the Less author to know
+		* if it's valid.
+		*/
+		const exprCtx = {
+			...ctx,
+			wrapInExpression: true
+		};
+		const node = $.SUBRULE($.expressionSum, { ARGS: [exprCtx] });
+		return wrapOuterExpressionIfNeeded.call($, node, exprCtx);
+	};
+}
+function mfNonIdentifierValue(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		return $.OR2([
+			{
+				GATE: () => {
+					const next = $.LA(1);
+					return next.tokenType === T.AtKeyword || next.tokenType === T.PropertyReference || next.tokenType === T.NestedReference;
+				},
+				ALT: () => {
+					const node = $.SUBRULE($.valueReference, { ARGS: [{
+						...ctx,
+						requireAccessorsAfterMixinCall: true
+					}] });
+					return wrapAtRulePreludeExpression.call($, node, ctx);
+				}
+			},
+			{ ALT: () => {
+				$.startRule();
+				let num1 = $.CONSUME(T.Number);
+				let num2;
+				$.OPTION(() => {
+					$.CONSUME(T.Slash);
+					num2 = $.CONSUME2(T.Number);
+				});
+				let location = $.endRule();
+				let num1Node = $.processValueToken(num1);
+				if (!num2) return num1Node;
+				return new List([num1Node, $.processValueToken(num2)], { sep: "/" }, location, $.context);
+			} },
+			{ ALT: () => {
+				let dim = $.CONSUME(T.Dimension);
+				return $.processValueToken(dim);
+			} }
+		]);
+	};
+}
+function wrappedDeclarationList(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.CONSUME(T.LCurly);
+		let rules = $.SUBRULE($.declarationList, { ARGS: [ctx] });
+		$.CONSUME(T.RCurly);
+		return rules;
+	};
+}
+function qualifiedRuleBody(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		let selector;
+		let isSelectorList;
+		selector = ctx.selector;
+		isSelectorList = typeof ctx.isSelectorList === "boolean" ? ctx.isSelectorList : selector instanceof SelectorList;
+		let guard;
+		if (!isSelectorList) $.OPTION(() => {
+			guard = $.SUBRULE($.guard, { ARGS: [ctx] });
+		});
+		$.CONSUME(T.LCurly);
+		let savedExtendNodes;
+		if (!$.RECORDING_PHASE) {
+			savedExtendNodes = ctx.extendNodes ? [...ctx.extendNodes] : void 0;
+			ctx.extendNodes = void 0;
+		}
+		let rules = $.SUBRULE2($.declarationList, { ARGS: [ctx] });
+		let end = $.CONSUME(T.RCurly);
+		if (!$.RECORDING_PHASE) {
+			const newExtends = ctx.extendNodes;
+			if (newExtends && newExtends.length) if (savedExtendNodes && savedExtendNodes.length > 0) ctx.extendNodes = [...savedExtendNodes, ...newExtends];
+			else ctx.extendNodes = newExtends;
+			else ctx.extendNodes = savedExtendNodes;
+			let extend = ctx.extendNodes;
+			if (extend?.length)
+ /** If it's not a selector list, then our only extend does not need to be grouped */
+			if (!isSelectorList) {
+				/** For extends inside rulesets (not bubbled), selector should be undefined
+				* so it defaults to ampersand and resolves to the ruleset's selector */
+				extend = extend.map((e) => extendWithSelector$1(e, void 0, $.context));
+				rules = prependRules(rules, extend, $.context);
+				ctx.extendNodes = void 0;
+			} else {
+				const selectorList = selector instanceof SelectorList ? selector : void 0;
+				if (!selectorList) return;
+				const selectorCount = selectorList.value.length;
+				const extendCount = extend.length;
+				let shouldBubble = false;
+				if (extendCount < selectorCount) shouldBubble = true;
+				else if (extendCount === selectorCount) {
+					let finalExtends = groupExtendsByTargetAndFlag(extend);
+					if (finalExtends.length === 1) {
+						let extendNodes = finalExtends[0];
+						let finalExtend = isArray$1(extendNodes) ? extendNodes[0] : extendNodes;
+						finalExtend = extendWithSelector$1(finalExtend, void 0, $.context);
+						rules = prependRules(rules, [finalExtend], $.context);
+						ctx.extendNodes = void 0;
+					} else shouldBubble = true;
+				} else shouldBubble = true;
+				if (shouldBubble) {}
+			}
+			const hasDefault = Boolean(ctx.hasDefault);
+			let node = new Ruleset({
+				selector,
+				rules: rules.rules,
+				guard
+			}, guard && hasDefault ? { hasDefault } : void 0, void 0, $.context);
+			ctx.hasDefault = false;
+			let [startOffset, startLine, startColumn] = selector.location;
+			let { endOffset, endLine, endColumn } = end;
+			node._location = [
+				startOffset,
+				startLine,
+				startColumn,
+				endOffset,
+				endLine,
+				endColumn
+			];
+			return node;
+		}
+	};
+}
+function qualifiedRule(T) {
+	const $ = this;
+	return (ctx = {}, altContext) => {
+		let selectorAlt = altContext ?? ((ctx) => [{
+			GATE: () => !ctx.inner,
+			ALT: () => {
+				let initialQualifiedRule = ctx.qualifiedRule;
+				ctx.qualifiedRule = true;
+				try {
+					return $.SUBRULE($.selectorList, { ARGS: [ctx] });
+				} finally {
+					ctx.qualifiedRule = initialQualifiedRule;
+				}
+			}
+		}, {
+			GATE: () => !!ctx.inner,
+			ALT: () => {
+				let initialQualifiedRule = ctx.qualifiedRule;
+				let initialFirstSelector = ctx.firstSelector;
+				ctx.firstSelector = true;
+				ctx.qualifiedRule = true;
+				try {
+					return $.SUBRULE2($.forgivingSelectorList, { ARGS: [ctx] });
+				} finally {
+					ctx.qualifiedRule = initialQualifiedRule;
+					ctx.firstSelector = initialFirstSelector;
+				}
+			}
+		}]);
+		let savedExtendNodes = ctx.extendNodes ? [...ctx.extendNodes] : void 0;
+		ctx.extendNodes = void 0;
+		let selector = $.OR(selectorAlt(ctx));
+		ctx.selector = selector;
+		let thisExtendNodes = ctx.extendNodes ? [...ctx.extendNodes] : void 0;
+		ctx.extendNodes = void 0;
+		let rule = $.SUBRULE3($.qualifiedRuleBody, { ARGS: [ctx] });
+		const bubblingExtends = ctx.extendNodes;
+		ctx.extendNodes = thisExtendNodes;
+		let parentExtendNodes = savedExtendNodes;
+		if (ctx.extendNodes) {
+			let qRuleset = rule;
+			for (const extendNode of ctx.extendNodes) {
+				const { selector: extendSelector } = extendNode;
+				if (extendSelector === void 0 || extendSelector instanceof Ampersand) {
+					const index = ctx.extendNodes.indexOf(extendNode);
+					ctx.extendNodes[index] = extendWithSelector$1(extendNode, selector, $.context);
+				}
+			}
+			/** Prepend a rules block */
+			rule = new Rules([...ctx.extendNodes, qRuleset]);
+			if (qRuleset._location) rule._location = qRuleset._location;
+			ctx.extendNodes = void 0;
+		}
+		if (bubblingExtends && bubblingExtends.length > 0) if (parentExtendNodes && parentExtendNodes.length > 0) ctx.extendNodes = [...parentExtendNodes, ...bubblingExtends];
+		else ctx.extendNodes = bubblingExtends;
+		else ctx.extendNodes = parentExtendNodes;
+		return rule;
+	};
+}
+/**
+* In order to not do any backtracking, anything with a class or id selector start
+* will end up here, and everything else will be shunted to the qualified rule.
+*/
+function mixinOrQualifiedRule(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const convertArgsForDefinition = (args) => {
+			if (!args || !args.value.length) return;
+			for (let i = 0; i < args.value.length; i++) {
+				const node = args.value[i];
+				const location = node.location.length ? node.location : void 0;
+				if (isNode(node, N.Any) && node.role === "name") {
+					const replacement = new VarDeclaration({
+						name: String(node.valueOf()),
+						value: new Nil(void 0, void 0, location, $.context)
+					}, { paramVar: true }, location, $.context);
+					args.adopt(replacement);
+					args.value[i] = replacement;
+				}
+			}
+		};
+		const convertArgsForCall = (args) => {
+			if (!args || !args.value.length) return;
+			for (let i = 0; i < args.value.length; i++) {
+				const node = args.value[i];
+				const location = node.location.length ? node.location : void 0;
+				let replacement;
+				if (isNode(node, N.Any) && node.role === "name") replacement = new Reference({ key: node.valueOf() }, { type: "variable" }, location, $.context);
+				else if (node instanceof Rest) {
+					const restValue = node.value;
+					if (typeof restValue === "string") replacement = new Rest(new Reference({ key: restValue }, { type: "variable" }, location, $.context), void 0, location, $.context);
+				}
+				if (replacement) {
+					args.adopt(replacement);
+					args.value[i] = replacement;
+				}
+			}
+		};
+		$.startRule();
+		let selector = $.OR([{
+			GATE: () => !ctx.inner,
+			ALT: () => {
+				let initialQualifiedRule = ctx.qualifiedRule;
+				ctx.qualifiedRule = true;
+				try {
+					return $.SUBRULE($.selectorList, { ARGS: [ctx] });
+				} finally {
+					ctx.qualifiedRule = initialQualifiedRule;
+				}
+			}
+		}, {
+			GATE: () => !!ctx.inner,
+			ALT: () => {
+				let initialQualifiedRule = ctx.qualifiedRule;
+				let initialFirstSelector = ctx.firstSelector;
+				ctx.firstSelector = true;
+				ctx.qualifiedRule = true;
+				try {
+					return $.SUBRULE2($.forgivingSelectorList, { ARGS: [ctx] });
+				} finally {
+					ctx.qualifiedRule = initialQualifiedRule;
+					ctx.firstSelector = initialFirstSelector;
+				}
+			}
+		}]);
+		let isSelectorList = selector instanceof SelectorList;
+		let guard;
+		let args;
+		let important;
+		const createMixinCall = (location) => {
+			let leftNode;
+			if (!isSelectorList && (selector instanceof CompoundSelector || selector instanceof BasicSelector || selector instanceof InterpolatedSelector || selector instanceof ComplexSelector)) {
+				const { key, rawKey } = normalizeMixinReferenceKey(selector);
+				leftNode = new Reference({
+					key,
+					rawKey
+				}, {
+					type: "mixin-ruleset",
+					role: "name"
+				}, void 0, $.context);
+			} else for (let s of selector.nodes()) if (s instanceof BasicSelector) leftNode = new Reference({
+				target: leftNode instanceof Reference ? leftNode : leftNode instanceof Call ? leftNode : void 0,
+				key: s.valueOf()
+			}, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, void 0, $.context);
+			/** Finally, pass this reference into a call */
+			leftNode = new Call({
+				name: leftNode,
+				args
+			}, { markImportant: !!important }, location, $.context);
+			return leftNode;
+		};
+		let isPossibleMixinDefinition = selector instanceof BasicSelector && (selector.isClass || selector.isId) || selector instanceof InterpolatedSelector && (selector.isClass || selector.isId);
+		let isPossibleMixinCall = true;
+		if (!$.RECORDING_PHASE && !isSelectorList && !isPossibleMixinDefinition) for (let s of selector.nodes()) {
+			/** Keep going until we get to basic value. */
+			if (s instanceof ComplexSelector || s instanceof CompoundSelector) continue;
+			if (s instanceof BasicSelector && (s.isClass || s.isId) || s instanceof InterpolatedSelector && (s.isClass || s.isId) || s instanceof Combinator && (s.value === ">" || s.value === " ")) continue;
+			isPossibleMixinCall = false;
+			break;
+		}
+		return $.OR2([
+			{
+				GATE: () => (isPossibleMixinDefinition || isPossibleMixinCall) && $.isType(T.LParen),
+				ALT: () => {
+					args = $.SUBRULE3($.mixinArgs, { ARGS: [ctx] });
+					let next = $.LA(1).tokenType;
+					if (next === T.LCurly || next === T.When) isPossibleMixinCall = false;
+					return $.OR3([{
+						GATE: () => isPossibleMixinDefinition,
+						ALT: () => {
+							$.OPTION(() => {
+								guard = $.SUBRULE4($.guard, { ARGS: [ctx] });
+							});
+							$.CONSUME(T.LCurly);
+							let rules = $.SUBRULE5($.declarationList, { ARGS: [ctx] });
+							$.CONSUME(T.RCurly);
+							if (!$.RECORDING_PHASE) {
+								convertArgsForDefinition(args);
+								const guardText = String(guard?.toString?.() ?? "");
+								const hasDefault = Boolean(ctx.hasDefault) || guardContainsDefaultCall(guard) || guardText.includes("??()");
+								const node = new Mixin({
+									name: selector.valueOf(),
+									params: args,
+									rules: rules.rules,
+									guard
+								}, guard && hasDefault ? { hasDefault } : void 0, $.endRule(), $.context);
+								ctx.hasDefault = false;
+								return node;
+							}
+							$.endRule();
+						}
+					}, {
+						GATE: () => isPossibleMixinCall,
+						ALT: () => {
+							$.OPTION2(() => {
+								important = $.CONSUME(T.Important);
+							});
+							let location = $.endRule();
+							if (!$.RECORDING_PHASE) convertArgsForCall(args);
+							let result;
+							{
+								/** in Less legacy mode, mixin calls can happen without a space. */
+								let noSpace = $.noSep();
+								let next = $.LA(1).tokenType;
+								if (noSpace && next === T.LSquare || (noSpace || $.looseMode) && next === T.LParen) result = $.OPTION3(() => $.SUBRULE6($.lookupOrCall, { ARGS: [{
+									...ctx,
+									node: $.RECORDING_PHASE ? void 0 : createMixinCall(location)
+								}] }));
+							}
+							return $.RECORDING_PHASE ? void 0 : result ?? createMixinCall(location);
+						}
+					}]);
+				}
+			},
+			{
+				GATE: () => isPossibleMixinCall && $.isType(T.Semi),
+				ALT: () => {
+					const semi = $.CONSUME(T.Semi);
+					const location = $.endRule();
+					if (!$.RECORDING_PHASE) {
+						$.warnDeprecation("Calling a mixin without parentheses is deprecated", semi, "mixin-call-no-parens");
+						return createMixinCall(location);
+					}
+				}
+			},
+			{ ALT: () => {
+				$.endRule();
+				let initialSelector = ctx.selector;
+				let initialIsSelectorList = ctx.isSelectorList;
+				ctx.selector = selector;
+				ctx.isSelectorList = isSelectorList;
+				let rule;
+				try {
+					rule = $.SUBRULE7($.qualifiedRuleBody, { ARGS: [ctx] });
+				} finally {
+					ctx.selector = initialSelector;
+					ctx.isSelectorList = initialIsSelectorList;
+				}
+				if (ctx.extendNodes) {
+					/** Prepend a rules block */
+					let qRule = rule;
+					for (const extendNode of ctx.extendNodes) {
+						const { selector: extendSelector } = extendNode;
+						if (extendSelector === void 0 || extendSelector instanceof Ampersand) {
+							const index = ctx.extendNodes.indexOf(extendNode);
+							ctx.extendNodes[index] = extendWithSelector$1(extendNode, selector, $.context);
+						}
+					}
+					rule = new Rules([...ctx.extendNodes, qRule]);
+					rule._location = qRule._location;
+					ctx.extendNodes = void 0;
+				}
+				return rule;
+			} }
+		]);
+	};
+}
+//#endregion
+//#region src/productions/selectors.ts
+const COMBINATORS = new Set([
+	" ",
+	">",
+	"+",
+	"~",
+	"|",
+	"||"
+]);
+function toCombinator(image) {
+	if (COMBINATORS.has(image)) return image;
+	throw new Error(`Unexpected selector combinator "${image}".`);
+}
+function isComplexSelectorComponentNode(node) {
+	return node instanceof Call || node instanceof Selector && !(node instanceof SelectorList) && !(node instanceof ComplexSelector);
+}
+function attributeSelector(T, valueAlt) {
+	const $ = this;
+	valueAlt ??= () => [
+		{
+			GATE: () => !$.isType(T.InterpolatedIdent),
+			ALT: () => {
+				const token = $.CONSUME5(T.Ident);
+				if ($.RECORDING_PHASE) return;
+				return new Any(token.image, { role: "ident" }, $.getLocationInfo(token), $.context);
+			}
+		},
+		{
+			GATE: () => $.isType(T.InterpolatedIdent),
+			ALT: () => {
+				const token = $.CONSUME(T.InterpolatedIdent);
+				if ($.RECORDING_PHASE) return;
+				const match = /([$@])\{([^}]+)\}/.exec(token.image);
+				if (match && match[0] === token.image) return createInterpolatedReference(match[1], match[2], $.getLocationInfo(token), $.context);
+				const result = getInterpolatedOrString(token.image, $.getLocationInfo(token), $.context);
+				return typeof result === "string" ? new Any(result, { role: "ident" }, $.getLocationInfo(token), $.context) : result;
+			}
+		},
+		{ ALT: () => $.SUBRULE($.string) }
+	];
+	return (ctx = {}) => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		$.CONSUME2(T.LSquare);
+		const key = $.SUBRULE2($.attributeName);
+		let op;
+		let value;
+		let mod;
+		$.OPTION(() => {
+			op = $.OR([{ ALT: () => $.CONSUME4(T.Eq) }, { ALT: () => $.CONSUME6(T.AttrMatch) }]);
+			value = $.OR2(valueAlt(ctx));
+		});
+		$.OPTION2(() => mod = $.CONSUME7(T.AttrFlag));
+		$.CONSUME8(T.RSquare);
+		if (!RECORDING_PHASE) {
+			const location = $.endRule();
+			return new AttributeSelector({
+				name: key.valueOf(),
+				op: op?.image,
+				value,
+				mod: mod?.image
+			}, void 0, location, $.context);
+		}
+	};
+}
+function getAmpersandTemplateValue(image) {
+	if (image === "&") return;
+	if (image.startsWith("&")) return image.slice(1) || void 0;
+	if (image.includes("&")) return image;
+}
+const { isArray } = Array;
+function getAllowedExtendSelectors(context) {
+	return context.opts.allowExtendSelectors;
+}
+function findDisallowedExtendSelector(selector, allowed) {
+	if (typeof selector === "string") return;
+	if (!allowed) return;
+	if (isNode(selector, N.SelectorList)) {
+		for (const item of selector.value) {
+			const disallowed = findDisallowedExtendSelector(item, allowed);
+			if (disallowed) return disallowed;
+		}
+		return;
+	}
+	const kinds = isNode(selector, N.BasicSelector) ? ["simple", "basic"] : isNode(selector, N.PseudoSelector) ? ["simple", "pseudo"] : isNode(selector, N.CompoundSelector) ? ["compound"] : isNode(selector, N.ComplexSelector) ? ["complex"] : ["simple"];
+	if (kinds.some((kind) => allowed.includes(kind))) return;
+	return {
+		kind: kinds[0],
+		selector
+	};
+}
+function formatAllowedExtendSelectors(allowed) {
+	if (allowed.length === 0) return "no selector kinds";
+	if (allowed.length === 1) return `${allowed[0]} value`;
+	return `${allowed.slice(0, -1).join(", ")}, or ${allowed[allowed.length - 1]} value`;
+}
+function validateExtendTarget($, selector, source) {
+	const allowed = getAllowedExtendSelectors($.context);
+	const disallowed = findDisallowedExtendSelector(selector, allowed);
+	if (!disallowed || !allowed) return;
+	throw new Error(`${source} only allows ${formatAllowedExtendSelectors(allowed)}, but found ${disallowed.kind} selector "${disallowed.selector.valueOf()}".`);
+}
+function mergeExtends(selector, extendTargets, location, context, flag) {
+	let extendNodes;
+	let currentTarget = extendTargets[0].target;
+	let currentFlag = extendTargets[0].flag ?? flag ? 0 : 1;
+	let currentNode = new Extend({
+		selector,
+		target: currentTarget,
+		flag: currentFlag
+	}, void 0, location, context);
+	const flushCurrent = () => {
+		(extendNodes ??= []).push(currentNode);
+	};
+	for (let i = 1; i < extendTargets.length; i++) {
+		let ext = extendTargets[i];
+		let thisFlag = ext.flag ?? flag ? 0 : 1;
+		/**
+		* Merge extends. We do this instead of merging earlier so that
+		* selector lists with different flags are not merged.
+		*/
+		if (thisFlag === currentFlag) {
+			const { target } = currentNode;
+			let nextTarget;
+			if (!(target instanceof SelectorList)) nextTarget = new SelectorList([target, ext.target], void 0, location, context);
+			else nextTarget = new SelectorList([...target.value, ext.target], void 0, location, context);
+			currentNode = new Extend({
+				selector,
+				target: nextTarget,
+				flag: currentFlag
+			}, void 0, location, context);
+		} else {
+			flushCurrent();
+			currentFlag = thisFlag;
+			currentTarget = ext.target;
+			currentNode = new Extend({
+				selector,
+				target: currentTarget,
+				flag: currentFlag
+			}, void 0, location, context);
+		}
+	}
+	if (!extendNodes) return currentNode;
+	flushCurrent();
+	if (extendNodes.length === 1) return extendNodes[0];
+	return extendNodes;
+}
+function extendWithSelector(node, selector, location, context) {
+	return new Extend({
+		selector,
+		target: node.target,
+		namespace: node.namespace,
+		flag: node.flag
+	}, void 0, location, context);
+}
+/** True for a node that could be one item in the old unquoted selector list (e.g. .a or #id). */
+function isSelectorLikeListItem(node) {
+	if (node.type === "SelectorCapture" || isNode(node, N.Call)) return false;
+	if (isNode(node, N.Reference)) return node.options.type === "mixin-ruleset";
+	if (node instanceof List) return node.value.length > 0 && node.value.every(isSelectorLikeListItem);
+	if (node instanceof Sequence) return node.value.length > 0 && node.value.every(isSelectorLikeListItem);
+	return false;
+}
+/** True only for the legacy unquoted selector-list form (e.g. @var: .a, .b, .c), not @var: .a; */
+function isLegacySelectorLikeValue(node) {
+	if (node.type === "SelectorCapture" || isNode(node, N.Call)) return false;
+	if (isNode(node, N.Reference)) return false;
+	if (node instanceof List) return node.value.length > 1 && node.value.every(isSelectorLikeListItem);
+	if (node instanceof Sequence) return node.value.length > 1 && node.value.every(isSelectorLikeListItem);
+	return false;
+}
+/**
+* We need to now handle a returned `Extend` node from the complexSelector rule
+*/
+function relativeSelector(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		return $.OR([{ ALT: () => {
+			let co = $.CONSUME(T.Combinator);
+			let node = $.SUBRULE2($.complexSelector, { ARGS: [ctx] });
+			if ($.RECORDING_PHASE) return node;
+			let combinator = new Combinator(toCombinator(co.image), void 0, $.getLocationInfo(co), $.context);
+			let targetNode = node instanceof Extend ? node.selector : node;
+			if (targetNode instanceof ComplexSelector) {
+				const nodes = [combinator, ...targetNode.value];
+				const complex = new ComplexSelector(nodes, void 0, $.getLocationFromNodes(nodes), $.context);
+				if (node instanceof Extend) {
+					const location = node.location.length === 6 ? [...node.location] : void 0;
+					if (location) {
+						location[0] = co.startOffset;
+						location[1] = co.startLine;
+						location[2] = co.startColumn;
+					}
+					node = extendWithSelector(node, complex, location, $.context);
+				} else node = complex;
+			} else {
+				if (!isComplexSelectorComponentNode(targetNode)) {
+					const targetType = typeof targetNode === "string" ? "string" : targetNode?.type ?? "none";
+					throw new Error(`Expected selector component after relative combinator; got ${targetType}.`);
+				}
+				let nodes = [combinator, targetNode];
+				let complex = new ComplexSelector(nodes, void 0, $.getLocationFromNodes(nodes), $.context);
+				if (node instanceof Extend) {
+					const location = node.location.length === 6 ? [...node.location] : void 0;
+					if (location) {
+						location[0] = co.startOffset;
+						location[1] = co.startLine;
+						location[2] = co.startColumn;
+					}
+					node = extendWithSelector(node, complex, location, $.context);
+				} else node = complex;
+			}
+			return node;
+		} }, { ALT: () => $.SUBRULE3($.complexSelector, { ARGS: [ctx] }) }]);
+	};
+}
+function forgivingSelectorList(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		let sequences;
+		let i = 0;
+		if (!RECORDING_PHASE) sequences = [];
+		$.AT_LEAST_ONE_SEP({
+			SEP: T.Comma,
+			DEF: () => {
+				const selector = $.SUBRULE($.relativeSelector, { ARGS: [ctx] });
+				if (!RECORDING_PHASE) {
+					i++;
+					if (i === 1 && ctx.qualifiedRule) sequences.push(selector);
+					else sequences.push(selector);
+				}
+			}
+		});
+		if (RECORDING_PHASE) return;
+		const location = $.endRule();
+		if (sequences.length === 1) return sequences[0];
+		return new SelectorList(sequences, void 0, location, $.context);
+	};
+}
+function selectorList(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		let sequences;
+		let i = 0;
+		if (!RECORDING_PHASE) sequences = [];
+		$.AT_LEAST_ONE_SEP({
+			SEP: T.Comma,
+			DEF: () => {
+				const selector = $.SUBRULE2($.complexSelector, { ARGS: [ctx] });
+				if (!RECORDING_PHASE) {
+					i++;
+					if (i === 1 && ctx.qualifiedRule) sequences.push(selector);
+					else sequences.push(selector);
+				}
+			}
+		});
+		if (RECORDING_PHASE) return;
+		const location = $.endRule();
+		if (sequences.length === 1) return sequences[0];
+		return new SelectorList(sequences, void 0, location, $.context);
+	};
+}
+function compoundSelector(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		/**
+		A sequence of simple value that are not separated by
+		a combinator.
+		.e.g. `a#selected`
+		*/
+		let RECORDING_PHASE = $.RECORDING_PHASE;
+		let value;
+		if (!RECORDING_PHASE) value = [];
+		let sel = $.SUBRULE($.simpleSelector, { ARGS: [ctx] });
+		if (!RECORDING_PHASE) value.push(sel);
+		$.MANY({
+			GATE: () => !$.hasWS() && !(ctx.inExtend && $.isType(T.All)),
+			DEF: () => {
+				let sel = $.SUBRULE2($.simpleSelector, { ARGS: [ctx] });
+				if (!RECORDING_PHASE) value.push(sel);
+			}
+		});
+		if (RECORDING_PHASE) return;
+		if (value.length === 1) return value[0];
+		return new CompoundSelector(value, void 0, $.getLocationFromNodes(value), $.context);
+	};
+}
+/**
+* Extended with :extend
+*/
+function complexSelector(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		let value;
+		if (!RECORDING_PHASE) value = [$.SUBRULE($.compoundSelector, { ARGS: [ctx] })];
+		else $.SUBRULE($.compoundSelector, { ARGS: [ctx] });
+		$.MANY({
+			GATE: () => {
+				if (ctx.inExtend && $.isType(T.All)) return false;
+				return $.hasWS() || $.isType(T.Combinator);
+			},
+			DEF: () => {
+				let co;
+				let combinator;
+				$.OPTION(() => {
+					co = $.CONSUME(T.Combinator);
+				});
+				if (!RECORDING_PHASE) if (co) combinator = new Combinator(toCombinator(co.image), void 0, $.getLocationInfo(co), $.context);
+				else {
+					const ws = $.claimSpaceCombinator($.LA(1).startOffset);
+					combinator = new Combinator(" ", void 0, ws ? $.getLocationInfo(ws) : void 0, $.context);
+				}
+				const compound = $.SUBRULE2($.compoundSelector, { ARGS: [ctx] });
+				if (!RECORDING_PHASE) value.push(combinator, compound);
+			}
+		});
+		let selector;
+		if (!RECORDING_PHASE) {
+			const location = $.endRule();
+			selector = value.length === 1 ? value[0] : new ComplexSelector(value, void 0, location, $.context);
+		}
+		let flag;
+		/** Inside :extend(...), only consume the optional trailing "all" keyword. */
+		$.OPTION2({
+			GATE: () => !!ctx.inExtend && $.isType(T.All),
+			DEF: () => {
+				flag = $.CONSUME(T.All);
+			}
+		});
+		/**
+		* Outside :extend(...), only enter the extend production when the next token
+		* is actually :extend(. Do not commit based on context alone.
+		*/
+		$.OPTION3({
+			GATE: () => !ctx.inExtend && !!ctx.qualifiedRule && $.isType(T.Extend),
+			DEF: () => {
+				const initialSelector = ctx.selector;
+				if (!RECORDING_PHASE) ctx.selector = selector;
+				try {
+					$.SUBRULE($.extend, { ARGS: [ctx] });
+				} finally {
+					ctx.selector = initialSelector;
+				}
+			}
+		});
+		if (ctx.inExtend) {
+			validateExtendTarget($, selector, ":extend()");
+			(ctx.extendTargets ??= []).push({
+				selector: ctx.selector,
+				target: selector,
+				flag
+			});
+		}
+		return selector;
+	};
+}
+/**
+* &:extend(...) statement ending with a semicolon.
+* This is the only valid standalone extend statement in Less.
+*/
+function ampersandExtend(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		$.CONSUME(T.Ampersand);
+		$.CONSUME(T.Extend);
+		ctx.inExtend = true;
+		$.SUBRULE($.selectorList, { ARGS: [ctx] });
+		ctx.inExtend = false;
+		let extendTargets = ctx.extendTargets;
+		let flag = $.OPTION(() => $.CONSUME(T.AllFlag));
+		$.CONSUME(T.RParen);
+		$.CONSUME(T.Semi);
+		let location = $.endRule();
+		if (!$.RECORDING_PHASE) {
+			let result = mergeExtends(void 0, extendTargets, location, $.context, flag);
+			/** We've converted these extend targets to nodes, so we can reset extend targets */
+			ctx.extendTargets = void 0;
+			if (ctx.extendNodes) if (isArray(result)) ctx.extendNodes = [...ctx.extendNodes, ...result];
+			else ctx.extendNodes.push(result);
+			else if (isArray(result)) ctx.extendNodes = result;
+			else ctx.extendNodes = [result];
+			return new Nil(void 0, void 0, location, $.context);
+		}
+	};
+}
+function extend(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		$.CONSUME(T.Extend);
+		ctx.inExtend = true;
+		$.SUBRULE($.selectorList, { ARGS: [ctx] });
+		let extendTargets = ctx.extendTargets;
+		ctx.inExtend = false;
+		let selector = ctx.selector;
+		let flag = $.OPTION(() => $.CONSUME(T.AllFlag));
+		$.CONSUME(T.RParen);
+		let location = $.endRule();
+		if (!$.RECORDING_PHASE) {
+			let merged = mergeExtends(selector, extendTargets, location, $.context, flag);
+			/**
+			* If we don't have as many extends as we have value, we need a way to signal
+			* that these should be bumped above the ruleset.
+			*/
+			/** We've converted these extend targets to nodes, so we can reset extend targets */
+			ctx.extendTargets = void 0;
+			if (ctx.extendNodes) if (isArray(merged)) ctx.extendNodes = [...ctx.extendNodes, ...merged];
+			else ctx.extendNodes.push(merged);
+			else if (isArray(merged)) ctx.extendNodes = merged;
+			else ctx.extendNodes = [merged];
+		}
+	};
+}
+function simpleSelector(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		let selector = $.OR([
+			{
+				GATE: () => (!ctx.inExtend || $.LA(1).tokenType !== T.All) && $.LA(1).tokenType !== T.InterpolatedIdent,
+				ALT: () => $.CONSUME(T.Ident)
+			},
+			{ ALT: () => {
+				let amp = $.CONSUME(T.Ampersand);
+				return new Ampersand({ appendValue: getAmpersandTemplateValue(amp.image) }, void 0, $.getLocationInfo(amp), $.context);
+			} },
+			{ ALT: () => {
+				$.startRule();
+				$.CONSUME(T.AmpersandLParen);
+				const parts = [];
+				let sawQuoted = false;
+				$.MANY(() => {
+					$.OR2([
+						{
+							GATE: () => $.isType(T.QuoteStart),
+							ALT: () => {
+								const quoted = $.SUBRULE($.string, { ARGS: [ctx] });
+								parts.push(quoted.valueOf());
+								sawQuoted = true;
+							}
+						},
+						{
+							GATE: () => $.isType(T.WS),
+							ALT: () => {
+								parts.push($.CONSUME(T.WS).image);
+							}
+						},
+						{ ALT: () => {
+							parts.push($.CONSUME(T.AmpersandTemplateContents).image);
+						} }
+					]);
+				});
+				$.CONSUME(T.AmpersandTemplateEnd);
+				const location = $.endRule();
+				const value = parts.join("");
+				return new Ampersand({ appendValue: sawQuoted && value === "" ? "" : value === "nil" ? "" : value }, void 0, location, $.context);
+			} },
+			{ ALT: () => $.CONSUME(T.InterpolatedIdent) },
+			{ ALT: () => $.CONSUME(T.InterpolatedSelector) },
+			{ ALT: () => $.SUBRULE($.classSelector, { ARGS: [ctx] }) },
+			{ ALT: () => $.SUBRULE($.idSelector, { ARGS: [ctx] }) },
+			{ ALT: () => $.CONSUME(T.Star) },
+			{ ALT: () => {
+				let initialIsQualifiedRule = ctx.qualifiedRule;
+				ctx.qualifiedRule = false;
+				/** Make sure we prevent things like :extend() inside pseudo-value */
+				try {
+					return $.SUBRULE($.pseudoSelector, { ARGS: [ctx] });
+				} finally {
+					ctx.qualifiedRule = initialIsQualifiedRule;
+				}
+			} },
+			(
+			/** @todo - replicate this fix we made with the Jess parser
+			*
+			* { ALT: () => $.attributeSelector(ctx, () => [
+			{
+			ALT: () => {
+			let token = $.CONSUME($.T.InterpolatedIdent);
+			let location = $.getLocationInfo(token);
+			let image = token.image;
+			let match = interpolatedRegex.exec(image);
+			interpolatedRegex.lastIndex = 0;
+			if (match && match[0] === image) {
+			return new Reference(
+			{ key: new Keyword(match[2]!, undefined, location, $.context) },
+			{ type: 'index' },
+			location,
+			$.context
+			);
+			}
+			return getInterpolatedNode(image, location, $.context);
+			}
+			},
+			*/
+			{ ALT: () => $.SUBRULE($.attributeSelector, { ARGS: [ctx] }) }),
+			(
+			/** Supports keyframes value */
+			{ ALT: () => $.CONSUME(T.DimensionInt) }),
+			{ ALT: () => $.CONSUME(T.DimensionNum) }
+		]);
+		if ($.isToken(selector)) {
+			if (selector.tokenType.name === "Ampersand") return new Ampersand({ appendValue: getAmpersandTemplateValue(selector.image) }, void 0, $.getLocationInfo(selector), $.context);
+			if (selector.tokenType.name === "InterpolatedSelector" || selector.tokenType.name === "InterpolatedIdent") {
+				let nameValue = selector.image;
+				return new InterpolatedSelector(getInterpolatedNode(nameValue, $.getLocationInfo(selector), $.context), void 0, $.getLocationInfo(selector), $.context);
+			}
+			return new BasicSelector(selector.image, void 0, $.getLocationInfo(selector), $.context);
+		}
+		return selector;
+	};
+}
+function anonymousMixinDefinition(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		let params;
+		let anonToken;
+		$.OPTION(() => {
+			anonToken = $.CONSUME(T.AnonMixinStart);
+			$.OPTION2(() => {
+				params = $.SUBRULE($.mixinArgList, { ARGS: [{
+					...ctx,
+					isDefinition: true
+				}] });
+			});
+			$.CONSUME(T.RParen);
+		});
+		let rules = $.SUBRULE($.wrappedDeclarationList, { ARGS: [ctx] });
+		if ($.RECORDING_PHASE) return;
+		if (!rules.options.rulesVisibility) rules.options.rulesVisibility = {};
+		if ($.leakyScope) {
+			rules.options.rulesVisibility.Mixin = "public";
+			rules.options.rulesVisibility.VarDeclaration = "private";
+		} else {
+			rules.options.rulesVisibility.Mixin = "private";
+			rules.options.rulesVisibility.VarDeclaration = "private";
+		}
+		if (!anonToken) {
+			/** To Less, this is a "detached ruleset" */
+			const shouldBeCollection = (() => {
+				let properties = [];
+				for (const node of rules.rules) if (node.type === "Declaration") properties.push(node);
+				else if (node.type === "Comment" || node.type === "VarDeclaration") continue;
+				else
+ /** Not a valid collection, parse as anonymous mixin */
+				return false;
+				if (properties.length === 0)
+ /** If just var declarations and/or comments, parse as collection */
+				return true;
+				/** If this looks like mostly CSS properties, parse as mixin instead */
+				return !(properties.filter((decl) => {
+					const { name } = decl;
+					const propName = typeof name === "string" ? name : name?.valueOf();
+					if (!propName) return false;
+					if (propName.startsWith("--")) return true;
+					return all.includes(propName);
+				}).length > properties.length / 2);
+			})();
+			const usage = ctx.detachedRulesetUsage ?? "none";
+			if (shouldBeCollection && !(usage === "function-arg" || usage === "mixin-arg" || usage === "default-param")) return new Collection(rules.rules, rules.options, $.endRule(), $.context);
+		}
+		return new Mixin({
+			params,
+			rules: rules.rules
+		}, void 0, $.endRule(), $.context);
+	};
+}
+/**
+* Mostly copied from css importAtRule, but it maps
+* differently to Jess nodes depending on if it's meant
+* to be a Jess-style import or just an at-rule
+*/
+function importAtRule(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const isCssUrl = (url, options) => {
+			if (options.includes("inline")) return false;
+			const lower = url.toLowerCase();
+			if (options.includes("less")) return false;
+			if (options.includes("css")) return true;
+			if (/\.css([?#].*)?$/.test(lower)) return true;
+			if (/\.less([?#].*)?$/.test(lower)) return false;
+			if (lower.startsWith("http://") || lower.startsWith("https://") || lower.startsWith("//")) return true;
+			return false;
+		};
+		$.startRule();
+		let name = $.CONSUME(T.AtImport);
+		let options = [];
+		$.OPTION(() => {
+			$.CONSUME(T.LParen);
+			$.AT_LEAST_ONE_SEP({
+				SEP: T.Comma,
+				DEF: () => {
+					let opt = $.CONSUME(T.PlainIdent);
+					options.push(opt.image);
+				}
+			});
+			$.CONSUME(T.RParen);
+		});
+		let urlNode = $.OR([{ ALT: () => $.SUBRULE($.urlFunction, { ARGS: [ctx] }) }, { ALT: () => $.SUBRULE($.string, { ARGS: [ctx] }) }]);
+		let extraNodes;
+		$.OPTION2(() => {
+			extraNodes = $.SUBRULE($.importPostlude, { ARGS: [{}] });
+		});
+		$.CONSUME(T.Semi);
+		if (!$.RECORDING_PHASE) {
+			let isAtRule;
+			let postludeNode;
+			isAtRule = isCssUrl(urlNode.valueOf(), options);
+			let preludeNodes = [urlNode];
+			if (extraNodes && extraNodes.length) if (isAtRule) {
+				isAtRule = true;
+				for (const n of extraNodes) preludeNodes.push(n);
+			} else {
+				const postludeLoc = $.getLocationFromNodes(extraNodes);
+				postludeNode = new Sequence(extraNodes, void 0, postludeLoc, $.context);
+			}
+			let location = $.endRule();
+			if (isAtRule) {
+				const prelude = new Sequence(preludeNodes, void 0, $.getLocationFromNodes(preludeNodes), $.context);
+				return new AtRuleStatement({
+					name: name.image,
+					prelude
+				}, void 0, location, $.context);
+			}
+			return new StyleImport({ path: urlNode }, {
+				type: "import",
+				importOptions: {
+					type: options.includes("less") ? "less" : void 0,
+					reference: options.includes("reference"),
+					once: !options.includes("multiple"),
+					multiple: options.includes("multiple"),
+					optional: options.includes("optional"),
+					inline: options.includes("inline"),
+					postlude: postludeNode
+				}
+			}, location, $.context);
+		}
+	};
+}
+/** Less variables */
+function varDeclarationOrCall(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		let name = $.SUBRULE($.varName, { ARGS: [{}] });
+		let value;
+		let args;
+		let important;
+		$.OR([{ ALT: () => {
+			$.CONSUME(T.Colon);
+			return $.OR2([{
+				GATE: () => {
+					const type = $.LA(1).tokenType;
+					return type === T.AnonMixinStart || type === T.LCurly;
+				},
+				ALT: () => {
+					value = $.SUBRULE($.anonymousMixinDefinition, { ARGS: [ctx] });
+					$.OPTION(() => $.CONSUME(T.Semi));
+					return value;
+				}
+			}, {
+				GATE: () => {
+					const type = $.LA(1).tokenType;
+					return type !== T.AnonMixinStart && type !== T.LCurly;
+				},
+				ALT: () => {
+					value = $.SUBRULE($.valueList, { ARGS: [{
+						...ctx,
+						allowMixinCallWithoutAccessor: true
+					}] });
+					$.OPTION2(() => {
+						important = $.CONSUME(T.Important);
+					});
+					return value;
+				}
+			}]);
+		} }, (
+		/** This is a variable call. Allow optional whitespace between name and (. */
+		{
+			GATE: () => $.isType(T.LParen),
+			ALT: () => {
+				args = $.SUBRULE($.mixinArgs, { ARGS: [ctx] });
+				return args;
+			}
+		})]);
+		let location = $.endRule();
+		if ($.RECORDING_PHASE) return;
+		let nameVal = getInterpolatedOrString(name.image);
+		let nameNode;
+		if (!(nameVal instanceof Interpolated)) nameNode = new Any(nameVal, { role: "ident" }, $.getLocationInfo(name), $.context);
+		else nameNode = nameVal;
+		/** An anonymous mixin call */
+		if (!value) {
+			const callNode = new Call({
+				name: new Reference({ key: nameNode }, {
+					type: "variable",
+					role: "name"
+				}),
+				args
+			}, important ? { markImportant: true } : void 0, location, $.context);
+			if (important) important = void 0;
+			return new Expression(callNode, void 0, location, $.context);
+		}
+		if (important && value instanceof Call) {
+			value.options = value.options || {};
+			value.options.markImportant = true;
+			important = void 0;
+		}
+		if (value && isLegacySelectorLikeValue(value)) {
+			const varName = String(nameNode.valueOf());
+			$.warnDeprecation(`Unquoted selector capture in '${varName}' is no longer supported. Use '*[ ... ]' (e.g. ${varName}: *[.a, .b]).`, $.LA(1), "unquoted-selector-capture");
+		}
+		return new VarDeclaration({
+			name: nameNode instanceof Any ? String(nameNode.valueOf()) : nameNode,
+			value,
+			important: important ? new Any(important.image, { role: "flag" }, $.getLocationInfo(important), $.context) : void 0
+		}, void 0, location, $.context);
+	};
+}
+function selectorCapture(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		$.CONSUME(T.Star);
+		const selector = $.OR([{
+			GATE: $.noSep.bind($),
+			ALT: () => {
+				$.CONSUME(T.LSquare);
+				const selector = $.SUBRULE($.forgivingSelectorList, { ARGS: [{
+					...ctx,
+					inner: true
+				}] });
+				$.CONSUME(T.RSquare);
+				return selector;
+			}
+		}]);
+		const location = $.endRule();
+		if ($.RECORDING_PHASE) return;
+		return new SelectorCapture(selector, void 0, location, $.context);
+	};
+}
+function valueSequence(_T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		let nodes;
+		if (!RECORDING_PHASE) nodes = [];
+		{
+			const exprCtx = {
+				...ctx,
+				wrapInExpression: true
+			};
+			let value = $.SUBRULE2($.expressionSum, { ARGS: [exprCtx] });
+			if (!RECORDING_PHASE) {
+				value = wrapOuterExpressionIfNeeded.call($, value, exprCtx);
+				nodes.push(value);
+			}
+		}
+		$.MANY(() => {
+			const exprCtx = {
+				...ctx,
+				wrapInExpression: true
+			};
+			let value = $.SUBRULE3($.expressionSum, { ARGS: [exprCtx] });
+			if (!RECORDING_PHASE) {
+				value = wrapOuterExpressionIfNeeded.call($, value, exprCtx);
+				nodes.push(value);
+			}
+		});
+		if (RECORDING_PHASE) return;
+		let location = $.endRule();
+		if (nodes.length === 1) return nodes[0];
+		return new Sequence(nodes, void 0, location, $.context);
+	};
+}
+function squareValue(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		$.CONSUME(T.LSquare);
+		let node = $.OR([{
+			GATE: () => !$.looseMode,
+			ALT: () => {
+				let ident = $.CONSUME(T.Ident);
+				return new Any(ident.image, { role: "ident" }, $.getLocationInfo(ident), $.context);
+			}
+		}, {
+			GATE: () => !!$.looseMode,
+			ALT: () => {
+				let nodes = [];
+				$.MANY(() => {
+					const wrapped = $.SUBRULE($.anyInnerValue, { ARGS: [ctx] });
+					nodes.push(wrapped);
+				});
+				return new Sequence(nodes, void 0, $.getLocationFromNodes(nodes), $.context);
+			}
+		}]);
+		$.CONSUME(T.RSquare);
+		return new Block(node, { type: "square" }, $.endRule(), $.context);
+	};
+}
+//#endregion
+//#region src/productions/values.ts
+const OPERATORS = new Set([
+	"+",
+	"-",
+	"*",
+	"/",
+	"%"
+]);
+function toOperator(image) {
+	if (image === "./") return "/";
+	if (OPERATORS.has(image)) return image;
+	throw new Error(`Unexpected operator "${image}".`);
+}
+function toQuote(image) {
+	if (image === "\"" || image === "'") return image;
+	throw new Error(`Unexpected quote "${image}".`);
+}
+function nonEmptyVarDeclarations(vars) {
+	if (vars.length === 0) throw new Error("Expected at least one variable declaration.");
+	return [vars[0], ...vars.slice(1)];
+}
+const cssNthValue = productions.nthValue;
+const cssKnownFunctions = productions.knownFunctions;
+const cssMathValue = productions.mathValue;
+function getParenFrames$1(ctx) {
+	return ctx?.parenFrames ?? [];
+}
+function withCalcFrame(ctx, delta) {
+	const calcFrames = (ctx?.calcFrames ?? 0) + delta;
+	return {
+		...ctx ?? {},
+		calcFrames
+	};
+}
+function slashDivisionEnabled($, ctx) {
+	const inParens = getParenFrames$1(ctx).at(-1) ?? false;
+	return ($.mathMode ?? "parens-division") === "always" || inParens;
+}
+function isDivisionLikeNode(node) {
+	if (!node) return false;
+	if (isNode(node, N.Color) || isNode(node, N.Dimension) || node instanceof Num || isNode(node, N.Reference) || isNode(node, N.Call) || isNode(node, N.Operation) || node.type === "Negative" || isNode(node, N.Expression)) return true;
+	if (isNode(node, N.Paren) || isNode(node, N.Expression)) return isDivisionLikeNode(node.value);
+	return false;
+}
+function isSlashListContinuationToken($, T) {
+	const next = $.LA(1);
+	return !(next.tokenType?.name === "EOF" || $.matchToken(next, T.Comma) || $.matchToken(next, T.Semi) || $.matchToken(next, T.RCurly) || $.matchToken(next, T.RParen) || $.matchToken(next, T.RSquare) || $.matchToken(next, T.Important) || $.matchToken(next, T.Plus) || $.matchToken(next, T.Minus) || $.matchToken(next, T.Star) || $.matchToken(next, T.Slash) || $.matchToken(next, T.Percent));
+}
+function shouldParseSlashDivision($, T, ctx, left, right) {
+	const enabled = slashDivisionEnabled($, ctx);
+	const leftLike = isDivisionLikeNode(left);
+	const rightLike = isDivisionLikeNode(right);
+	const continuation = isSlashListContinuationToken($, T);
+	if (!enabled) return false;
+	if (!leftLike || !rightLike) return false;
+	if (continuation) return false;
+	return true;
+}
+function startsCustomValueToken($, T) {
+	return $.isType(T.LParen) || $.isType(T.FunctionStart) || $.isType(T.FunctionalPseudoClass) || $.isType(T.LSquare) || $.isType(T.LCurly) || $.isType(T.SingleQuoteStart) || $.isType(T.DoubleQuoteStart) || $.isType(T.Value) || $.isType(T.PlainIdent) || $.isType(T.AtKeyword) || $.isType(T.PropertyReference) || $.isType(T.CustomProperty) || $.isType(T.Dimension) || $.isType(T.Number) || $.isType(T.Color) || $.isType(T.UnicodeRange) || $.isType(T.Colon) || $.isType(T.Comma) || $.isType(T.Important) || $.isType(T.Unknown);
+}
+function createEachPattern(mixin, location, context) {
+	const defaultVars = [
+		"value",
+		"key",
+		"index"
+	].map((name) => {
+		return new VarDeclaration({
+			name,
+			value: new Any("", { role: "any" })
+		}, { paramVar: true }, location, context);
+	});
+	if (!isNode(mixin, N.Mixin) || !mixin.params) return {
+		kind: "tuple",
+		values: nonEmptyVarDeclarations(defaultVars)
+	};
+	const params = mixin.params.value.map((param) => {
+		if (isNode(param, N.VarDeclaration)) return param;
+		if (isNode(param, N.Any) && param.role === "property") return new VarDeclaration({
+			name: String(param.value),
+			value: new Any("", { role: "any" })
+		}, { paramVar: true }, param.location, context);
+	}).filter((param) => Boolean(param));
+	if (params.length === 0) return {
+		kind: "tuple",
+		values: nonEmptyVarDeclarations(defaultVars)
+	};
+	if (params.length === 1) return {
+		kind: "single",
+		value: params[0]
+	};
+	return {
+		kind: "tuple",
+		values: nonEmptyVarDeclarations(params)
+	};
+}
+function expressionSum(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		let left = $.SUBRULE($.expressionProduct, { ARGS: [ctx] });
+		while (true) {
+			let op;
+			let right;
+			if ($.isType(T.Plus)) {
+				op = $.CONSUME(T.Plus).image;
+				right = $.SUBRULE2($.expressionProduct, { ARGS: [ctx] });
+			} else if ($.isType(T.Minus)) {
+				op = $.CONSUME(T.Minus).image;
+				right = $.SUBRULE4($.expressionProduct, { ARGS: [ctx] });
+			} else if ($.noSep() && $.matchToken($.LA(1), T.Signed)) {
+				const tok = $.CONSUME(T.Signed);
+				let startValue;
+				const str = tok.image;
+				op = str[0];
+				if (tok.payload && tok.payload[1]) startValue = new Dimension({
+					number: parseFloat(tok.payload[0]),
+					unit: tok.payload[1]
+				}, void 0, $.getLocationInfo(tok), $.context);
+				else {
+					const num = parseFloat(str);
+					if (!Number.isNaN(num)) startValue = new Num(num, void 0, $.getLocationInfo(tok), $.context);
+					else startValue = $.processValueToken(tok);
+				}
+				right = $.SUBRULE3($.expressionProduct, { ARGS: [{
+					...ctx,
+					startValue
+				}] });
+			} else break;
+			left = new Operation([
+				left,
+				toOperator(op),
+				right
+			], void 0, $.getLocationFromNodes([left, right]), $.context);
+		}
+		$.endRule();
+		return left;
+	};
+}
+function expressionProduct(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		let left = ctx.startValue ?? $.SUBRULE($.expressionValue, { ARGS: [ctx] });
+		while (true) {
+			let op;
+			if ($.isType(T.Star)) op = $.CONSUME(T.Star);
+			else if ($.isType(T.Slash)) op = $.CONSUME(T.Slash);
+			else if ($.isType(T.Percent)) op = $.CONSUME(T.Percent);
+			else break;
+			if (op.image === "./") $.warnDeprecation("./ operator is deprecated", op, "dot-slash-operator");
+			let right = $.SUBRULE2($.expressionValue, { ARGS: [ctx] });
+			const location = $.getLocationFromNodes([left, right]);
+			if (op.image === "/" && !shouldParseSlashDivision($, T, ctx, left, right)) {
+				if (isNode(left, N.List) && left.options?.sep === "/") left = new List([...left.value, right], { sep: "/" }, location, $.context);
+				else left = new List([left, right], { sep: "/" }, location, $.context);
+				continue;
+			}
+			left = new Operation([
+				left,
+				toOperator(op.image),
+				right
+			], void 0, location, $.context);
+		}
+		$.endRule();
+		return left;
+	};
+}
+function customValue(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		if ($.isType(T.UrlStart) || $.isType(T.Var) || $.isType(T.Calc) || $.isType(T.IfFunction) || $.isType(T.BooleanFunction) || $.isType(T.FunctionStart)) return $.SUBRULE($.functionCall, { ARGS: [ctx] });
+		if ($.isType(T.LParen) || $.isType(T.FunctionalPseudoClass) || $.isType(T.LSquare) || $.isType(T.LCurly)) return $.SUBRULE($.customBlock, { ARGS: [ctx] });
+		if ($.isType(T.SingleQuoteStart) || $.isType(T.DoubleQuoteStart)) return $.SUBRULE($.string, { ARGS: [ctx] });
+		let token;
+		if ($.isType(T.Value)) token = $.CONSUME(T.Value);
+		else if ($.isType(T.PlainIdent)) token = $.CONSUME(T.PlainIdent);
+		else if ($.isType(T.AtKeyword)) token = $.CONSUME(T.AtKeyword);
+		else if ($.isType(T.PropertyReference)) token = $.CONSUME(T.PropertyReference);
+		else if ($.isType(T.CustomProperty)) token = $.CONSUME(T.CustomProperty);
+		else if ($.isType(T.Dimension)) token = $.CONSUME(T.Dimension);
+		else if ($.isType(T.Number)) token = $.CONSUME(T.Number);
+		else if ($.isType(T.Color)) token = $.CONSUME(T.Color);
+		else if ($.isType(T.UnicodeRange)) token = $.CONSUME(T.UnicodeRange);
+		else if ($.isType(T.Colon)) token = $.CONSUME(T.Colon);
+		else if ($.isType(T.Comma)) token = $.CONSUME(T.Comma);
+		else if ($.isType(T.Important)) token = $.CONSUME(T.Important);
+		else token = $.CONSUME(T.Unknown);
+		if (!$.RECORDING_PHASE) return $.processValueToken(token, ctx);
+	};
+}
+function innerCustomValue(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		if ($.isType(T.Semi)) {
+			const semi = $.CONSUME(T.Semi);
+			if ($.RECORDING_PHASE) return;
+			return new Any(semi.image, { role: "semi" }, $.getLocationInfo(semi), $.context);
+		}
+		return $.SUBRULE($.customValue, { ARGS: [ctx] });
+	};
+}
+function customBlock(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		let start;
+		let end;
+		let nodes;
+		if (!RECORDING_PHASE) nodes = [];
+		if ($.isType(T.LParen)) {
+			start = $.CONSUME(T.LParen);
+			while (!$.isType(T.RParen) && (startsCustomValueToken($, T) || $.isType(T.Semi))) {
+				const val = $.SUBRULE($.innerCustomValue, { ARGS: [ctx] });
+				if (!RECORDING_PHASE) nodes.push(val);
+			}
+			end = $.CONSUME(T.RParen);
+		} else if ($.isType(T.FunctionStart) || $.isType(T.FunctionalPseudoClass)) {
+			start = $.isType(T.FunctionStart) ? $.CONSUME(T.FunctionStart) : $.CONSUME(T.FunctionalPseudoClass);
+			while (!$.isType(T.RParen) && (startsCustomValueToken($, T) || $.isType(T.Semi))) {
+				const val = $.SUBRULE2($.innerCustomValue, { ARGS: [ctx] });
+				if (!RECORDING_PHASE) nodes.push(val);
+			}
+			end = $.CONSUME2(T.RParen);
+		} else if ($.isType(T.LSquare)) {
+			start = $.CONSUME(T.LSquare);
+			while (!$.isType(T.RSquare) && (startsCustomValueToken($, T) || $.isType(T.Semi))) {
+				const val = $.SUBRULE3($.innerCustomValue, { ARGS: [ctx] });
+				if (!RECORDING_PHASE) nodes.push(val);
+			}
+			end = $.CONSUME(T.RSquare);
+		} else {
+			start = $.CONSUME(T.LCurly);
+			while (!$.isType(T.RCurly) && (startsCustomValueToken($, T) || $.isType(T.Semi))) {
+				const val = $.SUBRULE4($.innerCustomValue, { ARGS: [ctx] });
+				if (!RECORDING_PHASE) nodes.push(val);
+			}
+			end = $.CONSUME(T.RCurly);
+		}
+		if (RECORDING_PHASE) return;
+		const location = $.endRule();
+		let type;
+		switch (start.image) {
+			case "[":
+				type = "square";
+				break;
+			case "{":
+				type = "curly";
+				break;
+		}
+		if (type) {
+			const seqLoc = nodes.length ? $.getLocationFromNodes(nodes) : void 0;
+			return new Block(new Sequence(nodes, void 0, seqLoc, $.context), { type }, location, $.context);
+		}
+		const startNode = new Any(start.image, { role: "any" }, $.getLocationInfo(start), $.context);
+		const endNode = new Any(end.image, { role: "any" }, $.getLocationInfo(end), $.context);
+		return new Sequence([
+			startNode,
+			...nodes,
+			endNode
+		], void 0, location, $.context);
+	};
+}
+function expressionValue(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		/** Can create a negative expression */
+		let minus = $.OPTION(() => $.CONSUME(T.Minus));
+		let node = $.OR([{ ALT: () => {
+			$.startRule();
+			let escape;
+			$.OPTION2(() => {
+				escape = $.CONSUME(T.Tilde);
+			});
+			$.CONSUME(T.LParen);
+			const innerCtx = {
+				...ctx,
+				inner: true,
+				allowComma: true,
+				parenFrames: [...getParenFrames$1(ctx), true]
+			};
+			let node = $.SUBRULE($.valueList, { ARGS: [innerCtx] });
+			let isSemiList = false;
+			if (escape) {
+				let semiNodes = [];
+				$.OPTION3(() => {
+					$.CONSUME(T.Semi);
+					isSemiList = true;
+					semiNodes.push(node);
+					node = $.SUBRULE2($.valueList, { ARGS: [innerCtx] });
+					semiNodes.push(node);
+					$.MANY({
+						GATE: () => $.isType(T.Semi),
+						DEF: () => {
+							$.CONSUME2(T.Semi);
+							node = $.SUBRULE3($.valueList, { ARGS: [innerCtx] });
+							semiNodes.push(node);
+						}
+					});
+				});
+				if (isSemiList) node = new List(semiNodes, { sep: ";" });
+			}
+			$.CONSUME(T.RParen);
+			let location = $.endRule();
+			node = node;
+			return new Paren(node, { escaped: !!escape }, location, $.context);
+		} }, { ALT: () => $.SUBRULE($.value, { ARGS: [ctx] }) }]);
+		let location = $.endRule();
+		if (minus) return new Negative(node, void 0, location, $.context);
+		return node;
+	};
+}
+/**
+* Add interpolation
+*/
+function nthValue(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		let nthValueAlt = (ctx = {}) => [
+			{ ALT: () => $.CONSUME(T.InterpolatedIdent) },
+			{ ALT: () => $.CONSUME(T.NthOdd) },
+			{ ALT: () => $.CONSUME(T.NthEven) },
+			{ ALT: () => $.CONSUME(T.Integer) },
+			{ ALT: () => {
+				$.OR2([
+					{ ALT: () => $.CONSUME(T.NthSignedDimension) },
+					{ ALT: () => $.CONSUME(T.NthUnsignedDimension) },
+					{ ALT: () => $.CONSUME(T.NthSignedPlus) },
+					{ ALT: () => $.CONSUME(T.NthIdent) }
+				]);
+				$.OPTION(() => {
+					$.OR3([{ ALT: () => $.CONSUME(T.SignedInt) }, { ALT: () => {
+						$.CONSUME(T.Minus);
+						$.CONSUME(T.UnsignedInt);
+					} }]);
+				});
+				$.OPTION2(() => {
+					$.CONSUME(T.Of);
+					$.SUBRULE($.complexSelector, { ARGS: [ctx] });
+				});
+			} }
+		];
+		return cssNthValue.call($, T, nthValueAlt)(ctx);
+	};
+}
+function knownFunctions(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		let functions = (ctx = {}) => [
+			{ ALT: () => $.SUBRULE($.urlFunction, { ARGS: [ctx] }) },
+			{ ALT: () => $.SUBRULE2($.varFunction, { ARGS: [ctx] }) },
+			{ ALT: () => $.SUBRULE3($.calcFunction, { ARGS: [ctx] }) },
+			{ ALT: () => $.SUBRULE4($.ifFunction, { ARGS: [ctx] }) },
+			{ ALT: () => $.SUBRULE5($.booleanFunction, { ARGS: [ctx] }) }
+		];
+		return cssKnownFunctions.call($, T, functions)(ctx);
+	};
+}
+function urlFunction(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		$.CONSUME(T.UrlStart);
+		let node = $.OR([
+			{ ALT: () => $.SUBRULE($.string, { ARGS: [ctx] }) },
+			{ ALT: () => $.SUBRULE($.varReference, { ARGS: [ctx] }) },
+			{ ALT: () => $.CONSUME(T.NonQuotedUrl) }
+		]);
+		$.CONSUME(T.UrlEnd);
+		if ($.RECORDING_PHASE) return;
+		const location = $.endRule();
+		if (!(node instanceof Node)) {
+			const rawValue = node.image;
+			const tokenLocation = $.getLocationInfo(node);
+			if (rawValue.startsWith("@") || rawValue.startsWith("$")) {
+				const resolved = getInterpolatedOrString(rawValue, tokenLocation, $.context);
+				if (resolved instanceof Interpolated) node = resolved;
+				else node = new Reference(resolved, { type: rawValue.startsWith("$") ? "property" : "variable" }, tokenLocation, $.context);
+			} else node = new Any(rawValue, { role: "urlvalue" }, tokenLocation, $.context);
+		}
+		return new Url(node, void 0, location, $.context);
+	};
+}
+/**
+* Override CSS calc() parsing so we can maintain parse-time `calcFrames`.
+* This is the parse-time analogue of `Call.evalNode`'s calcFrames++/--.
+*/
+function calcFunction(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		$.CONSUME(T.Calc);
+		const innerCtx = withCalcFrame(ctx, 1);
+		const args = $.SUBRULE($.mathSum, { ARGS: [innerCtx] });
+		$.CONSUME(T.RParen);
+		const location = $.endRule();
+		return new Call({
+			name: "calc",
+			args: new List([args])
+		}, void 0, location, $.context);
+	};
+}
+function ifFunction(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		let name = $.CONSUME(T.IfFunction);
+		let args = new List([]);
+		let isCssBranch = false;
+		const firstNode = $.SUBRULE($.guardInner, { ARGS: [{
+			...ctx,
+			inValueList: true
+		}] });
+		if ($.isType(T.Assign)) {
+			isCssBranch = true;
+			const branches = [];
+			const pushBranch = (condition, value) => {
+				const sep = new Any(":", { role: "operator" }, void 0, $.context);
+				const loc = $.getLocationFromNodes([condition, value]);
+				branches.push(new Sequence([
+					condition,
+					sep,
+					value
+				], void 0, loc, $.context));
+			};
+			$.CONSUME(T.Assign);
+			pushBranch(firstNode, $.SUBRULE($.valueList, { ARGS: [{
+				...ctx,
+				inner: true
+			}] }));
+			$.MANY({
+				GATE: () => $.isType(T.Semi) && !$.isTypeAt(2, T.RParen),
+				DEF: () => {
+					$.CONSUME2(T.Semi);
+					const condition = $.SUBRULE2($.guardInner, { ARGS: [{
+						...ctx,
+						inValueList: true
+					}] });
+					$.CONSUME2(T.Assign);
+					pushBranch(condition, $.SUBRULE2($.valueList, { ARGS: [{
+						...ctx,
+						inner: true
+					}] }));
+				}
+			});
+			$.OPTION(() => $.CONSUME3(T.Semi));
+			$.CONSUME2(T.RParen);
+			args = new List([branches.length === 1 ? branches[0] : new List(branches, { sep: ";" }, $.getLocationFromNodes(branches), $.context)]);
+		} else {
+			isCssBranch = false;
+			let node = firstNode;
+			const parenValue = node instanceof Paren ? node.value : void 0;
+			args = new List([parenValue instanceof Node ? parenValue : node]);
+			$.OR([{ ALT: () => {
+				$.CONSUME(T.Semi);
+				node = $.SUBRULE2($.valueList, { ARGS: [{
+					...ctx,
+					allowAnonymousMixins: true
+				}] });
+				args = new List([...args.value, node], args.options, $.getLocationFromNodes([...args.value, node]), $.context);
+				$.OPTION(() => {
+					$.CONSUME4(T.Semi);
+					node = $.SUBRULE3($.valueList, { ARGS: [{
+						...ctx,
+						allowAnonymousMixins: true
+					}] });
+					args = new List([...args.value, node], args.options, $.getLocationFromNodes([...args.value, node]), $.context);
+				});
+			} }, { ALT: () => {
+				$.CONSUME(T.Comma);
+				node = $.SUBRULE($.callArgument, { ARGS: [{
+					...ctx,
+					allowAnonymousMixins: true
+				}] });
+				args = new List([...args.value, node], args.options, $.getLocationFromNodes([...args.value, node]), $.context);
+				$.OPTION2(() => {
+					$.CONSUME2(T.Comma);
+					node = $.SUBRULE2($.callArgument, { ARGS: [{
+						...ctx,
+						allowAnonymousMixins: true
+					}] });
+					args = new List([...args.value, node], args.options, $.getLocationFromNodes([...args.value, node]), $.context);
+				});
+			} }]);
+			$.CONSUME3(T.RParen);
+		}
+		let location = $.endRule();
+		return new Call({
+			name: new Reference("if", {
+				type: "function",
+				fallbackValue: isCssBranch ? true : void 0
+			}, $.getLocationInfo(name), $.context),
+			args
+		}, void 0, location, $.context);
+	};
+}
+function booleanFunction(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		$.CONSUME(T.BooleanFunction);
+		let arg = $.SUBRULE($.guardInner, { ARGS: [{
+			...ctx,
+			inValueList: true
+		}] });
+		$.CONSUME(T.RParen);
+		let location = $.endRule();
+		const argValue = arg instanceof Paren ? arg.value : void 0;
+		return new Expression(argValue instanceof Node ? argValue : arg, { parens: true }, location, $.context);
+	};
+}
+function varReference(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		let node = $.OR([
+			{ ALT: () => {
+				let token = $.CONSUME(T.PropertyReference);
+				if ($.RECORDING_PHASE) return;
+				if (ctx.inCustomPropertyValue) {
+					const atName = token.image;
+					const ident = token.image.slice(1);
+					$.warnDeprecation(`${atName} in custom property values is treated as literal text, not a property reference. Use \${${ident}} if you want it to be evaluated.`, token, "property-in-unknown-value");
+					return new Reference({ key: new Quoted(token.image.slice(1), { quote: "'" }, $.getLocationInfo(token), $.context) }, {
+						type: "index",
+						role: "ident"
+					}, $.getLocationInfo(token), $.context);
+				}
+				return new Reference({ key: new Quoted(token.image.slice(1), { quote: "'" }, $.getLocationInfo(token), $.context) }, { type: "index" }, $.getLocationInfo(token), $.context);
+			} },
+			{ ALT: () => {
+				let token = $.CONSUME(T.NestedReference);
+				if ($.RECORDING_PHASE) return;
+				const raw = token.image;
+				const isPropertyLookup = raw.startsWith("$");
+				const type = raw.startsWith("@") ? "variable" : "index";
+				const rawKey = getInterpolatedOrString(raw);
+				const key = isPropertyLookup ? typeof rawKey === "string" ? new Quoted(rawKey, { quote: "'" }, $.getLocationInfo(token), $.context) : new Quoted(rawKey, { quote: "'" }, $.getLocationInfo(token), $.context) : rawKey;
+				if (ctx.inCustomPropertyValue && typeof key === "string") return new Reference({ key }, {
+					type: "variable",
+					role: "ident"
+				}, $.getLocationInfo(token), $.context);
+				if (typeof key === "string") return new Reference(key, { type }, $.getLocationInfo(token), $.context);
+				return new Reference({ key }, { type }, $.getLocationInfo(token), $.context);
+			} },
+			{ ALT: () => {
+				let token = $.SUBRULE($.varName, { ARGS: [ctx] });
+				if ($.RECORDING_PHASE) return;
+				if (ctx.inCustomPropertyValue) {
+					const atName = token.image;
+					const ident = token.image.slice(1);
+					$.warnDeprecation(`${atName} in custom property values is treated as literal text, not a variable reference. Use @{${ident}} if you want it to be evaluated.`, token, "variable-in-unknown-value");
+					return new Reference({ key: token.image.slice(1) }, {
+						type: "variable",
+						role: "ident"
+					}, $.getLocationInfo(token), $.context);
+				}
+				if (ctx.atRulePreludeBareVariableAs === "index") {
+					const nextToken = $.LA(1).tokenType;
+					if ($.noSep() && (nextToken === T.LSquare || nextToken === T.LParen)) return new Reference(token.image.slice(1), { type: "variable" }, $.getLocationInfo(token), $.context);
+					const atName = token.image;
+					const ident = token.image.slice(1);
+					$.warnDeprecation(`"${atName}" in at-rule preludes is deprecated. Use "@{${ident}}" in Less; outside declaration values this is normalized to indexed lookup syntax.`, token, "at-rule-prelude-variable");
+					return new Reference({ key: ident }, {
+						type: "index",
+						role: "ident"
+					}, $.getLocationInfo(token), $.context);
+				}
+				return new Reference(token.image.slice(1), { type: "variable" }, $.getLocationInfo(token), $.context);
+			} }
+		]);
+		$.OR2([
+			{ ALT: () => {
+				/** This spreads a (list) value within a containing list when evaluated */
+				let token = $.CONSUME(T.Ellipsis);
+				if (!$.RECORDING_PHASE) node = new Rest(node, void 0, $.getLocationFromNodes([node, token]), $.context);
+			} },
+			{
+				GATE: () => {
+					if (node?.options?.type !== "variable") return false;
+					let next = $.LA(1).tokenType;
+					if (next !== T.LSquare && next !== T.LParen) return false;
+					if (!$.noSep()) return false;
+					return true;
+				},
+				ALT: () => {
+					$.AT_LEAST_ONE({
+						GATE: () => {
+							let next = $.LA(1).tokenType;
+							if (next !== T.LSquare && next !== T.LParen) return false;
+							if (!$.noSep()) return false;
+							return true;
+						},
+						DEF: () => {
+							node = $.SUBRULE($.lookupOrCall, { ARGS: [{
+								...ctx,
+								node
+							}] });
+						}
+					});
+					$.OPTION(() => {
+						$.OPTION2(() => $.CONSUME(T.Gt));
+						node = $.SUBRULE($.mixinReference, { ARGS: [{
+							...ctx,
+							node
+						}] });
+					});
+				}
+			},
+			{ ALT: () => void 0 }
+		]);
+		return node;
+	};
+}
+function valueReference(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		return $.OR([{ ALT: () => $.SUBRULE($.varReference, { ARGS: [ctx] }) }, { ALT: () => $.SUBRULE2($.mixinReference, { ARGS: [ctx] }) }]);
+	};
+}
+function functionCall(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const modernColorFunctions = new Set([
+			"rgb",
+			"rgba",
+			"hsl",
+			"hsla"
+		]);
+		const isModernColorCall = (name, args) => {
+			if (!modernColorFunctions.has(name.toLowerCase())) return false;
+			if (!args || args.value.length !== 1) return false;
+			const firstArg = args.value[0];
+			return Boolean(isNode(firstArg, N.Sequence) && firstArg.value.length >= 2);
+		};
+		let funcAlt = (ctx = {}) => [{
+			GATE: () => {
+				let tokenType = $.LA(1).tokenType;
+				return tokenType === T.UrlStart || tokenType === T.Var || tokenType === T.Calc || tokenType === T.IfFunction || tokenType === T.BooleanFunction;
+			},
+			ALT: () => $.SUBRULE($.knownFunctions, { ARGS: [ctx] })
+		}, {
+			GATE: () => {
+				let tokenType = $.LA(1).tokenType;
+				return tokenType !== T.UrlStart && tokenType !== T.Var && tokenType !== T.Calc && tokenType !== T.IfFunction && tokenType !== T.BooleanFunction;
+			},
+			ALT: () => {
+				$.startRule();
+				const fnStart = $.CONSUME(T.FunctionStart);
+				const fnNameForCtx = fnStart.image.slice(0, -1);
+				let args;
+				$.OPTION(() => args = $.SUBRULE2($.functionCallArgs, { ARGS: [{
+					...ctx,
+					currentFunctionName: fnNameForCtx
+				}] }));
+				$.CONSUME(T.RParen);
+				const location = $.endRule();
+				const nameValue = fnNameForCtx;
+				if (nameValue === "unit" && args?.value[1] instanceof Any) {
+					const unitArg = args.value[1];
+					const quotedUnit = new Quoted(unitArg.valueOf(), { quote: "\"" }, void 0, $.context);
+					const newArgsData = [...args.value];
+					newArgsData[1] = quotedUnit;
+					args = new List(newArgsData, args.options, $.getLocationFromNodes(newArgsData), $.context);
+				}
+				if (ctx.detachedRulesetUsage === "default-param" && nameValue === "default") return new Call({
+					name: "default",
+					args
+				}, void 0, location, $.context);
+				if (nameValue === "each" && args?.value.length === 2 && isNode(args.value[1], N.Mixin)) {
+					const iterable = args.value[0];
+					const callback = args.value[1];
+					return new For({
+						pattern: createEachPattern(callback, location, $.context),
+						iterable: {
+							kind: "node",
+							value: iterable
+						},
+						rules: callback.rules
+					}, void 0, location, $.context);
+				}
+				const nameNode = new Reference(nameValue, {
+					type: "function",
+					fallbackValue: true
+				}, $.getLocationInfo(fnStart), $.context);
+				/** Less / Sass functions we try to call that throw just get turned into calls. */
+				const modernSyntax = isModernColorCall(nameValue, args);
+				return new Call({
+					name: nameNode,
+					args
+				}, {
+					silentFail: true,
+					...modernSyntax ? { modernSyntax: true } : {}
+				}, location, $.context);
+			}
+		}];
+		return $.OR(funcAlt(ctx));
+	};
+}
+function functionCallArgs(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		const prevInner = ctx.inner;
+		ctx.inner = true;
+		const argCtx = {
+			...ctx,
+			allowComma: false,
+			parenFrames: [...getParenFrames$1(ctx), false],
+			detachedRulesetUsage: "function-arg",
+			inFunctionArgs: true
+		};
+		let commaNodes;
+		let semiNodes = [];
+		let isSemiList = false;
+		try {
+			let node = $.SUBRULE($.callArgument, { ARGS: [argCtx] });
+			commaNodes = [node];
+			$.MANY({
+				GATE: () => $.isType(T.Comma),
+				DEF: () => {
+					$.CONSUME(T.Comma);
+					node = $.SUBRULE2($.callArgument, { ARGS: [argCtx] });
+					commaNodes.push(node);
+				}
+			});
+			$.OPTION(() => {
+				$.CONSUME(T.Semi);
+				isSemiList = true;
+				if (commaNodes.length > 1) semiNodes.push(new List(commaNodes, void 0, $.getLocationFromNodes(commaNodes), $.context));
+				else semiNodes.push(commaNodes[0]);
+				node = $.SUBRULE3($.callArgument, { ARGS: [{
+					...argCtx,
+					allowComma: true
+				}] });
+				semiNodes.push(node);
+				$.MANY2({
+					GATE: () => $.isType(T.Semi),
+					DEF: () => {
+						$.CONSUME2(T.Semi);
+						node = $.SUBRULE4($.callArgument, { ARGS: [{
+							...argCtx,
+							allowComma: true
+						}] });
+						semiNodes.push(node);
+					}
+				});
+			});
+		} finally {
+			ctx.inner = prevInner;
+		}
+		$.endRule();
+		return new List(isSemiList ? semiNodes : commaNodes, isSemiList ? { sep: ";" } : void 0);
+	};
+}
+function value(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		if ($.isType(T.Percent)) {}
+		let _isMixinReference = void 0;
+		const isMixinReference = () => {
+			if (_isMixinReference === void 0) {
+				let tt1 = $.LA(1).tokenType;
+				let tt2 = $.LA(2).tokenType;
+				/**
+				* We'll allow a few "bare" mixin references without parens
+				* or square brackets, but not if they'll conflict with
+				* other syntax.
+				*/
+				_isMixinReference = tt1 === T.DotName || tt1 === T.HashName || tt1 === T.InterpolatedSelector || (tt1 === T.ColorIdentStart || tt1 === T.InterpolatedSelector) && (tt2 === T.Gt || tt2 === T.DotName || tt2 === T.HashName || tt2 === T.InterpolatedSelector || $.noSep(1) && (tt2 === T.LParen || tt2 === T.LSquare || tt2 === T.HashName || tt2 === T.DotName));
+			}
+			return _isMixinReference;
+		};
+		let node = $.OR([
+			{
+				GATE: () => $.check(T.FunctionStart),
+				ALT: () => $.SUBRULE($.functionCall, { ARGS: [ctx] })
+			},
+			{
+				GATE: () => $.isType(T.Star) && $.isTypeAt(2, T.LSquare),
+				ALT: () => $.SUBRULE($.selectorCapture, { ARGS: [ctx] })
+			},
+			{
+				GATE: isMixinReference,
+				ALT: () => $.SUBRULE($.mixinReference, { ARGS: [ctx] })
+			},
+			{
+				GATE: () => !isMixinReference(),
+				ALT: () => $.CONSUME(T.Color)
+			},
+			{
+				GATE: () => !isMixinReference(),
+				ALT: () => $.CONSUME2(T.Ident)
+			},
+			{ ALT: () => $.SUBRULE($.varReference, { ARGS: [ctx] }) },
+			{ ALT: () => $.CONSUME(T.DefaultGuardFunc) },
+			{ ALT: () => $.CONSUME(T.Dimension) },
+			{ ALT: () => $.CONSUME(T.Number) },
+			{
+				GATE: () => ctx.currentFunctionName === "unit",
+				ALT: () => $.CONSUME(T.Percent)
+			},
+			{ ALT: () => $.CONSUME(T.UnicodeRange) },
+			{ ALT: () => $.SUBRULE($.string, { ARGS: [ctx] }) },
+			{ ALT: () => $.CONSUME(T.JavaScript) },
+			(
+			/** Explicitly not marked as an ident */
+			{ ALT: () => $.CONSUME(T.When) }),
+			{ ALT: () => $.SUBRULE($.squareValue, { ARGS: [ctx] }) },
+			{
+				GATE: () => $.looseMode && !!ctx.inner,
+				ALT: () => $.CONSUME(T.Colon)
+			},
+			{
+				GATE: () => $.looseMode && !!ctx.inFunctionArgs,
+				ALT: () => $.CONSUME(T.Eq)
+			},
+			{
+				GATE: () => $.looseMode,
+				ALT: () => $.CONSUME(T.Unknown)
+			},
+			{
+				GATE: () => $.legacyMode,
+				ALT: () => $.CONSUME(T.LegacyMSFilter)
+			}
+		]);
+		if (!$.RECORDING_PHASE) {
+			if (!(node instanceof Node)) node = $.processValueToken(node);
+			return node;
+		}
+	};
+}
+function string(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		return $.OR([{
+			GATE: () => $.isType(T.SingleQuoteStart),
+			ALT: () => {
+				$.startRule();
+				let quote = $.CONSUME(T.SingleQuoteStart);
+				let contents;
+				$.OPTION2(() => contents = $.CONSUME(T.SingleQuoteStringContents));
+				$.CONSUME(T.SingleQuoteEnd);
+				let quoteImg = quote.image;
+				let escaped = false;
+				if (quoteImg.startsWith("~")) {
+					escaped = true;
+					quoteImg = quoteImg.slice(1);
+				}
+				let location = $.endRule();
+				let value = contents?.image;
+				if (escaped && value) value = value.replace(/\\(?:\r\n?|\n|\f)/g, "\n");
+				if ($.RECORDING_PHASE) return;
+				const quoteChar = toQuote(quoteImg);
+				if (value && (value.includes("@{") || value.includes("${"))) return new Quoted(processStringInterpolation(value, location, $.context), {
+					quote: quoteChar,
+					escaped
+				}, location, $.context);
+				return new Quoted(new Any(value ?? "", { role: "any" }), {
+					quote: quoteChar,
+					escaped
+				}, location, $.context);
+			}
+		}, {
+			GATE: () => $.isType(T.DoubleQuoteStart),
+			ALT: () => {
+				$.startRule();
+				let quote = $.CONSUME(T.DoubleQuoteStart);
+				let contents;
+				$.OPTION3(() => contents = $.CONSUME(T.DoubleQuoteStringContents));
+				$.CONSUME(T.DoubleQuoteEnd);
+				let quoteImg = quote.image;
+				let escaped = false;
+				if (quoteImg.startsWith("~")) {
+					escaped = true;
+					quoteImg = quoteImg.slice(1);
+				}
+				let location = $.endRule();
+				let value = contents?.image;
+				if (escaped && value) value = value.replace(/\\(?:\r\n?|\n|\f)/g, "\n");
+				if ($.RECORDING_PHASE) return;
+				const quoteChar = toQuote(quoteImg);
+				if (value && (value.includes("@{") || value.includes("${"))) return new Quoted(processStringInterpolation(value, location, $.context), {
+					quote: quoteChar,
+					escaped
+				}, location, $.context);
+				return new Quoted(new Any(value ?? "", { role: "any" }), {
+					quote: quoteChar,
+					escaped
+				}, location, $.context);
+			}
+		}]);
+	};
+}
+/**
+* Find interpolation patterns like @{...} or ${...}, handling nested braces.
+* Returns an array of { start, end, prefix, content } for each match.
+*/
+function 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) {
+			const content = value.slice(contentStart, i - 1);
+			matches.push({
+				start,
+				end: i,
+				prefix,
+				content
+			});
+		}
+	} else i++;
+	return matches;
+}
+function processStringInterpolation(value, location, context) {
+	const matches = findInterpolations(value);
+	if (matches.length === 0) return new Any(value, { role: "any" }, location, context);
+	const replacements = [];
+	let source = value;
+	let offset = 0;
+	for (const match of matches) {
+		const adjustedStart = match.start - offset;
+		const adjustedEnd = match.end - offset;
+		const before = source.slice(0, adjustedStart);
+		const after = source.slice(adjustedEnd);
+		source = before + INTERPOLATION_PLACEHOLDER + after;
+		offset += match.end - match.start - INTERPOLATION_PLACEHOLDER.length;
+		const innerResult = processStringInterpolation(match.content, location, context);
+		if (innerResult instanceof Interpolated) {
+			const nestedRef = new Reference({ key: innerResult }, {
+				type: "variable",
+				role: "ident"
+			}, location, context);
+			replacements.push(new Expression(nestedRef, void 0, location, context));
+		} else replacements.push(createInterpolatedReference(match.prefix, match.content, location, context));
+	}
+	return new Interpolated({
+		source,
+		replacements
+	}, { role: "ident" }, location, context);
+}
+function mathValue(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		let valueAlt = (ctx = {}) => [
+			{ ALT: () => $.CONSUME(T.AtKeyword) },
+			{ ALT: () => $.CONSUME(T.Number) },
+			{ ALT: () => $.CONSUME(T.Dimension) },
+			{ ALT: () => $.CONSUME(T.Ident) },
+			{ ALT: () => $.SUBRULE($.functionCall, { ARGS: [ctx] }) },
+			{
+				GATE: () => $.LA(1).image.startsWith("~"),
+				ALT: () => $.SUBRULE2($.string, { ARGS: [ctx] })
+			},
+			{
+				GATE: () => !$.isTypeAt(2, T.LParen),
+				ALT: () => $.CONSUME(T.MathConstant)
+			},
+			{ ALT: () => $.SUBRULE($.mathParen, { ARGS: [ctx] }) }
+		];
+		return cssMathValue.call($, T, valueAlt)(ctx);
+	};
+}
+function mathProduct(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		let left = $.SUBRULE($.mathValue, { ARGS: [ctx] });
+		while ($.isType(T.Star) || $.isType(T.Divide)) {
+			const op = $.isType(T.Star) ? $.CONSUME(T.Star) : $.CONSUME(T.Divide);
+			const right = $.SUBRULE2($.mathValue, { ARGS: [ctx] });
+			if (!RECORDING_PHASE) {
+				const opStr = toOperator(op.image);
+				left = new Operation([
+					left,
+					opStr,
+					right
+				], { inCalc: true }, void 0, $.context);
+			}
+		}
+		if (RECORDING_PHASE) return;
+		left._location = $.endRule();
+		return left;
+	};
+}
+function mathSum(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		let left = $.SUBRULE($.mathProduct, { ARGS: [ctx] });
+		$.MANY(() => {
+			const op = $.CONSUME(T.AdditionOperator);
+			const right = $.SUBRULE2($.mathProduct, { ARGS: [ctx] });
+			if (!RECORDING_PHASE) {
+				const opStr = toOperator(op.image);
+				left = new Operation([
+					left,
+					opStr,
+					right
+				], { inCalc: true }, void 0, $.context);
+			}
+		});
+		if (RECORDING_PHASE) return;
+		left._location = $.endRule();
+		return left;
+	};
+}
+//#endregion
+//#region src/productions/guards.ts
+function isScriptUsePath(path) {
+	const filePart = path.replace(/[?#].*$/u, "");
+	return path === "#less" || path.startsWith("#less/") || /\.(?:js|mjs|cjs|ts|mts|cts|json)$/i.test(filePart);
+}
+function defaultNamespaceFromPath(path) {
+	if (path === "#less") return "less";
+	if (path.startsWith("#less/")) return path.split("/").filter(Boolean).pop();
+	const base = path.split("/").filter(Boolean).pop();
+	if (!base) return;
+	return base.replace(/\.(less|css|jess|js|mjs|cjs|ts|mts|cts|json)$/i, "") || void 0;
+}
+function getParenFrames(ctx) {
+	return ctx?.parenFrames ?? [];
+}
+function isDefaultGuardCall(node) {
+	if (!node || !isNode(node, N.Call)) return false;
+	const callName = node.name;
+	const callNameStr = String(typeof callName === "object" && callName !== null && "valueOf" in callName ? callName.valueOf() : callName ?? "");
+	if (callNameStr === "default" || callNameStr === "??") return true;
+	if (callName instanceof Reference) {
+		const key = callName.key;
+		const keyStr = String(typeof key === "object" && key !== null && "valueOf" in key ? key.valueOf() : key ?? "");
+		return keyStr === "default" || keyStr === "??";
+	}
+	return false;
+}
+const cssUnknownAtRule = productions.unknownAtRule;
+function isGuardComparisonToken(tt, T) {
+	return tt === T.CompareOperator || tt === T.Eq || tt === T.Gt || tt === T.GtEq || tt === T.GtEqAlias || tt === T.Lt || tt === T.LtEq || tt === T.LtEqAlias;
+}
+function normalizeComparisonOperator(op) {
+	switch (op) {
+		case "=>":
+		case ">=": return ">=";
+		case "=<":
+		case "<=": return "<=";
+		case "=": return "=";
+		case ">": return ">";
+		case "<": return "<";
+		default: return "=";
+	}
+}
+function guard(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.CONSUME(T.When);
+		return $.OR([{
+			GATE: () => !!ctx.inValueList,
+			ALT: () => $.SUBRULE($.comparison, { ARGS: [ctx] })
+		}, { ALT: () => {
+			return $.SUBRULE($.guardOr, { ARGS: [{
+				...ctx,
+				allowComma: true
+			}] });
+		} }]);
+	};
+}
+/**
+* 'or' expression
+* Allows an (outer) comma like historical media queries
+*/
+function guardOr(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		let left = $.SUBRULE($.guardAnd, { ARGS: [ctx] });
+		let right;
+		$.MANY({
+			GATE: () => ctx.allowComma && $.isType(T.Comma) || $.isType(T.Or),
+			DEF: () => {
+				/**
+				* Nest expressions within expressions for correct
+				* order of operations.
+				*/
+				$.OR([{ ALT: () => $.CONSUME(T.Comma) }, { ALT: () => $.CONSUME(T.Or) }]);
+				right = $.SUBRULE2($.guardAnd, { ARGS: [ctx] });
+				let location = $.endRule();
+				$.startRule();
+				left = new Condition([
+					left,
+					"or",
+					right
+				], void 0, location, $.context);
+			}
+		});
+		$.endRule();
+		return left;
+	};
+}
+function guardDefault(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		let guard = $.OR([{ ALT: () => $.CONSUME(T.DefaultGuardIdent) }, { ALT: () => $.CONSUME(T.DefaultGuardFunc) }]);
+		if ($.RECORDING_PHASE) return;
+		ctx.hasDefault = true;
+		return new DefaultGuard(guard.image, void 0, $.getLocationInfo(guard));
+	};
+}
+/**
+* 'and' and 'or' expressions
+*
+*  In Media queries level 4, you cannot have
+*  `([expr]) or ([expr]) and ([expr])` because
+*  of evaluation order ambiguity.
+*  However, Less allows it.
+*/
+function guardAnd(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		let left;
+		$.MANY_SEP({
+			SEP: T.And,
+			DEF: () => {
+				let not;
+				$.OPTION(() => not = $.CONSUME(T.Not));
+				let allowComma = ctx.allowComma;
+				ctx.allowComma = false;
+				let right;
+				try {
+					right = $.OR([{ ALT: () => $.SUBRULE($.guardInParens, { ARGS: [ctx] }) }, {
+						GATE: () => {
+							const tokenType = $.LA(1).tokenType;
+							return tokenType !== T.Not && tokenType !== T.DefaultGuardFunc && tokenType !== T.DefaultGuardIdent;
+						},
+						ALT: () => $.SUBRULE($.expressionSum, { ARGS: [ctx] })
+					}]);
+					$.OPTION2({
+						GATE: () => isGuardComparisonToken($.LA(1).tokenType, T),
+						DEF: () => {
+							const op = $.CONSUME(T.CompareOperator);
+							const compareRight = $.SUBRULE2($.expressionSum, { ARGS: [ctx] });
+							if (!$.RECORDING_PHASE) right = new Condition([
+								right,
+								normalizeComparisonOperator(op.image),
+								compareRight
+							], void 0, $.getLocationFromNodes([right, compareRight]), $.context);
+						}
+					});
+				} finally {
+					ctx.allowComma = allowComma;
+				}
+				if (!$.RECORDING_PHASE) {
+					if (isDefaultGuardCall(right)) {
+						ctx.hasDefault = true;
+						right = new DefaultGuard("default()", void 0, Array.isArray(right.location) && right.location.length === 6 ? right.location : void 0);
+					}
+					if (not) {
+						let [, , , endOffset, endLine, endColumn] = right.location;
+						let [startOffset, startLine, startColumn] = $.getLocationInfo(not);
+						right = new Condition([right], { negate: true }, [
+							startOffset,
+							startLine,
+							startColumn,
+							endOffset,
+							endLine,
+							endColumn
+						], $.context);
+					}
+					if (!left) {
+						left = right;
+						return;
+					}
+					left = new Condition([
+						left,
+						"and",
+						right
+					], void 0, $.getLocationFromNodes([left, right]), $.context);
+				}
+			}
+		});
+		return left;
+	};
+}
+function guardInParens(T) {
+	const $ = this;
+	return (ctx) => {
+		$.startRule();
+		let node = $.OR([{ ALT: () => $.SUBRULE($.guardDefault, { ARGS: [ctx] }) }, { ALT: () => {
+			$.CONSUME(T.LParen);
+			let node = $.SUBRULE($.guardInner, { ARGS: [ctx] });
+			$.CONSUME(T.RParen);
+			return node;
+		} }]);
+		if (isDefaultGuardCall(node)) {
+			ctx.hasDefault = true;
+			node = new DefaultGuard("default()", void 0, Array.isArray(node.location) && node.location.length === 6 ? node.location : void 0);
+		}
+		node = node;
+		return new Paren(node, void 0, $.endRule(), $.context);
+	};
+}
+function guardInner(_T) {
+	const $ = this;
+	return (ctx = {}) => {
+		return $.SUBRULE($.guardOr, { ARGS: [ctx] });
+	};
+}
+function guardWithConditionValue(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		if ($.isType(T.DefaultGuardIdent) || $.isType(T.DefaultGuardFunc)) {
+			$.OR([{ ALT: () => $.CONSUME(T.DefaultGuardIdent) }, { ALT: () => $.CONSUME(T.DefaultGuardFunc) }]);
+			return;
+		}
+		return $.SUBRULE($.guardInParens, { ARGS: [ctx] });
+	};
+}
+function guardWithCondition(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.SUBRULE($.guardWithConditionValue, { ARGS: [ctx] });
+		$.AT_LEAST_ONE(() => {
+			$.OR([
+				{ ALT: () => $.CONSUME(T.Or) },
+				{ ALT: () => $.CONSUME(T.And) },
+				{ ALT: () => $.CONSUME(T.Comma) }
+			]);
+			$.SUBRULE2($.guardWithConditionValue, { ARGS: [ctx] });
+		});
+	};
+}
+/**
+* Currently, Less only allows a single comparison expression,
+* unlike Media Queries Level 4, which allows a left and right
+* comparison.
+*/
+function comparison(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		let left = $.SUBRULE($.expressionSum, { ARGS: [ctx] });
+		const op = $.CONSUME(T.CompareOperator);
+		let right = $.SUBRULE2($.expressionSum, { ARGS: [ctx] });
+		if (isDefaultGuardCall(right)) {
+			ctx.hasDefault = true;
+			right = new DefaultGuard("default()", void 0, Array.isArray(right.location) && right.location.length === 6 ? right.location : void 0);
+		}
+		left = new Condition([
+			left,
+			normalizeComparisonOperator(op.image),
+			right
+		], void 0, $.getLocationFromNodes([left, right]), $.context);
+		return left;
+	};
+}
+/**
+* Less (perhaps unwisely) allows bubbling of normally document-root
+* at-rules, so we need to override CSS here.
+*/
+function innerAtRule(_T) {
+	const $ = this;
+	return (ctx = {}) => {
+		return $.OR([
+			{ ALT: () => $.SUBRULE($.mediaAtRule, { ARGS: [{
+				...ctx,
+				inner: true
+			}] }) },
+			{ ALT: () => $.SUBRULE($.supportsAtRule, { ARGS: [{
+				...ctx,
+				inner: true
+			}] }) },
+			{ ALT: () => $.SUBRULE($.layerAtRule, { ARGS: [{
+				...ctx,
+				inner: true
+			}] }) },
+			{ ALT: () => $.SUBRULE($.containerAtRule, { ARGS: [{
+				...ctx,
+				inner: true
+			}] }) },
+			{ ALT: () => $.SUBRULE($.keyframesAtRule, { ARGS: [{
+				...ctx,
+				inner: true
+			}] }) },
+			{ ALT: () => $.SUBRULE($.documentAtRule, { ARGS: [{
+				...ctx,
+				inner: true
+			}] }) },
+			{ ALT: () => $.SUBRULE($.importAtRule, { ARGS: [ctx] }) },
+			{ ALT: () => $.SUBRULE($.pageAtRule, { ARGS: [ctx] }) },
+			{ ALT: () => $.SUBRULE($.fontFaceAtRule, { ARGS: [ctx] }) },
+			{ ALT: () => $.SUBRULE($.nestedAtRule, { ARGS: [ctx] }) },
+			{ ALT: () => $.SUBRULE($.nonNestedAtRule, { ARGS: [ctx] }) },
+			{ ALT: () => $.SUBRULE($.unknownAtRule, { ARGS: [{
+				...ctx,
+				inner: true
+			}] }) }
+		]);
+	};
+}
+/**
+* Less override: allow variable reference as the first segment of a layer-name
+* CSS: <ident> ('.' <ident>)*
+* Less: (<var-ref> | <ident>) ('.' <ident>)*
+*/
+function layerName(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const preludeCtx = {
+			...ctx,
+			atRulePreludeBareVariableAs: "index"
+		};
+		$.startRule();
+		let RECORDING_PHASE = $.RECORDING_PHASE;
+		let nodes;
+		if (!RECORDING_PHASE) nodes = [];
+		const first = $.OR([{ ALT: () => $.SUBRULE($.valueReference, { ARGS: [preludeCtx] }) }, {
+			GATE: () => $.isType(T.Ident),
+			ALT: () => $.CONSUME(T.Ident)
+		}]);
+		if (!RECORDING_PHASE) if (first instanceof Node) nodes.push(first);
+		else nodes.push($.processValueToken(first));
+		$.MANY({
+			GATE: $.noSep.bind($),
+			DEF: () => {
+				const seg = $.CONSUME(T.DotName);
+				if (!RECORDING_PHASE) nodes.push($.processValueToken(seg));
+			}
+		});
+		if (RECORDING_PHASE) return;
+		const loc = $.endRule();
+		return new Sequence(nodes, void 0, loc, $.context);
+	};
+}
+/**
+* Less override: allow variable reference for @keyframes name
+* CSS: Ident | String
+* Less: valueReference | Ident | String
+*/
+function keyframesName(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const preludeCtx = {
+			...ctx,
+			atRulePreludeBareVariableAs: "index"
+		};
+		let node;
+		$.OR([
+			{ ALT: () => node = $.SUBRULE($.valueReference, { ARGS: [preludeCtx] }) },
+			{
+				GATE: () => $.isType(T.Ident) && !$.isType(T.InterpolatedIdent),
+				ALT: () => {
+					const tok = $.CONSUME(T.Ident);
+					node = $.processValueToken(tok);
+				}
+			},
+			{ ALT: () => node = $.SUBRULE($.string, { ARGS: [] }) }
+		]);
+		return node;
+	};
+}
+/**
+* One of the rare rules that returns a token, because
+* other rules will transform it differently.
+*/
+function mixinName(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		/** e.g. .mixin, #mixin */
+		let name = $.OR([
+			{ ALT: () => $.CONSUME(T.HashName) },
+			{ ALT: () => $.CONSUME(T.ColorIdentStart) },
+			{ ALT: () => $.CONSUME(T.DotName) },
+			{ ALT: () => $.CONSUME(T.InterpolatedIdent) },
+			{ ALT: () => $.CONSUME(T.InterpolatedSelector) }
+		]);
+		if ($.RECORDING_PHASE) return;
+		const asReference = ctx.asReference;
+		let nameNode;
+		let nameValue = name.image;
+		let location = $.getLocationInfo(name);
+		if (nameValue.includes("@") || nameValue.includes("$")) {
+			const interpolated = getInterpolatedNode(nameValue, location, $.context);
+			nameNode = interpolated;
+			if (asReference) if (isNode(ctx.node, N.Reference) && ctx.node.options.type === "mixin-ruleset") nameNode = new Reference({
+				target: ctx.node,
+				key: interpolated
+			}, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, location, $.context);
+			else {
+				const target = ctx.node;
+				nameNode = new Reference({
+					target: target instanceof Call ? target : target instanceof Reference ? target : void 0,
+					key: interpolated
+				}, {
+					type: "mixin-ruleset",
+					role: "name"
+				}, location, $.context);
+			}
+		} else if (asReference) if (isNode(ctx.node, N.Reference) && ctx.node.options.type === "mixin-ruleset") {
+			const existingKey = ctx.node.key;
+			const existingRawKey = ctx.node.rawKey;
+			let mergedKeys;
+			if (Array.isArray(existingKey)) mergedKeys = [...existingKey];
+			else mergedKeys = [String(existingKey)];
+			mergedKeys.push(nameValue);
+			const rawPrefix = Array.isArray(existingRawKey) ? existingRawKey.join(" > ") : typeof existingRawKey === "string" ? existingRawKey : Array.isArray(existingKey) ? existingKey.join(" > ") : String(existingKey);
+			nameNode = new Reference({
+				key: mergedKeys.length === 1 ? mergedKeys[0] : mergedKeys,
+				rawKey: `${rawPrefix} > ${nameValue}`
+			}, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, location, $.context);
+		} else {
+			const target = ctx.node;
+			nameNode = new Reference({
+				target: target instanceof Call ? target : target instanceof Reference ? target : void 0,
+				key: nameValue
+			}, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, location, $.context);
+		}
+		else nameNode = new Any(nameValue, { role: "name" }, $.getLocationInfo(name), $.context);
+		return nameNode;
+	};
+}
+/**
+* Used within a value. These can be
+* chained more recursively, unlike
+* Less 1.x-4.x
+*   e.g. .mixin1() > .mixin2[@val1].ns() > .sub-mixin[@val2]
+*
+* This production intelligently decides whether to produce a Call or Reference
+* based on whether there are parentheses at the end:
+* - foo: #id; // Reference
+* - foo: .class; // Reference
+* - foo: #id > .scoped; // Reference
+* - foo: #id > .scoped(); // Call
+* - foo: #id[]; // Reference with accessor
+* - foo: #id > .scoped[foo]; // Reference with accessor
+* - foo: #id > .scoped[@ref](); // Call with accessor
+*/
+function mixinReference(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		let leftNode = $.SUBRULE($.mixinName, { ARGS: [{
+			...ctx,
+			asReference: true
+		}] });
+		$.MANY({
+			GATE: () => {
+				let next = $.LA(1).tokenType;
+				return $.noSep() && (next === T.LParen || next === T.LSquare);
+			},
+			DEF: () => {
+				leftNode = $.SUBRULE($.lookupOrCall, { ARGS: [{
+					...ctx,
+					node: leftNode
+				}] });
+			}
+		});
+		$.OPTION(() => {
+			$.OPTION2(() => $.CONSUME(T.Gt));
+			leftNode = $.SUBRULE($.mixinReference, { ARGS: [{
+				...ctx,
+				node: leftNode
+			}] });
+		});
+		return leftNode;
+	};
+}
+function mixinArgs(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		let args;
+		const hasWhitespace = !$.noSep();
+		const openingParenToken = hasWhitespace ? $.LA(1) : void 0;
+		$.CONSUME(T.LParen);
+		const argCtx = {
+			...ctx,
+			node: void 0,
+			allowComma: false,
+			parenFrames: [...getParenFrames(ctx), false],
+			detachedRulesetUsage: ctx.isDefinition ? "default-param" : "mixin-arg"
+		};
+		if (!$.isType(T.RParen)) args = $.SUBRULE($.mixinArgList, { ARGS: [argCtx] });
+		$.CONSUME(T.RParen);
+		if (hasWhitespace && openingParenToken) {
+			const nextAfterParens = $.LA(1).tokenType;
+			if (!(nextAfterParens === T.LCurly || nextAfterParens === T.When)) $.warnDeprecation("Whitespace between a mixin name and parentheses for a mixin call is deprecated", openingParenToken, "mixin-call-whitespace");
+		}
+		return args;
+	};
+}
+function lookupOrCall(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		return $.OR([{ ALT: () => {
+			let keyToken;
+			$.CONSUME(T.LSquare);
+			$.OPTION(() => keyToken = $.OR2([
+				{ ALT: () => $.CONSUME(T.NestedReference) },
+				{ ALT: () => $.CONSUME(T.AtKeyword) },
+				{ ALT: () => $.CONSUME(T.PropertyReference) },
+				{ ALT: () => $.CONSUME(T.InterpolatedIdent) },
+				{
+					GATE: () => !$.isType(T.NestedReference) && !$.isType(T.AtKeyword) && !$.isType(T.PropertyReference) && !$.isType(T.InterpolatedIdent) && $.isType(T.Ident),
+					ALT: () => $.CONSUME(T.Ident)
+				}
+			]));
+			$.CONSUME(T.RSquare);
+			if ($.RECORDING_PHASE) return;
+			let ref;
+			const targetNode = ctx.node;
+			const target = targetNode instanceof Call ? targetNode : targetNode instanceof Reference ? targetNode : void 0;
+			if (keyToken) {
+				let tokenStr = keyToken.image;
+				let type = tokenStr.startsWith("@") ? "variable" : "index";
+				if (keyToken.tokenType === T.NestedReference) {
+					tokenStr = keyToken.image;
+					if (!tokenStr.startsWith("$") && !tokenStr.startsWith("@")) tokenStr = "$" + tokenStr;
+				}
+				let rawResult = getInterpolatedOrString(tokenStr, $.getLocationInfo(keyToken), $.context);
+				let result = rawResult;
+				if (type === "index") result = new Quoted(rawResult, { quote: "'" }, $.getLocationInfo(keyToken), $.context);
+				const targetType = isNode(target, N.Reference) ? target.options.type : void 0;
+				const shouldMergeKeys = targetType === "mixin" || targetType === "mixin-ruleset";
+				if (isNode(target, N.Reference) && target.options.type === type && typeof result === "string" && shouldMergeKeys) {
+					const existingKey = target.key;
+					let mergedKeys;
+					if (Array.isArray(existingKey)) mergedKeys = [...existingKey];
+					else mergedKeys = [String(existingKey)];
+					mergedKeys.push(result);
+					ref = new Reference({ key: mergedKeys.length === 1 ? mergedKeys[0] : mergedKeys }, { type }, $.endRule(), $.context);
+				} else ref = new Reference({
+					target,
+					key: result
+				}, { type }, $.endRule(), $.context);
+			} else ref = new Reference({
+				target,
+				key: -1
+			}, { type: "index" }, $.endRule(), $.context);
+			/** Reference targets will technically precede the reference, so we need to update the location to the target start location */
+			if (target) {
+				let [targetStartOffset, targetStartLine, targetStartColumn] = target.location;
+				ref.location.start = targetStartOffset;
+				ref.location[1] = targetStartLine;
+				ref.location[2] = targetStartColumn;
+			}
+			return ref;
+		} }, { ALT: () => {
+			let args = $.SUBRULE($.mixinArgs, { ARGS: [ctx] });
+			if ($.RECORDING_PHASE) return;
+			return new Call({
+				name: ctx.node,
+				args
+			}, void 0, $.endRule(), $.context);
+		} }]);
+	};
+}
+/**
+* @see https://lesscss.org/features/#mixins-feature-mixins-parametric-feature
+*
+* This rule is recursive to allow chevrotain-allstar (hopefully) to lookahead
+* and find semi-colon separators vs. commas.
+*/
+function mixinArgList(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		let commaNodes = [$.SUBRULE($.mixinArg, { ARGS: [ctx] })];
+		const semiNodes = [];
+		let isSemiList = false;
+		const collapseCommaNodesIntoSemiNodes = (semi) => {
+			if (!commaNodes) return;
+			if (commaNodes.length > 1) {
+				const [head, ...rest] = commaNodes;
+				let hasDeclarations = false;
+				if (head instanceof VarDeclaration) {
+					const headValue = head.value instanceof Node ? head.value : void 0;
+					const nodes = headValue ? [headValue, ...rest] : [...rest];
+					hasDeclarations = rest.some((n) => n instanceof VarDeclaration);
+					const value = new List(nodes, void 0, $.getLocationFromNodes(nodes), $.context);
+					semiNodes.push(new VarDeclaration({
+						name: head.name,
+						value,
+						important: head.important
+					}, head.options, head.location, $.context));
+				} else {
+					hasDeclarations = commaNodes.some((n) => n instanceof VarDeclaration);
+					semiNodes.push(new List(commaNodes, void 0, $.getLocationFromNodes(commaNodes), $.context));
+				}
+				if (hasDeclarations) {
+					const indexOfSemi = $.input.indexOf(semi);
+					const previousToken = $.input[indexOfSemi - 1];
+					$.SAVE_ERROR(new NoViableAltException("Cannot mix ; and , as delimiter types", semi, previousToken));
+				}
+			} else semiNodes.push(commaNodes[0]);
+			commaNodes = void 0;
+		};
+		while ($.isType(T.Comma) || $.isType(T.Semi)) {
+			if ($.isType(T.Comma)) {
+				const comma = $.CONSUME(T.Comma);
+				const node = $.SUBRULE2($.mixinArg, { ARGS: [ctx] });
+				if (commaNodes) commaNodes.push(node);
+				else {
+					$.SAVE_ERROR(new NoViableAltException("Cannot mix ; and , as delimiter types", comma, $.LA(0)));
+					semiNodes.push(node);
+				}
+				continue;
+			}
+			const semi = $.CONSUME(T.Semi);
+			isSemiList = true;
+			collapseCommaNodesIntoSemiNodes(semi);
+			if ($.isType(T.RParen)) break;
+			const prevAllow = ctx.allowComma;
+			ctx.allowComma = true;
+			const node = $.SUBRULE3($.mixinArg, { ARGS: [ctx] });
+			ctx.allowComma = prevAllow;
+			semiNodes.push(node);
+		}
+		let location = $.endRule();
+		return new List(isSemiList ? semiNodes : commaNodes, { sep: isSemiList ? ";" : "," }, location, $.context);
+	};
+}
+/**
+* Less is more lenient about at-keywords. See lessTokens.ts for more details.
+*/
+function varName(T) {
+	const $ = this;
+	return () => {
+		return $.CONSUME(T.AtName);
+	};
+}
+/**
+* Originally, we were creating alternatives for mixin calls and mixin definitions
+* that could mostly overlap, which led to longer parsing. Instead, we parse
+* as if it could be either, and then we disambiguate at the end.
+*/
+function mixinArg(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const firstToken = $.LA(1);
+		const atStart = $.matchToken(firstToken, T.AtName);
+		const tt2 = $.LA(2).tokenType;
+		const tt3 = $.LA(3).tokenType;
+		const hasWsAfterName = tt2 === T.WS;
+		const nextTokenType = hasWsAfterName ? tt3 : tt2;
+		if (atStart && nextTokenType === T.Ellipsis) {
+			$.startRule();
+			const name = $.CONSUME(T.AtName);
+			if (hasWsAfterName) $.CONSUME(T.WS);
+			$.CONSUME(T.Ellipsis);
+			if ($.RECORDING_PHASE) return;
+			return new Rest(name.image.slice(1), void 0, $.endRule(), $.context);
+		}
+		if (atStart && nextTokenType === T.Colon) {
+			$.startRule();
+			const name = $.CONSUME2(T.AtName);
+			if (hasWsAfterName) $.CONSUME2(T.WS);
+			$.CONSUME(T.Colon);
+			const value = $.SUBRULE3($.callArgument, { ARGS: [{
+				...ctx,
+				allowComma: !!ctx.allowComma,
+				detachedRulesetUsage: "default-param"
+			}] });
+			const location = $.endRule();
+			if ($.RECORDING_PHASE) return;
+			return new VarDeclaration({
+				name: name.image.slice(1),
+				value
+			}, { paramVar: true }, location, $.context);
+		}
+		if (atStart && (nextTokenType === T.RParen || nextTokenType === T.Comma || nextTokenType === T.Semi)) {
+			$.startRule();
+			const name = $.CONSUME3(T.AtName);
+			if ($.RECORDING_PHASE) return;
+			const location = $.endRule();
+			if (ctx.isDefinition) return new VarDeclaration({
+				name: name.image.slice(1),
+				value: new Nil(void 0, void 0, location, $.context)
+			}, { paramVar: true }, location, $.context);
+			return new Any(name.image.slice(1), { role: "name" }, location, $.context);
+		}
+		if ($.isType(T.Ellipsis)) {
+			const ellipsis = $.CONSUME2(T.Ellipsis);
+			return new Rest(void 0, void 0, $.getLocationInfo(ellipsis), $.context);
+		}
+		return $.SUBRULE($.callArgument, { ARGS: [ctx] });
+	};
+}
+function callArgument(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		return $.OR([
+			{
+				GATE: () => $.isType(T.AnonMixinStart) || $.isType(T.LCurly),
+				ALT: () => $.SUBRULE($.anonymousMixinDefinition, { ARGS: [ctx] })
+			},
+			{
+				GATE: () => !ctx.allowComma,
+				ALT: () => $.SUBRULE($.valueSequence, { ARGS: [ctx] })
+			},
+			{
+				GATE: () => !!ctx.allowComma,
+				ALT: () => $.SUBRULE($.valueList, { ARGS: [ctx] })
+			}
+		]);
+	};
+}
+/**
+* Override unknownAtRule to handle @-export for stylesheet forwarding.
+* @-export is like @-compose but with forward semantics and no `with` support.
+*/
+function unknownAtRule(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const img = $.LA(1).image;
+		if (img === "@use" || img === "@-use") return $.SUBRULE($.useAtRule, { ARGS: [ctx] });
+		if (img === "@-export") return $.SUBRULE($.exportAtRule, { ARGS: [ctx] });
+		return cssUnknownAtRule.call($, T)(ctx);
+	};
+}
+/**
+* Parse Less v5 script-module imports.
+*
+* Stylesheet composition uses `@compose`; `@use` / `@-use` only become
+* JsImport nodes for script-style paths and aliases like `#less/math`.
+*/
+function useAtRule(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		const name = $.CONSUME(T.AtName);
+		const pathNode = $.SUBRULE($.string, { ARGS: [ctx] });
+		let namespace;
+		$.OPTION({
+			GATE: () => $.LA(1).tokenType === T.PlainIdent && $.LA(1).image === "as",
+			DEF: () => {
+				$.CONSUME(T.PlainIdent);
+				$.OR2([{ ALT: () => {
+					namespace = $.CONSUME2(T.PlainIdent).image;
+				} }, { ALT: () => {
+					namespace = $.CONSUME(T.Star).image;
+				} }]);
+			}
+		});
+		$.CONSUME(T.Semi);
+		const location = $.endRule();
+		if ($.RECORDING_PHASE) return;
+		const rawPath = pathNode.valueOf();
+		if (isScriptUsePath(rawPath)) return new JsImport({ path: pathNode }, { namespace: namespace ?? defaultNamespaceFromPath(rawPath) }, location, $.context);
+		const preludeNodes = [pathNode];
+		if (namespace) preludeNodes.push(new Any("as", { role: "ident" }, void 0, $.context), new Any(namespace, { role: namespace === "*" ? "operator" : "ident" }, void 0, $.context));
+		return new AtRuleStatement({
+			name: name.image,
+			prelude: new Sequence(preludeNodes, void 0, $.getLocationFromNodes(preludeNodes), $.context)
+		}, void 0, location, $.context);
+	};
+}
+/**
+* Parse @-export './foo.jess' [as <namespace>]
+*
+* Creates a StyleImport with forward semantics (members not visible locally but transitive).
+* Does NOT support `with` (unlike @-compose).
+* Participates in evaldTrees caching like @-compose.
+*/
+function exportAtRule(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		$.CONSUME(T.AtKeyword);
+		const pathNode = $.OR([{ ALT: () => $.SUBRULE($.urlFunction, { ARGS: [ctx] }) }, { ALT: () => $.SUBRULE($.string, { ARGS: [ctx] }) }]);
+		let namespace;
+		$.OPTION(() => {
+			const la = $.LA(1);
+			if (!((la.tokenType === T.PlainIdent || la.tokenType === T.Ident) && la.image === "as")) return;
+			if ($.isType(T.Ident)) $.CONSUME(T.Ident);
+			else $.CONSUME(T.PlainIdent);
+			namespace = ($.isType(T.Ident) ? $.CONSUME(T.Ident) : $.CONSUME(T.PlainIdent)).image;
+		});
+		$.CONSUME(T.Semi);
+		const loc = $.endRule();
+		return new StyleImport({ path: pathNode }, {
+			type: "compose",
+			namespace,
+			importOptions: { forward: true }
+		}, loc, $.context);
+	};
+}
+//#endregion
+//#region src/productions/index.ts
+var productions_exports = /* @__PURE__ */ __exportAll({
+	ampersandExtend: () => ampersandExtend,
+	anonymousMixinDefinition: () => anonymousMixinDefinition,
+	attributeSelector: () => attributeSelector,
+	booleanFunction: () => booleanFunction,
+	calcFunction: () => calcFunction,
+	callArgument: () => callArgument,
+	comparison: () => comparison,
+	complexSelector: () => complexSelector,
+	compoundSelector: () => compoundSelector,
+	customBlock: () => customBlock,
+	customValue: () => customValue,
+	declaration: () => declaration,
+	declarationList: () => declarationList,
+	exportAtRule: () => exportAtRule,
+	expressionProduct: () => expressionProduct,
+	expressionSum: () => expressionSum,
+	expressionValue: () => expressionValue,
+	extend: () => extend,
+	forgivingSelectorList: () => forgivingSelectorList,
+	functionCall: () => functionCall,
+	functionCallArgs: () => functionCallArgs,
+	guard: () => guard,
+	guardAnd: () => guardAnd,
+	guardDefault: () => guardDefault,
+	guardInParens: () => guardInParens,
+	guardInner: () => guardInner,
+	guardOr: () => guardOr,
+	guardWithCondition: () => guardWithCondition,
+	guardWithConditionValue: () => guardWithConditionValue,
+	ifFunction: () => ifFunction,
+	importAtRule: () => importAtRule,
+	innerAtRule: () => innerAtRule,
+	innerCustomValue: () => innerCustomValue,
+	keyframesName: () => keyframesName,
+	knownFunctions: () => knownFunctions,
+	layerName: () => layerName,
+	lessMediaQueryFromReference: () => lessMediaQueryFromReference,
+	lessMediaQueryFromString: () => lessMediaQueryFromString,
+	lessMediaQueryTail: () => lessMediaQueryTail,
+	lookupOrCall: () => lookupOrCall,
+	main: () => main,
+	mathProduct: () => mathProduct,
+	mathSum: () => mathSum,
+	mathValue: () => mathValue,
+	mediaCondition: () => mediaCondition,
+	mediaConditionWithoutOr: () => mediaConditionWithoutOr,
+	mediaFeature: () => mediaFeature,
+	mediaInParens: () => mediaInParens,
+	mediaQuery: () => mediaQuery,
+	mfNonIdentifierValue: () => mfNonIdentifierValue,
+	mfValue: () => mfValue,
+	mixinArg: () => mixinArg,
+	mixinArgList: () => mixinArgList,
+	mixinArgs: () => mixinArgs,
+	mixinName: () => mixinName,
+	mixinOrQualifiedRule: () => mixinOrQualifiedRule,
+	mixinReference: () => mixinReference,
+	nthValue: () => nthValue,
+	qualifiedRule: () => qualifiedRule,
+	qualifiedRuleBody: () => qualifiedRuleBody,
+	relativeSelector: () => relativeSelector,
+	selectorCapture: () => selectorCapture,
+	selectorList: () => selectorList,
+	simpleSelector: () => simpleSelector,
+	squareValue: () => squareValue,
+	string: () => string,
+	stylesheet: () => stylesheet,
+	unknownAtRule: () => unknownAtRule,
+	urlFunction: () => urlFunction,
+	useAtRule: () => useAtRule,
+	value: () => value,
+	valueReference: () => valueReference,
+	valueSequence: () => valueSequence,
+	varDeclarationOrCall: () => varDeclarationOrCall,
+	varName: () => varName,
+	varReference: () => varReference,
+	wrappedDeclarationList: () => wrappedDeclarationList
+});
+//#endregion
+//#region src/lessRecursiveParser.ts
+/**
+* @deprecated LEGACY — Chevrotain-based Less parser engine (extends the deprecated
+* CssRecursiveParser). Superseded by the functional macro grammar in ./grammar.ts.
+* Kept only for benchmarking; TO BE DELETED once the functional parser fully lands.
+*/
+var LessRecursiveParser = class LessRecursiveParser extends CssRecursiveParser {
+	looseMode;
+	leakyScope;
+	/** Warnings collected during parsing */
+	warnings = [];
+	/** See `LessParserConfig.mathMode` */
+	mathMode;
+	/** See `LessParserConfig.wrapOuterExpressions` */
+	wrapOuterExpressions;
+	processLegacyMSFilterToken(token) {
+		const location = this.getLocationInfo(token);
+		const source = token.image.replace(/\s*=\s*/g, "=");
+		const matches = [...source.matchAll(/@([_a-zA-Z\xA0-\uFFFF][-_a-zA-Z0-9\xA0-\uFFFF]*)/g)];
+		if (matches.length === 0) return new Any(source, { type: token.tokenType?.name }, location);
+		return new Interpolated({
+			source: source.replace(/@([_a-zA-Z\xA0-\uFFFF][-_a-zA-Z0-9\xA0-\uFFFF]*)/g, (_full, _name, offset, fullSource) => {
+				const key = fullSource.slice(0, offset).match(/([A-Za-z]+)=$/)?.[1];
+				if (key && /colorstr$/i.test(key)) return `"${INTERPOLATION_PLACEHOLDER}"`;
+				return INTERPOLATION_PLACEHOLDER;
+			}),
+			replacements: matches.map((match) => createInterpolatedReference("@", match[1], location, this.context))
+		}, { role: "any" }, location);
+	}
+	constructor(T, config = {}) {
+		let { legacyMode, looseMode = true, leakyScope = true, mathMode = "parens-division", wrapOuterExpressions = true, ...rest } = config;
+		legacyMode = legacyMode ?? looseMode;
+		super(T, {
+			legacyMode,
+			...rest
+		});
+		this.T = T;
+		this.looseMode = looseMode;
+		this.leakyScope = leakyScope;
+		this.mathMode = mathMode;
+		this.wrapOuterExpressions = wrapOuterExpressions;
+		this.warnings = [];
+		for (const [key, factory] of Object.entries(productions_exports)) {
+			if (typeof factory !== "function") continue;
+			const rule = factory.call(this, this.T);
+			if (key in productions) this.OVERRIDE_RULE(key, rule);
+			else this.RULE(key, rule);
+		}
+		if (this.constructor === LessRecursiveParser) this.performSelfAnalysis();
+	}
+	processValueToken(token, ctx) {
+		let tokenType = token.tokenType;
+		const T = this.T;
+		if (tokenType.name === "AtKeyword" || tokenMatcher(token, T.AtKeyword)) {
+			if (ctx?.inCustomPropertyValue) {
+				const atName = token.image;
+				const ident = token.image.slice(1);
+				this.warnDeprecation(`"${atName}" in custom property values is treated as literal text, not a variable reference. Use "\@{${ident}}" if you want it to be evaluated.`, token, "variable-in-unknown-value");
+				return new Any(token.image, { role: "any" }, this.getLocationInfo(token));
+			}
+			if (ctx?.atRulePreludeBareVariableAs === "index") {
+				const nextToken = this.LA(1).tokenType;
+				if (this.noSep() && (nextToken === T.LSquare || nextToken === T.LParen)) return new Reference(token.image.slice(1), { type: "variable" }, this.getLocationInfo(token));
+				const atName = token.image;
+				const ident = token.image.slice(1);
+				this.warnDeprecation(`"${atName}" in at-rule preludes is deprecated. Use "@{${ident}}" in Less; outside declaration values this is normalized to indexed lookup syntax.`, token, "at-rule-prelude-variable");
+				return new Reference({ key: ident }, {
+					type: "index",
+					role: "ident"
+				}, this.getLocationInfo(token));
+			}
+			return new Reference(token.image.slice(1), { type: "variable" }, this.getLocationInfo(token));
+		} else if (tokenType.name === "PropertyReference") {
+			if (ctx?.inCustomPropertyValue) {
+				const atName = token.image;
+				const ident = token.image.slice(1);
+				this.warnDeprecation(`"${atName}" in custom property values is treated as literal text, not a property reference. Use "\${${ident}}" if you want it to be evaluated.`, token, "property-in-unknown-value");
+				return new Any(token.image, { role: "any" }, this.getLocationInfo(token));
+			}
+			return super.processValueToken(token, ctx);
+		} else if (tokenType === T["DefaultGuardFunc"]) return new DefaultGuard(token.image, void 0, this.getLocationInfo(token));
+		else if (tokenType.name === "JavaScript" || T["JavaScript"] && tokenMatcher(token, T["JavaScript"])) throw new Error("Inline JavaScript using backticks is not supported. Use @use / @-use to import a script module instead. Script-module documentation is coming soon.");
+		else if (tokenType === T["InterpolatedIdent"]) {
+			const result = getInterpolatedOrString(token.image, this.getLocationInfo(token), this.context);
+			if (result instanceof Interpolated) return result;
+			else return new Any(result, { role: "ident" }, this.getLocationInfo(token));
+		} else if (tokenType === T["LegacyMSFilter"]) return this.processLegacyMSFilterToken(token);
+		else if (tokenType === T["PlainIdent"]) {
+			const image = token.image;
+			if (image === "true" || image === "false") return new Bool(image === "true", void 0, this.getLocationInfo(token));
+		}
+		return super.processValueToken(token, ctx);
+	}
+	warnDeprecation(message, token, deprecationId) {
+		this.warnings.push({
+			message,
+			token,
+			deprecation: deprecationId
+		});
+	}
+};
+//#endregion
+//#region src/lessParser.ts
+/**
+* Cached lexer + parser singletons. Chevrotain initialization (~500ms)
+* only happens once — config changes are applied via instance properties
+* before each parse.
+*/
+let cachedLexer;
+let cachedParser;
+let cachedTokenMap;
+function getSharedLexerAndParser(config) {
+	if (!cachedLexer || !cachedParser) {
+		const { lexer, T } = createLexerDefinition(lessFragments(), lessTokens());
+		cachedTokenMap = T;
+		cachedLexer = new Lexer(lexer, {
+			ensureOptimizations: true,
+			skipValidations: process.env.TEST !== "true"
+		});
+		cachedParser = new LessRecursiveParser(cachedTokenMap, config);
+	}
+	const { looseMode = true, leakyScope = true, mathMode = "parens-division", wrapOuterExpressions = true, legacyMode = looseMode } = config;
+	cachedParser.looseMode = looseMode;
+	cachedParser.leakyScope = leakyScope;
+	cachedParser.mathMode = mathMode;
+	cachedParser.wrapOuterExpressions = wrapOuterExpressions;
+	cachedParser.legacyMode = legacyMode;
+	return {
+		lexer: cachedLexer,
+		parser: cachedParser
+	};
+}
+/**
+* @deprecated LEGACY — Chevrotain-lexer + recursive-descent Less parser. Superseded
+* by the functional macro grammar (`LessParser` in ./grammar.ts). Kept only for
+* benchmarking / migration reference; TO BE DELETED once the functional parser
+* fully lands.
+*/
+var LessParser$1 = class {
+	lexer;
+	parser;
+	constructor(config = {}) {
+		config = {
+			looseMode: true,
+			...config
+		};
+		const shared = getSharedLexerAndParser(config);
+		this.lexer = shared.lexer;
+		this.parser = shared.parser;
+		this.parse = this.parse.bind(this);
+	}
+	parse(text, rule = "stylesheet", options) {
+		const parser = this.parser;
+		const lexerResult = this.lexer.tokenize(text);
+		parser.warnings = [];
+		if (options?.context) parser.context = options.context;
+		parser.context.opts.trivia = void 0;
+		parser.input = lexerResult.tokens;
+		const ruleMethod = parser[rule];
+		if (typeof ruleMethod !== "function") throw new Error(`Unknown parser rule: ${rule}`);
+		const tree = ruleMethod.call(parser);
+		const trivia = parser.trivia;
+		parser.context.opts.trivia = trivia;
+		const resultTree = tree ?? nil();
+		(resultTree.sourceRoot?._treeContext ?? parser.context).opts.trivia = trivia;
+		const warnings = [...parser.warnings];
+		return {
+			tree: resultTree,
+			lexerResult,
+			errors: parser.errors,
+			trivia,
+			warnings
+		};
+	}
+	/**
+	* @todo Implement content assist for the new parser
+	*/
+	suggest(text, init) {
+		return [];
+	}
+};
+//#endregion
+export { LessGrammar, LessParser, LessParser as Parser, LessParser$1 as LessParserChevrotain, LessRecursiveParser, parseLessFn };