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

package/lib/index.cjs

@@ -0,0 +1,4097 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+let _jesscss_css_parser = require("@jesscss/css-parser");
+let _jesscss_core = require("@jesscss/core");
+let chevrotain = require("chevrotain");
+let known_css_properties = require("known-css-properties");
+//#region src/lessTokens.ts
+function $preBuildFragments() {
+	const fragments = (0, _jesscss_css_parser.rawCssFragments)().map((f) => [...f]);
+	fragments.unshift(["lineComment", "\\/\\/[^\\n\\r]*"]);
+	fragments.push(["interpolated", "[@$]\\{(?:{{nmchar}}*)\\}"]);
+	return fragments;
+}
+function $preBuildTokens() {
+	const tokens = (0, _jesscss_css_parser.rawCssTokens)();
+	/**
+	* Keyed by what to insert after
+	*
+	* @todo - Move merge utility to css-parser
+	*/
+	const merges = {
+		Assign: [{
+			name: "Ellipsis",
+			pattern: /\.\.\./,
+			categories: ["BlockMarker"]
+		}, (
+		/**
+		* Less's historical parser unfortunately allows
+		* at-keywords that are not valid in CSS. One is
+		* that Less allows at-keywords to begin with numbers.
+		* Another is that it allows an at-rule that only
+		* contains a single dash. So we capture this as
+		* a separate token.
+		*
+		* We also do this later in the token stack so that we
+		* don't accidentally grab something like
+		* @-webkit-keyframes while looking for @-.
+		*/
+		{
+			name: "AtKeywordLessExtension",
+			pattern: "@(?:-|\\d(?:{{nmchar}})*)",
+			categories: ["BlockMarker", "AtName"]
+		})],
+		PlainIdent: [
+			{
+				name: "Interpolated",
+				pattern: _jesscss_css_parser.LexerType.NA
+			},
+			{
+				name: "LineComment",
+				pattern: "{{lineComment}}",
+				label: _jesscss_css_parser.SKIPPED_LABEL
+			},
+			{
+				name: "PlusAssign",
+				pattern: "\\+{{whitespace}}*:",
+				categories: ["BlockMarker", "Assign"]
+			},
+			{
+				name: "UnderscoreAssign",
+				pattern: "\\+{{whitespace}}*_{{whitespace}}*:",
+				categories: ["BlockMarker", "Assign"]
+			},
+			{
+				name: "AnonMixinStart",
+				pattern: /[.#]\(/,
+				categories: ["BlockMarker"]
+			},
+			{
+				name: "GtEqAlias",
+				pattern: /=>/,
+				categories: ["CompareOperator"]
+			},
+			{
+				name: "LtEqAlias",
+				pattern: /=</,
+				categories: ["CompareOperator"]
+			},
+			{
+				name: "Extend",
+				pattern: /:extend\(/,
+				categories: ["BlockMarker"]
+			},
+			{
+				name: "VarOrProp",
+				pattern: _jesscss_css_parser.LexerType.NA
+			},
+			{
+				name: "NestedReference",
+				pattern: ["([@$]+{{ident}}?){2,}", _jesscss_css_parser.groupCapture],
+				start_chars_hint: ["@", "$"],
+				categories: ["VarOrProp"],
+				line_breaks: true
+			},
+			{
+				name: "PropertyReference",
+				pattern: "\\${{ident}}",
+				categories: ["VarOrProp"]
+			},
+			(
+			/** Can be used in unit function or mod operation */
+			{
+				name: "Percent",
+				pattern: /%/
+			}),
+			{
+				name: "DefaultGuardIdent",
+				pattern: /default/,
+				longer_alt: "PlainIdent",
+				categories: ["Ident"]
+			},
+			{
+				name: "DefaultGuardFunc",
+				pattern: /default(?:\(\))/
+			}
+		],
+		Ampersand: [
+			{
+				name: "AmpersandExtend",
+				pattern: /&:extend\(/,
+				categories: ["BlockMarker"]
+			},
+			{
+				name: "AmpersandLParen",
+				pattern: /&\(/,
+				push_mode: "AmpersandTemplate",
+				categories: [
+					"Selector",
+					"NestedRuleStart",
+					"BlockMarker"
+				]
+			},
+			{
+				name: "AllFlag",
+				pattern: /!all/,
+				categories: ["BlockMarker"]
+			}
+		],
+		UrlStart: [
+			(
+			/**
+			* Keywords that we don't identify as idents
+			* should be manually added to other places where an ident is valid.
+			*/
+			{
+				name: "When",
+				pattern: /when/i,
+				longer_alt: "PlainIdent",
+				categories: ["BlockMarker"]
+			}),
+			{
+				name: "FormatFunction",
+				pattern: /%\(/,
+				categories: ["BlockMarker", "FunctionStart"]
+			},
+			{
+				name: "IfFunction",
+				pattern: /if\(/,
+				categories: ["BlockMarker", "FunctionStart"]
+			},
+			{
+				name: "BooleanFunction",
+				pattern: /boolean\(/,
+				categories: ["BlockMarker", "FunctionStart"]
+			},
+			{
+				name: "JavaScript",
+				pattern: /~?`[^`]*`/,
+				line_breaks: true
+			}
+		],
+		Signed: [
+			{
+				name: "InterpolatedIdent",
+				pattern: "(?:{{ident}}|-)?{{interpolated}}(?:{{interpolated}}|{{nmchar}})*",
+				categories: [
+					"Interpolated",
+					"Selector",
+					"Ident"
+				]
+			},
+			{
+				name: "InterpolatedCustomProperty",
+				pattern: "--{{ident}}?{{interpolated}}(?:{{interpolated}}|{{nmchar}})*",
+				categories: ["Interpolated"]
+			},
+			(
+			/**
+			* Unfortunately, there's grammatical ambiguity between
+			* interpolated props and a naked interpolated selector name,
+			* making this awkward token necessary.
+			*/
+			{
+				name: "InterpolatedSelector",
+				pattern: ["[.#]{{ident}}?{{interpolated}}(?:{{interpolated}}|{{nmchar}})*", _jesscss_css_parser.groupCapture],
+				categories: ["Interpolated", "Selector"],
+				start_chars_hint: [".", "#"],
+				line_breaks: true
+			})
+		]
+	};
+	let defaultTokens = tokens.modes.Default.slice();
+	let tokenLength = defaultTokens.length;
+	for (let i = 0; i < tokenLength; i++) {
+		let token = defaultTokens[i];
+		const { name } = token;
+		const copyToken = () => {
+			token = structuredClone(token);
+		};
+		let alterations = true;
+		switch (name) {
+			case "Ampersand":
+				copyToken();
+				/**
+				* Captures not just ampersands, but "ampersand merges", where
+				* the intent of the author was to merge the parent selector with a token
+				* suffix or prefix.
+				*
+				* e.g.
+				*   1. &-foo
+				*   2. &(foo)
+				*   3. &1
+				*   4. .foo-&
+				*/
+				token.pattern = "(?:[.#](?:{{ident}}-)?&|&){{nmchar}}*";
+				token.start_chars_hint = [
+					"&",
+					".",
+					"#"
+				];
+				break;
+			case "DotName":
+			case "HashName":
+				copyToken();
+				token.longer_alt = "Ampersand";
+				break;
+			case "Divide":
+				copyToken();
+				token.pattern = /\.?\//;
+				break;
+			case "SingleQuoteStart":
+				copyToken();
+				token.pattern = /~?'/;
+				break;
+			case "DoubleQuoteStart":
+				copyToken();
+				token.pattern = /~?"/;
+				break;
+			default: alterations = false;
+		}
+		if (alterations) defaultTokens[i] = token;
+		const merge = merges[name];
+		if (merge) {
+			/** Insert after current token */
+			defaultTokens = defaultTokens.slice(0, i + 1).concat(merge, defaultTokens.slice(i + 1));
+			tokens.modes.Default = defaultTokens;
+			const mergeLength = merge.length;
+			tokenLength += mergeLength;
+			i += mergeLength;
+		}
+	}
+	tokens.modes.AmpersandTemplate = [
+		{
+			name: "AmpersandTemplateEnd",
+			pattern: /\)/,
+			pop_mode: true,
+			categories: ["FunctionLikeEnd"]
+		},
+		{
+			name: "AmpersandTemplateContents",
+			pattern: _jesscss_core.AMPERSAND_TEMPLATE_CONTENTS_REGEX,
+			categories: ["Selector"]
+		},
+		"SingleQuoteStart",
+		"DoubleQuoteStart",
+		"WS"
+	];
+	return tokens;
+}
+const Fragments = $preBuildFragments();
+const Tokens = $preBuildTokens();
+const lessFragments = () => Fragments;
+const lessTokens = () => Tokens;
+//#endregion
+//#region src/utils.ts
+const INTERPOLATION_REGEX = /([$@]){([^}]+)}/g;
+const createInterpolatedReference$4 = (prefix, varName, location, context) => {
+	const isProperty = prefix === "$";
+	return new _jesscss_core.Reference({ key: isProperty ? new _jesscss_core.Quoted(varName, { quote: "'" }, location, context) : varName }, {
+		type: isProperty ? "property" : "variable",
+		role: "ident"
+	}, location, context);
+};
+const getInterpolatedOrString = (name, location, context) => {
+	const matches = [];
+	INTERPOLATION_REGEX.lastIndex = 0;
+	let result;
+	while ((result = INTERPOLATION_REGEX.exec(name)) !== null) {
+		const [fullMatch, prefix, varName] = result;
+		if (varName && prefix) matches.push({
+			fullMatch,
+			prefix,
+			varName,
+			index: result.index
+		});
+	}
+	if (matches.length > 0) {
+		let source = name;
+		const replacements = [];
+		let offset = 0;
+		for (let i = 0; i < matches.length; i++) {
+			const match = matches[i];
+			const adjustedIndex = match.index - offset;
+			const beforeMatch = source.substring(0, adjustedIndex);
+			const afterMatch = source.substring(adjustedIndex + match.fullMatch.length);
+			source = beforeMatch + _jesscss_core.INTERPOLATION_PLACEHOLDER + afterMatch;
+			offset += match.fullMatch.length - _jesscss_core.INTERPOLATION_PLACEHOLDER.length;
+			const ref = createInterpolatedReference$4(match.prefix, match.varName, location, context);
+			replacements.push(ref);
+		}
+		return new _jesscss_core.Interpolated({
+			source,
+			replacements
+		}, { role: "ident" }, location, context);
+	}
+	const atPos = name.indexOf("@", 1);
+	const dollarPos = name.indexOf("$", 1);
+	if (atPos === -1 && dollarPos === -1) if (name.startsWith("@") || name.startsWith("$")) return name.slice(1);
+	else return name;
+	const nextPos = atPos !== -1 ? atPos : dollarPos;
+	const start = name.slice(1, nextPos);
+	const end = name.slice(nextPos);
+	const type = end.startsWith("@") ? "variable" : "property";
+	const endResult = getInterpolatedOrString(end, location, context);
+	if (typeof endResult === "string") {
+		const endKey = type === "property" ? new _jesscss_core.Quoted(endResult, { quote: "'" }, location, context) : endResult;
+		return new _jesscss_core.Interpolated({
+			source: start + _jesscss_core.INTERPOLATION_PLACEHOLDER,
+			replacements: [new _jesscss_core.Reference({ key: endKey }, {
+				type,
+				role: "ident"
+			}, location, context)]
+		}, { role: "ident" });
+	} else
+ /**
+	* endResult is already an Interpolated node, so we need to handle this
+	* differently.
+	*
+	* @todo - test deep nesting
+	*/
+	return new _jesscss_core.Interpolated({
+		source: start + _jesscss_core.INTERPOLATION_PLACEHOLDER,
+		replacements: [endResult]
+	}, { role: "ident" });
+};
+//#endregion
+//#region src/productions/root.ts
+const cssMain = _jesscss_css_parser.productions.main;
+const cssDeclaration = _jesscss_css_parser.productions.declaration;
+_jesscss_css_parser.productions.mediaTypeQuery;
+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 ((0, _jesscss_core.isNode)(current, _jesscss_core.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 _jesscss_core.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 wrapOuterExpressionIfNeeded(node, ctx) {
+	if (!this.wrapOuterExpressions) return node;
+	if (!ctx?.wrapInExpression) return node;
+	if (node instanceof _jesscss_core.Expression) return node;
+	if ((0, _jesscss_core.isNode)(node, _jesscss_core.N.Operation)) {
+		const left = node.left;
+		const op = node.get("operator");
+		const right = node.right;
+		if ((0, _jesscss_core.shouldOperateWithMathFrames)({
+			mathMode: this.mathMode ?? "parens-division",
+			parenFrames: getParenFrames$2(ctx),
+			calcFrames: getCalcFrames(ctx)
+		}, op, left, right)) return new _jesscss_core.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 (!$.preSkippedTokenMap) 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 !$.preSkippedTokenMap.has(token.startOffset) || isColon && $.preSkippedTokenMap.has(postToken.startOffset);
+}
+let interpolatedRegex$2 = /([$@]){([^}]+)}/g;
+const createInterpolatedReference$3 = (prefix, value, location, context) => {
+	const isProperty = prefix === "$";
+	return new _jesscss_core.Reference({ key: isProperty ? new _jesscss_core.Quoted(value, { quote: "'" }, location, context) : value }, {
+		type: isProperty ? "property" : "variable",
+		role: "ident"
+	}, location, context);
+};
+const getInterpolated$2 = (name, location, context) => {
+	const replacements = [];
+	let result;
+	let source = name;
+	while (result = interpolatedRegex$2.exec(name)) {
+		const [match, propOrVar, value] = result;
+		source = source.replace(match, _jesscss_core.INTERPOLATION_PLACEHOLDER);
+		const reference = createInterpolatedReference$3(propOrVar, value, location, context);
+		replacements.push(reference);
+	}
+	return new _jesscss_core.Interpolated({
+		source,
+		replacements
+	}, { role: "ident" }, location, context);
+};
+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 selectors.
+*
+* @todo Group complex selectors into selector lists
+*/
+function groupExtendsByTargetAndFlag(extendNodes) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const ext of extendNodes) {
+		let target = ext.target;
+		let flag = ext.get("flag") ?? 1;
+		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 && (0, _jesscss_core.isNode)(root, _jesscss_core.N.Rules)) {
+			let charsetLoc = $.getLocationInfo(charset);
+			let rootLoc = root.location;
+			root.setData([new _jesscss_core.Any(charset.image, { role: "charset" }, charsetLoc, context), ...root.value]);
+			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 shouldTryQualifiedRuleInDeclarationList = () => {
+			const isSelectorLikeContinuation = (offset) => {
+				const tok = $.LA(offset);
+				return $.matchToken(tok, T.LCurly) || $.matchToken(tok, T.Comma) || $.matchToken(tok, T.Combinator) || $.matchToken(tok, T.LSquare) || $.matchToken(tok, T.Colon) || $.matchToken(tok, T.NthPseudoClass) || $.matchToken(tok, T.SelectorPseudoClass);
+			};
+			if (typeof $.shouldTryQualifiedRuleInDeclarationList === "function") return $.shouldTryQualifiedRuleInDeclarationList();
+			if (!$.isTypeAt(1, T.Ident)) return true;
+			if (!$.isTypeAt(2, T.Assign)) return true;
+			if ($.hasWS(2)) return false;
+			const tt3 = $.LA(3).tokenType;
+			if (tt3 === T.Colon || tt3 === T.NthPseudoClass || tt3 === T.SelectorPseudoClass || $.matchToken($.LA(3), T.FunctionStart)) return true;
+			if (!$.matchToken($.LA(3), T.Ident)) return false;
+			return isSelectorLikeContinuation(4);
+		};
+		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] }) },
+				{ 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 _jesscss_core.Node)) {
+						/** This is a semi-colon or charset token */
+						let tok = value;
+						if (tok.image.includes("@charset")) rules.push(new _jesscss_core.Any(tok.image, { role: "charset" }, $.getLocationInfo(tok), context));
+						else if (lastRule) lastRule.options.semi = true;
+						else rules.push(new _jesscss_core.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 _jesscss_core.Nil));
+			rules = [...ctx.extendNodes, ...filteredRules];
+			ctx.extendNodes = void 0;
+		}
+		let returnNode = $.getRulesWithComments(rules, $.getLocationInfo($.LA(1)));
+		return $.wrap(returnNode, true);
+	};
+}
+function declarationList(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const shouldTryQualifiedRuleInDeclarationList = () => {
+			const isSelectorLikeContinuation = (offset) => {
+				const tok = $.LA(offset);
+				return $.matchToken(tok, T.LCurly) || $.matchToken(tok, T.Comma) || $.matchToken(tok, T.Combinator) || $.matchToken(tok, T.LSquare) || $.matchToken(tok, T.Colon) || $.matchToken(tok, T.NthPseudoClass) || $.matchToken(tok, T.SelectorPseudoClass);
+			};
+			if (typeof $.shouldTryQualifiedRuleInDeclarationList === "function") return $.shouldTryQualifiedRuleInDeclarationList();
+			if (!$.isTypeAt(1, T.Ident)) return true;
+			if (!$.isTypeAt(2, T.Assign)) return true;
+			if ($.hasWS(2)) return false;
+			const tt3 = $.LA(3).tokenType;
+			if (tt3 === T.Colon || tt3 === T.NthPseudoClass || tt3 === T.SelectorPseudoClass || $.matchToken($.LA(3), T.FunctionStart)) return true;
+			if (!$.matchToken($.LA(3), T.Ident)) return false;
+			return isSelectorLikeContinuation(4);
+		};
+		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 = {}) => {
+			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] })
+				},
+				{ ALT: () => $.SUBRULE4($.ampersandExtend, { ARGS: [ctx] }) },
+				{
+					GATE: () => $.check(T.FunctionStart),
+					ALT: () => {
+						const fnCall = $.SUBRULE5($.functionCall, { ARGS: [ctx] });
+						if (fnCall instanceof _jesscss_core.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 customPropertyAlt = (consumeName, occurrence) => ({ ALT: () => {
+			let nodes;
+			if (!$.RECORDING_PHASE) nodes = [];
+			const name = consumeName();
+			const assign = 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 = getInterpolated$2(nameValue, $.getLocationInfo(name), $.context);
+				else nameNode = $.wrap(new _jesscss_core.Any(name.image, { role: "property" }, $.getLocationInfo(name), $.context), true);
+				const value = new _jesscss_core.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 = $.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 _jesscss_core.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 = getInterpolated$2(nameValue, $.getLocationInfo(name), $.context);
+					else nameNode = $.wrap(new _jesscss_core.Any(name.image, { role: "property" }, $.getLocationInfo(name), $.context), true);
+					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: () => $.SUBRULE2($.valueReference, { ARGS: [{
+					...ctx,
+					requireAccessorsAfterMixinCall: true
+				}] })
+			},
+			{ ALT: () => $.SUBRULE($.mediaFeature, { ARGS: [ctx] }) }
+		]);
+		$.CONSUME(T.RParen);
+		if (RECORDING_PHASE) return;
+		const location = $.endRule();
+		return $.wrap(new _jesscss_core.Paren($.wrap(node, "both"), void 0, location, $.context));
+	};
+}
+function mediaQuery(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		return $.OR2([
+			{
+				GATE: () => $.startsMediaCondition(T),
+				ALT: () => $.SUBRULE($.mediaConditionWithoutOr, { ARGS: [ctx] })
+			},
+			{
+				GATE: () => isEscapedString($, T),
+				ALT: () => $.SUBRULE($.lessMediaQueryFromString, { ARGS: [ctx] })
+			},
+			{
+				GATE: () => startsLessMediaQueryReference($, T),
+				ALT: () => $.SUBRULE2($.lessMediaQueryFromReference, { ARGS: [ctx] })
+			},
+			{ ALT: () => $.SUBRULE7($.mediaTypeQuery, { ARGS: [ctx] }) }
+		]);
+	};
+}
+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: first
+		}] });
+	};
+}
+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: () => $.SUBRULE2($.valueReference, { ARGS: [{
+							...ctx,
+							requireAccessorsAfterMixinCall: true
+						}] })
+					},
+					{
+						GATE: () => $.startsMediaCondition(T),
+						ALT: () => $.SUBRULE2($.mediaConditionWithoutOr, { ARGS: [ctx] })
+					},
+					{ ALT: () => $.SUBRULE2($.mediaType, { ARGS: [ctx] }) }
+				]);
+				if (!RECORDING_PHASE) {
+					nodes.push($.wrap(new _jesscss_core.Keyword(andToken.image, void 0, $.getLocationInfo(andToken), $.context), "both"));
+					nodes.push(next);
+				}
+			}
+		});
+		if (RECORDING_PHASE) return;
+		const location = $.endRule();
+		if (nodes.length === 1) return nodes[0];
+		return new _jesscss_core.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 _jesscss_core.QueryCondition(nodes, void 0, $.endRule(), $.context);
+	} }]);
+}
+function mediaFeature(T) {
+	const $ = this;
+	const createFeatureIdentNode = (token, role) => {
+		const location = $.getLocationInfo(token);
+		const resolved = getInterpolatedOrString(token.image, location, $.context);
+		if (typeof resolved === "string") return new _jesscss_core.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();
+							return $.wrap(new _jesscss_core.Declaration({
+								name: $.wrap(createFeatureIdentNode(ident, "property"), true),
+								value: $.wrap(value)
+							}, void 0, location, $.context), "both");
+						}
+					} },
+					{
+						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($.wrap(createFeatureIdentNode(ident, "ident"), true));
+								seq.location[0] = startOffset;
+								seq.location[1] = startLine;
+								seq.location[2] = startColumn;
+								return new _jesscss_core.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 _jesscss_core.QueryCondition([
+									$.wrap(createFeatureIdentNode(ident, "ident"), true),
+									$.wrap(new _jesscss_core.Any(op.image, { role: "operator" }, $.getLocationInfo(op), $.context), "both"),
+									value
+								], void 0, location, $.context);
+							}
+						}
+					}
+				]);
+			});
+			if (!RECORDING_PHASE && !rule) {
+				const location = $.endRule();
+				const identNode = createFeatureIdentNode(ident, "ident");
+				return $.wrap(new _jesscss_core.QueryCondition([identNode], void 0, location, $.context), "both");
+			}
+			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 _jesscss_core.QueryCondition([
+						left,
+						$.wrap(new _jesscss_core.Any(op.image, { role: "operator" }, $.getLocationInfo(op), $.context)),
+						$.wrap(createFeatureIdentNode(value, "ident"), "both")
+					], 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[0] = startOffset;
+				seq.location[1] = startLine;
+				seq.location[2] = startColumn;
+				return new _jesscss_core.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: () => $.SUBRULE($.valueReference, { ARGS: [{
+					...ctx,
+					requireAccessorsAfterMixinCall: true
+				}] })
+			},
+			{ ALT: () => {
+				$.startRule();
+				let num1 = $.CONSUME(T.Number);
+				let num2;
+				$.OPTION(() => {
+					$.CONSUME(T.Slash);
+					num2 = $.CONSUME2(T.Number);
+				});
+				let location = $.endRule();
+				let num1Node = $.wrap($.processValueToken(num1), "both");
+				if (!num2) return num1Node;
+				return new _jesscss_core.List([num1Node, $.wrap($.processValueToken(num2), "both")], { sep: "/" }, location, $.context);
+			} },
+			{ ALT: () => {
+				let dim = $.CONSUME(T.Dimension);
+				return $.wrap($.processValueToken(dim), "both");
+			} }
+		]);
+	};
+}
+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 _jesscss_core.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 */
+				for (let e of extend) e.setData("selector", void 0);
+				rules.setData([...extend, ...rules.value]);
+				ctx.extendNodes = void 0;
+			} else {
+				const selectorList = selector instanceof _jesscss_core.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.setData("selector", void 0);
+						rules.setData([finalExtend, ...rules.value]);
+						ctx.extendNodes = void 0;
+					} else shouldBubble = true;
+				} else shouldBubble = true;
+				if (shouldBubble) {}
+			}
+			let node = new _jesscss_core.Ruleset({
+				selector,
+				rules,
+				guard
+			}, void 0, void 0, $.context);
+			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) if (extendNode.selector === void 0 || extendNode.selector instanceof _jesscss_core.Ampersand) extendNode.setData("selector", selector);
+			/** Prepend a rules block */
+			rule = new _jesscss_core.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 && node.location.length > 0 ? node.location : void 0;
+				if (node instanceof _jesscss_core.Any && node.role === "name") {
+					const nameNode = new _jesscss_core.Any(node.valueOf(), {
+						...node.options,
+						role: "property"
+					}, node.location, $.context);
+					args.setData(i, new _jesscss_core.VarDeclaration({
+						name: nameNode,
+						value: new _jesscss_core.Nil(void 0, void 0, location, $.context)
+					}, { paramVar: true }, location, $.context));
+				}
+			}
+		};
+		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 && node.location.length > 0 ? node.location : void 0;
+				if (node instanceof _jesscss_core.Any && node.role === "name") args.setData(i, new _jesscss_core.Reference({ key: node.valueOf() }, { type: "variable" }, location, $.context));
+				else if (node instanceof _jesscss_core.Rest) {
+					const restValue = node.get("value");
+					if (typeof restValue === "string") args.setData(i, new _jesscss_core.Rest(new _jesscss_core.Reference({ key: restValue }, { type: "variable" }, location, $.context), void 0, location, $.context));
+				}
+			}
+		};
+		$.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 _jesscss_core.SelectorList;
+		let guard;
+		let args;
+		let important;
+		const createMixinCall = (location) => {
+			let leftNode;
+			if (!isSelectorList && (selector instanceof _jesscss_core.CompoundSelector || selector instanceof _jesscss_core.ComplexSelector || selector instanceof _jesscss_core.BasicSelector)) leftNode = new _jesscss_core.Reference({ key: selector }, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, void 0, $.context);
+			else for (let s of selector.nodes()) if (s instanceof _jesscss_core.BasicSelector) leftNode = new _jesscss_core.Reference({
+				target: leftNode instanceof _jesscss_core.Reference ? leftNode : leftNode instanceof _jesscss_core.Call ? leftNode : void 0,
+				key: s.valueOf()
+			}, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, void 0, $.context);
+			/** Finally, pass this reference into a call */
+			leftNode = new _jesscss_core.Call({
+				name: leftNode,
+				args
+			}, { markImportant: !!important }, location, $.context);
+			return leftNode;
+		};
+		let isPossibleMixinDefinition = selector instanceof _jesscss_core.BasicSelector && (selector.isClass || selector.isId) || selector instanceof _jesscss_core.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 selectors. */
+			if (s instanceof _jesscss_core.ComplexSelector || s instanceof _jesscss_core.CompoundSelector) continue;
+			if (s instanceof _jesscss_core.BasicSelector && (s.isClass || s.isId) || s instanceof _jesscss_core.InterpolatedSelector && (s.isClass || s.isId) || s instanceof _jesscss_core.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 _jesscss_core.Mixin({
+									name: selector.valueOf(),
+									params: args,
+									rules,
+									guard
+								}, hasDefault ? { hasDefault: true } : 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) if (extendNode.selector === void 0 || extendNode.selector instanceof _jesscss_core.Ampersand) extendNode.setData("selector", selector);
+					rule = new _jesscss_core.Rules([...ctx.extendNodes, qRule]);
+					rule._location = qRule._location;
+					ctx.extendNodes = void 0;
+				}
+				return rule;
+			} }
+		]);
+	};
+}
+//#endregion
+//#region src/productions/selectors.ts
+let interpolatedRegex$1 = /([$@]){([^}]+)}/g;
+const createInterpolatedReference$2 = (prefix, value, location, context) => {
+	const isProperty = prefix === "$";
+	return new _jesscss_core.Reference({ key: isProperty ? new _jesscss_core.Quoted(value, { quote: "'" }, location, context) : value }, {
+		type: isProperty ? "property" : "variable",
+		role: "ident"
+	}, location, context);
+};
+const getInterpolated$1 = (name, location, context) => {
+	const replacements = [];
+	let result;
+	let source = name;
+	while (result = interpolatedRegex$1.exec(name)) {
+		const [match, propOrVar, value] = result;
+		source = source.replace(match, _jesscss_core.INTERPOLATION_PLACEHOLDER);
+		const reference = createInterpolatedReference$2(propOrVar, value, location, context);
+		replacements.push(reference);
+	}
+	return new _jesscss_core.Interpolated({
+		source,
+		replacements
+	}, { role: "ident" }, location, context);
+};
+function attributeSelector(T, valueAlt) {
+	const $ = this;
+	valueAlt ??= () => [
+		{
+			GATE: () => !$.isType(T.InterpolatedIdent),
+			ALT: () => {
+				const token = $.CONSUME5(T.Ident);
+				if ($.RECORDING_PHASE) return;
+				return new _jesscss_core.Any(token.image, { role: "ident" }, $.getLocationInfo(token), $.context);
+			}
+		},
+		{
+			GATE: () => $.isType(T.InterpolatedIdent),
+			ALT: () => {
+				const token = $.CONSUME(T.InterpolatedIdent);
+				if ($.RECORDING_PHASE) return;
+				const match = interpolatedRegex$1.exec(token.image);
+				interpolatedRegex$1.lastIndex = 0;
+				if (match && match[0] === token.image) return createInterpolatedReference$2(match[1], match[2], $.getLocationInfo(token), $.context);
+				const result = getInterpolatedOrString(token.image, $.getLocationInfo(token), $.context);
+				return typeof result === "string" ? new _jesscss_core.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 _jesscss_core.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 (!allowed) return;
+	if ((0, _jesscss_core.isNode)(selector, _jesscss_core.N.SelectorList)) {
+		for (const item of selector.value) {
+			const disallowed = findDisallowedExtendSelector(item, allowed);
+			if (disallowed) return disallowed;
+		}
+		return;
+	}
+	const kinds = (0, _jesscss_core.isNode)(selector, _jesscss_core.N.BasicSelector) ? ["simple", "basic"] : (0, _jesscss_core.isNode)(selector, _jesscss_core.N.PseudoSelector) ? ["simple", "pseudo"] : (0, _jesscss_core.isNode)(selector, _jesscss_core.N.CompoundSelector) ? ["compound"] : (0, _jesscss_core.isNode)(selector, _jesscss_core.N.ComplexSelector) ? ["complex"] : ["simple"];
+	if (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]} selectors`;
+	return `${allowed.slice(0, -1).join(", ")}, or ${allowed[allowed.length - 1]} selectors`;
+}
+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 _jesscss_core.Extend({
+		selector,
+		target: currentTarget,
+		flag: currentFlag
+	}, void 0, location, context);
+	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) {
+			let target = currentNode.target;
+			if (!(target instanceof _jesscss_core.SelectorList)) currentNode.setData("target", new _jesscss_core.SelectorList([target, ext.target], void 0, location, context));
+			else target.setData([...target.value, ext.target]);
+		} else {
+			if (!extendNodes || !extendNodes.includes(currentNode)) (extendNodes ??= []).push(currentNode);
+			currentFlag = thisFlag;
+			currentTarget = ext.target;
+			currentNode = new _jesscss_core.Extend({
+				selector,
+				target: currentTarget,
+				flag: currentFlag
+			}, void 0, location, context);
+			extendNodes.push(currentNode);
+		}
+	}
+	if (!extendNodes) return currentNode;
+	if (extendNodes.length === 1) return extendNodes[0];
+	return extendNodes;
+}
+/** 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" || (0, _jesscss_core.isNode)(node, _jesscss_core.N.Call)) return false;
+	if ((0, _jesscss_core.isNode)(node, _jesscss_core.N.Reference)) return node.options.type === "mixin-ruleset";
+	if (node instanceof _jesscss_core.List || node instanceof _jesscss_core.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" || (0, _jesscss_core.isNode)(node, _jesscss_core.N.Call)) return false;
+	if ((0, _jesscss_core.isNode)(node, _jesscss_core.N.Reference)) return false;
+	if (node instanceof _jesscss_core.List || node instanceof _jesscss_core.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] });
+			const coImage = co.image;
+			let combinator = new _jesscss_core.Combinator(coImage, void 0, $.getLocationInfo(co), $.context);
+			let targetNode = node instanceof _jesscss_core.Extend ? node.selector : node;
+			if (targetNode instanceof _jesscss_core.ComplexSelector) {
+				targetNode.setData([combinator, ...targetNode.value]);
+				targetNode._location = $.getLocationFromNodes(targetNode.value);
+			} else {
+				let nodes = [combinator, targetNode];
+				let complex = new _jesscss_core.ComplexSelector(nodes, void 0, $.getLocationFromNodes(nodes), $.context);
+				if (node instanceof _jesscss_core.Extend) {
+					node.setData("selector", complex);
+					let location = node.location;
+					location[0] = co.startOffset;
+					location[1] = co.startLine;
+					location[2] = co.startColumn;
+				} 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($.wrap(selector, true));
+					else sequences.push($.wrap(selector, i === 1 ? true : "both"));
+				}
+			}
+		});
+		if (RECORDING_PHASE) return;
+		const location = $.endRule();
+		if (sequences.length === 1) return sequences[0];
+		return new _jesscss_core.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($.wrap(selector, true));
+					else sequences.push($.wrap(selector, i === 1 ? true : "both"));
+				}
+			}
+		});
+		if (RECORDING_PHASE) return;
+		const location = $.endRule();
+		if (sequences.length === 1) return sequences[0];
+		return new _jesscss_core.SelectorList(sequences, void 0, location, $.context);
+	};
+}
+function compoundSelector(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		/**
+		A sequence of simple selectors that are not separated by
+		a combinator.
+		.e.g. `a#selected`
+		*/
+		let RECORDING_PHASE = $.RECORDING_PHASE;
+		let selectors;
+		if (!RECORDING_PHASE) selectors = [];
+		let sel = $.SUBRULE($.simpleSelector, { ARGS: [ctx] });
+		if (!RECORDING_PHASE) selectors.push(sel);
+		$.MANY({
+			GATE: () => !$.hasWS() && !(ctx.inExtend && $.isType(T.All)),
+			DEF: () => {
+				let sel = $.SUBRULE2($.simpleSelector, { ARGS: [ctx] });
+				if (!RECORDING_PHASE) {
+					/** Make sure we don't add implicit whitespace */
+					sel.pre = 0;
+					selectors.push(sel);
+				}
+			}
+		});
+		if (RECORDING_PHASE) return;
+		if (selectors.length === 1) return selectors[0];
+		return new _jesscss_core.CompoundSelector(selectors, void 0, $.getLocationFromNodes(selectors), $.context);
+	};
+}
+/**
+* Extended with :extend
+*/
+function complexSelector(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		const RECORDING_PHASE = $.RECORDING_PHASE;
+		$.startRule();
+		let selectors;
+		if (!RECORDING_PHASE) selectors = [$.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) {
+					const coImg = co.image;
+					combinator = $.wrap(new _jesscss_core.Combinator(coImg, void 0, $.getLocationInfo(co), $.context), "both");
+				} else {
+					const startOffset = $.LA(1).startOffset;
+					combinator = new _jesscss_core.Combinator(" ", void 0, void 0, $.context);
+					let pre = $.getPrePost(startOffset);
+					if (pre === 1) pre = 0;
+					else if (pre) {
+						const last = pre[pre.length - 1];
+						if (typeof last === "string" && last.endsWith(" ")) pre[pre.length - 1] = last.slice(0, -1);
+					}
+					combinator.pre = pre;
+				}
+				const compound = $.SUBRULE2($.compoundSelector, { ARGS: [ctx] });
+				if (!RECORDING_PHASE) selectors.push(combinator, compound);
+			}
+		});
+		let selector;
+		if (!RECORDING_PHASE) {
+			const location = $.endRule();
+			selector = selectors.length === 1 ? selectors[0] : new _jesscss_core.ComplexSelector(selectors, 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.AmpersandExtend);
+		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 _jesscss_core.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 selectors, 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 _jesscss_core.Ampersand({ template: 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 _jesscss_core.Ampersand({ template: sawQuoted && value === "" ? new _jesscss_core.Nil() : value === "nil" ? new _jesscss_core.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-selectors */
+				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 getInterpolated(image, location, $.context);
+			}
+			},
+			*/
+			{ ALT: () => $.SUBRULE($.attributeSelector, { ARGS: [ctx] }) }),
+			(
+			/** Supports keyframes selectors */
+			{ ALT: () => $.CONSUME(T.DimensionInt) }),
+			{ ALT: () => $.CONSUME(T.DimensionNum) }
+		]);
+		if ($.isToken(selector)) {
+			if (selector.tokenType.name === "Ampersand") return new _jesscss_core.Ampersand({ template: getAmpersandTemplateValue(selector.image) }, void 0, $.getLocationInfo(selector), $.context);
+			if (selector.tokenType.name === "InterpolatedSelector" || selector.tokenType.name === "InterpolatedIdent") {
+				let nameValue = selector.image;
+				return new _jesscss_core.InterpolatedSelector(getInterpolated$1(nameValue, $.getLocationInfo(selector), $.context), void 0, $.getLocationInfo(selector), $.context);
+			}
+			return new _jesscss_core.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 ($.leakyRules) {
+			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.value) 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.name;
+					const propName = typeof name === "string" ? name : name.valueOf();
+					if (propName.startsWith("--")) return true;
+					return known_css_properties.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 _jesscss_core.Collection(rules.value, rules.options, $.endRule(), $.context);
+		}
+		return new _jesscss_core.Mixin({
+			params,
+			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 = [$.wrap(urlNode)];
+			if (extraNodes && extraNodes.length) if (isAtRule) {
+				isAtRule = true;
+				for (const n of extraNodes) preludeNodes.push(n);
+			} else {
+				const postludeLoc = $.getLocationFromNodes(extraNodes);
+				postludeNode = new _jesscss_core.Sequence(extraNodes, void 0, postludeLoc, $.context);
+			}
+			let location = $.endRule();
+			if (isAtRule) {
+				const prelude = new _jesscss_core.Sequence(preludeNodes, void 0, $.getLocationFromNodes(preludeNodes), $.context);
+				return new _jesscss_core.AtRule({
+					name: $.wrap(new _jesscss_core.Any(name.image, { role: "atkeyword" }, $.getLocationInfo(name), $.context), true),
+					prelude
+				}, void 0, location, $.context);
+			}
+			return new _jesscss_core.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 _jesscss_core.Interpolated)) nameNode = new _jesscss_core.Any(nameVal, { role: "ident" }, $.getLocationInfo(name), $.context);
+		else nameNode = nameVal;
+		/** An anonymous mixin call */
+		if (!value) {
+			const callNode = new _jesscss_core.Call({
+				name: new _jesscss_core.Reference({ key: nameNode }, {
+					type: "variable",
+					role: "name"
+				}),
+				args
+			}, important ? { markImportant: true } : void 0, location, $.context);
+			if (important) important = void 0;
+			return new _jesscss_core.Expression(callNode, void 0, location, $.context);
+		}
+		if (important && value instanceof _jesscss_core.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 _jesscss_core.VarDeclaration({
+			name: $.wrap(nameNode, true),
+			value: $.wrap(value, true),
+			important: important ? $.wrap(new _jesscss_core.Any(important.image, { role: "flag" }, $.getLocationInfo(important), $.context), true) : 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 _jesscss_core.SelectorCapture($.wrap(selector, true), 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 _jesscss_core.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 _jesscss_core.Any(ident.image, { role: "ident" }, $.getLocationInfo(ident), $.context);
+			}
+		}, {
+			GATE: () => !!$.looseMode,
+			ALT: () => {
+				let nodes = [];
+				$.MANY(() => {
+					let node = $.SUBRULE($.anyInnerValue, { ARGS: [ctx] });
+					const wrapped = $.wrap(node);
+					nodes.push(wrapped);
+				});
+				return new _jesscss_core.Sequence(nodes, void 0, $.getLocationFromNodes(nodes), $.context);
+			}
+		}]);
+		$.CONSUME(T.RSquare);
+		return new _jesscss_core.Block(node, { type: "square" }, $.endRule(), $.context);
+	};
+}
+//#endregion
+//#region src/productions/values.ts
+const cssNthValue = _jesscss_css_parser.productions.nthValue;
+const cssKnownFunctions = _jesscss_css_parser.productions.knownFunctions;
+const cssMathValue = _jesscss_css_parser.productions.mathValue;
+function getParenFrames$1(ctx) {
+	return ctx?.parenFrames ?? [];
+}
+function withCalcFrame(ctx, delta) {
+	const calcFrames = (ctx?.calcFrames ?? 0) + delta;
+	return {
+		...ctx ?? {},
+		calcFrames
+	};
+}
+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);
+}
+const createInterpolatedReference$1 = (prefix, value, location, context) => {
+	const isProperty = prefix === "$";
+	return new _jesscss_core.Reference({ key: isProperty ? new _jesscss_core.Quoted(value, { quote: "'" }, location, context) : value }, {
+		type: isProperty ? "property" : "variable",
+		role: "ident"
+	}, location, context);
+};
+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 _jesscss_core.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 _jesscss_core.Num(num, void 0, $.getLocationInfo(tok), $.context);
+					else startValue = $.processValueToken(tok);
+				}
+				right = $.SUBRULE3($.expressionProduct, { ARGS: [{
+					...ctx,
+					startValue
+				}] });
+			} else break;
+			left = new _jesscss_core.Operation([
+				$.wrap(left, true),
+				op,
+				$.wrap(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] });
+			left = new _jesscss_core.Operation([
+				$.wrap(left, true),
+				op.image,
+				$.wrap(right)
+			], void 0, $.getLocationFromNodes([left, right]), $.context);
+		}
+		$.endRule();
+		return left;
+	};
+}
+function customValue(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		if ($.isType(T.LParen) || $.isType(T.FunctionStart) || $.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 $.wrap($.processValueToken(token, ctx), void 0, ctx);
+	};
+}
+function innerCustomValue(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		if ($.isType(T.Semi)) {
+			const semi = $.CONSUME(T.Semi);
+			if ($.RECORDING_PHASE) return;
+			return $.wrap(new _jesscss_core.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;
+			const seq = new _jesscss_core.Sequence(nodes, void 0, seqLoc, $.context);
+			return $.wrap(new _jesscss_core.Block($.wrap(seq, true, ctx), { type }, location, $.context), void 0, ctx);
+		}
+		const startNode = $.wrap(new _jesscss_core.Any(start.image, { role: "any" }, $.getLocationInfo(start), $.context), void 0, ctx);
+		const endNode = $.wrap(new _jesscss_core.Any(end.image, { role: "any" }, $.getLocationInfo(end), $.context), void 0, ctx);
+		return new _jesscss_core.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($.wrap(node, true));
+					node = $.SUBRULE2($.valueList, { ARGS: [innerCtx] });
+					semiNodes.push($.wrap(node, true));
+					$.MANY({
+						GATE: () => $.isType(T.Semi),
+						DEF: () => {
+							$.CONSUME2(T.Semi);
+							node = $.SUBRULE3($.valueList, { ARGS: [innerCtx] });
+							semiNodes.push($.wrap(node, true));
+						}
+					});
+				});
+				if (isSemiList) node = new _jesscss_core.List(semiNodes, { sep: ";" });
+			}
+			$.CONSUME(T.RParen);
+			let location = $.endRule();
+			node = $.wrap(node, "both");
+			return new _jesscss_core.Paren(node, { escaped: !!escape }, location, $.context);
+		} }, { ALT: () => $.SUBRULE($.value, { ARGS: [ctx] }) }]);
+		let location = $.endRule();
+		if (minus) return new _jesscss_core.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 _jesscss_core.Node)) {
+			const rawValue = node.image;
+			const tokenLocation = $.getLocationInfo(node);
+			if (rawValue.startsWith("@") || rawValue.startsWith("$")) {
+				const resolved = getInterpolatedOrString(rawValue, tokenLocation, $.context);
+				if (resolved instanceof _jesscss_core.Interpolated) node = resolved;
+				else node = new _jesscss_core.Reference(resolved, { type: rawValue.startsWith("$") ? "property" : "variable" }, tokenLocation, $.context);
+			} else node = new _jesscss_core.Any(rawValue, { role: "urlvalue" }, tokenLocation, $.context);
+		}
+		return new _jesscss_core.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 _jesscss_core.Call({
+			name: "calc",
+			args: new _jesscss_core.List([args])
+		}, void 0, location, $.context);
+	};
+}
+function ifFunction(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.startRule();
+		let name = $.CONSUME(T.IfFunction);
+		let args = new _jesscss_core.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 = $.wrap(new _jesscss_core.Any(":", { role: "operator" }, void 0, $.context), true);
+				const loc = $.getLocationFromNodes([condition, value]);
+				branches.push(new _jesscss_core.Sequence([
+					$.wrap(condition, true),
+					sep,
+					$.wrap(value, true)
+				], 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 _jesscss_core.List([branches.length === 1 ? branches[0] : new _jesscss_core.List(branches, { sep: ";" }, $.getLocationFromNodes(branches), $.context)]);
+		} else {
+			isCssBranch = false;
+			let node = firstNode;
+			const parenValue = node instanceof _jesscss_core.Paren ? node.get("value") : void 0;
+			args = new _jesscss_core.List([parenValue instanceof _jesscss_core.Node ? parenValue : node]);
+			$.OR([{ ALT: () => {
+				$.CONSUME(T.Semi);
+				node = $.SUBRULE2($.valueList, { ARGS: [{
+					...ctx,
+					allowAnonymousMixins: true
+				}] });
+				args = new _jesscss_core.List([...args.value, node], args.options, $.getLocationFromNodes([...args.value, node]), $.context);
+				$.OPTION(() => {
+					$.CONSUME4(T.Semi);
+					node = $.SUBRULE3($.valueList, { ARGS: [{
+						...ctx,
+						allowAnonymousMixins: true
+					}] });
+					args = new _jesscss_core.List([...args.value, node], args.options, $.getLocationFromNodes([...args.value, node]), $.context);
+				});
+			} }, { ALT: () => {
+				$.CONSUME(T.Comma);
+				node = $.SUBRULE($.callArgument, { ARGS: [{
+					...ctx,
+					allowAnonymousMixins: true
+				}] });
+				args = new _jesscss_core.List([...args.value, node], args.options, $.getLocationFromNodes([...args.value, node]), $.context);
+				$.OPTION2(() => {
+					$.CONSUME2(T.Comma);
+					node = $.SUBRULE2($.callArgument, { ARGS: [{
+						...ctx,
+						allowAnonymousMixins: true
+					}] });
+					args = new _jesscss_core.List([...args.value, node], args.options, $.getLocationFromNodes([...args.value, node]), $.context);
+				});
+			} }]);
+			$.CONSUME3(T.RParen);
+		}
+		let location = $.endRule();
+		return new _jesscss_core.Call({
+			name: new _jesscss_core.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 _jesscss_core.Paren ? arg.get("value") : void 0;
+		return new _jesscss_core.Expression(argValue instanceof _jesscss_core.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 _jesscss_core.Reference({ key: token.image.slice(1) }, {
+						type: "property",
+						role: "ident"
+					}, $.getLocationInfo(token), $.context);
+				}
+				return new _jesscss_core.Reference(token.image.slice(1), { type: "property" }, $.getLocationInfo(token), $.context);
+			} },
+			{ ALT: () => {
+				let token = $.CONSUME(T.NestedReference);
+				if ($.RECORDING_PHASE) return;
+				const raw = token.image;
+				const type = raw.startsWith("@") ? "variable" : "property";
+				const key = getInterpolatedOrString(raw);
+				if (ctx.inCustomPropertyValue && typeof key === "string") return new _jesscss_core.Reference({ key }, {
+					type: "variable",
+					role: "ident"
+				}, $.getLocationInfo(token), $.context);
+				if (typeof key === "string") return new _jesscss_core.Reference(key, { type }, $.getLocationInfo(token), $.context);
+				return new _jesscss_core.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 _jesscss_core.Reference({ key: token.image.slice(1) }, {
+						type: "variable",
+						role: "ident"
+					}, $.getLocationInfo(token), $.context);
+				}
+				return new _jesscss_core.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 _jesscss_core.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 $.wrap(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((0, _jesscss_core.isNode)(firstArg, _jesscss_core.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 _jesscss_core.Any) {
+					const unitArg = args.value[1];
+					const quotedUnit = new _jesscss_core.Quoted(unitArg.valueOf(), { quote: "\"" }, void 0, $.context);
+					quotedUnit.pre = unitArg.pre;
+					quotedUnit.post = unitArg.post;
+					const newArgsData = [...args.value];
+					newArgsData[1] = quotedUnit;
+					args = new _jesscss_core.List(newArgsData, args.options, $.getLocationFromNodes(newArgsData), $.context);
+				}
+				const nameNode = new _jesscss_core.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 _jesscss_core.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 = [$.wrap(node, true)];
+			$.MANY({
+				GATE: () => $.isType(T.Comma),
+				DEF: () => {
+					$.CONSUME(T.Comma);
+					node = $.SUBRULE2($.callArgument, { ARGS: [argCtx] });
+					commaNodes.push($.wrap(node, true));
+				}
+			});
+			$.OPTION(() => {
+				$.CONSUME(T.Semi);
+				isSemiList = true;
+				if (commaNodes.length > 1) semiNodes.push(new _jesscss_core.List(commaNodes, void 0, $.getLocationFromNodes(commaNodes), $.context));
+				else semiNodes.push(commaNodes[0]);
+				node = $.SUBRULE3($.callArgument, { ARGS: [{
+					...argCtx,
+					allowComma: true
+				}] });
+				semiNodes.push($.wrap(node, true));
+				$.MANY2({
+					GATE: () => $.isType(T.Semi),
+					DEF: () => {
+						$.CONSUME2(T.Semi);
+						node = $.SUBRULE4($.callArgument, { ARGS: [{
+							...argCtx,
+							allowComma: true
+						}] });
+						semiNodes.push($.wrap(node, true));
+					}
+				});
+			});
+		} finally {
+			ctx.inner = prevInner;
+		}
+		$.endRule();
+		return new _jesscss_core.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 _jesscss_core.Node)) node = $.processValueToken(node);
+			return $.wrap(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");
+				const quoteChar = quoteImg;
+				if (value && (value.includes("@{") || value.includes("${"))) return new _jesscss_core.Quoted(processStringInterpolation(value, location, $.context), {
+					quote: quoteChar,
+					escaped
+				}, location, $.context);
+				return new _jesscss_core.Quoted(new _jesscss_core.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");
+				const quoteChar = quoteImg;
+				if (value && (value.includes("@{") || value.includes("${"))) return new _jesscss_core.Quoted(processStringInterpolation(value, location, $.context), {
+					quote: quoteChar,
+					escaped
+				}, location, $.context);
+				return new _jesscss_core.Quoted(new _jesscss_core.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 _jesscss_core.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 + _jesscss_core.INTERPOLATION_PLACEHOLDER + after;
+		offset += match.end - match.start - _jesscss_core.INTERPOLATION_PLACEHOLDER.length;
+		const innerResult = processStringInterpolation(match.content, location, context);
+		if (innerResult instanceof _jesscss_core.Interpolated) {
+			const nestedRef = new _jesscss_core.Reference({ key: innerResult }, {
+				type: "variable",
+				role: "ident"
+			}, location, context);
+			replacements.push(new _jesscss_core.Expression(nestedRef, void 0, location, context));
+		} else replacements.push(createInterpolatedReference$1(match.prefix, match.content, location, context));
+	}
+	return new _jesscss_core.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 = op.image;
+				left = new _jesscss_core.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 = op.image;
+				left = new _jesscss_core.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 getParenFrames(ctx) {
+	return ctx?.parenFrames ?? [];
+}
+const interpolatedRegex = /([$@])\{([^}]+)\}/g;
+const createInterpolatedReference = (prefix, value, location, context) => {
+	const isProperty = prefix === "$";
+	return new _jesscss_core.Reference({ key: isProperty ? new _jesscss_core.Quoted(value, { quote: "'" }, location, context) : value }, {
+		type: isProperty ? "property" : "variable",
+		role: "ident"
+	}, location, context);
+};
+const getInterpolated = (name, location, context) => {
+	const replacements = [];
+	let result;
+	let source = name;
+	interpolatedRegex.lastIndex = 0;
+	while (result = interpolatedRegex.exec(name)) {
+		const [match, propOrVar, value] = result;
+		source = source.replace(match, _jesscss_core.INTERPOLATION_PLACEHOLDER);
+		const reference = createInterpolatedReference(propOrVar, value, location, context);
+		replacements.push(reference);
+	}
+	return new _jesscss_core.Interpolated({
+		source,
+		replacements
+	}, { role: "ident" }, location, context);
+};
+function isDefaultGuardCall(node) {
+	if (!node || !(0, _jesscss_core.isNode)(node, _jesscss_core.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 _jesscss_core.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 = _jesscss_css_parser.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) {
+	if (op === "=>") return ">=";
+	if (op === "=<") return "<=";
+	return op;
+}
+function guard(T) {
+	const $ = this;
+	return (ctx = {}) => {
+		$.CONSUME(T.When);
+		return $.OR([{
+			GATE: () => !!ctx.inValueList,
+			ALT: () => $.SUBRULE($.comparison, { ARGS: [ctx] })
+		}, { ALT: () => {
+			ctx.allowComma = true;
+			return $.SUBRULE($.guardOr, { ARGS: [ctx] });
+		} }]);
+	};
+}
+/**
+* '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 _jesscss_core.Condition([
+					$.wrap(left, true),
+					"or",
+					$.wrap(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 _jesscss_core.DefaultGuard(guard.image, void 0, $.getLocationInfo(guard), $.context);
+	};
+}
+/**
+* '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 _jesscss_core.Condition([
+								$.wrap(right, true),
+								normalizeComparisonOperator(op.image),
+								$.wrap(compareRight)
+							], void 0, $.getLocationFromNodes([right, compareRight]), $.context);
+						}
+					});
+				} finally {
+					ctx.allowComma = allowComma;
+				}
+				if (!$.RECORDING_PHASE) {
+					if (isDefaultGuardCall(right)) {
+						ctx.hasDefault = true;
+						right = new _jesscss_core.DefaultGuard("default()", void 0, Array.isArray(right.location) && right.location.length === 6 ? right.location : void 0, $.context);
+					}
+					if (not) {
+						let [, , , endOffset, endLine, endColumn] = right.location;
+						let [startOffset, startLine, startColumn] = $.getLocationInfo(not);
+						right = new _jesscss_core.Condition([$.wrap(right, true)], { negate: true }, [
+							startOffset,
+							startLine,
+							startColumn,
+							endOffset,
+							endLine,
+							endColumn
+						], $.context);
+					}
+					if (!left) {
+						left = right;
+						return;
+					}
+					left = new _jesscss_core.Condition([
+						$.wrap(left, true),
+						"and",
+						$.wrap(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 _jesscss_core.DefaultGuard("default()", void 0, Array.isArray(node.location) && node.location.length === 6 ? node.location : void 0, $.context);
+		}
+		node = $.wrap(node, "both");
+		return new _jesscss_core.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 _jesscss_core.DefaultGuard("default()", void 0, Array.isArray(right.location) && right.location.length === 6 ? right.location : void 0, $.context);
+		}
+		left = new _jesscss_core.Condition([
+			$.wrap(left, true),
+			normalizeComparisonOperator(op.image),
+			$.wrap(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 = {}) => {
+		$.startRule();
+		let RECORDING_PHASE = $.RECORDING_PHASE;
+		let nodes;
+		if (!RECORDING_PHASE) nodes = [];
+		const first = $.OR([{ ALT: () => $.SUBRULE($.valueReference, { ARGS: [ctx] }) }, {
+			GATE: () => $.isType(T.Ident),
+			ALT: () => $.CONSUME(T.Ident)
+		}]);
+		if (!RECORDING_PHASE) if (first instanceof _jesscss_core.Node) nodes.push($.wrap(first));
+		else nodes.push($.wrap($.processValueToken(first)));
+		$.MANY({
+			GATE: $.noSep.bind($),
+			DEF: () => {
+				const seg = $.CONSUME(T.DotName);
+				if (!RECORDING_PHASE) nodes.push($.wrap($.processValueToken(seg)));
+			}
+		});
+		if (RECORDING_PHASE) return;
+		const loc = $.endRule();
+		return new _jesscss_core.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 = {}) => {
+		let node;
+		$.OR([
+			{ ALT: () => node = $.SUBRULE($.valueReference, { ARGS: [ctx] }) },
+			{
+				GATE: () => $.isType(T.Ident) && !$.isType(T.InterpolatedIdent),
+				ALT: () => {
+					const tok = $.CONSUME(T.Ident);
+					node = $.wrap($.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 = getInterpolated(nameValue, location, $.context);
+			nameNode = interpolated;
+			if (asReference) if ((0, _jesscss_core.isNode)(ctx.node, _jesscss_core.N.Reference) && ctx.node.options.type === "mixin-ruleset") nameNode = new _jesscss_core.Reference({
+				target: ctx.node,
+				key: interpolated
+			}, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, location, $.context);
+			else {
+				const target = ctx.node;
+				nameNode = new _jesscss_core.Reference({
+					target: target instanceof _jesscss_core.Call ? target : target instanceof _jesscss_core.Reference ? target : void 0,
+					key: interpolated
+				}, {
+					type: "mixin-ruleset",
+					role: "name"
+				}, location, $.context);
+			}
+		} else if (asReference) if ((0, _jesscss_core.isNode)(ctx.node, _jesscss_core.N.Reference) && ctx.node.options.type === "mixin-ruleset") {
+			const existingKey = ctx.node.key;
+			let mergedKeys;
+			if (Array.isArray(existingKey)) mergedKeys = [...existingKey];
+			else mergedKeys = [String(existingKey)];
+			mergedKeys.push(nameValue);
+			nameNode = new _jesscss_core.Reference({ key: mergedKeys.length === 1 ? mergedKeys[0] : mergedKeys }, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, location, $.context);
+		} else {
+			const target = ctx.node;
+			nameNode = new _jesscss_core.Reference({
+				target: target instanceof _jesscss_core.Call ? target : target instanceof _jesscss_core.Reference ? target : void 0,
+				key: nameValue
+			}, {
+				type: "mixin-ruleset",
+				role: "name"
+			}, location, $.context);
+		}
+		else nameNode = $.wrap(new _jesscss_core.Any(nameValue, { role: "name" }, $.getLocationInfo(name), $.context), true);
+		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 _jesscss_core.Call ? targetNode : targetNode instanceof _jesscss_core.Reference ? targetNode : void 0;
+			if (keyToken) {
+				let tokenStr = keyToken.image;
+				let type = tokenStr.startsWith("@") ? "variable" : "property";
+				if (keyToken.tokenType === T.NestedReference) {
+					let tokenStr = keyToken.image;
+					if (!tokenStr.startsWith("$") && !tokenStr.startsWith("@")) tokenStr = "$" + tokenStr;
+				}
+				let result = getInterpolatedOrString(tokenStr, $.getLocationInfo(keyToken), $.context);
+				const targetType = (0, _jesscss_core.isNode)(target, _jesscss_core.N.Reference) ? target.options.type : void 0;
+				const shouldMergeKeys = targetType === "mixin" || targetType === "mixin-ruleset" || targetType === "ruleset";
+				if ((0, _jesscss_core.isNode)(target, _jesscss_core.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 _jesscss_core.Reference({ key: mergedKeys.length === 1 ? mergedKeys[0] : mergedKeys }, { type }, $.endRule(), $.context);
+				} else ref = new _jesscss_core.Reference({
+					target,
+					key: result
+				}, { type }, $.endRule(), $.context);
+			} else ref = new _jesscss_core.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[0] = targetStartOffset;
+				ref.location[1] = targetStartLine;
+				ref.location[2] = targetStartColumn;
+			}
+			return ref;
+		} }, { ALT: () => {
+			let args = $.SUBRULE($.mixinArgs, { ARGS: [ctx] });
+			if ($.RECORDING_PHASE) return;
+			return new _jesscss_core.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();
+		const first = $.SUBRULE($.mixinArg, { ARGS: [ctx] });
+		let commaNodes = [$.wrap(first, true)];
+		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 _jesscss_core.VarDeclaration) {
+					const nodes = [head.value, ...rest];
+					hasDeclarations = rest.some((n) => n instanceof _jesscss_core.VarDeclaration);
+					head.setData("value", new _jesscss_core.List(nodes, void 0, $.getLocationFromNodes(nodes), $.context));
+					semiNodes.push(head);
+				} else {
+					hasDeclarations = commaNodes.some((n) => n instanceof _jesscss_core.VarDeclaration);
+					semiNodes.push(new _jesscss_core.List(commaNodes, void 0, $.getLocationFromNodes(commaNodes), $.context));
+				}
+				if (hasDeclarations) {
+					const indexOfSemi = $.input.indexOf(semi);
+					const previousToken = $.input[indexOfSemi - 1];
+					$.SAVE_ERROR(new chevrotain.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($.wrap(node, true));
+				else {
+					$.SAVE_ERROR(new chevrotain.NoViableAltException("Cannot mix ; and , as delimiter types", comma, $.LA(0)));
+					semiNodes.push($.wrap(node, true));
+				}
+				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($.wrap(node, true));
+		}
+		let location = $.endRule();
+		let nodes = isSemiList ? semiNodes : commaNodes;
+		let sep = isSemiList ? ";" : ",";
+		return $.wrap(new _jesscss_core.List(nodes, { sep }, location, $.context), "both");
+	};
+}
+/**
+* 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 _jesscss_core.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 _jesscss_core.VarDeclaration({
+				name: new _jesscss_core.Any(name.image.slice(1), { role: "property" }, $.getLocationInfo(name), $.context),
+				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;
+			return new _jesscss_core.Any(name.image.slice(1), { role: "name" }, $.endRule(), $.context);
+		}
+		if ($.isType(T.Ellipsis)) {
+			const ellipsis = $.CONSUME2(T.Ellipsis);
+			return new _jesscss_core.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 = {}) => {
+		if ($.LA(1).image === "@-export") return $.SUBRULE($.exportAtRule, { ARGS: [ctx] });
+		return cssUnknownAtRule.call($, T)(ctx);
+	};
+}
+/**
+* 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 _jesscss_core.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,
+	value: () => value,
+	valueReference: () => valueReference,
+	valueSequence: () => valueSequence,
+	varDeclarationOrCall: () => varDeclarationOrCall,
+	varName: () => varName,
+	varReference: () => varReference,
+	wrappedDeclarationList: () => wrappedDeclarationList
+});
+//#endregion
+//#region src/lessRecursiveParser.ts
+var LessRecursiveParser = class LessRecursiveParser extends _jesscss_css_parser.CssRecursiveParser {
+	looseMode;
+	leakyRules;
+	/** Warnings collected during parsing */
+	warnings = [];
+	/** See `LessParserConfig.mathMode` */
+	mathMode;
+	/** See `LessParserConfig.wrapOuterExpressions` */
+	wrapOuterExpressions;
+	constructor(T, config = {}) {
+		let { legacyMode, looseMode = true, leakyRules = true, mathMode = "parens-division", wrapOuterExpressions = true, ...rest } = config;
+		legacyMode = legacyMode ?? looseMode;
+		super(T, {
+			legacyMode,
+			...rest
+		});
+		this.T = T;
+		this.looseMode = looseMode;
+		this.leakyRules = leakyRules;
+		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 _jesscss_css_parser.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" || (0, chevrotain.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 _jesscss_core.Any(token.image, { role: "any" }, this.getLocationInfo(token), this.context);
+			}
+			return new _jesscss_core.Reference(token.image.slice(1), { type: "variable" }, this.getLocationInfo(token), this.context);
+		} 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 _jesscss_core.Any(token.image, { role: "any" }, this.getLocationInfo(token), this.context);
+			}
+			return super.processValueToken(token, ctx);
+		} else if (tokenType === T["DefaultGuardFunc"]) return new _jesscss_core.DefaultGuard(token.image, void 0, this.getLocationInfo(token), this.context);
+		else if (tokenType.name === "JavaScript" || T["JavaScript"] && (0, chevrotain.tokenMatcher)(token, T["JavaScript"])) throw new Error("Inline JavaScript using backticks is not supported. Use @use to import a JavaScript/TypeScript 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 _jesscss_core.Interpolated) return result;
+			else return new _jesscss_core.Any(result, { role: "ident" }, this.getLocationInfo(token), this.context);
+		} else if (tokenType === T["PlainIdent"]) {
+			const image = token.image;
+			if (image === "true" || image === "false") return new _jesscss_core.Bool(image === "true", void 0, this.getLocationInfo(token), this.context);
+		}
+		return super.processValueToken(token, ctx);
+	}
+	shouldTryQualifiedRuleInDeclarationList() {
+		const { Ident, Assign, Colon, LCurly, Comma, LSquare, NthPseudoClass, SelectorPseudoClass, FunctionStart } = this.T;
+		const isSelectorLikeContinuation = (offset) => {
+			const tok = this.LA(offset);
+			return (0, chevrotain.tokenMatcher)(tok, LCurly) || (0, chevrotain.tokenMatcher)(tok, Comma) || (0, chevrotain.tokenMatcher)(tok, this.T.Combinator) || (0, chevrotain.tokenMatcher)(tok, LSquare) || (0, chevrotain.tokenMatcher)(tok, Colon) || (0, chevrotain.tokenMatcher)(tok, NthPseudoClass) || (0, chevrotain.tokenMatcher)(tok, SelectorPseudoClass);
+		};
+		if (!this.isTypeAt(1, Ident)) return true;
+		if (!this.isTypeAt(2, Assign)) return true;
+		if (this.hasWS(2)) return false;
+		const tt3 = this.LA(3).tokenType;
+		if (tt3 === Colon || tt3 === NthPseudoClass || tt3 === SelectorPseudoClass || (0, chevrotain.tokenMatcher)(this.LA(3), FunctionStart)) return true;
+		if (!(0, chevrotain.tokenMatcher)(this.LA(3), Ident)) return false;
+		return isSelectorLikeContinuation(4);
+	}
+	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 } = (0, _jesscss_css_parser.createLexerDefinition)(lessFragments(), lessTokens());
+		cachedTokenMap = T;
+		cachedLexer = new chevrotain.Lexer(lexer, {
+			ensureOptimizations: true,
+			skipValidations: process.env.TEST !== "true"
+		});
+		cachedParser = new LessRecursiveParser(cachedTokenMap, config);
+	}
+	const { looseMode = true, leakyRules = true, mathMode = "parens-division", wrapOuterExpressions = true, legacyMode = looseMode } = config;
+	cachedParser.looseMode = looseMode;
+	cachedParser.leakyRules = leakyRules;
+	cachedParser.mathMode = mathMode;
+	cachedParser.wrapOuterExpressions = wrapOuterExpressions;
+	cachedParser.legacyMode = legacyMode;
+	return {
+		lexer: cachedLexer,
+		parser: cachedParser
+	};
+}
+/**
+* Less parser using the new recursive-descent engine.
+* Keeps Chevrotain's lexer, replaces the parser.
+*/
+var LessParser = 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.input = lexerResult.tokens;
+		const ruleMethod = parser[rule];
+		if (typeof ruleMethod !== "function") throw new Error(`Unknown parser rule: ${rule}`);
+		const tree = ruleMethod.call(parser);
+		const warnings = [...parser.warnings];
+		return {
+			tree,
+			lexerResult,
+			errors: parser.errors,
+			warnings
+		};
+	}
+	/**
+	* @todo Implement content assist for the new parser
+	*/
+	suggest(text, init) {
+		return [];
+	}
+};
+//#endregion
+exports.Fragments = Fragments;
+exports.LessParser = LessParser;
+exports.LessRecursiveParser = LessRecursiveParser;
+exports.Parser = LessParser;
+exports.Tokens = Tokens;
+exports.lessFragments = lessFragments;
+exports.lessTokens = lessTokens;