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

package/src/productions/root.ts

@@ -1,1613 +0,0 @@
-/* eslint-disable -- Retired Chevrotain parser; not linted (see @ts-nocheck below). */
-// @ts-nocheck — Retired Chevrotain parser. Uses the legacy 6-tuple `.location`
-// shape removed from Node in the provenance-side-table refactor; the functional
-// Parséman grammar (grammar-rules.ts + builders.ts) is the maintained parser.
-// Not type-checked.
-// Root production rules for LessRecursiveParser
-// Converted from lines 1-1145 of productions.ts (Chevrotain → hand-written recursive-descent)
-import type { RuleContext } from '../lessRecursiveParser.js';
-import type { IToken } from 'chevrotain';
-import { type IOrAlt } from 'chevrotain';
-import { productions as cssProductions } from '@jesscss/css-parser/jess';
-
-import {
-  Node,
-  Ampersand,
-  Block,
-  Any,
-  type LocationInfo,
-  type TreeContext,
-  type Operator,
-  type ConditionOperator,
-  Ruleset,
-  BasicSelector,
-  Combinator,
-  type Combinators,
-  List,
-  Sequence,
-  QueryCondition,
-  Call,
-  Paren,
-  Operation,
-  Quoted,
-  AtRule,
-  Interpolated,
-  InterpolatedSelector,
-  Reference,
-  Dimension,
-  Num,
-  Extend,
-  type Extend as ExtendType,
-  Negative,
-  Mixin,
-  Condition,
-  VarDeclaration,
-  Declaration,
-  CustomDeclaration,
-  DefaultGuard,
-  Rest,
-  StyleImport,
-  Expression,
-  Keyword,
-  SelectorCapture,
-  ComplexSelector,
-  CompoundSelector,
-  SelectorList,
-  Rules,
-  Url,
-  Nil,
-  Collection,
-  type ComplexSelectorComponent,
-  type Selector,
-  type SimpleSelector,
-  type AnyRole,
-  isNode,
-  N,
-  shouldOperateWithMathFrames
-} from '@jesscss/core';
-import { createInterpolatedReference, getInterpolatedNode, getInterpolatedOrString, normalizeMixinReferenceKey } from '../utils.js';
-import type { ExtendTarget, TokenMap } from '../lessRecursiveParser.js';
-import { all } from 'known-css-properties';
-
-/** Use `any` for `this` to avoid structural incompatibility between LessRecursiveParser and CssRecursiveParser */
-type P = any;
-type Alt = IOrAlt<any>[];
-type AltContext = (ctx?: RuleContext) => Alt;
-type ProductionRule = (...args: any[]) => any;
-
-// ── Save references to CSS production factories ────────────────────────
-const cssMain = cssProductions.main;
-const cssDeclaration = cssProductions.declaration;
-const cssMediaTypeQuery = cssProductions.mediaTypeQuery;
-
-// ── Helper functions ──────────────────────────────────────────────────
-
-function extendWithSelector(node: ExtendType, selector: Selector | undefined, context: TreeContext): ExtendType {
-  return new Extend({
-    selector,
-    target: node.target,
-    namespace: node.namespace,
-    flag: node.flag
-  }, undefined, node.location, context);
-}
-
-function prependRules(rules: Rules, nodes: Node[], context: TreeContext): Rules {
-  const out = new Rules([...nodes, ...rules.rules], rules.options, rules.location.length ? rules.location : undefined, context);
-  out._location = rules._location;
-  return out;
-}
-
-function getParenFrames(ctx: RuleContext | undefined): boolean[] {
-  return ctx?.parenFrames ?? [];
-}
-
-function getCalcFrames(ctx: RuleContext | undefined): number {
-  return ctx?.calcFrames ?? 0;
-}
-
-function withCalcFrame(ctx: RuleContext | undefined, delta: number): RuleContext {
-  const calcFrames = getCalcFrames(ctx) + delta;
-  return { ...(ctx ?? {}), calcFrames };
-}
-
-function guardContainsDefaultCall(node: Node | undefined): boolean {
-  if (!node) {
-    return false;
-  }
-  const isNodeLike = (value: unknown): value is Node => {
-    return Boolean(
-      value
-      && typeof value === 'object'
-      && 'type' in value && typeof value.type === 'string'
-      && 'valueOf' in value && typeof value.valueOf === 'function'
-    );
-  };
-  const queue: unknown[] = [node];
-  const seen = new Set<unknown>();
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current || seen.has(current) || !isNodeLike(current)) {
-      continue;
-    }
-    seen.add(current);
-    if (current.type === 'DefaultGuard') {
-      return true;
-    }
-    if (isNode(current, N.Call)) {
-      const callName = current.name;
-      const callNameStr = String(
-        (typeof callName === 'object' && callName !== null && 'valueOf' in callName)
-          ? callName.valueOf()
-          : callName ?? ''
-      );
-      if (callNameStr === 'default' || callNameStr === '??') {
-        return true;
-      }
-      if (callName instanceof Reference) {
-        const key = callName.key;
-        const keyStr = String(
-          (typeof key === 'object' && key !== null && 'valueOf' in key)
-            ? key.valueOf()
-            : key ?? ''
-        );
-        if (keyStr === 'default' || keyStr === '??') {
-          return true;
-        }
-      }
-    }
-    if ('data' in current) {
-      const value = current.data;
-      if (Array.isArray(value)) {
-        queue.push(...value);
-      } else if (value && typeof value === 'object') {
-        queue.push(...Object.values(value));
-      }
-    }
-  }
-  return false;
-}
-
-function isDefaultGuardCall(node: Node | undefined): node is Call {
-  if (!node || !isNode(node, N.Call)) {
-    return false;
-  }
-  const callName = node.name;
-  const callNameStr = String(
-    (typeof callName === 'object' && callName !== null && 'valueOf' in callName)
-      ? callName.valueOf()
-      : callName ?? ''
-  );
-  if (callNameStr === 'default' || callNameStr === '??') {
-    return true;
-  }
-  if (callName instanceof Reference) {
-    const key = callName.key;
-    const keyStr = String(
-      (typeof key === 'object' && key !== null && 'valueOf' in key)
-        ? key.valueOf()
-        : key ?? ''
-    );
-    return keyStr === 'default' || keyStr === '??';
-  }
-  return false;
-}
-
-function loc(node: Node): LocationInfo | undefined {
-  const location = node.location;
-  return location.length === 6 ? (location as LocationInfo) : undefined;
-}
-
-function wrapAtRulePreludeExpression(this: P, node: Node, ctx: RuleContext | undefined): Node {
-  if (!this.wrapOuterExpressions || ctx?.atRulePreludeBareVariableAs !== 'index') {
-    return node;
-  }
-  if (node instanceof Expression) {
-    return node;
-  }
-  if (isNode(node, N.Reference) && !node.target && typeof node.key === 'string') {
-    return node;
-  }
-  return new Expression(node, undefined, loc(node), this.context);
-}
-
-export function wrapOuterExpressionIfNeeded(this: P, node: Node, ctx: RuleContext | undefined): Node {
-  if (!this.wrapOuterExpressions) {
-    return node;
-  }
-  if (!ctx?.wrapInExpression) {
-    return node;
-  }
-  // Expressions should never contain Expressions; avoid nesting.
-  if (node instanceof Expression) {
-    return node;
-  }
-
-  // Math expressions: only wrap if this operation would actually be performed.
-  if (isNode(node, N.Operation)) {
-    const mathMode = this.mathMode ?? 'parens-division';
-    const shouldOperate = shouldOperateWithMathFrames(
-      {
-        mathMode,
-        parenFrames: getParenFrames(ctx),
-        calcFrames: getCalcFrames(ctx)
-      },
-      node.operator,
-      node.left,
-      node.right
-    );
-    if (shouldOperate) {
-      return new Expression(node, { parens: true }, loc(node), this.context);
-    }
-  }
-
-  return node;
-}
-
-function isEscapedString($: P, T: TokenMap): boolean {
-  const next = $.LA(1);
-  return (
-    next.image.startsWith('~')
-    && (
-      $.matchToken(next, T.QuoteStart)
-      || $.matchToken(next, T.DoubleQuoteStart)
-      || $.matchToken(next, T.SingleQuoteStart)
-    )
-  );
-}
-
-function startsLessMediaQueryReference($: P, T: TokenMap): boolean {
-  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($: P, T: TokenMap): boolean {
-  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($: P, T: TokenMap): boolean {
-  let token = $.LA(2);
-  let isColon = token.tokenType === T.Colon;
-  let isParen = token.tokenType === T.LParen;
-  let postToken = $.LA(3);
-
-  if (!$.trivia) {
-    return false;
-  }
-
-  if (!isColon && !isParen) {
-    return false;
-  }
-
-  // Known at-rule tokens (@media, @supports, etc.) followed by ( without space:
-  // Only treat as a variable call if the parens are empty — @media();
-  // Otherwise it's an at-rule — @media(min-width: 0) { }
-  if (isParen && $.matchToken($.LA(1), T.AtName) && $.LA(1).tokenType !== T.AtKeyword) {
-    if (postToken.tokenType === T.RParen) {
-      // @media() — empty parens, allow as deprecated variable call
-      $.warnDeprecation(
-        'Using known at-rule names as variables is deprecated',
-        $.LA(1),
-        'at-rule-variable'
-      );
-      return true;
-    }
-    // @media(min-width: ...) — at-rule, not a variable
-    return false;
-  }
-
-  let isVariable = !$.trivia.has(token.startOffset, 'before')
-    || (isColon && $.trivia.has(postToken.startOffset, 'before'));
-  return isVariable;
-}
-
-const { isArray } = Array;
-
-/**
- * Groups extends by target (using valueOf()) and flag.
- * Returns an array of grouped Extend nodes where extends with the same target and flag
- * are combined into a single Extend node with a SelectorList of all matching value.
- *
- * @todo Group complex value into selector lists
- */
-function groupExtendsByTargetAndFlag(
-  extendNodes: Extend[]
-): Array<Extend | Extend[]> {
-  // Group extends by target and flag
-  const groups = new Map<string, Extend | Extend[]>();
-
-  for (const ext of extendNodes) {
-    const { target, flag = 1 } = ext; // ExtendFlag.Exact = 1
-    // Create a key from target valueOf() and flag
-    const key = `${target.valueOf()}|${flag}`;
-
-    let group = groups.get(key);
-    if (!group) {
-      groups.set(key, ext);
-    } else if (isArray(group)) {
-      group.push(ext);
-    } else {
-      groups.set(key, [group, ext]);
-    }
-  }
-
-  return Array.from(groups.values());
-}
-
-// ── Exported production rules ─────────────────────────────────────────
-
-/** Charset moved within `main` (explained in that rule) */
-export function stylesheet(this: P, T: TokenMap): ProductionRule {
-  const $ = this;
-  return (options: Record<string, any> = {}) => {
-    let context: TreeContext;
-    if (options.context) {
-      context = $.context = options.context;
-    } else {
-      context = $.context;
-    }
-
-    let charset: IToken | undefined;
-
-    if (!$.looseMode) {
-      $.OPTION(() => {
-        charset = $.CONSUME(T.Charset);
-      });
-    }
-
-    const ctx: RuleContext = { isRoot: true };
-
-    let root: Node = $.SUBRULE($.main, { ARGS: [ctx] });
-
-    if (charset && isNode(root, N.Rules)) {
-      let charsetLoc = $.getLocationInfo(charset);
-      root = new Rules(
-        [new Any(charset.image, { role: 'charset' }, charsetLoc, context!), ...root.rules],
-        root.options,
-        root.location.length ? root.location : undefined,
-        context!
-      );
-      let rootLoc = root.location;
-      rootLoc[0] = charsetLoc[0];
-      rootLoc[1] = charsetLoc[1];
-      rootLoc[2] = charsetLoc[2];
-    }
-
-    return root;
-  };
-}
-
-/**
- * Starts with a colon, with these conditions
- *  1. It is not preceded by a space or
- *  2. If it is preceded by a space, then it is
- *     followed by a space.
- */
-
-export function main(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    const isAmpersandExtendStart = () =>
-      $.LA(1).tokenType === T.Ampersand && $.LA(2).tokenType === T.Extend;
-    const isMixinOrQualifiedStart = () => {
-      const next = $.LA(1).tokenType;
-      return next === T.DotName || next === T.HashName || next === T.ColorIdentStart;
-    };
-    const isCustomPropertyStart = () =>
-      $.isType(T.InterpolatedCustomProperty) || $.isType(T.CustomProperty);
-    const isAtRuleStart = () => $.matchToken($.LA(1), T.AtName);
-    const shouldTryQualifiedRule = () =>
-      !isCustomPropertyStart()
-      && !isMixinOrQualifiedStart()
-      && !isAtRuleStart()
-      && $.shouldTryQualifiedRuleInDeclarationList();
-
-    const ruleAlt = (ctx: RuleContext = {}): Alt => {
-      let isVariable = isVariableLike($, T);
-      return [
-        { ALT: () => $.SUBRULE($.functionCall, { ARGS: [ctx] }) },
-        {
-          GATE: isAmpersandExtendStart,
-          ALT: () => $.SUBRULE2($.ampersandExtend, { ARGS: [ctx] })
-        },
-        {
-          GATE: isMixinOrQualifiedStart,
-          ALT: () => $.SUBRULE3($.mixinOrQualifiedRule, { ARGS: [ctx] })
-        },
-        {
-          GATE: () => isVariable,
-          ALT: () => $.SUBRULE4($.varDeclarationOrCall, { ARGS: [ctx] })
-        },
-        {
-          GATE: () => !isVariable && isAtRuleStart(),
-          ALT: () => $.SUBRULE5($.atRule, { ARGS: [ctx] })
-        },
-        {
-          GATE: isCustomPropertyStart,
-          ALT: () => $.SUBRULE7($.declaration, { ARGS: [ctx] })
-        },
-        {
-          GATE: shouldTryQualifiedRule,
-          ALT: () => $.SUBRULE6($.qualifiedRule, { ARGS: [ctx] })
-        },
-
-        /**
-         * Historically, Less allows `@charset` anywhere,
-         * to avoid outputting it in the wrong place.
-         * Ideally, this would result in an error if, say,
-         * the `@charset` was defined at the bottom of the file,
-         * but that wasn't the solution made.
-         * @see https://github.com/less/less.js/issues/2126
-         */
-        {
-          GATE: () => $.looseMode,
-          ALT: () => $.CONSUME(T.Charset)
-        },
-        { ALT: () => $.CONSUME(T.Semi) }
-      ];
-    };
-
-    let RECORDING_PHASE = $.RECORDING_PHASE;
-    let context: TreeContext;
-    let rules: Node[];
-    if (!RECORDING_PHASE) {
-      context = $.context;
-      rules = [];
-    }
-
-    let requiredSemi = false;
-
-    let lastRule: Node | undefined;
-    /**
-     * 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);
-        // Stop at RCurly (belongs to parent block) or end of input
-        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: Node | IToken = $.OR(localAlt);
-        if (!RECORDING_PHASE) {
-          /** @todo - When do we not have a value? */
-          if (value) {
-            if (!(value instanceof Node)) {
-              /** This is a semi-colon or charset token */
-              let tok = value as IToken;
-              if (tok.image.includes('@charset')) {
-                rules!.push(new Any(tok.image, { role: 'charset' }, $.getLocationInfo(tok), context!));
-              } else {
-                if (lastRule) {
-                  lastRule.options.semi = true;
-                } else {
-                  rules!.push(new Any(';', { role: 'semi' }, $.getLocationInfo($.LA(1)), context!));
-                }
-              }
-            } else {
-              requiredSemi = !!value.requiredSemi;
-              rules!.push(value);
-              lastRule = value;
-            }
-          }
-        }
-      }
-    });
-
-    if (RECORDING_PHASE) {
-      return;
-    }
-    // Process any extendNodes that were set (e.g., by ampersandExtend at root level)
-    if (ctx.extendNodes && ctx.extendNodes!.length > 0) {
-      // Filter out Nil nodes (returned by ampersandExtend to avoid duplication)
-      const filteredRules = rules!.filter(r => !(r instanceof Nil));
-      rules = [...ctx.extendNodes!, ...filteredRules];
-      ctx.extendNodes = undefined;
-    }
-    let returnNode = $.getRulesWithComments(rules!, $.getLocationInfo($.LA(1)));
-    // Attaches remaining whitespace at the end of rules
-    return returnNode!;
-  };
-}
-
-export function declarationList(this: P, T: TokenMap): ProductionRule {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    const isMixinOrQualifiedStart = () => {
-      const next = $.LA(1).tokenType;
-      return next === T.DotName || next === T.HashName || next === T.ColorIdentStart;
-    };
-    const isCustomPropertyStart = () =>
-      $.isType(T.InterpolatedCustomProperty) || $.isType(T.CustomProperty);
-    const isAtRuleStart = () => $.matchToken($.LA(1), T.AtName);
-    const isAmpersandExtendStart = () =>
-      $.LA(1).tokenType === T.Ampersand && $.LA(2).tokenType === T.Extend;
-    const shouldTryQualifiedRule = () =>
-      !isCustomPropertyStart()
-      && !isMixinOrQualifiedStart()
-      && !isAtRuleStart()
-      && $.shouldTryQualifiedRuleInDeclarationList();
-
-    const ruleAlt = (ctx: RuleContext = {}): Alt => {
-      const isVariable = isVariableLike($, T);
-      return [
-        {
-          GATE: isMixinOrQualifiedStart,
-          ALT: () => {
-            return $.SUBRULE($.mixinOrQualifiedRule, { ARGS: [{ ...ctx, inner: true }] });
-          }
-        },
-        {
-          GATE: () => isVariable,
-          ALT: () => $.SUBRULE2($.varDeclarationOrCall, { ARGS: [ctx] })
-        },
-        {
-          GATE: () => !isVariable && isAtRuleStart(),
-          ALT: () => $.SUBRULE3($.innerAtRule, { ARGS: [ctx] })
-        },
-        {
-          GATE: isAmpersandExtendStart,
-          ALT: () => $.SUBRULE4($.ampersandExtend, { ARGS: [ctx] })
-        },
-        {
-          GATE: () => $.check(T.FunctionStart),
-          ALT: () => {
-            const fnCall = $.SUBRULE5($.functionCall, { ARGS: [ctx] });
-            if (fnCall instanceof Call) {
-              fnCall.requiredSemi = false;
-            }
-            return fnCall;
-          }
-        },
-        {
-          GATE: isCustomPropertyStart,
-          ALT: () => $.SUBRULE8($.declaration, { ARGS: [ctx] })
-        },
-        {
-          GATE: shouldTryQualifiedRule,
-          ALT: () => {
-            return $.SUBRULE6($.qualifiedRule, { ARGS: [{ ...ctx, inner: true }] });
-          }
-        },
-        {
-          ALT: () => {
-            return $.SUBRULE7($.declaration, { ARGS: [ctx] });
-          }
-        },
-        { ALT: () => $.CONSUME(T.Semi) }
-      ];
-    };
-
-    return cssMain.call($, T, ruleAlt)(ctx);
-  };
-}
-
-export function declaration(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    const normalizeLessAssignToken = (assign: IToken): IToken => {
-      if (assign.tokenType === T.PlusAssign) {
-        return { ...assign, image: '+,:' };
-      }
-      if (assign.tokenType === T.UnderscoreAssign) {
-        return { ...assign, image: '+_:' };
-      }
-      return assign;
-    };
-
-    const customPropertyAlt = (consumeName: () => IToken, occurrence: 2 | 3) => ({
-      ALT: () => {
-        let nodes: Node[] | undefined;
-        if (!$.RECORDING_PHASE) {
-          nodes = [];
-        }
-        const name = consumeName();
-        const rawAssign = occurrence === 2
-          ? $.CONSUME2(T.Assign)
-          : $.CONSUME3(T.Assign);
-        const assign = normalizeLessAssignToken(rawAssign);
-        $.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: Node;
-          const nameValue = name.image;
-          if (nameValue.includes('@') || nameValue.includes('$')) {
-            nameNode = getInterpolatedNode(nameValue, $.getLocationInfo(name), $.context);
-          } else {
-            nameNode = new Any(name.image, { role: 'property' }, $.getLocationInfo(name), $.context);
-          }
-          const value = new Sequence(nodes!, undefined, location, $.context);
-          return [nameNode, assign, value];
-        }
-      }
-    });
-
-    const ruleAlt = (ctx: RuleContext = {}): Alt => [
-      {
-        ALT: () => {
-          let name: IToken;
-          $.OR2([
-            {
-              ALT: () => {
-                name = $.CONSUME(T.Ident);
-              }
-            },
-            {
-              GATE: () => $.legacyMode,
-              ALT: () => name = $.CONSUME(T.LegacyPropIdent)
-            }
-          ]);
-          const assign = normalizeLessAssignToken($.CONSUME(T.Assign));
-          let value: Node | undefined;
-          if ($.looseMode) {
-            $.OPTION2({
-              GATE: () => !($.isType(T.Semi) || $.isType(T.RCurly)),
-              DEF: () => {
-                value = $.SUBRULE($.valueList, { ARGS: [ctx] });
-              }
-            });
-            if (!$.RECORDING_PHASE && !value) {
-              value = new Sequence([], undefined, undefined, $.context);
-            }
-          } else {
-            value = $.SUBRULE($.valueList, { ARGS: [ctx] });
-          }
-          let important: IToken | undefined;
-
-          $.OPTION(() => {
-            important = $.CONSUME(T.Important);
-          });
-          if (!$.RECORDING_PHASE) {
-            let nameNode: Node;
-            const nameValue = name!.image;
-            if (nameValue.includes('@') || nameValue.includes('$')) {
-              nameNode = getInterpolatedNode(nameValue, $.getLocationInfo(name!), $.context);
-            } else {
-              nameNode = new Any(name!.image, { role: 'property' }, $.getLocationInfo(name!), $.context);
-            }
-            return [nameNode, assign, value, important];
-          }
-        }
-      },
-      customPropertyAlt(() => $.CONSUME(T.InterpolatedCustomProperty), 2),
-      customPropertyAlt(() => $.CONSUME(T.CustomProperty), 3)
-    ];
-
-    return cssDeclaration.call($, T, ruleAlt)(ctx);
-  };
-}
-
-export function mediaInParens(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    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] })
-      },
-      {
-        /**
-         * Less allows media/container conditions to be supplied by variables or
-         * namespaced references, but only when the inner token stream actually
-         * starts like a Less reference, not a plain CSS media feature.
-         */
-        GATE: () => (
-          $.isType(T.PropertyReference)
-          || $.isType(T.NestedReference)
-          || $.isType(T.AtName)
-          || $.isType(T.HashName)
-          || $.isType(T.DotName)
-          || $.isType(T.ColorIdentStart)
-          || $.isType(T.InterpolatedSelector)
-        ),
-        ALT: () => {
-          const node = $.SUBRULE2($.valueReference, { ARGS: [{ ...ctx, requireAccessorsAfterMixinCall: true }] });
-          return wrapAtRulePreludeExpression.call($, node, ctx);
-        }
-      },
-      {
-        ALT: () => $.SUBRULE($.mediaFeature, { ARGS: [ctx] })
-      }
-    ]);
-
-    $.CONSUME(T.RParen);
-
-    if (RECORDING_PHASE) {
-      return;
-    }
-    const location = $.endRule();
-    return new Paren(node, undefined, location, $.context);
-  };
-}
-
-export function mediaQuery(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    const preludeCtx: RuleContext = { ...ctx, atRulePreludeBareVariableAs: 'index' };
-    return $.OR2([
-      {
-        GATE: () => $.startsMediaCondition(T),
-        ALT: () => $.SUBRULE($.mediaConditionWithoutOr, { ARGS: [preludeCtx] })
-      },
-      {
-        GATE: () => isEscapedString($, T),
-        ALT: () => $.SUBRULE($.lessMediaQueryFromString, { ARGS: [preludeCtx] })
-      },
-      {
-        GATE: () => startsLessMediaQueryReference($, T),
-        ALT: () => $.SUBRULE2($.lessMediaQueryFromReference, { ARGS: [preludeCtx] })
-      },
-      {
-        ALT: () => $.SUBRULE7($.mediaTypeQuery, { ARGS: [preludeCtx] })
-      }
-    ]);
-  };
-}
-
-export function mediaCondition(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => $.SUBRULE($.mediaConditionWithoutOr, { ARGS: [ctx] });
-}
-
-export function lessMediaQueryFromString(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    const first = $.SUBRULE($.string, { ARGS: [ctx] });
-    return $.SUBRULE($.lessMediaQueryTail, { ARGS: [{ ...ctx, startValue: first }] });
-  };
-}
-
-export function lessMediaQueryFromReference(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    const first = $.SUBRULE($.valueReference, { ARGS: [{ ...ctx, requireAccessorsAfterMixinCall: true }] });
-    return $.SUBRULE2($.lessMediaQueryTail, {
-      ARGS: [{
-        ...ctx,
-        startValue: wrapAtRulePreludeExpression.call($, first, ctx)
-      }]
-    });
-  };
-}
-
-export function lessMediaQueryTail(this: P, T: TokenMap): ProductionRule {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    const RECORDING_PHASE = $.RECORDING_PHASE;
-    $.startRule();
-    let nodes: Node[] | undefined;
-    if (!RECORDING_PHASE) {
-      nodes = [ctx.startValue!];
-    }
-
-    $.MANY({
-      GATE: () => $.isType(T.And),
-      DEF: () => {
-        const andToken = $.CONSUME(T.And);
-        const next = $.OR([
-          {
-            GATE: () => isEscapedString($, T),
-            ALT: () => $.SUBRULE2($.string, { ARGS: [ctx] })
-          },
-          {
-            GATE: () => startsLessMediaQueryReference($, T),
-            ALT: () => {
-              const next = $.SUBRULE2($.valueReference, { ARGS: [{ ...ctx, requireAccessorsAfterMixinCall: true }] });
-              return wrapAtRulePreludeExpression.call($, next, ctx);
-            }
-          },
-          {
-            GATE: () => $.startsMediaCondition(T),
-            ALT: () => $.SUBRULE2($.mediaConditionWithoutOr, { ARGS: [ctx] })
-          },
-          {
-            ALT: () => $.SUBRULE2($.mediaType, { ARGS: [ctx] })
-          }
-        ]);
-
-        if (!RECORDING_PHASE) {
-          nodes!.push(new Keyword(andToken.image, undefined, $.getLocationInfo(andToken), $.context));
-          nodes!.push(next);
-        }
-      }
-    });
-
-    if (RECORDING_PHASE) {
-      return;
-    }
-    const location = $.endRule();
-    if (nodes!.length === 1) {
-      return nodes![0]!;
-    }
-    return new QueryCondition(nodes!, undefined, location, $.context);
-  };
-}
-
-export function mediaConditionWithoutOr(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => $.OR([
-    { ALT: () => $.SUBRULE($.mediaNot, { ARGS: [ctx] }) },
-    {
-      ALT: () => {
-        const RECORDING_PHASE = $.RECORDING_PHASE;
-        $.startRule();
-        let nodes: Node[] | undefined;
-        if (!RECORDING_PHASE) {
-          nodes = [];
-        }
-        const node = $.SUBRULE($.mediaInParens, { ARGS: [ctx] });
-        if (!RECORDING_PHASE) {
-          nodes!.push(node);
-        }
-        $.MANY({
-          GATE: () => $.isType(T.And),
-          DEF: () => {
-            const rule = $.SUBRULE($.mediaAnd, { ARGS: [ctx] });
-            if (!RECORDING_PHASE) {
-              nodes!.push(...rule);
-            }
-          }
-        });
-        if (RECORDING_PHASE) {
-          return;
-        }
-        if (nodes!.length === 1) {
-          $.endRule();
-          return nodes![0]!;
-        }
-        return new QueryCondition(nodes!, undefined, $.endRule(), $.context);
-      }
-    }
-  ]);
-}
-
-export function mediaFeature(this: P, T: TokenMap) {
-  const $ = this;
-
-  function createFeatureIdentNode(token: IToken, role: 'property'): Any<'property'> | Interpolated<'property'>;
-  function createFeatureIdentNode(token: IToken, role: 'ident'): Any<'ident'> | Interpolated<AnyRole>;
-  function createFeatureIdentNode(token: IToken, role: 'ident' | 'property') {
-    const location = $.getLocationInfo(token);
-    const resolved = getInterpolatedOrString(token.image, location, $.context);
-    if (typeof resolved === 'string') {
-      return new Any(resolved, { role }, location, $.context);
-    }
-    return resolved;
-  }
-
-  return (ctx: RuleContext = {}) => $.OR([
-    {
-      GATE: () => {
-        return $.isType(T.InterpolatedIdent) || $.isType(T.Ident);
-      },
-      ALT: () => {
-        const RECORDING_PHASE = $.RECORDING_PHASE;
-        $.startRule();
-        let rule: Node | undefined;
-        const ident = $.LA(1).tokenType === T.InterpolatedIdent
-          ? $.CONSUME(T.InterpolatedIdent)
-          : $.CONSUME(T.Ident);
-        $.OPTION(() => {
-          rule = $.OR2([
-            {
-              ALT: () => {
-                $.CONSUME(T.Colon);
-                const value = $.SUBRULE($.mfValue, { ARGS: [ctx] });
-                if (!RECORDING_PHASE) {
-                  const location = $.endRule();
-                  const featureName = createFeatureIdentNode(ident, 'property');
-                  return new Declaration({
-                    name: featureName instanceof Any ? String(featureName.valueOf()) : featureName,
-                    value: value
-                  }, undefined, location, $.context);
-                }
-              }
-            },
-            {
-              GATE: () => ($.isTypeAt(1, T.MfLt) || $.isTypeAt(1, T.MfGt))
-                && ($.isTypeAt(2, T.Ident) || $.isTypeAt(2, T.InterpolatedIdent)),
-              ALT: () => {
-                const seq = $.SUBRULE($.mediaRange, { ARGS: [ctx] });
-
-                if (!RECORDING_PHASE) {
-                  const [startOffset, startLine, startColumn] = $.endRule();
-                  seq.value.unshift(createFeatureIdentNode(ident, 'ident'));
-                  seq.location.start = startOffset;
-                  seq.location[1] = startLine;
-                  seq.location[2] = startColumn;
-                  return new QueryCondition(seq.value, undefined, seq.location, $.context);
-                }
-                return seq;
-              }
-            },
-            {
-              GATE: () => $.isTypeAt(1, T.MfLt) || $.isTypeAt(1, T.MfGt) || $.LA(1).tokenType === T.Eq,
-              ALT: () => {
-                const op = $.SUBRULE($.mfComparison, { ARGS: [ctx] });
-                const value = $.SUBRULE($.mfNonIdentifierValue, { ARGS: [ctx] });
-
-                if (!RECORDING_PHASE) {
-                  const location = $.endRule();
-                  return new QueryCondition([
-                    createFeatureIdentNode(ident, 'ident'),
-                    new Any(op.image, { role: 'operator' }, $.getLocationInfo(op), $.context),
-                    value
-                  ], undefined, location, $.context);
-                }
-              }
-            }
-          ]);
-        });
-        if (!RECORDING_PHASE && !rule) {
-          const location = $.endRule();
-          const identNode = createFeatureIdentNode(ident, 'ident');
-          return new QueryCondition([identNode], undefined, location, $.context);
-        }
-        return rule;
-      }
-    },
-    {
-      ALT: () => {
-        const RECORDING_PHASE = $.RECORDING_PHASE;
-        $.startRule();
-        const left = $.SUBRULE2($.mfNonIdentifierValue, { ARGS: [{ ...ctx }] });
-        return $.OR3([
-          {
-            GATE: () => {
-              const tt2 = $.LA(2).tokenType;
-              if (!(($.isTypeAt(1, T.MfLt) || $.isTypeAt(1, T.MfGt) || $.LA(1).tokenType === T.Eq)
-                && (tt2 === T.Ident || tt2 === T.InterpolatedIdent))) {
-                return false;
-              }
-              if ($.isTypeAt(3, T.MfLt) || $.isTypeAt(3, T.MfGt)) {
-                return false;
-              }
-              return true;
-            },
-            ALT: () => {
-              const op = $.SUBRULE2($.mfComparison, { ARGS: [{ ...ctx }] });
-              const value = $.LA(1).tokenType === T.Ident
-                ? $.CONSUME2(T.Ident)
-                : $.CONSUME2(T.InterpolatedIdent);
-              if (!RECORDING_PHASE) {
-                const location = $.endRule();
-                return new QueryCondition([
-                  left,
-                  new Any(op.image, { role: 'operator' }, $.getLocationInfo(op), $.context),
-                  createFeatureIdentNode(value, 'ident')
-                ], undefined, location, $.context);
-              }
-            }
-          },
-          {
-            ALT: () => {
-              const seq = $.SUBRULE2($.mediaRange, { ARGS: [{ ...ctx }] });
-              if (!RECORDING_PHASE) {
-                const [startOffset, startLine, startColumn] = $.endRule();
-                seq.value.unshift(left);
-                seq.location.start = startOffset;
-                seq.location[1] = startLine;
-                seq.location[2] = startColumn;
-                return new QueryCondition(seq.value, undefined, seq.location, $.context);
-              }
-              return seq;
-            }
-          }
-        ]);
-      }
-    }
-  ]);
-}
-
-export function mfValue(this: P, T: TokenMap): ProductionRule {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    /**
-     * 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: RuleContext = { ...ctx, wrapInExpression: true };
-    const node = $.SUBRULE($.expressionSum, { ARGS: [exprCtx] });
-    return wrapOuterExpressionIfNeeded.call($, node, exprCtx);
-  };
-}
-
-export function mfNonIdentifierValue(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    return $.OR2([
-      {
-        GATE: () => {
-          const next = $.LA(1);
-          return next.tokenType === T.AtKeyword || next.tokenType === T.PropertyReference || next.tokenType === T.NestedReference;
-        },
-        ALT: () => {
-          const node = $.SUBRULE($.valueReference, { ARGS: [{ ...ctx, requireAccessorsAfterMixinCall: true }] });
-          return wrapAtRulePreludeExpression.call($, node, ctx);
-        }
-      },
-      {
-        ALT: () => {
-          $.startRule();
-          let num1 = $.CONSUME(T.Number);
-          let num2: IToken | undefined;
-          $.OPTION(() => {
-            $.CONSUME(T.Slash);
-            num2 = $.CONSUME2(T.Number);
-          });
-          let location = $.endRule();
-          let num1Node = $.processValueToken(num1);
-          if (!num2) {
-            return num1Node;
-          }
-          let num2Node = $.processValueToken(num2);
-          return new List([num1Node, num2Node], { sep: '/' }, location, $.context);
-        }
-      },
-      {
-        ALT: () => {
-          let dim = $.CONSUME(T.Dimension);
-          return $.processValueToken(dim);
-        }
-      }
-    ]);
-  };
-}
-
-export function wrappedDeclarationList(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    $.CONSUME(T.LCurly);
-    let rules = $.SUBRULE($.declarationList, { ARGS: [ctx] });
-    $.CONSUME(T.RCurly);
-    return rules;
-  };
-}
-
-export function qualifiedRuleBody(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    let selector!: Selector;
-    let isSelectorList: boolean | undefined;
-    selector = ctx.selector!;
-    isSelectorList = typeof ctx.isSelectorList === 'boolean' ? ctx.isSelectorList : selector instanceof SelectorList;
-
-    let guard: Condition | undefined;
-    if (!isSelectorList) {
-      $.OPTION(() => {
-        guard = $.SUBRULE($.guard, { ARGS: [ctx] });
-      });
-    }
-    $.CONSUME(T.LCurly);
-    let savedExtendNodes: Extend[] | undefined;
-    if (!$.RECORDING_PHASE) {
-      // Save extendNodes before parsing declarationList, so nested rulesets don't inherit them
-      // Make a copy of the array (not just a reference) so mutations during nested parsing don't affect it
-      savedExtendNodes = ctx.extendNodes ? [...ctx.extendNodes] : undefined;
-      ctx.extendNodes = undefined;
-    }
-    let rules = $.SUBRULE2($.declarationList, { ARGS: [ctx] });
-    let end = $.CONSUME(T.RCurly);
-    if (!$.RECORDING_PHASE) {
-    // After declarationList, check if new extends were added (e.g., by ampersandExtend)
-    // If so, merge them with the saved extends; otherwise restore the saved extends
-      const newExtends = ctx.extendNodes;
-      if (newExtends && newExtends.length) {
-      // New extends were added during declarationList (e.g., &:extend())
-        if (savedExtendNodes && savedExtendNodes.length > 0) {
-        // Merge with saved extends
-          ctx.extendNodes = [...savedExtendNodes, ...newExtends];
-        } else {
-        // Keep the new extends
-          ctx.extendNodes = newExtends;
-        }
-      } else {
-      // No new extends, restore saved extends
-        ctx.extendNodes = savedExtendNodes;
-      }
-      let extend = ctx.extendNodes;
-      if (extend?.length) {
-      /** If it's not a selector list, then our only extend does not need to be grouped */
-        if (!isSelectorList) {
-        /** For extends inside rulesets (not bubbled), selector should be undefined
-         * so it defaults to ampersand and resolves to the ruleset's selector */
-          extend = extend.map(e => extendWithSelector(e, undefined, $.context));
-          rules = prependRules(rules, extend, $.context);
-          ctx.extendNodes = undefined;
-        } else {
-          const selectorList = selector instanceof SelectorList ? selector : undefined;
-          if (!selectorList) {
-            return;
-          }
-          const selectorCount = selectorList.value.length;
-          const extendCount = extend.length;
-
-          // Determine if extends should bubble up:
-          // 1. If any value in the list have extends (extendCount < selectorCount)
-          // 2. If all value have extends but their "all" flags don't match
-          let shouldBubble = false;
-
-          if (extendCount < selectorCount) {
-          // Some value have extends, some don't - bubble up
-            shouldBubble = true;
-          } else if (extendCount === selectorCount) {
-          // All value have extends - check if flags match
-            let finalExtends = groupExtendsByTargetAndFlag(extend);
-            if (finalExtends.length === 1) {
-            // All extends have same target and flag - can be inside ruleset
-              let extendNodes = finalExtends[0]!;
-              let finalExtend = isArray(extendNodes) ? extendNodes[0]! : extendNodes;
-              finalExtend = extendWithSelector(finalExtend, undefined, $.context);
-              rules = prependRules(rules, [finalExtend], $.context);
-              ctx.extendNodes = undefined;
-            } else {
-            // Multiple extend groups (different targets/flags) - bubble up
-              shouldBubble = true;
-            }
-          } else {
-          // extendCount > selectorCount - shouldn't happen, but bubble to be safe
-            shouldBubble = true;
-          }
-
-          if (shouldBubble) {
-          // Keep extends in ctx.extendNodes so they bubble up to qualifiedRule
-          // Don't clear ctx.extendNodes - let them bubble
-          // The extends will be prepended above the ruleset in qualifiedRule
-          }
-        }
-      }
-      const hasDefault = Boolean(ctx.hasDefault);
-      let node = new Ruleset(
-        { selector, rules: rules.rules, guard },
-        guard && hasDefault ? { hasDefault } : undefined,
-        undefined,
-        $.context
-      );
-      ctx.hasDefault = false;
-      let [startOffset, startLine, startColumn] = selector.location!;
-      let { endOffset, endLine, endColumn } = end;
-      node._location = [startOffset!, startLine!, startColumn!, endOffset!, endLine!, endColumn!];
-
-      return node;
-    }
-  };
-}
-
-export function qualifiedRule(this: P, T: TokenMap): ProductionRule {
-  const $ = this;
-  return (ctx: RuleContext = {}, altContext?: AltContext) => {
-    let selectorAlt = altContext ?? ((ctx: RuleContext) => [
-      {
-        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;
-          }
-        }
-      }
-    ]);
-    // qualifiedRule
-    //   : selectorList WS* LCURLY declarationList RCURLY
-    //   ;
-    // Save parent's extendNodes before parsing selector (which may set extendNodes)
-    let savedExtendNodes = ctx.extendNodes ? [...ctx.extendNodes] : undefined;
-    // Set extendNodes to a fresh empty array upon entry to this qualifiedRule
-    // so nested rulesets don't inherit extends from parent rulesets
-    ctx.extendNodes = undefined;
-    let selector: Selector = $.OR(selectorAlt(ctx));
-    // Use the same context object so modifications propagate back
-    ctx.selector = selector;
-    // Now extendNodes may have been set by extend() during selector parsing
-    // Save it for this ruleset, then clear it so nested rulesets don't see it
-    let thisExtendNodes = ctx.extendNodes ? [...ctx.extendNodes] : undefined;
-    ctx.extendNodes = undefined;
-    let rule: Node = $.SUBRULE3($.qualifiedRuleBody, { ARGS: [ctx] });
-    // After qualifiedRuleBody returns, ctx.extendNodes may contain:
-    // 1. Extends that should bubble up (from nested rulesets or this ruleset that didn't match)
-    // 2. Nothing (if all extends were processed)
-    // Restore this ruleset's extendNodes (from selector parsing) to process them
-
-    const bubblingExtends = (ctx as { extendNodes?: Extend[] }).extendNodes; // Extends that should bubble up
-    ctx.extendNodes = thisExtendNodes;
-    // Restore parent's extendNodes after processing this ruleset's extends
-    let parentExtendNodes = savedExtendNodes;
-    if (ctx.extendNodes) {
-      let qRuleset = rule;
-      // Set the Extend nodes' selector to the ruleset's selector (not &)
-      // This allows the extends to work correctly when evaluated in the wrapper Rules context
-      for (const extendNode of ctx.extendNodes) {
-        const { selector: extendSelector } = extendNode;
-        if (extendSelector === undefined || extendSelector instanceof Ampersand) {
-          const index = ctx.extendNodes.indexOf(extendNode);
-          ctx.extendNodes[index] = extendWithSelector(extendNode, selector, $.context);
-        }
-      }
-      /** Prepend a rules block */
-      rule = new Rules([
-        ...ctx.extendNodes,
-        qRuleset
-      ]);
-      // Set location from the ruleset (which has proper location info)
-      if (qRuleset._location) {
-        rule._location = qRuleset._location;
-      }
-      ctx.extendNodes = undefined;
-    }
-    // Restore parent's extendNodes and merge with any bubbling extends
-    const hasBubblingExtends = bubblingExtends && bubblingExtends.length > 0;
-    if (hasBubblingExtends) {
-      // Bubble them up to parent
-      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.
- */
-export function mixinOrQualifiedRule(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    // Helper function to convert Any nodes to VarDeclaration nodes for mixin definition parameters
-    const convertArgsForDefinition = (args: List<Node> | undefined): void => {
-      if (!args || !args.value.length) {
-        return;
-      }
-
-      for (let i = 0; i < args.value.length; i++) {
-        const node = args.value[i]!;
-
-        const location: LocationInfo | undefined = node.location.length ? node.location as LocationInfo : undefined;
-
-        // If it's an Any node with role: 'name', convert it to VarDeclaration for mixin definition parameters
-        if (isNode(node, N.Any) && node.role === 'name') {
-          const replacement = new VarDeclaration({
-            name: String(node.valueOf()),
-            value: new Nil(undefined, undefined, location, $.context)
-          }, { paramVar: true }, location, $.context);
-          args.adopt(replacement);
-          args.value[i] = replacement;
-        }
-        // Rest nodes with string values can stay as-is for mixin definitions
-      }
-    };
-
-    // Helper function to convert Any nodes to Reference nodes for mixin call arguments
-    const convertArgsForCall = (args: List<Node> | undefined): void => {
-      if (!args || !args.value.length) {
-        return;
-      }
-
-      for (let i = 0; i < args.value.length; i++) {
-        const node = args.value[i]!;
-
-        const location: LocationInfo | undefined = node.location.length ? node.location as LocationInfo : undefined;
-
-        // If it's an Any node with role: 'name', convert it to Reference for mixin call arguments
-        let replacement: Node | undefined;
-        if (isNode(node, N.Any) && node.role === 'name') {
-          replacement = new Reference({ key: node.valueOf() }, { type: 'variable' }, location, $.context);
-        } else if (node instanceof Rest) {
-          const restValue = node.value;
-          if (typeof restValue === 'string') {
-            replacement = new Rest(new Reference({ key: restValue }, { type: 'variable' }, location, $.context), undefined, location, $.context);
-          }
-        }
-        if (replacement) {
-          args.adopt(replacement);
-          args.value[i] = replacement;
-        }
-      }
-    };
-
-    // qualifiedRule
-    //   : selectorList WS* LCURLY declarationList RCURLY
-    //   ;
-    $.startRule();
-
-    let selector: Selector = $.OR([
-      {
-        GATE: () => !ctx.inner,
-        ALT: () => {
-          let initialQualifiedRule = ctx.qualifiedRule;
-          ctx.qualifiedRule = true;
-          try {
-            return $.SUBRULE($.selectorList, { ARGS: [ctx] });
-          } finally {
-            ctx.qualifiedRule = initialQualifiedRule;
-          }
-        }
-      },
-      {
-        GATE: () => !!ctx.inner,
-        ALT: () => {
-          let initialQualifiedRule = ctx.qualifiedRule;
-          let initialFirstSelector = ctx.firstSelector;
-          ctx.firstSelector = true;
-          ctx.qualifiedRule = true;
-          try {
-            return $.SUBRULE2($.forgivingSelectorList, { ARGS: [ctx] });
-          } finally {
-            ctx.qualifiedRule = initialQualifiedRule;
-            ctx.firstSelector = initialFirstSelector;
-          }
-        }
-      }
-    ]);
-
-    let isSelectorList = selector instanceof SelectorList;
-    let guard: Condition | undefined;
-    let args: List<Node> | undefined;
-    let important: IToken | undefined;
-
-    const createMixinCall = (location: LocationInfo) => {
-      let leftNode!: Node;
-
-      if (!isSelectorList && (
-        selector instanceof CompoundSelector
-        || selector instanceof BasicSelector
-        || selector instanceof InterpolatedSelector
-        || selector instanceof ComplexSelector
-      )) {
-        const { key, rawKey } = normalizeMixinReferenceKey(selector);
-        leftNode = new Reference({ key, rawKey }, { type: 'mixin-ruleset', role: 'name' }, undefined, $.context);
-      } else {
-        // For other cases (like SelectorList or when we need nested references),
-        // iterate through selector nodes and create nested references
-        for (let s of selector.nodes()) {
-          if (s instanceof BasicSelector) {
-            const target = leftNode instanceof Reference ? leftNode : leftNode instanceof Call ? leftNode : undefined;
-            leftNode = new Reference({ target, key: s.valueOf() }, { type: 'mixin-ruleset', role: 'name' }, undefined, $.context);
-          }
-        }
-      }
-
-      /** Finally, pass this reference into a call */
-      leftNode = new Call({ name: leftNode, args }, { markImportant: !!important }, location, $.context);
-      return leftNode;
-    };
-
-    let isPossibleMixinDefinition = (selector instanceof BasicSelector && (selector.isClass || selector.isId))
-      || (selector instanceof InterpolatedSelector && (selector.isClass || selector.isId));
-    let isPossibleMixinCall = true;
-    if (!$.RECORDING_PHASE && !isSelectorList && !isPossibleMixinDefinition) {
-      for (let s of selector.nodes()) {
-        /** Keep going until we get to basic value. */
-        if (s instanceof ComplexSelector || s instanceof CompoundSelector) {
-          continue;
-        }
-        if (
-          (s instanceof BasicSelector && (s.isClass || s.isId))
-          || (s instanceof InterpolatedSelector && (s.isClass || s.isId))
-          || (s instanceof Combinator && (s.value === '>' || s.value === ' '))
-        ) {
-          continue;
-        }
-        isPossibleMixinCall = false;
-        break;
-      }
-    }
-    return $.OR2([
-      {
-        GATE: () => (isPossibleMixinDefinition || isPossibleMixinCall) && $.isType(T.LParen),
-        ALT: () => {
-          args = $.SUBRULE3($.mixinArgs, { ARGS: [ctx] });
-          let next = $.LA(1).tokenType;
-          if (next === T.LCurly || next === T.When) {
-            isPossibleMixinCall = false;
-          }
-          return $.OR3([
-            {
-              GATE: () => isPossibleMixinDefinition,
-              /** Mixin definition */
-              ALT: () => {
-                $.OPTION(() => {
-                  guard = $.SUBRULE4($.guard, { ARGS: [ctx] });
-                });
-                $.CONSUME(T.LCurly);
-
-                let rules = $.SUBRULE5($.declarationList, { ARGS: [ctx] });
-                $.CONSUME(T.RCurly);
-                if (!$.RECORDING_PHASE) {
-                  // Convert Any nodes to VarDeclaration nodes for mixin definition parameters
-                  convertArgsForDefinition(args);
-                  const guardText = String(guard?.toString?.() ?? '');
-                  const hasDefault = Boolean(ctx.hasDefault) || guardContainsDefaultCall(guard) || guardText.includes('??()');
-                  const node = new Mixin(
-                    { name: selector.valueOf(), params: args, rules: rules.rules, guard },
-                    guard && hasDefault ? { hasDefault } : undefined,
-                    $.endRule(),
-                    $.context
-                  );
-                  ctx.hasDefault = false;
-                  return node;
-                }
-                $.endRule();
-              }
-            },
-            {
-              GATE: () => isPossibleMixinCall,
-              /** Mixin call */
-              ALT: () => {
-                $.OPTION2(() => {
-                  important = $.CONSUME(T.Important);
-                });
-                let location: LocationInfo = $.endRule();
-                if (!$.RECORDING_PHASE) {
-                  // Convert Any nodes to Reference nodes for mixin call arguments
-                  convertArgsForCall(args);
-                }
-                let result: Node | undefined;
-                {
-                  /** 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 ? undefined! : createMixinCall(location) }] }));
-                  }
-                }
-                // Note: Mixin calls without parentheses are handled in the semicolon-terminated ALT below
-                return $.RECORDING_PHASE ? undefined : (result ?? createMixinCall(location!));
-              }
-            }
-          ]);
-        }
-      },
-      {
-        GATE: () => isPossibleMixinCall && $.isType(T.Semi),
-        ALT: () => {
-          // Call terminated by a semi-colon and not parens, deprecated
-          const semi = $.CONSUME(T.Semi);
-          const location = $.endRule();
-          if (!$.RECORDING_PHASE) {
-            // Mixin call without parentheses - deprecated
-            $.warnDeprecation(
-              'Calling a mixin without parentheses is deprecated',
-              semi,
-              'mixin-call-no-parens'
-            );
-            return createMixinCall(location);
-          }
-        }
-      },
-      {
-        /** Parse as qualified rule */
-        ALT: () => {
-          $.endRule();
-          let initialSelector = ctx.selector;
-          let initialIsSelectorList = ctx.isSelectorList;
-          ctx.selector = selector;
-          ctx.isSelectorList = isSelectorList;
-          let rule: Node;
-          try {
-            rule = $.SUBRULE7($.qualifiedRuleBody, { ARGS: [ctx] });
-          } finally {
-            ctx.selector = initialSelector;
-            ctx.isSelectorList = initialIsSelectorList;
-          }
-          if (ctx.extendNodes) {
-            /** Prepend a rules block */
-            let qRule = rule;
-            // Set the Extend nodes' selector to the ruleset's selector (not &)
-            // This allows the extends to work correctly when evaluated in the wrapper Rules context
-            for (const extendNode of ctx.extendNodes) {
-              const { selector: extendSelector } = extendNode;
-              if (extendSelector === undefined || extendSelector instanceof Ampersand) {
-                const index = ctx.extendNodes.indexOf(extendNode);
-                ctx.extendNodes[index] = extendWithSelector(extendNode, selector, $.context);
-              }
-            }
-            rule = new Rules([
-              ...ctx.extendNodes,
-              qRule
-            ]);
-            rule._location = qRule._location;
-            ctx.extendNodes = undefined;
-          }
-          return rule;
-        }
-      }
-    ]);
-  };
-}