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

package/src/builders.ts

@@ -1,3190 +0,0 @@
-/**
- * LessGrammar — builder methods for the Less grammar.
- *
- * Builder-only class: no grammar rules, no Parséman Parser base.
- * Grammar rules live in grammar-fn.ts (macro-compiled functional grammar),
- * which uses LessGrammar via a thin BuilderHost subclass.
- * Extends CssParser to inherit the shared CSS builder methods.
- */
-
-import type { FieldMap, Span } from 'parseman';
-import type { CSTLeaf, CSTError } from 'parseman';
-import {
-  CssParser,
-  spannedComponents, type Spanned, type Component
-} from '@jesscss/css-parser/jess';
-import { getInterpolatedOrString, getInterpolatedNode, createInterpolatedReference } from './utils.js';
-
-import {
-  type Node,
-  type LocationInfo,
-  Any, Keyword, Rules, Ruleset,
-  type Selector,
-  ComplexSelector, type ComplexSelectorValue,
-  CompoundSelector,
-  isSelectorListLike, selectorListItems,
-  Declaration,
-  VarDeclaration, type VarDeclarationOptions,
-  NESTABLE_AT_RULES,
-  Reference, type ReferenceValue,
-  Ampersand, List, DefaultGuard, Extend, ExtendFlag, Call,
-  For, type ForPattern,
-  Interpolated, InterpolatedSelector, Sequence, CustomDeclaration,
-  Color, Paren, Condition, type ConditionOperator,
-  Num, Dimension,
-  Mixin, Expression, Operation, Negative,
-  shouldOperateWithMathFrames, type MathMode,
-  StyleImport,
-  JsImport,
-  Nil,
-  Rest,
-  Quoted,
-  Url,
-  AtRuleStatement,
-  AtRule,
-  QueryCondition,
-  INTERPOLATION_PLACEHOLDER,
-  Block
-} from '@jesscss/core';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-type JessNode = Node<any, any>;
-type Child = JessNode | CSTLeaf | CSTError;
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-// Mirrors grammar.ts's `knownAtVar` regex (isVariableLike in the reference): a
-// known at-rule name (incl. vendor-prefixed document/keyframes/viewport) used
-// as a variable call (`@media()`) is only legal with empty parens, and is
-// itself a deprecated form.
-const KNOWN_AT_RULE_VAR_NAME_RE = /^(?:(?:-moz-)?document|(?:-[a-z]+-)?keyframes|(?:-ms-)?viewport|import|media|supports|layer|container|scope|page|font-face|starting-style|property|counter-style|color-profile|font-palette-values|namespace)$/i;
-
-function spanToLocation(span: Span): LocationInfo {
-  return { start: span.start, end: span.end };
-}
-
-function nodeChildren(children: ReadonlyArray<Child>): JessNode[] {
-  return children.filter((c): c is JessNode => c._tag === 'node') as JessNode[];
-}
-
-// ---------------------------------------------------------------------------
-// LessGrammar
-// ---------------------------------------------------------------------------
-
-export class LessGrammar extends CssParser {
-  /** Math mode governing when arithmetic operates / when `/` divides. Less default. */
-  mathMode: MathMode = 'parens-division';
-
-  /** Bare ident/keyword token in value or guard position. */
-  private _lessKeyword(text: string, loc: LocationInfo): Keyword {
-    return this._valueKeyword(text, loc);
-  }
-
-  private _isKeywordLike(node: unknown): node is Keyword | Any {
-    return !!node && typeof node === 'object'
-      && ((node as { type?: string }).type === 'Keyword' || (node as { type?: string }).type === 'Any');
-  }
-
-  private _isEmptyKeywordLike(node: unknown): boolean {
-    return !node
-      || (this._isKeywordLike(node) && !String((node as { value?: string }).value ?? '').trim());
-  }
-
-  // -- buildNode -------------------------------------------------------------
-  /* eslint-disable @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/naming-convention */
-
-  protected override buildNode(
-    type: string,
-    span: Span,
-    children: ReadonlyArray<JessNode | CSTLeaf | CSTError>,
-    _state: unknown,
-    _rawChildren: ReadonlyArray<{ _tag: string }>,
-    fields?: FieldMap,
-    triviaLog: readonly number[] = []
-  ): JessNode {
-    const loc = spanToLocation(span);
-    const raw = _rawChildren;
-    switch (type) {
-      case 'VarDeclaration':      return this._buildVarDeclaration(children, raw, loc);
-      case 'Reference':           return this._buildReference(children, loc);
-      case 'LessAmpersand':       return this._buildAmpersand(children, loc);
-      case 'ComplexSelector': return this._buildComplexSelector(raw, loc);
-      case 'SelectorList':    return this._buildSelectorList(raw, loc);
-      case 'Ruleset':             return this._buildRuleset(children, raw, loc) as unknown as JessNode;
-      case 'Declaration':
-        this._warnDeprecatedValue(span);
-        return this._buildLessDeclaration(raw, loc);
-      case 'CustomDeclaration':
-        this._warnCustomPropVars(span);
-        return this._buildLessCustomDecl(children, loc);
-      case 'Block':               return this._buildLessCustomBlock(children, loc);
-      case 'AtRuleBlock':
-        this._warnAtRulePreludeVars(span);
-        return this._buildAtRuleBlock(children, loc) as unknown as JessNode;
-      case 'QueryAtRuleBlock':
-        this._warnAtRulePreludeVars(span);
-        return this._buildLessQueryAtRuleBlock(children, raw, loc);
-      case 'NamedColor':          return this._buildNamedColor(children, loc);
-      case 'Comparison':          return this._buildComparison(raw, loc);
-      case 'GuardDefault':        return new DefaultGuard('default()', {}, loc) as unknown as JessNode;
-      case 'GuardInParens':       return this._buildGuardInParens(children, loc);
-      case 'GuardTerm':           return this._buildGuardTerm(raw, loc);
-      case 'GuardAnd':            return this._buildGuardJoin(children, loc, 'and');
-      case 'GuardOr':             return this._buildGuardJoin(children, loc, 'or');
-      case 'Guard':               return this._buildGuard(children, loc);
-      case 'CondArgTerm':         return this._buildCondArgTerm(raw, loc);
-      case 'CondArgAnd':          return this._buildCondArgJoin(children, loc, 'and');
-      case 'CondArgOr':           return this._buildCondArgJoin(children, loc, 'or');
-      case 'UnicodeRange':        return this._lessKeyword(this._source.slice(span.start, span.end), loc) as unknown as JessNode;
-      case 'PseudoSelector':      return this._buildLessPseudo(type, span, children, _state, raw, fields, triviaLog, loc);
-      case 'InterpolatedSelector': return this._buildInterpolatedSelector(children, loc);
-      case 'VarCall':             return this._buildVarCall(children, raw, loc);
-      case 'MixinCall':           return this._buildMixinCall(children, raw, loc);
-      case 'Rest':                return this._buildRest(children, loc);
-      case 'NamedArg':            return this._buildNamedArg(raw, loc);
-      case 'MixinArgs':           return this._buildMixinArgs(raw, loc);
-      case 'AnonymousMixinDefinition': return this._buildAnonMixin(children, loc) as unknown as JessNode;
-      case 'DetachedRuleset':     return this._buildDetachedRuleset(children, loc) as unknown as JessNode;
-      case 'For':                 return this._buildEachFor(children, loc) as unknown as JessNode;
-      case 'FormatCall':          return this._buildFormatCall(raw, loc);
-      case 'MixinOrQualifiedRule': return this._buildMixinOrQualified(children, loc);
-      case 'Negative':            return new Negative(this._negativeOperand(children), undefined, loc) as unknown as JessNode;
-      case 'OperationTop':        return this._buildOperation(children, loc, this.mathMode === 'always') as unknown as JessNode;
-      case 'EscapedValue':        return this._buildEscapedValue(children, loc);
-      case 'InterpValue':         return this._buildInterpValue(raw, loc);
-      case 'NsAccessor':          return this._buildNsAccessor(children, loc);
-      case 'AtRuleStatement':     return this._buildAtRuleStatement(children, loc);
-      case 'ExtendTarget':        return this._buildExtendTarget(children, raw, loc);
-      case 'ExtendPseudo':        return this._buildExtendPseudo(children, loc);
-      case 'ExtendStatement':     return this._buildExtendStatement(children, raw, loc);
-      default:                    return super.buildNode(type, span, children, _state, raw, fields, triviaLog) as unknown as JessNode;
-    }
-  }
-
-  // -- Private Less AST builders ---------------------------------------------
-
-  /**
-   * The operand of a `Negative` (`-value`). The grammar emits the leading `-`
-   * as a leaf followed by the operand, which may itself be a node or a bare
-   * string terminal (e.g. `-@color` → `var(--color)`'s inner `-color-accent`).
-   * Prefer a node child; otherwise take the operand leaf's text so `Negative`
-   * coerces it to the canonical node form rather than receiving `undefined`.
-   */
-  private _negativeOperand(children: ReadonlyArray<Child>): JessNode | string {
-    const node = nodeChildren(children)[0];
-    if (node) {
-      return node;
-    }
-    const operand = children.find((c): c is CSTLeaf => c._tag === 'leaf' && c.value !== '-');
-    return operand?.value ?? '';
-  }
-
-  private _buildVarDeclaration(children: ReadonlyArray<JessNode | CSTLeaf | CSTError>, rawChildren: ReadonlyArray<{ _tag: string }>, loc: LocationInfo) {
-    const items = spannedComponents(rawChildren);
-    const rawName = typeof items[0]?.comp === 'string' ? items[0]!.comp : '';
-    const name = rawName.startsWith('@') ? rawName.slice(1) : rawName;
-    // Less.js still accepts a digit-leading variable name (`@3`) — its name regex
-    // is `[\w-]+` — but it's a footgun (collides with numeric tokens), so flag it.
-    if (/^-?\d/.test(name)) {
-      this._warn(
-        `Variable name "@${name}" starts with a digit; digit-leading variable names are deprecated.`,
-        'digit-leading-variable'
-      );
-    }
-    const colonIdx = items.findIndex(i => i.comp === ':');
-    const afterColon = items[colonIdx + 1];
-    if (afterColon?.comp === '{') {
-      // Detached ruleset: @var: { ... }
-      const ruleNodes = nodeChildren(children);
-      const openBrace = items[colonIdx + 1]!;
-      const closeBrace = items[items.length - 1]!.comp === '}'
-        ? items[items.length - 1]!
-        : undefined;
-      // Raw-string detached ruleset (grammar's rawDetachedBlock fallback): the body
-      // had no structurable declarations but is non-empty (special-char keys like
-      // bootstrap's `@escaped-characters: { <: %3c; … }`). Historical Less keeps such
-      // a block as a raw `Quoted` string (braces included); @plugin functions such as
-      // escape-svg read it via `.value`.
-      if (ruleNodes.length === 0 && closeBrace) {
-        const bodyText = this._source.slice(openBrace.span.end, closeBrace.span.start);
-        if (bodyText.trim() !== '') {
-          const rawBlock = this._source.slice(openBrace.span.start, closeBrace.span.end);
-          const nameNode = name || undefined;
-          return new VarDeclaration(
-            { name: (nameNode ?? name) as any, value: new Quoted(rawBlock, {}, loc) as any } as any,
-            {} as VarDeclarationOptions,
-            loc
-          );
-        }
-      }
-      const mixin = new Mixin({ rules: ruleNodes }, {}, loc);
-      const nameNode = name || undefined;
-      return new VarDeclaration(
-        { name: (nameNode ?? name) as any, value: mixin as any } as any,
-        {} as VarDeclarationOptions,
-        loc
-      );
-    }
-    let end = items.length;
-    let bangIdx = -1;
-    for (let i = colonIdx + 1; i < items.length; i++) {
-      const c = items[i]!.comp;
-      if (c === '!') {
-        end = i;
-        bangIdx = i;
-        break;
-      }
-      if (c === 'important' || c === ';') {
-        end = i;
-        break;
-      }
-    }
-    const valItems = items.slice(colonIdx + 1, end);
-    // A tolerated trailing comma (`@x: a, b, c,;`) is not a value item — Less 4.x
-    // drops it, so a comma-list value keeps N items, not N + 1 empty. (Plain
-    // declarations go through the CSS builder, which already filters empty
-    // segments; the Less var path assembles valItems directly, so strip it here.)
-    if (valItems.length > 0 && valItems[valItems.length - 1]!.comp === ',') {
-      valItems.pop();
-    }
-    if (valItems.length) {
-      const vText = this._source.slice(valItems[0]!.span.start, valItems[valItems.length - 1]!.span.end);
-      if (/(?:^|[\s,])\.-?[_a-zA-Z]/.test(vText)) {
-        this._warn(
-          `Unquoted selector capture in variable "@${name}" is deprecated; wrap the value in quotes or ~"...".`,
-          'unquoted-selector-capture'
-        );
-      }
-    }
-    const nsRef = this._tryParseNamespaceRef(valItems, loc);
-    let { value: rawValue } = nsRef ? { value: nsRef } : this._assembleLessValue(valItems, loc);
-    // Check for trailing [accessor] and/or () in source that the grammar couldn't consume.
-    // (nsRef already handles this via internal lookahead; only do it when nsRef is null)
-    if (!nsRef && valItems.length > 0) {
-      const lastSpan = valItems[valItems.length - 1]!.span;
-      const afterVal = this._source.slice(lastSpan.end);
-      // The grammar may partially consume '[' into the Reference CST due to parseman
-      // not rolling back CST leaves on optional-sequence failure. Detect this case:
-      // rawValue is Reference with target set but key='' (empty from grammar bug).
-      const rv = rawValue as any;
-      // Grammar bug: parseman leaks '[' into CST but accessor fails → Reference(target, key=''|Quoted(''))
-      const rvKey = rv?.key;
-      const isEmptyKey = rvKey === '' || rvKey === undefined
-        || (rvKey && typeof rvKey === 'object' && rvKey.type === 'Quoted' && (rvKey.value === '' || rvKey.valueOf?.() === ''));
-      const grammarPartialAccessor =
-        rv && rv.type === 'Reference' && rv.target !== undefined && isEmptyKey;
-      const accMatch = /^\s*\[([^\]]+)\]/.exec(afterVal);
-      if (accMatch) {
-        const accText = accMatch[1]!.trim();
-        const accessorKey = this._decodeAccessorKey(accText, loc);
-        // A numeric accessor key (`foo[2]` / `foo[]` → last, key -1) is an INDEX
-        // lookup; a variable dispatch would fail with `'-1' is not defined`.
-        const accessorRefOptions = typeof accessorKey === 'number'
-          ? { type: 'index' as const }
-          : {};
-        if (grammarPartialAccessor) {
-          // Fix in-place: replace the wrong key on the existing Reference wrapper
-          rawValue = new Reference(
-            { target: rv.target as any, key: accessorKey as any } as unknown as ReferenceValue,
-            accessorRefOptions,
-            loc
-          ) as unknown as JessNode;
-        } else {
-          // No partial grammar accessor: wrap with new Reference
-          rawValue = new Reference(
-            { target: rawValue as any, key: accessorKey as any } as unknown as ReferenceValue,
-            accessorRefOptions,
-            loc
-          ) as unknown as JessNode;
-        }
-        const afterAcc = afterVal.slice(accMatch[0].length);
-        if (/^\s*\(\s*\)/.test(afterAcc)) {
-          rawValue = new Call({ name: rawValue as any } as any, {}, loc) as unknown as JessNode;
-        }
-      }
-    }
-    const value = typeof rawValue === 'string' && rawValue
-      ? this._lessKeyword(rawValue, loc)
-      : rawValue;
-    // `important` is the verbatim source text (`!important`, `! important`, …),
-    // not a boolean — the declaration stores the string it will re-emit.
-    let important: string | undefined;
-    if (bangIdx >= 0) {
-      const bang = items[bangIdx]!;
-      const kw = items[bangIdx + 1];
-      const impEnd = kw && typeof kw.comp === 'string' && kw.comp.toLowerCase() === 'important'
-        ? kw.span.end
-        : bang.span.end;
-      important = this._source.slice(bang.span.start, impEnd);
-    }
-    const nameNode = name || undefined;
-    return new VarDeclaration(
-      { name: (nameNode ?? name) as any, value, important } as any,
-      {} as VarDeclarationOptions,
-      loc
-    );
-  }
-
-  /**
-   * Build a Less variable reference and its accessor/call chain. Faithful 1:1
-   * port of the Chevrotain `varReference` + `lookupOrCall` productions
-   * (productions/values.ts, productions/guards.ts): a `@var` base glued to a
-   * left-folded chain of `[index]` accessors and `(call)`s. The grammar's
-   * noTrivia() guarantees the chain is adjacent (no whitespace between segments).
-   */
-  private _buildReference(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    const varName = ls[0]?.value ?? '';
-    // Head sigil types the base reference. `@a` → variable. `$color` → a bare
-    // property accessor: an `index` reference with a Quoted key and no target,
-    // resolved against the current scope (port of varReference's PropertyReference
-    // branch). Anything else → bare index base.
-    const isVar = varName.startsWith('@');
-    const isProp = varName.startsWith('$');
-    let base: JessNode = isProp
-      ? new Reference(
-        { key: new Quoted(varName.slice(1), { quote: '\'' }, loc) as any } as unknown as ReferenceValue,
-        { type: 'index' },
-        loc
-      ) as unknown as JessNode
-      : new Reference(
-        isVar ? varName.slice(1) : varName,
-        isVar ? { type: 'variable' as const } : {},
-        loc
-      ) as unknown as JessNode;
-    let i = 1;
-    while (i < ls.length) {
-      const tok = ls[i]!.value;
-      if (tok === '[') {
-        if (ls[i + 1]?.value === ']') {
-          // Empty `[]` → key = -1, type index (lookupOrCall else-branch).
-          base = new Reference(
-            { target: base as any, key: -1 } as unknown as ReferenceValue,
-            { type: 'index' }, loc
-          ) as unknown as JessNode;
-          i += 2;
-        } else {
-          base = this._applyReferenceAccessor(base, ls[i + 1]!.value, loc);
-          i += 3; // '[', key, ']'
-        }
-      } else if (tok === '(') {
-        const payload: Record<string, unknown> = { name: base };
-        if (ls[i + 1]?.value === ')') {
-          i += 2;
-        } else {
-          const args = this._buildRefCallArgs(ls[i + 1]!.value, loc);
-          if (args) {
-            payload.args = args;
-          }
-          i += 3; // '(', content, ')'
-        }
-        base = new Call(payload as any, {}, loc) as unknown as JessNode;
-      } else {
-        break;
-      }
-    }
-    return base;
-  }
-
-  /**
-   * Build a namespace INDEXED-accessor value: a `.`/`#` selector-path head glued to
-   * a `[accessor]` (and any further `[accessor]`/`(call)` chain), e.g.
-   * `#ns.options[val1]`. The grammar (NsAccessor) captures this as ONE value operand
-   * so it survives arithmetic folding; here we reassemble it into the mixin-ruleset
-   * name Reference + accessor chain — the SAME shape the declaration-value
-   * _assembleSegment path produces for a lone `#ns.options[val1]`. Call-headed forms
-   * (`.mixin()`, `.mixin()[k]`) do NOT reach here (they keep the GluedParen path).
-   * Leaves: [ headText, '[', key?, ']', '(', content?, ')' … ].
-   */
-  private _buildNsAccessor(children: ReadonlyArray<Child>, loc: LocationInfo): JessNode {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    const headText = (ls[0]?.value ?? '').trim();
-    // Split the selector path into segments: `#ns.options` → ['#ns', '.options'];
-    // combinators (`#ns > .a`) are dropped, each `.`/`#` name is one segment.
-    const pathSegs = headText.match(/[#.][^#.>+~\s]*/g) ?? [headText];
-    const nameKey: string | string[] = pathSegs.length === 1 ? pathSegs[0]! : pathSegs;
-    const rawKey = pathSegs.length > 1 ? pathSegs.join('') : undefined;
-    let base: JessNode = new Reference(
-      { key: nameKey, ...(rawKey ? { rawKey } : {}) } as unknown as ReferenceValue,
-      { type: 'mixin-ruleset', role: 'name' } as any, loc
-    ) as unknown as JessNode;
-    let i = 1;
-    while (i < ls.length) {
-      const tok = ls[i]!.value;
-      if (tok === '[') {
-        if (ls[i + 1]?.value === ']') {
-          base = new Reference(
-            { target: base as any, key: -1 } as unknown as ReferenceValue,
-            { type: 'index' }, loc
-          ) as unknown as JessNode;
-          i += 2;
-        } else {
-          base = this._applyReferenceAccessor(base, ls[i + 1]!.value, loc);
-          i += 3;
-        }
-      } else if (tok === '(') {
-        const payload: Record<string, unknown> = { name: base };
-        if (ls[i + 1]?.value === ')') {
-          i += 2;
-        } else {
-          const args = this._buildRefCallArgs(ls[i + 1]!.value, loc);
-          if (args) {
-            payload.args = args;
-          }
-          i += 3;
-        }
-        base = new Call(payload as any, {}, loc) as unknown as JessNode;
-      } else {
-        break;
-      }
-    }
-    return base;
-  }
-
-  /**
-   * Apply one `[key]` accessor to `base`, reproducing lookupOrCall's key logic:
-   * type is `variable` when the key token starts with `@`, else `index`; the key
-   * text runs through getInterpolatedOrString (handling `$@x`/`@{x}` interpolation),
-   * and index keys are wrapped in a Quoted.
-   */
-  private _applyReferenceAccessor(base: JessNode, keyStr: string, loc: LocationInfo): JessNode {
-    const type: 'variable' | 'index' = keyStr.startsWith('@') ? 'variable' : 'index';
-    let result: string | JessNode = getInterpolatedOrString(keyStr, loc) as string | JessNode;
-    if (type === 'index') {
-      result = new Quoted(result as any, { quote: '\'' }, loc) as unknown as JessNode;
-    }
-    return new Reference(
-      { target: base as any, key: result as any } as unknown as ReferenceValue,
-      { type }, loc
-    ) as unknown as JessNode;
-  }
-
-  /**
-   * Build mixin-call args for a `(…)` segment in a reference chain from the raw
-   * captured content. Comma-separated values become a List; an empty segment
-   * yields null (no args). Sub-structure here is intentionally shallow — the
-   * accessor-chain call form is rare and no consumer inspects nested arg shape.
-   */
-  private _buildRefCallArgs(content: string, loc: LocationInfo): JessNode | null {
-    const trimmed = content.trim();
-    if (!trimmed) {
-      return null;
-    }
-    const parts = trimmed.split(',').map(p => p.trim()).filter(Boolean);
-    const items = parts.map(p => p.startsWith('@')
-      ? new Reference(p.slice(1), { type: 'variable' as const }, loc) as unknown as Node
-      : this._lessKeyword(p, loc) as unknown as Node);
-    return new List(items as any, undefined, loc) as unknown as JessNode;
-  }
-
-  private _buildNamedColor(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    const name = ls[0]?.value ?? '';
-    return new Color({ node: name }, {}, loc) as unknown as JessNode;
-  }
-
-  private _normalizeCompareOp(op: string): ConditionOperator {
-    switch (op) {
-      case '=>':
-      case '>=':
-        return '>=';
-      case '=<':
-      case '<=':
-        return '<=';
-      case '>':
-        return '>';
-      case '<':
-        return '<';
-      default:
-        return '=';
-    }
-  }
-
-  /** A guard comparison operator leaf (`=`, `<`, `>=`, `=<`, `=~`, …). */
-  private _isCompareOpLeaf(text: string): boolean {
-    return />=|<=|=>|=<|=~|[<>=]/.test(text);
-  }
-
-  /**
-   * Split a guard term's ordered components into `left [op right]`. A bare-keyword
-   * operand (`foo`, `true`) is a leaf string — not a node — so `nodeChildren`
-   * alone drops it; walk the ordered stream so string operands become real
-   * keyword nodes (their guard truthiness is decided at eval by `Condition`).
-   */
-  private _guardComparison(raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo):
-  { left: Node; op?: ConditionOperator; right?: Node } {
-    const items = spannedComponents(raw);
-    let op: ConditionOperator | undefined;
-    const operands: Node[] = [];
-    for (const it of items) {
-      if (typeof it.comp === 'string') {
-        if (this._isCompareOpLeaf(it.comp)) {
-          op = this._normalizeCompareOp(it.comp);
-          continue;
-        }
-        operands.push(this._lessKeyword(it.comp, loc) as unknown as Node);
-      } else {
-        operands.push(it.comp as unknown as Node);
-      }
-    }
-    const left = this._maybeDefaultGuard(operands[0] ?? this._lessKeyword('', loc), loc);
-    const right = operands[1] !== undefined ? this._maybeDefaultGuard(operands[1], loc) : undefined;
-    return { left, op, right };
-  }
-
-  private _buildComparison(raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo) {
-    const { left, op, right } = this._guardComparison(raw, loc);
-    if (op && right) {
-      return new Condition([left, op, right], {}, loc) as unknown as JessNode;
-    }
-    return new Condition([left], {}, loc) as unknown as JessNode;
-  }
-
-  /**
-   * Coerce a `_assembleValue` result — a single Component or a raw space-group
-   * array — into ONE Node, so it can be a Condition operand. A single string
-   * becomes a keyword; a space-group array becomes a `Sequence` (the same coercion
-   * the List serializer applies to a raw group).
-   */
-  private _condOperandNode(comps: Spanned[], loc: LocationInfo): Node {
-    const { value } = this._assembleValue(comps, loc);
-    if (Array.isArray(value)) {
-      const nodes = (value as Component[]).map(c =>
-        typeof c === 'string' ? this._lessKeyword(c, loc) as unknown as Node : c as unknown as Node);
-      return new Sequence(nodes as any, undefined, loc) as unknown as Node;
-    }
-    if (typeof value === 'string') {
-      return this._lessKeyword(value, loc) as unknown as Node;
-    }
-    return value as unknown as Node;
-  }
-
-  /**
-   * `CondArgTerm` — a name-independent condition-argument term: optional leading
-   * `not`, a bounded value operand, and an optional `<op> right` comparison. Builds
-   * a `Condition` (comparison → `[left, op, right]`; bare `not` → `{negate:true}`)
-   * or, when neither a `not` nor a `compareOp` is present, the plain operand value
-   * (byte-identical to an ordinary value arg). Multi-token operands (`1px solid`)
-   * survive as a `Sequence`, unlike the single-operand guard path.
-   */
-  private _buildCondArgTerm(raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo): JessNode {
-    const items = spannedComponents(raw);
-    const hasNot = items.length > 0 && items[0]!.comp === 'not';
-    const rest = hasNot ? items.slice(1) : items;
-    const opIdx = rest.findIndex(it => typeof it.comp === 'string' && this._isCompareOpLeaf(it.comp));
-    let term: Node;
-    if (opIdx >= 0) {
-      const left = this._condOperandNode(rest.slice(0, opIdx), loc);
-      const op = this._normalizeCompareOp(rest[opIdx]!.comp as string);
-      const right = this._condOperandNode(rest.slice(opIdx + 1), loc);
-      term = new Condition([left, op, right], {}, loc) as unknown as Node;
-    } else {
-      term = this._condOperandNode(rest, loc);
-    }
-    if (hasNot) {
-      return new Condition([term as any], { negate: true }, loc) as unknown as JessNode;
-    }
-    return term as unknown as JessNode;
-  }
-
-  /**
-   * Fold a left-associative `and`/`or` chain of condition-arg terms into Conditions.
-   *
-   * Less accepts a bare `and`/`or` join in value-position condition args (`if(@a > 5
-   * and @b < 2, …)`) — verified against less@4.6.7 (`if`/`boolean` route their arg
-   * through `condition()` with no `needsParens`, so bare comparisons split on `and`/
-   * `or`). We keep accepting the bare form for Less parity, but NORMALIZE the AST so
-   * each join operand is `Paren`-wrapped: `@a > 5 and @b < 2` builds the SAME tree as
-   * the explicitly-parenthesised `(@a > 5) and (@b < 2)`. This is a structural
-   * normalisation only — `Paren(Condition)` evaluates to the same boolean as the bare
-   * `Condition`, so rendered CSS is byte-identical. A single unjoined operand (one
-   * node) is untouched (no synthetic Paren).
-   */
-  private _buildCondArgJoin(children: ReadonlyArray<Child>, loc: LocationInfo, op: ConditionOperator): JessNode {
-    const nodes = nodeChildren(children);
-    if (nodes.length === 0) {
-      return this._lessKeyword('', loc) as unknown as JessNode;
-    }
-    if (nodes.length === 1) {
-      return nodes[0]! as unknown as JessNode;
-    }
-    const wrap = (n: Node): Node =>
-      (n as { type?: string }).type === 'Paren'
-        ? n
-        : (new Paren(n as any, {}, loc) as unknown as Node);
-    let left = wrap(nodes[0]!);
-    for (let i = 1; i < nodes.length; i++) {
-      left = new Condition([left, op, wrap(nodes[i]!)], {}, loc) as unknown as Node;
-    }
-    return left as unknown as JessNode;
-  }
-
-  /** Coerce a default() call/reference into a DefaultGuard, mirroring isDefaultGuardCall. */
-  private _maybeDefaultGuard(node: Node, loc: LocationInfo): Node {
-    const n = node as any;
-    if (n?.type === 'Call') {
-      const name = n.name;
-      const nameStr = String(
-        typeof name === 'object' && name !== null && 'valueOf' in name ? name.valueOf() : name ?? ''
-      );
-      if (nameStr === 'default' || nameStr === '??') {
-        return new DefaultGuard('default()', {}, loc) as unknown as Node;
-      }
-    }
-    return node;
-  }
-
-  /** guardInParens: `(` guardOr `)` → Paren, or a bare default() → Paren(DefaultGuard). */
-  private _buildGuardInParens(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    let inner = nodeChildren(children)[0] ?? this._lessKeyword('', loc);
-    inner = this._maybeDefaultGuard(inner, loc) as Node;
-    // `(default())` nests guardInParens(GuardDefault) inside another guardInParens;
-    // collapse the redundant Paren-around-Paren(DefaultGuard) to a single Paren.
-    const innerAny = inner as any;
-    if (innerAny?.type === 'Paren' && (innerAny.value as any)?.type === 'DefaultGuard') {
-      return inner as unknown as JessNode;
-    }
-    return new Paren(inner as any, {}, loc) as unknown as JessNode;
-  }
-
-  /** A single guard term: optional `not`, then a paren-guard or a comparison/value. */
-  private _buildGuardTerm(raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo) {
-    const items = spannedComponents(raw);
-    const hasNot = items.some(i => typeof i.comp === 'string' && i.comp === 'not');
-    // Everything after an optional leading `not` is the operand run.
-    const rest = raw.filter(rc => !(rc._tag === 'leaf' && (rc as { value?: string }).value === 'not'));
-    const nodes = nodeChildren(rest as ReadonlyArray<Child>);
-    let term: Node;
-    if (nodes.length >= 1 && (nodes[0] as any).type === 'Paren') {
-      // guardInParens branch (already a Paren node)
-      term = nodes[0]!;
-    } else {
-      const { left, op, right } = this._guardComparison(rest, loc);
-      term = op && right
-        ? new Condition([left, op, right], {}, loc) as unknown as Node
-        : left;
-    }
-    if (hasNot) {
-      return new Condition([term as any], { negate: true }, loc) as unknown as JessNode;
-    }
-    return term as unknown as JessNode;
-  }
-
-  /** Fold a left-associative chain of terms joined by `and` / `or`. */
-  private _buildGuardJoin(children: ReadonlyArray<Child>, loc: LocationInfo, op: ConditionOperator) {
-    const nodes = nodeChildren(children);
-    if (nodes.length === 0) {
-      return this._lessKeyword('', loc) as unknown as JessNode;
-    }
-    let left = nodes[0]!;
-    for (let i = 1; i < nodes.length; i++) {
-      left = new Condition([left, op, nodes[i]!], {}, loc) as unknown as Node;
-    }
-    return left as unknown as JessNode;
-  }
-
-  /** guard: `when` guardOr — returns the single guardOr child. */
-  private _buildGuard(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    return (nodeChildren(children)[0] ?? this._lessKeyword('', loc)) as unknown as JessNode;
-  }
-
-  /**
-   * Deprecated Less `%(format, args…)` string formatting, LOWERED at build time.
-   *
-   * Jess already has full string interpolation, so `%()` is redundant Less-4 legacy —
-   * we emit a `percent-format` deprecation warning and, when the format is a string
-   * literal, splice its `%[sda]` directives into the canonical `Interpolated` node
-   * (the same one `@{var}` string interpolation builds), wrapped in a `Quoted` that
-   * preserves the literal's quote char / escaped flag:
-   *   - `%s`  → bare interpolation slot (a Quoted arg inserts with its quotes stripped);
-   *   - `%d`/`%a` → identical bare slot (d/a are the same in Less);
-   *   - `%S`/`%D`/`%A` → the arg WRAPPED in `escape(…)` (URL-encode);
-   *   - `%%` → a literal `%`.
-   * A dynamic (non-literal) format (`%(hello)`, `%(e("…"), …)`) can't be lowered at
-   * parse time, so it falls back to a best-effort runtime `%` Call with the same warning.
-   */
-  private _buildFormatCall(raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo): JessNode {
-    this._warn('%() string formatting is deprecated — use string interpolation', 'percent-format');
-
-    // Assemble the args exactly like a normal Call so bare keywords (`%(hello)`) are
-    // keyword-ified and comma runs fold uniformly.
-    const argList = this._assembleArgs(this._betweenParens(spannedComponents(raw)), loc) as unknown as List<Node>;
-    const args = (argList.value ?? []) as Node[];
-    const format = args[0];
-    const rest = args.slice(1);
-
-    // The format must be a Quoted literal (plain `"…"`, `'…'`, or escaped `~"…"`)
-    // wrapping a bare string to lower; anything else stays a runtime call.
-    if (format instanceof Quoted && typeof format.value === 'string') {
-      const { source, replacements } = this._lowerFormatString(format.value, rest, loc);
-      const interp = new Interpolated({ source, replacements: replacements as any }, { role: 'ident' }, loc);
-      return new Quoted(interp as any, { quote: format.quote, escaped: format.escaped }, loc) as unknown as JessNode;
-    }
-
-    // Dynamic / non-literal format (`%(hello)`, `%(e("…"), …)`): best-effort runtime `%` Call.
-    const nameRef = new Reference('%', { type: 'function', fallbackValue: true } as any, loc);
-    return new Call({ name: nameRef as any, args: argList as any }, { silentFail: true } as any, loc) as unknown as JessNode;
-  }
-
-  /**
-   * Turn a printf-style format string into an `Interpolated` source + replacements.
-   * `%[sda]` → one `INTERPOLATION_PLACEHOLDER` slot consuming the next positional arg
-   * (uppercase → wrapped in `escape(…)` to URL-encode); `%%` → a literal `%`.
-   */
-  private _lowerFormatString(
-    formatText: string, restArgs: ReadonlyArray<Node>, loc: LocationInfo
-  ): { source: string; replacements: Node[] } {
-    let source = '';
-    const replacements: Node[] = [];
-    let argIndex = 0;
-    for (let i = 0; i < formatText.length; i++) {
-      const ch = formatText[i]!;
-      if (ch !== '%') {
-        source += ch;
-        continue;
-      }
-      const next = formatText[i + 1];
-      if (next === '%') {
-        source += '%';
-        i++;
-        continue;
-      }
-      if (next && /[sda]/i.test(next)) {
-        const arg = restArgs[argIndex++];
-        if (arg) {
-          source += INTERPOLATION_PLACEHOLDER;
-          // Uppercase directive (`%S`/`%D`/`%A`) → URL-encode the inserted value.
-          if (/[A-Z]/.test(next)) {
-            const escapeRef = new Reference('escape', { type: 'function', fallbackValue: true } as any, loc);
-            const escapeArgs = new List([arg] as any, {}, loc);
-            replacements.push(new Call({ name: escapeRef as any, args: escapeArgs as any }, { silentFail: true } as any, loc) as unknown as Node);
-          } else {
-            replacements.push(arg);
-          }
-        } else {
-          // No matching arg — Less leaves the directive in place as literal text.
-          source += ch + next;
-        }
-        i++;
-        continue;
-      }
-      source += ch;
-    }
-    return { source, replacements };
-  }
-
-  private _buildInterpolatedSelector(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    const replacements: Node[] = [];
-    let source = '';
-    for (const l of ls) {
-      if (l.value.startsWith('@{')) {
-        const varName = l.value.slice(2, -1);
-        replacements.push(new Reference(varName, { role: 'ident' }, loc) as unknown as Node);
-        source += INTERPOLATION_PLACEHOLDER;
-      } else {
-        source += l.value;
-      }
-    }
-    const interp = new Interpolated({ source, replacements }, { role: 'ident' }, loc);
-    return new InterpolatedSelector(interp as any, {}, loc) as unknown as JessNode;
-  }
-
-  private _buildLessPseudo(
-    type: string, span: Span,
-    children: ReadonlyArray<JessNode | CSTLeaf | CSTError>,
-    state: unknown, raw: ReadonlyArray<{ _tag: string }>, fields: FieldMap | undefined, triviaLog: readonly number[], loc: LocationInfo
-  ): JessNode {
-    // `:extend(...)` is parsed by the dedicated ExtendPseudo grammar rule, never
-    // here — generic PseudoSelector is guarded against it (extendAhead). So this
-    // builder only ever sees real CSS pseudo-classes/elements.
-    const pseudo = super.buildNode(type, span, children, state, raw, fields, triviaLog) as JessNode;
-    // `readPseudoArg` (css builder) only recognizes node/array args. Under the Less
-    // grammar an `nth` arg (`4n+1`) arrives as a leaf string and a single-member
-    // selector list collapses to a bare string — both of which it skips, leaving
-    // `arg` undefined (`:not(.one)` → `:not`). Recover the arg as the child that
-    // sits between the `(` and `)` leaves.
-    let pseudoArg = (pseudo as unknown as { arg?: unknown }).arg;
-    if (pseudoArg === undefined) {
-      const open = children.findIndex(c => (c as CSTLeaf)._tag === 'leaf' && (c as CSTLeaf).value === '(');
-      if (open >= 0) {
-        const inner = children[open + 1];
-        const isClose = (inner as CSTLeaf)?._tag === 'leaf' && (inner as CSTLeaf).value === ')';
-        if (inner !== undefined && !isClose) {
-          // A collapsed single-member selector list arrives as a bare string, an
-          // `nth` value as a leaf token; both wrap to a Keyword so the pseudo arg
-          // is an eval-able Node. A real node (multi-member list, etc.) passes through.
-          const recovered = typeof inner === 'string'
-            ? this._lessKeyword(inner, loc)
-            : (inner as CSTLeaf)._tag === 'leaf'
-                ? this._lessKeyword((inner as CSTLeaf).value, loc)
-                : (inner as unknown as JessNode);
-          (pseudo as unknown as { arg: unknown }).arg = recovered;
-          pseudoArg = recovered;
-        }
-      }
-    }
-    if (Array.isArray(pseudoArg)) {
-      // Unknown-pseudo: raw string array → Keyword[] for structured serialization.
-      const keywordNodes = (pseudoArg as unknown[]).map(item =>
-        typeof item === 'string' && item !== ' '
-          ? this._lessKeyword(item, loc)
-          : item as JessNode
-      );
-      (pseudo as unknown as { arg: unknown }).arg = keywordNodes;
-    }
-    return pseudo;
-  }
-
-  private _buildLessDeclaration(raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo) {
-    const items = spannedComponents(raw);
-    const decl = this._buildDeclaration(raw, loc);
-    const colonIdx = items.findIndex(i => i.comp === ':');
-    const merge = colonIdx > 0 ? items[colonIdx - 1]?.comp : undefined;
-    const assign = merge === '+_' ? '+_:' : merge === '+' ? '+,:' : ':';
-    const d = decl as unknown as { _options?: Record<string, unknown>; options?: Record<string, unknown>; name?: unknown };
-    d._options = { ...(d._options ?? {}), assign };
-    // Wrap the string name. An interpolated property name (`@{prop}`, `pre-@{x}`)
-    // becomes an Interpolated (port of `declaration`'s getInterpolatedNode branch);
-    // a plain name becomes a bare string (or Interpolated when templated).
-    if (typeof d.name === 'string' && d.name) {
-      const nameStr = d.name;
-      (decl as unknown as { name: unknown }).name =
-        (nameStr.includes('@{') || nameStr.includes('${'))
-          ? getInterpolatedNode(nameStr, loc)
-          : nameStr;
-    }
-    // Arithmetic precedence is now folded in the grammar (topSum → Operation node),
-    // so a top-level `10px + 5px` arrives as a single Operation. Wrap it in an
-    // explicit parenthesized Expression (the Jess `$( … )` form) when math mode would
-    // actually perform the operation. Port of wrapOuterExpressionIfNeeded.
-    const dvRaw = (decl as unknown as { value?: unknown }).value;
-    if (dvRaw && typeof dvRaw === 'object' && (dvRaw as { type?: string }).type === 'Operation') {
-      const f = dvRaw as unknown as { operator?: any; left?: any; right?: any };
-      if (shouldOperateWithMathFrames({ mathMode: this.mathMode, parenFrames: [], calcFrames: 0 }, f.operator, f.left, f.right)) {
-        (decl as unknown as { value: unknown }).value = new Expression(dvRaw as any, { parens: true } as any, loc);
-      }
-      return decl;
-    }
-    // A top-level `/`-list that math mode WOULD divide (e.g. `math:always`) promotes to
-    // a division Operation. Default `parens-division` keeps a top-level slash a list.
-    const dvList = (decl as unknown as { value?: unknown }).value;
-    if (dvList && (dvList as any).type === 'List' && (dvList as any).options?.sep === '/' && this.mathMode === 'always') {
-      const items = (dvList as any).value as JessNode[];
-      if (items.length >= 2 && items.every(it => this._isDivisionLike(it))) {
-        let op: JessNode = items[0]!;
-        for (let i = 1; i < items.length; i++) {
-          op = new Operation([op, '/', items[i]] as any, undefined, loc) as unknown as JessNode;
-        }
-        const f = op as unknown as { operator: any; left: any; right: any };
-        (decl as unknown as { value: unknown }).value =
-          shouldOperateWithMathFrames({ mathMode: this.mathMode, parenFrames: [], calcFrames: 0 }, f.operator, f.left, f.right)
-            ? new Expression(op as any, { parens: true } as any, loc)
-            : op;
-        return decl;
-      }
-    }
-    // Legacy IE `filter: progid:…(…)` values. Chevrotain lexes the whole run as one
-    // `LegacyMSFilter` token and `processLegacyMSFilterToken` collapses it to a single
-    // Interpolated (role=any): the raw source with every `@var` replaced by a
-    // placeholder (colorstr assignments keep the surrounding quotes) and the `@var`
-    // references as replacements. We have no such token — the value parsed into a
-    // Sequence/List/Paren tree — but for a `progid:` filter run we reconstruct the
-    // identical node from the raw value source.
-    const dv = (decl as unknown as { value?: unknown }).value;
-    const dvIsArray = Array.isArray(dv);
-    const dvHasNode = dvIsArray && (dv as unknown[]).some(p => !!p && typeof p === 'object' && 'type' in (p as object));
-    if (dvIsArray && dvHasNode) {
-      const src = this._source.slice(loc.start, loc.end);
-      const colonPos = src.indexOf(':');
-      const rawVal = colonPos >= 0 ? src.slice(colonPos + 1).trim().replace(/;\s*$/, '').trim() : src;
-      if (/^progid:/i.test(rawVal)) {
-        const legacy = this._buildLegacyMSFilter(rawVal, loc);
-        (decl as unknown as { value: unknown }).value = legacy;
-      }
-    }
-    return decl;
-  }
-
-  /**
-   * Port of `processLegacyMSFilterToken` (lessRecursiveParser.ts): a `progid:…`
-   * filter value string → Interpolated(role=any) with `@var` runs templated out,
-   * or a plain Keyword when the run has no variables.
-   */
-  private _buildLegacyMSFilter(source: string, loc: LocationInfo): JessNode {
-    source = source.replace(/\s*=\s*/g, '=');
-    const varRe = /@([_a-zA-Z\xA0-￿][-_a-zA-Z0-9\xA0-￿]*)/g;
-    const matches = [...source.matchAll(varRe)];
-    if (matches.length === 0) {
-      return this._lessKeyword(source, loc) as unknown as JessNode;
-    }
-    const templatedSource = source.replace(
-      varRe,
-      (_full, _name, offset: number, fullSource: string) => {
-        const prefix = fullSource.slice(0, offset);
-        const key = prefix.match(/([A-Za-z]+)=$/)?.[1];
-        if (key && /colorstr$/i.test(key)) {
-          return `"${INTERPOLATION_PLACEHOLDER}"`;
-        }
-        return INTERPOLATION_PLACEHOLDER;
-      }
-    );
-    const replacements = matches.map(match =>
-      createInterpolatedReference('@', match[1]!, loc) as unknown as JessNode);
-    return new Interpolated(
-      { source: templatedSource, replacements: replacements as any },
-      { role: 'any' },
-      loc
-    ) as unknown as JessNode;
-  }
-
-  // Precedence is folded in the grammar (mathSum/topSum → Operation); the base
-  // _buildOperation / _isDivisionLike (inherited from CssParser) handle the slash-
-  // vs-list decision. `OperationTop` dispatches here with slashEnabled = math:always.
-
-  private _buildAmpersand(children: ReadonlyArray<Child>, loc: LocationInfo): JessNode {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    const hasParen = ls.some(l => l.value === '(');
-    if (!hasParen) {
-      // The ampersand token is always `&`-led (`&`, `&-bar`, `&1`) — a `.`/`#` prefix
-      // like `.foo-&` parses as a separate BasicSelector + a bare `&`, not one token.
-      // The suffix after `&` is the append value; a bare `&` has none.
-      const image = ls[0]?.value ?? '&';
-      const appendValue = this._ampersandTemplateValue(image);
-      return new Ampersand(appendValue, {}, loc) as unknown as JessNode;
-    }
-    const content = ls.find(l => l.value !== '&' && l.value !== '(' && l.value !== ')')?.value ?? '';
-    const trimmed = content.trim();
-    const appendValue = trimmed === 'nil'
-      ? ''
-      : trimmed.replace(/^(['"])([\s\S]*)\1$/, '$2');
-    return new Ampersand(appendValue, {}, loc) as unknown as JessNode;
-  }
-
-  /** The append value of a `&`-led ampersand token: the suffix after `&` (`&-bar` →
-   * `-bar`, `&1` → `1`), or undefined for a bare `&`. */
-  private _ampersandTemplateValue(image: string): string | undefined {
-    return image === '&' ? undefined : image.slice(1) || undefined;
-  }
-
-  /**
-   * A single extend target inside `extend( … )`: a complex selector plus its
-   * optional `all` / `!all` flag (selectors.ts `complexSelector`'s OPTION2 flag).
-   * Produced as an `Extend` carrier the surrounding pseudo/statement groups.
-   */
-  private _buildExtendTarget(
-    _children: ReadonlyArray<Child>, raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo
-  ): JessNode {
-    // Components: the target selector (string or selector node) + an optional
-    // trailing `all` / `!all` flag leaf. The complexSelector builder collapses a
-    // lone `.x` to a bare string, so accept either form here.
-    const comps = spannedComponents(raw);
-    const isFlag = (c: unknown): c is string => typeof c === 'string' && /^!?all$/.test(c);
-    const hasFlag = comps.some(c => isFlag(c.comp));
-    const flag = hasFlag ? ExtendFlag.All : ExtendFlag.Exact;
-    const targetComp = comps.find(c => !isFlag(c.comp))?.comp;
-    const target = (typeof targetComp === 'string'
-      ? targetComp
-      : (targetComp ?? '&')) as Selector;
-    return new Extend({ target, flag }, {}, loc) as unknown as JessNode;
-  }
-
-  /**
-   * `:extend( … )` pseudo form (selectors.ts `extend`): groups its ExtendTarget
-   * children. Targets sharing one flag collapse to a single Extend whose target is
-   * a SelectorList (or the lone selector); mixed flags stay as one Extend each,
-   * returned in a List. Mirrors mergeExtends' target-and-flag grouping.
-   */
-  private _buildExtendPseudo(children: ReadonlyArray<Child>, loc: LocationInfo): JessNode {
-    // Grammar guarantees ≥1 target: `extendBody = sepBy(ExtendTarget, ',')`.
-    const targets = nodeChildren(children).filter(n => n.type === 'Extend') as unknown as Array<{
-      target: Selector; flag: number;
-    }>;
-    const firstFlag = targets[0]!.flag;
-    const allSameFlag = targets.every(t => t.flag === firstFlag);
-    if (allSameFlag) {
-      const target = targets.length === 1
-        ? targets[0]!.target
-        : this._makeSelectorList(targets.map(t => t.target) as any, loc) as unknown as Selector;
-      return new Extend({ target, flag: firstFlag }, {}, loc) as unknown as JessNode;
-    }
-    const extendNodes: JessNode[] = targets.map(t =>
-      new Extend({ target: t.target, flag: t.flag }, {}, loc) as unknown as JessNode
-    );
-    return new List(extendNodes as any, {}, loc) as unknown as JessNode;
-  }
-
-  /**
-   * `&:extend( … );` (or bare `:extend( … );`) statement form (selectors.ts
-   * `ampersandExtend`). The ExtendPseudo child already carries the grouped
-   * Extend(s); the leading `&` is just the statement marker.
-   */
-  private _buildExtendStatement(
-    children: ReadonlyArray<Child>, _raw: ReadonlyArray<{ _tag: string }>, _loc: LocationInfo
-  ): JessNode {
-    // ExtendPseudo always yields the grouped Extend (or List of Extends).
-    const built = nodeChildren(children).find(n => n.type === 'Extend' || n.type === 'List')!;
-    return built as unknown as JessNode;
-  }
-
-  /**
-   * Decode a single `[key]` accessor into its Less lookup-key AST — the ONE shared
-   * decoder for every accessor-chain builder path (var-decl value, declaration value,
-   * at-rule prelude, namespace ref). Accepts either a raw authored key STRING (the
-   * text inside the brackets, e.g. `@@foo`, `$@x`, `bar`, ``), or a SquareParen `Paren`
-   * node whose inner content the grammar already parsed (a raw string or a `@var`
-   * Reference). Returns the key exactly as the reference lookupOrCall production would:
-   *
-   *   `[]`        → -1        (index, empty)
-   *   `[@@name]`  → Reference{type:variable,key:name}   (dynamic variable lookup)
-   *   `[$@name]` / `[@$name]` → Quoted(Interpolated(@name))  (dynamic property lookup)
-   *   `[@name]`   → 'name'    (static variable lookup; bare string key)
-   *   `[$name]`   → Quoted('name')   (property lookup; `$` marker dropped)
-   *   `[name]`    → Quoted('name')   (index)
-   *
-   * Exactly one `@`/`$` marker is the lookup marker and is never kept.
-   */
-  private _decodeAccessorKey(
-    rawTextOrNode: JessNode | string,
-    loc: LocationInfo
-  ): JessNode | string | number {
-    // Recover the authored key text: a bare string, a SquareParen node's inner
-    // content (string or parsed `@foo` Reference), or an already-extracted string.
-    let rawText: string | undefined;
-    let innerVal: unknown;
-    if (typeof rawTextOrNode === 'string') {
-      rawText = rawTextOrNode.trim();
-    } else {
-      innerVal = (rawTextOrNode as any).node ?? (rawTextOrNode as any).value;
-      // Empty `[]` — no inner content, or an empty Keyword placeholder → index key -1.
-      if (!innerVal
-        || this._isEmptyKeywordLike(innerVal)) {
-        return -1;
-      }
-      if (typeof innerVal === 'string') {
-        rawText = innerVal.trim();
-      } else if (typeof innerVal === 'object'
-        && (innerVal as any).type === 'Reference' && typeof (innerVal as any).key === 'string') {
-        rawText = '@' + (innerVal as any).key;
-      } else if (this._isKeywordLike(innerVal)
-        && typeof (innerVal as any).value === 'string') {
-        // A bare/ident/`$prop` accessor key parsed as a Keyword leaf (e.g.
-        // `#ns[foo]`, `#ns.vars[$sub]`) — recover its text so the `$`/`@`/bare
-        // key logic below applies uniformly with the string path.
-        rawText = (innerVal as any).value.trim();
-      }
-    }
-    if (rawText === undefined || rawText === '') {
-      // Empty `[]` (bare string) → index key -1. A non-string/non-@var node (e.g. an
-      // interpolated key) falls back to its `.key` or the node itself.
-      if (rawText === '') {
-        return -1;
-      }
-      return (innerVal as any)?.key ?? (innerVal as JessNode);
-    }
-    // `@@name` → dynamic variable lookup; key is a variable Reference.
-    if (rawText.startsWith('@@')) {
-      return new Reference(rawText.slice(2), { type: 'variable' as const }, loc) as unknown as JessNode;
-    }
-    // `$@name` / `@$name` → property lookup with a dynamic (variable) name:
-    // Quoted(Interpolated(@name)). The `$`/`@` markers are never kept.
-    if (rawText.startsWith('$@') || rawText.startsWith('@$')) {
-      const varRef = new Reference(rawText.slice(2), { role: 'ident' as const }, loc) as unknown as Node;
-      const interp = new Interpolated(
-        { source: INTERPOLATION_PLACEHOLDER, replacements: [varRef] as any },
-        { role: 'ident' as const }, loc
-      ) as unknown as string;
-      return new Quoted(interp, {}, loc) as unknown as JessNode;
-    }
-    // `@name` → variable lookup; key is the bare name (a string).
-    if (rawText.startsWith('@')) {
-      return rawText.slice(1);
-    }
-    // `$name` (property reference) or bare `name` (index) → Quoted(name); the `$`
-    // property marker is dropped.
-    return new Quoted(rawText.replace(/^\$/, ''), {}, loc) as unknown as JessNode;
-  }
-
-  protected override _assembleSegment(seg: Spanned[], loc: LocationInfo): Component {
-    const result = super._assembleSegment(seg, loc);
-    const isNsNameEarly = (c: unknown): c is string =>
-      typeof c === 'string' && /^[#.]-?[_a-zA-Z]/.test(c.trim());
-    if (!Array.isArray(result)) {
-      // A lone `#ns.mixin` / `.mixin` string in declaration-value position is a
-      // mixin-ruleset name Reference — not a raw string. Faithful to the reference
-      // `mixinReference`→`mixinName` (asReference:true). (The var-decl namespace path
-      // does this too via _tryParseNamespaceRef.)
-      if (isNsNameEarly(result)) {
-        const segs = (result as string).trim().match(/[#.][^#.]*/g) ?? [(result as string).trim()];
-        const nameKey: string | string[] = segs.length === 1 ? segs[0]! : segs;
-        const rawKey = segs.length > 1 ? segs.join('') : undefined;
-        return new Reference(
-          { key: nameKey, ...(rawKey ? { rawKey } : {}) } as unknown as ReferenceValue,
-          { type: 'mixin-ruleset', role: 'name' } as any, loc
-        ) as unknown as Component;
-      }
-      return result as Component;
-    }
-    if (result.length < 2) {
-      return result as Component;
-    }
-    const comps = result as Component[];
-    const isNsName = (c: unknown): c is string =>
-      typeof c === 'string' && /^[#.]-?[_a-zA-Z€-￿]/.test(c.trim());
-    const isSquareParen = (c: unknown): c is JessNode =>
-      !!c && typeof c === 'object' && (c as any).type === 'Paren'
-      && (c as any)._options?.delimiter === 'square';
-    const isRoundParen = (c: unknown): c is JessNode =>
-      !!c && typeof c === 'object' && (c as any).type === 'Paren'
-      && (c as any)._options?.delimiter !== 'square';
-    if (!isNsName(comps[0])) {
-      return comps as unknown as Component;
-    }
-    // Consume all leading #/.-prefixed strings as namespace path segments.
-    // A single token like '#ns.breakpoint' also gets split into sub-segments.
-    const splitNsToken = (s: string): string[] => s.match(/[#.][^#.]*/g) ?? [s];
-    let i = 0;
-    const pathSegs: string[] = [];
-    while (i < comps.length && isNsName(comps[i])) {
-      pathSegs.push(...splitNsToken((comps[i] as string).trim()));
-      i++;
-    }
-    const rawPathText = pathSegs.join('');
-    const nameKey: string | string[] = pathSegs.length === 1 ? pathSegs[0]! : pathSegs;
-    const rawKey = pathSegs.length > 1 ? rawPathText : undefined;
-    let base: JessNode = new Reference(
-      { key: nameKey, ...(rawKey ? { rawKey } : {}) } as unknown as ReferenceValue,
-      { type: 'mixin-ruleset', role: 'name' } as any, loc
-    ) as unknown as JessNode;
-    // A bare `#ns.mixin` / `.mixin` / `#ns > .a` run in declaration-value position,
-    // with NO following `[`/`(`, is still a mixin-ruleset name Reference — not a raw
-    // string/array. Faithful to the reference `mixinReference`→`mixinName`
-    // (asReference:true) `flushPendingAsRef` shape. (The var-decl path does this too.)
-    if (i >= comps.length || (!isSquareParen(comps[i]) && !isRoundParen(comps[i]))) {
-      // Only rewrite when the namespace run is the WHOLE value; a trailing non-paren
-      // component means this wasn't a lone namespace target (leave it as-is).
-      return (i === comps.length ? base : comps as unknown) as Component;
-    }
-    while (i < comps.length) {
-      const item = comps[i];
-      if (isSquareParen(item)) {
-        const innerKey = this._decodeAccessorKey(item as JessNode, loc);
-        // A bare-string key (`@var`) or an `@@name` indirection Reference is a
-        // variable lookup; a Quoted/number key is a property (`index`) lookup —
-        // mirror _applyReferenceAccessor's key→type logic (the var-decl accessor
-        // path does the same).
-        const keyIsVar = typeof innerKey === 'string'
-          || (innerKey != null && typeof innerKey === 'object'
-            && (innerKey as any).type === 'Reference');
-        const accType: 'variable' | 'index' = keyIsVar ? 'variable' : 'index';
-        base = new Reference(
-          { target: base as any, key: innerKey as any } as unknown as ReferenceValue,
-          { type: accType }, loc
-        ) as unknown as JessNode;
-        i++;
-      } else if (isRoundParen(item)) {
-        const innerContent = (item as any).value ?? (item as any).node;
-        const isEmpty = this._isEmptyKeywordLike(innerContent);
-        const argsNode = isEmpty ? null : this._parenToArgs(item, loc);
-        const callPayload: Record<string, unknown> = { name: base };
-        if (argsNode) {
-          callPayload.args = argsNode;
-        }
-        base = new Call(callPayload as any, {}, loc) as unknown as JessNode;
-        i++;
-      } else {
-        break;
-      }
-    }
-    return (i === comps.length ? base : comps as unknown) as Component;
-  }
-
-  private _buildEscapedValue(children: ReadonlyArray<Child>, loc: LocationInfo): JessNode {
-    const inner = nodeChildren(children)[0];
-    if (!inner) {
-      return this._lessKeyword('', loc) as unknown as JessNode;
-    }
-    // Quoted keeps `escaped` as its own readonly instance field (render reads the
-    // field, not `_options`), so mutating `_options` alone would leave the field
-    // `false` and the string would print quoted. Rebuild the Quoted through its
-    // constructor so both the field and `_options` carry `escaped: true`. Paren
-    // (`~(…)`) reads `_options.escaped` directly, so the option merge suffices.
-    if (inner instanceof Quoted) {
-      return new Quoted(
-        inner.value,
-        { quote: inner.quote, escaped: true },
-        loc
-      ) as unknown as JessNode;
-    }
-    const n = inner as unknown as { _options?: Record<string, unknown> };
-    n._options = { ...(n._options ?? {}), escaped: true };
-    return inner;
-  }
-
-  // `@{colorVar}` / `pre-@{x}` in value position. Port of `processValueToken`'s
-  // InterpolatedIdent branch: getInterpolatedOrString → Interpolated (role=ident),
-  // or a plain Keyword when the run resolves to a bare string.
-  private _buildInterpValue(raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo): JessNode {
-    const items = spannedComponents(raw);
-    const image = items.map(i => (typeof i.comp === 'string' ? i.comp : '')).join('');
-    const result = getInterpolatedOrString(image, loc);
-    if (typeof result === 'string') {
-      return this._lessKeyword(result, loc) as unknown as JessNode;
-    }
-    return result as unknown as JessNode;
-  }
-
-  /**
-   * A quoted string value. Unlike plain CSS, Less interpolates `@{var}` / `${prop}`
-   * inside quoted (and escaped `~"…"`) strings and inside `@import` paths. When the
-   * raw content holds an interpolation, split it into an `Interpolated` value the same
-   * way the reference parser's `processStringInterpolation` does (source with
-   * INTERPOLATION_PLACEHOLDER, `@var`/`$prop` references in `replacements`); otherwise
-   * fall through to the plain CSS builder (bare-string value).
-   */
-  /**
-   * The Less `Url` grammar tokenizes the inner string as bare leaves (no child
-   * node), so the css base builder wraps a quoted url body in a raw-string
-   * `Quoted` — which never interpolates `@{var}`/`${prop}`. Less 4.x DOES resolve
-   * interpolation inside a QUOTED url body (`url("@{base}/@{i}.svg")`), the same as
-   * any other quoted string, so route the quoted inner through the same
-   * interpolation-aware construction `_buildQuoted` uses. Unquoted url bodies stay
-   * verbatim (Less 4.x leaves `url(@{x})` literal), as does a quoted body with no
-   * interpolation.
-   */
-  protected override _buildUrl(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    const innerNode = nodeChildren(children)[0];
-    if (innerNode) {
-      return super._buildUrl(children, loc);
-    }
-    const inner = children
-      .filter((c): c is CSTLeaf => c._tag === 'leaf')
-      .filter(l => !/^url\($/i.test(l.value) && l.value !== ')')
-      .map(l => l.value).join('').trim();
-    const quote = inner[0];
-    if ((quote === '"' || quote === '\'') && inner.at(-1) === quote) {
-      const body = inner.slice(1, -1);
-      if (body.includes('@{') || body.includes('${')) {
-        const value = this._buildStringInterpolation(body, loc);
-        return new Url(
-          new Quoted(value as any, { quote }, loc) as any,
-          undefined, loc
-        ) as unknown as JessNode;
-      }
-    }
-    return super._buildUrl(children, loc);
-  }
-
-  protected override _buildQuoted(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    const text = children
-      .filter((c): c is CSTLeaf => c._tag === 'leaf')
-      .map(l => l.value)
-      .join('');
-    const inner = text.slice(1, -1);
-    if (inner.includes('@{') || inner.includes('${')) {
-      const value = this._buildStringInterpolation(inner, loc);
-      return new Quoted(value as any, { quote: text[0] as '"' | '\'' }, loc) as unknown as JessNode;
-    }
-    return super._buildQuoted(children, loc);
-  }
-
-  /**
-   * Build an escaped `~'…'` Quoted (at-rule prelude position), interpolating any
-   * `@{var}` / `${prop}` in its body the same way `_buildQuoted` does — so
-   * `~'@{a} / @{b}'` renders its substituted values instead of literal text.
-   */
-  private _buildEscapedQuoted(inner: string, quote: '"' | '\'', loc: LocationInfo): JessNode {
-    const value = (inner.includes('@{') || inner.includes('${'))
-      ? this._buildStringInterpolation(inner, loc)
-      : inner;
-    return new Quoted(value as any, { quote, escaped: true }, loc) as unknown as JessNode;
-  }
-
-  /**
-   * Split a quoted-string body on `@{…}` / `${…}` interpolations into an
-   * `Interpolated` (source + reference replacements). Port of the reference parser's
-   * `processStringInterpolation`/`findInterpolations` (productions/values.ts): brace
-   * matching is nesting-aware, and a nested-interpolated name resolves through a
-   * variable Reference wrapped in an Expression.
-   */
-  private _buildStringInterpolation(value: string, loc: LocationInfo): Interpolated {
-    const matches = this._findInterpolations(value);
-    const replacements: Node[] = [];
-    let source = value;
-    let offset = 0;
-    for (const match of matches) {
-      const adjustedStart = match.start - offset;
-      const adjustedEnd = match.end - offset;
-      source = source.slice(0, adjustedStart) + INTERPOLATION_PLACEHOLDER + source.slice(adjustedEnd);
-      offset += (match.end - match.start) - INTERPOLATION_PLACEHOLDER.length;
-      if (match.content.includes('@{') || match.content.includes('${')) {
-        // Nested interpolation resolves through a variable Reference, kept
-        // expression-wrapped so it re-renders as a single interpolated slot.
-        const nestedRef = new Reference(
-          { key: this._buildStringInterpolation(match.content, loc) as any } as unknown as ReferenceValue,
-          { type: 'variable', role: 'ident' } as any, loc
-        );
-        replacements.push(new Expression(nestedRef as any, undefined, loc) as unknown as Node);
-      } else {
-        replacements.push(createInterpolatedReference(match.prefix, match.content, loc) as unknown as Node);
-      }
-    }
-    return new Interpolated({ source, replacements: replacements as any }, { role: 'ident' }, loc);
-  }
-
-  /**
-   * Locate `@{…}` / `${…}` interpolation runs in a string, counting nested braces so
-   * `@{@{x}}` and `@{fn(a, b)}` are matched whole. Returns start/end/prefix/content.
-   */
-  private _findInterpolations(value: string): Array<{ start: number; end: number; prefix: string; content: string }> {
-    const matches: Array<{ start: number; end: number; prefix: string; content: string }> = [];
-    let i = 0;
-    while (i < value.length) {
-      if ((value[i] === '@' || value[i] === '$') && value[i + 1] === '{') {
-        const prefix = value[i]!;
-        const start = i;
-        i += 2;
-        let braceCount = 1;
-        const contentStart = i;
-        while (i < value.length && braceCount > 0) {
-          if (value[i] === '{') {
-            braceCount++;
-          } else if (value[i] === '}') {
-            braceCount--;
-          }
-          i++;
-        }
-        if (braceCount === 0) {
-          matches.push({ start, end: i, prefix, content: value.slice(contentStart, i - 1) });
-        }
-      } else {
-        i++;
-      }
-    }
-    return matches;
-  }
-
-  protected override _buildCall(rawChildren: ReadonlyArray<{ _tag: string }>, loc: LocationInfo) {
-    const call = super._buildCall(rawChildren, loc) as unknown as {
-      name: unknown; args: unknown; _options?: Record<string, unknown>;
-    };
-    const key = typeof call.name === 'string' ? call.name : '';
-    // Function calls share the mixin args grammar, so they get the same `,`/`;`
-    // mix rejection (e.g. `foo(@a: 1; @b: 2, @c: 3)`).
-    this._checkMixedArgDelimiters(call.args as unknown as JessNode, 'function', loc);
-    // Lower `;`-args to comma + `~(…)` (after the mixed-delimiter check), matching
-    // the mixin path so function calls converge on the same unified AST.
-    const loweredArgs = this._lowerSemiArgs(call.args as unknown as JessNode, loc);
-    const nameRef = new Reference(key, { type: 'function', fallbackValue: true } as any, loc);
-    const next = new Call({ name: nameRef as any, args: loweredArgs as any }, { silentFail: true } as any, loc);
-    return next as unknown as JessNode;
-  }
-
-  private _buildLessCustomDecl(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    const propNameText = ls[0]?.value ?? '';
-    // `--@{key}: …` (port of the reference's InterpolatedCustomProperty branch):
-    // an interpolated name becomes an Interpolated node, same as a regular
-    // declaration's `getInterpolatedNode` branch.
-    const name = (propNameText.includes('@') || propNameText.includes('$'))
-      ? getInterpolatedNode(propNameText, loc)
-      : propNameText;
-    const valueNodes = nodeChildren(children);
-    if (valueNodes.length > 0) {
-      const value = valueNodes.length === 1 ? valueNodes[0]! : valueNodes;
-      return new CustomDeclaration({ name: name as any, value: value as any }, undefined, loc);
-    }
-    const valueText = ls.slice(2).filter(l => l.value !== ';').map(l => l.value).join('').trim();
-    return new CustomDeclaration({ name: name as any, value: this._lessKeyword(valueText, loc) as any }, undefined, loc);
-  }
-
-  /**
-   * `--foo: { color: @a; }` — a curly-brace custom-property value whose body
-   * opportunistically structured as a declaration list (customCurlyBlock in the
-   * grammar), so nested `@var`/calls evaluate normally instead of staying opaque
-   * text. Wrapped in a Block(type: 'curly') so `{`/`}` re-render around it.
-   */
-  private _buildLessCustomBlock(children: ReadonlyArray<Child>, loc: LocationInfo): JessNode {
-    const bodyNodes = nodeChildren(children);
-    // Block.value must remain a single Node; Sequence is the interim container until
-    // Block can hold a bare declaration array.
-    const seq = new Sequence(bodyNodes as any, undefined, loc);
-    return new Block(seq as any, { type: 'curly' }, loc) as unknown as JessNode;
-  }
-
-  private _warnDeprecatedValue(span: Span) {
-    const text = this._source.slice(span.start, span.end);
-    if (/\d\s*\.\//.test(text)) {
-      this._warn('The ./ operator is deprecated and will be removed.', 'dot-slash-operator');
-    }
-  }
-
-  private _warnCustomPropVars(span: Span) {
-    const text = this._source.slice(span.start, span.end);
-    const colon = text.indexOf(':');
-    const value = colon >= 0 ? text.slice(colon + 1) : text;
-    const at = value.match(/@[a-zA-Z][\w-]*/);
-    if (at && !value.includes('@{')) {
-      this._warn(
-        `"${at[0]}" in custom property values is treated as literal text. Use @{${at[0].slice(1)}} for interpolation.`,
-        'variable-in-unknown-value'
-      );
-    }
-    const dollar = value.match(/\$[a-zA-Z][\w-]*/);
-    if (dollar && !value.includes('${')) {
-      this._warn(
-        `"${dollar[0]}" in custom property values is treated as literal text. Use \${${dollar[0].slice(1)}} for interpolation.`,
-        'property-in-unknown-value'
-      );
-    }
-  }
-
-  private _warnAtRulePreludeVars(span: Span) {
-    const text = this._source.slice(span.start, span.end);
-    const varName = this._firstTopLevelBareAtVar(text);
-    if (varName !== null) {
-      this._warn(
-        `A bare "@${varName}" in an at-rule prelude is deprecated. Use @{${varName}} interpolation instead.`,
-        'variable-in-at-rule-prelude'
-      );
-    }
-  }
-
-  /**
-   * The first bare `@ident` reference in an at-rule prelude that is deprecated
-   * under Less 4.x PR #4462 (`variable-in-at-rule-prelude`), or null when there
-   * is none. A bare `@var` in a *structural* (top-level) prelude position still
-   * resolves but is deprecated in favour of `@{var}` interpolation; the scan
-   * therefore ignores, mirroring `hasTopLevelBareVariable` / `warnBareAtRuleVariable`:
-   *   - the leading at-rule name itself (`@media`, `@-moz-document`, …);
-   *   - `@{ident}` interpolation — the supported migration target;
-   *   - a `@var` inside `(...)` — a declaration/feature value (e.g. the `@size`
-   *     in `@media (min-width: @size)`), which stays valid;
-   *   - `@`/`(` characters inside string literals, which are not structural.
-   */
-  private _firstTopLevelBareAtVar(text: string): string | null {
-    let depth = 0;
-    // Skip the leading at-rule name (`@media`, `@-moz-document`, …).
-    let i = /^\s*@-?[\w-]+/.exec(text)?.[0].length ?? 0;
-    for (; i < text.length; i++) {
-      const c = text[i]!;
-      if (c === '"' || c === '\'') {
-        // A string literal: skip its contents so inner `(`/`@` are not counted.
-        i++;
-        while (i < text.length && text[i] !== c) {
-          i++;
-        }
-        continue;
-      }
-      if (c === '@') {
-        if (text[i + 1] === '{') {
-          // `@{ident}` interpolation — skip the whole group (its `}` is not the
-          // block opener, and a later bare `@var` must still be reported).
-          i += 2;
-          while (i < text.length && text[i] !== '}') {
-            i++;
-          }
-          continue;
-        }
-        if (depth === 0) {
-          const m = /^@(-?[a-zA-Z\x80-￿][\w-]*)/.exec(text.slice(i));
-          if (m) {
-            return m[1]!;
-          }
-        }
-        continue;
-      }
-      if (c === '{') {
-        // The block's opening brace ends the prelude.
-        break;
-      }
-      if (c === '(') {
-        depth++;
-      } else if (c === ')' && depth > 0) {
-        depth--;
-      }
-    }
-    return null;
-  }
-
-  private _buildMixinCall(
-    children: ReadonlyArray<Child>,
-    raw: ReadonlyArray<{ _tag: string }>,
-    loc: LocationInfo
-  ): JessNode {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    // `!important` (the `!`/`important` leaves) must end the name path and set
-    // markImportant — never leak into the Reference key.
-    const markImportant = ls.some(l => l.value === '!');
-    const nameParts: string[] = [];
-    for (const l of ls) {
-      if (l.value === '(' || l.value === ';' || l.value === '!') {
-        break;
-      }
-      nameParts.push(l.value);
-    }
-    const name = nameParts.join('');
-    const nodes = nodeChildren(children);
-    const argsList = nodes.find(n => n.type === 'List');
-    const hasArgs = argsList && (argsList as unknown as { value?: unknown[] }).value?.length;
-    if (argsList === undefined) {
-      this._warn('Calling a mixin without parentheses is deprecated', 'mixin-call-no-parens');
-    } else {
-      const src = this._source.slice(loc.start, loc.end);
-      if (/^\S+\s+\(/.test(src)) {
-        this._warn('Whitespace between a mixin name and parentheses is deprecated', 'mixin-call-whitespace');
-      }
-    }
-    const ref = new Reference(
-      { key: name } as unknown as ReferenceValue,
-      { type: 'mixin-ruleset', role: 'name' } as any,
-      loc
-    );
-    const callArgs = hasArgs ? this._convertArgsForCall(argsList as unknown as JessNode, loc) : undefined;
-    return new Call(
-      { name: ref as any, args: callArgs as any },
-      { markImportant } as any, loc
-    ) as unknown as JessNode;
-  }
-
-  /**
-   * `@name(...)` (no `:`) → a detached-ruleset variable CALL. Faithful port of
-   * `varDeclarationOrCall`'s LParen branch (selectors.ts): build a `Reference`
-   * over the var name (`type: 'variable', role: 'name'`), wrap in a `Call` with
-   * the (optional) args, and wrap THAT in an `Expression` (a top-level variable
-   * call is an expression, not a parenthesized one). `!important` sets
-   * `markImportant` on the Call, mirroring the production.
-   */
-  private _buildVarCall(
-    children: ReadonlyArray<Child>,
-    raw: ReadonlyArray<{ _tag: string }>,
-    loc: LocationInfo
-  ): JessNode {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    const markImportant = ls.some(l => l.value === '!');
-    // First leaf is the `@name` token (the MixinArgs parens live in the sub-node).
-    const nameLeaf = ls.find(l => l.value.startsWith('@'));
-    const rawName = nameLeaf?.value ?? '';
-    const name = rawName.startsWith('@') ? rawName.slice(1) : rawName;
-    const nameNode = this._lessKeyword(name, loc);
-    const nameRef = new Reference(
-      { key: nameNode } as unknown as ReferenceValue,
-      { type: 'variable', role: 'name' } as any,
-      loc
-    );
-    const nodes = nodeChildren(children);
-    const argsList = nodes.find(n => n.type === 'List');
-    const hasArgs = argsList && (argsList as unknown as { value?: unknown[] }).value?.length;
-    // `@media()` etc — a known at-rule name used as a variable call, allowed only
-    // with empty parens (port of isVariableLike's 'at-rule-variable' warning).
-    if (!hasArgs && KNOWN_AT_RULE_VAR_NAME_RE.test(name)) {
-      this._warn('Using known at-rule names as variables is deprecated', 'at-rule-variable');
-    }
-    const callArgs = hasArgs ? this._convertArgsForCall(argsList as unknown as JessNode, loc) : undefined;
-    const call = new Call(
-      { name: nameRef as any, args: callArgs as any },
-      (markImportant ? { markImportant: true } : undefined) as any,
-      loc
-    );
-    return new Expression(call as unknown as Node, undefined, loc) as unknown as JessNode;
-  }
-
-  /** `...` or `@name...` variadic arg → `Rest`. Definition-shape (string name); a
-   * CALL turns it into `Rest(Reference)` via `_convertArgsForCall`. */
-  private _buildRest(raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo): JessNode {
-    const items = spannedComponents(raw);
-    const nameItem = items.find(i => typeof i.comp === 'string' && i.comp.startsWith('@'));
-    const name = nameItem ? String(nameItem.comp).slice(1) : '';
-    return new Rest(name, {}, loc) as unknown as JessNode;
-  }
-
-  /** `@name: value` named arg/param → `VarDeclaration`. The value is assembled by the
-   * shared value builder (`_assembleValue`) — the same machinery as a declaration
-   * value, so trivia and Keyword-ification are handled and no manual trimming is
-   * needed. Named args flow through function calls too; the runtime decides whether
-   * the target accepts them. */
-  private _buildNamedArg(raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo): JessNode {
-    const items = spannedComponents(raw);
-    const colonIdx = items.findIndex(i => i.comp === ':');
-    const nameItem = items.find(i => typeof i.comp === 'string' && i.comp.startsWith('@'));
-    const name = String(nameItem?.comp ?? '').slice(1);
-    const valueItems = colonIdx >= 0 ? items.slice(colonIdx + 1) : [];
-    const { value } = this._assembleValue(valueItems, loc);
-    // A param/arg VarDeclaration value is always a single Node in the callable-
-    // binding path (it calls `value.hasFlag(...)`). `_assembleValue` leaves a lone
-    // bare keyword (`@a: inherit`) as a raw string, and a space-separated segment
-    // (`@padding: 40px 10px`) as a bare Component array — wrap each into a Node.
-    let paramValue: Component;
-    if (typeof value === 'string') {
-      paramValue = this._valueKeyword(value, loc) as unknown as Component;
-    } else if (Array.isArray(value)) {
-      const seq = value.map(c => this._argComponent(c, loc));
-      paramValue = new Sequence(seq as unknown as Node[], undefined, loc) as unknown as Component;
-    } else {
-      paramValue = value;
-    }
-    return new VarDeclaration(
-      { name: name as any, value: paramValue as any } as any,
-      {} as VarDeclarationOptions,
-      loc
-    ) as unknown as JessNode;
-  }
-
-  /** Mixin-call args are assembled by the SAME builder as function-call args
-   * (`_assembleArgs` via `_betweenParens`) — identical comma/semicolon and value
-   * handling. Named args are `VarDeclaration`s and variadic args `Rest`, which pass
-   * through as single components. A bare `@name` is a `Reference` (the call shape);
-   * the mixin-DEFINITION builder reinterprets a lone `@name` as a param. */
-  private _buildMixinArgs(raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo) {
-    const inner = this._betweenParens(spannedComponents(raw));
-    const args = this._assembleArgs(inner, loc);
-    this._checkMixedArgDelimiters(args as unknown as JessNode, 'mixin', loc);
-    // Lower `;`-args to comma + `~(…)` (after the mixed-delimiter check, which
-    // needs the `;`-List) so Less `;` and Jess `~(…)` produce the same AST.
-    return this._lowerSemiArgs(args as unknown as JessNode, loc) as unknown as typeof args;
-  }
-
-  /** Less forbids mixing the COMMA and SEMICOLON argument separators: once a
-   * semicolon separates args, a comma is a value-list separator, so a semicolon-group
-   * may not hold 2+ named params (`@a: 1, @b: 2`). `_assembleArgs` renders such a group
-   * as a List of ≥2 VarDeclarations. (This is purely about the `,` vs `;` argument
-   * separators — a `/` inside a value is unrelated and never checked.) Applies to BOTH
-   * mixin and function calls (args are unified). */
-  private _checkMixedArgDelimiters(args: JessNode | undefined, kind: 'mixin' | 'function', loc: LocationInfo): void {
-    const list = args as unknown as { type?: string; options?: { sep?: string }; value?: JessNode[] };
-    if (list?.type !== 'List' || list.options?.sep !== ';' || !Array.isArray(list.value)) {
-      return;
-    }
-    for (const el of list.value) {
-      const group = el as unknown as { type?: string; value?: JessNode[] };
-      if (group?.type === 'List' && Array.isArray(group.value)
-        && group.value.filter(n => (n as { type?: string })?.type === 'VarDeclaration').length >= 2) {
-        this._error(`Cannot mix ; and , as delimiter types in ${kind} arguments`, loc.start);
-        break;
-      }
-    }
-  }
-
-  /**
-   * Lower Less `;`-separated call args to the unified Jess representation: the outer
-   * args `List{ sep: ';' }` becomes comma-separated, and each element that is itself
-   * a comma-`List` (a `;`-group that held a comma-list) is wrapped in an escaped
-   * `Paren` — the same shape Jess authors write as `~(1, 2)`. So
-   * `.mixin(1, 2; 3, 4)` and Jess `mixin(~(1, 2), ~(3, 4))` converge on one AST.
-   *
-   * The escaped `Paren` evaluates to its inner value STRIPPED (paren.ts §escaped),
-   * so `~(1, 2)` binds/renders identically to the bare list `1, 2` — representation
-   * only, semantics unchanged. Scalar (non-List) elements pass through untouched.
-   *
-   * MUST run AFTER `_checkMixedArgDelimiters` (which inspects the `;`-List).
-   */
-  private _lowerSemiArgs(args: JessNode | undefined, loc: LocationInfo): JessNode | undefined {
-    const list = args as unknown as { type?: string; options?: { sep?: string }; value?: JessNode[] } | undefined;
-    if (!list || list.type !== 'List' || list.options?.sep !== ';' || !Array.isArray(list.value)) {
-      return args;
-    }
-    const lowered = list.value.map((el) => {
-      // A comma-list arg (an inner `List`) becomes `~(…)`; scalars stay as-is.
-      if ((el as { type?: string })?.type === 'List') {
-        return new Paren(el as unknown as Node, { escaped: true }, loc) as unknown as JessNode;
-      }
-      return el;
-    });
-    return new List(lowered as unknown as Node[], undefined, loc) as unknown as JessNode;
-  }
-
-  /**
-   * Mixin-DEFINITION param conversion. With combinator-composed args a bare `@name`
-   * value parses as a `Reference{variable}` (the CALL shape); in a DEFINITION it is a
-   * param, so convert it to `VarDeclaration(name, Nil)`. Named params (`@a: 1`),
-   * variadic (`Rest`) and pattern-match values stay as-is. Returns a NEW List (the
-   * def/call split must not mutate a shared node).
-   */
-  private _convertArgsForDefinition(argsList: JessNode | undefined, loc: LocationInfo): JessNode | undefined {
-    if (!argsList || argsList.type !== 'List') {
-      return argsList;
-    }
-    const list = argsList as unknown as List<Node>;
-    const value = (list as unknown as { value?: JessNode[] }).value;
-    if (!value || value.length === 0) {
-      return argsList;
-    }
-    let changed = false;
-    const converted = value.map((node): JessNode => {
-      if (node.type === 'Reference'
-        && (node as unknown as { options?: { type?: string } }).options?.type === 'variable') {
-        const key = (node as unknown as { key?: unknown }).key;
-        const name = typeof key === 'string'
-          ? key
-          : String((key as { valueOf?(): unknown } | undefined)?.valueOf?.() ?? '');
-        changed = true;
-        return new VarDeclaration(
-          { name: name as any, value: new Nil('', {}, loc) as unknown as JessNode as any } as any,
-          {} as VarDeclarationOptions,
-          loc
-        ) as unknown as JessNode;
-      }
-      return node;
-    });
-    if (!changed) {
-      return argsList;
-    }
-    return new List(converted as any, list.options as any, loc) as unknown as JessNode;
-  }
-
-  /**
-   * Mixin-CALL argument conversion (reference `convertArgsForCall`, root.ts).
-   * `_buildMixinArgs` builds bare `@name` args as definition-style VarDeclarations
-   * (Nil value) — correct for a DEFINITION param, but in a CALL a bare `@name` is a
-   * variable being PASSED, i.e. a `Reference{type:variable}`. Named args (`@a: 1`)
-   * and value args stay as-is; a `Rest('name')` becomes `Rest(Reference{variable})`.
-   * Returns a NEW List (the def/call split must not mutate a shared node).
-   */
-  private _convertArgsForCall(argsList: JessNode | undefined, loc: LocationInfo): JessNode | undefined {
-    if (!argsList || argsList.type !== 'List') {
-      return argsList;
-    }
-    const list = argsList as unknown as List<Node>;
-    const value = (list as unknown as { value?: JessNode[] }).value;
-    if (!value || value.length === 0) {
-      return argsList;
-    }
-    let changed = false;
-    const converted = value.map((node): JessNode => {
-      if (node.type === 'VarDeclaration') {
-        const decl = node as unknown as { name: JessNode; value?: JessNode };
-        const val = decl.value;
-        if (!val || val.type === 'Nil') {
-          // Bare `@name` → a variable reference being passed to the call.
-          const key = (decl.name as unknown as { valueOf(): string }).valueOf();
-          changed = true;
-          return new Reference(
-            { key } as unknown as ReferenceValue,
-            { type: 'variable' } as any,
-            loc
-          ) as unknown as JessNode;
-        }
-        return node;
-      }
-      if (node.type === 'Rest') {
-        const restVal = (node as unknown as { value: unknown }).value;
-        if (typeof restVal === 'string') {
-          changed = true;
-          return new Rest(
-            new Reference({ key: restVal } as unknown as ReferenceValue, { type: 'variable' } as any, loc) as any,
-            {} as any,
-            loc
-          ) as unknown as JessNode;
-        }
-        return node;
-      }
-      return node;
-    });
-    if (!changed) {
-      return argsList;
-    }
-    return new List(
-      converted as any,
-      list.options as any,
-      loc
-    ) as unknown as JessNode;
-  }
-
-  private _buildAnonMixin(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    // `.(@p) { … }` → a nameless Mixin (reference `anonymousMixinDefinition`,
-    // selectors.ts: `new Mixin({ params, rules })`), NOT a `.`-selector Ruleset.
-    // The MixinArgs sub-node is the param List; everything else is the body.
-    const nodes = nodeChildren(children);
-    const argsList = nodes.find(n => n.type === 'List');
-    const rules = nodes.filter(n => n !== argsList);
-    // Definition params: a bare `@name` value is a param, so reinterpret it.
-    const defParams = this._convertArgsForDefinition(argsList as unknown as JessNode, loc);
-    const params = (defParams as unknown as { value?: unknown[] })?.value?.length
-      ? defParams as unknown as List<Node>
-      : undefined;
-    return new Mixin(
-      { params, rules } as any,
-      undefined,
-      loc
-    ) as unknown as JessNode;
-  }
-
-  /**
-   * `each(<iterable>, { … })` → a `For` control node (the $for shape), not a Call.
-   * The value(s) before the comma are the iterable; the callback block's body becomes
-   * the loop rules. A literal block callback carries no captured params here, so the
-   * pattern defaults to the Less `[value, key, index]` triple.
-   */
-  /** A bare detached ruleset `{ … }` in value / argument position → a Mixin holding
-   * its rules (same shape `@var: { … }` produces in `_buildVarDeclaration`). */
-  private _buildDetachedRuleset(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    const ruleNodes = nodeChildren(children);
-    return new Mixin({ rules: ruleNodes } as any, {}, loc);
-  }
-
-  private _buildEachFor(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    // Args come from the shared functionCallArgs: the callback (detached ruleset /
-    // `.(…){…}`) is a Mixin sub-node; everything else is the iterable.
-    const nodes = nodeChildren(children);
-    const callback = nodes.find(n => n.type === 'Mixin') as unknown as { rules?: JessNode[]; params?: JessNode } | undefined;
-    const iterableNodes = nodes.filter(n => (n as unknown) !== (callback as unknown));
-    const paramsList = ((callback?.params as unknown as { type?: string } | undefined)?.type === 'List')
-      ? callback!.params as JessNode
-      : undefined;
-    const ruleNodes = callback?.rules ?? [];
-    const iterable: JessNode = iterableNodes.length === 1
-      ? iterableNodes[0]!
-      : (new List(iterableNodes as any, undefined, loc) as unknown as JessNode);
-    return new For(
-      { pattern: this._eachPattern(paramsList, loc), iterable: { kind: 'node', value: iterable as unknown as Node }, rules: ruleNodes as unknown as Node[] },
-      undefined,
-      loc
-    );
-  }
-
-  private _eachPattern(paramsList: JessNode | undefined, loc: LocationInfo): ForPattern {
-    // Explicit `.(@v; @i)` callback params parse straight into VarDeclaration nodes
-    // (name 'v'/'i'); reuse them as the loop's binding pattern.
-    const params = ((paramsList as unknown as { value?: JessNode[] } | undefined)?.value ?? [])
-      .filter((p): p is JessNode => p?.type === 'VarDeclaration');
-    if (params.length === 1) {
-      return { kind: 'single', value: params[0] as any };
-    }
-    if (params.length >= 2) {
-      return { kind: 'tuple', values: [params[0], ...params.slice(1)] as any };
-    }
-    // A param-less block callback iterates with the Less default triple.
-    const paramVar = (name: string) => new VarDeclaration(
-      { name, value: this._lessKeyword('', loc) } as any,
-      { paramVar: true } as any,
-      loc
-    );
-    return { kind: 'tuple', values: [paramVar('value'), paramVar('key'), paramVar('index')] };
-  }
-
-  private _buildMixinOrQualified(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    const nodes = nodeChildren(children);
-    const hasBlock = ls.some(l => l.value === '{');
-    // `!important` on a mixin call: the `!`/`important` leaves are direct children
-    // (MixinArgs's own parens live in the sub-node, not in `ls`). The `!` ends the
-    // name path and flips markImportant — it must NOT leak into the Reference key.
-    const markImportant = ls.some(l => l.value === '!');
-    const nameParts: string[] = [];
-    for (const l of ls) {
-      if (l.value === '(' || l.value === '{' || l.value === '}' || l.value === ';' || l.value === ')' || l.value === '!') {
-        break;
-      }
-      nameParts.push(l.value);
-    }
-    const name = nameParts.join('');
-    const argsList = nodes.find(n => n.type === 'List');
-    const guard = nodes.find(n => n.type === 'Paren' || n.type === 'Condition' || n.type === 'DefaultGuard');
-    // argsList presence (from MixinArgs sub-node) signals explicit parens
-    const hasExplicitParens = argsList !== undefined;
-    if (hasBlock) {
-      const rawRuleNodes = nodes.filter(n => n !== argsList && n !== guard);
-      // Lift standalone comments in the body (the Mixin/qualified-rule body is built
-      // inline here, bypassing _buildRuleset's own comment lift).
-      const braceIdx = this._source.indexOf('{', loc.start);
-      const bodyStart = braceIdx >= 0 ? braceIdx + 1 : loc.start;
-      const closeIdx = this._source.lastIndexOf('}', loc.end - 1);
-      const bodyEnd = closeIdx >= bodyStart ? closeIdx : loc.end;
-      const ruleNodes = this._liftStandaloneComments(rawRuleNodes as any, bodyStart, bodyEnd, loc);
-      if (hasExplicitParens) {
-        // Has explicit parens -- it's a Mixin definition
-        const guardText = guard !== undefined ? (guard as any).toTrimmedString?.() ?? '' : '';
-        const hasDefault = guardText.includes('default');
-        // Definition params: reinterpret a bare `@name` value as a param.
-        const defParams = this._convertArgsForDefinition(argsList as unknown as JessNode, loc);
-        const nonEmptyParams = (defParams as unknown as { value?: unknown[] })?.value?.length
-          ? defParams as unknown as List<Node>
-          : undefined;
-        return new Mixin(
-          { name, params: nonEmptyParams, rules: ruleNodes, guard: guard as any },
-          { hasDefault: !!hasDefault },
-          loc
-        ) as unknown as JessNode;
-      }
-      // No parens -- qualified rule (Ruleset)
-      // Extract any Extend nodes from the selector and prepend them to rules
-      const { cleanedSelector, extractedExtends } = this._extractExtendsFromSelectorText(name || '&', loc);
-      const finalRules = extractedExtends.length > 0
-        ? [...extractedExtends, ...ruleNodes]
-        : ruleNodes;
-      return new Ruleset(
-        { selector: cleanedSelector || '&', rules: finalRules, guard: guard as any },
-        undefined, loc
-      ) as unknown as JessNode;
-    }
-    // Build the rawKey ComplexSelector from the name parts (for complex paths)
-    const combinatorValues = new Set(['>', '+', '~']);
-    const selectorTokens = nameParts.filter(p => !combinatorValues.has(p.trim()) && p.trim() !== '');
-    const hasComplexPath = selectorTokens.length > 1;
-    const refKey: string | string[] = hasComplexPath ? selectorTokens : name;
-    const rawKey = hasComplexPath ? new ComplexSelector(nameParts as unknown as ComplexSelectorValue, undefined, loc) : undefined;
-    const isMixinName = name.startsWith('.') || name.startsWith('#');
-    const ref = isMixinName
-      ? new Reference(
-        { key: refKey, ...(rawKey ? { rawKey } : {}) } as unknown as ReferenceValue,
-        { type: 'mixin-ruleset', role: 'name' } as any,
-        loc
-      )
-      : new Reference(
-        { key: refKey } as unknown as ReferenceValue,
-        { type: 'function', silentFail: true, fallbackValue: true } as any,
-        loc
-      );
-    const hasArgs2 = argsList && (argsList as unknown as { value?: unknown[] }).value?.length;
-    const hasSemi = ls.some(l => l.value === ';');
-    if (hasSemi && !hasExplicitParens) {
-      this._warn('Calling a mixin without parentheses is deprecated', 'mixin-call-no-parens');
-    } else if (hasSemi && hasExplicitParens) {
-      const src = this._source.slice(loc.start, loc.end);
-      if (/^\S+\s+\(/.test(src)) {
-        this._warn('Whitespace between a mixin name and parentheses is deprecated', 'mixin-call-whitespace');
-      }
-    }
-    const callArgs = hasArgs2 ? this._convertArgsForCall(argsList, loc) : undefined;
-    return new Call(
-      { name: ref as any, args: callArgs as any },
-      { markImportant } as any, loc
-    ) as unknown as JessNode;
-  }
-
-  private _extractExtendsFromSelectorText(selectorText: string, _loc: LocationInfo) {
-    // Simple passthrough - extend extraction from selector text is handled elsewhere
-    return { cleanedSelector: selectorText, extractedExtends: [] as JessNode[] };
-  }
-
-  private _selectorHasNestedExtend(sel: JessNode | string | undefined): boolean {
-    if (!sel || typeof sel === 'string') {
-      return false;
-    }
-    if (sel.type === 'PseudoSelector') {
-      const arg = (sel as unknown as { arg?: JessNode }).arg;
-      return arg ? this._treeHasExtend(arg) : false;
-    }
-    if (sel instanceof CompoundSelector || sel instanceof ComplexSelector) {
-      return sel.value.some(p => this._selectorHasNestedExtend(p as JessNode));
-    }
-    if (isSelectorListLike(sel)) {
-      return selectorListItems(sel).some(p => this._selectorHasNestedExtend(p as JessNode));
-    }
-    return false;
-  }
-
-  private _treeHasExtend(node: JessNode): boolean {
-    if (node instanceof Extend) {
-      return true;
-    }
-    if (node instanceof CompoundSelector || node instanceof ComplexSelector) {
-      return node.value.some(p => this._treeHasExtend(p as JessNode));
-    }
-    if (isSelectorListLike(node)) {
-      return selectorListItems(node).some(p => this._treeHasExtend(p as JessNode));
-    }
-    return false;
-  }
-
-  /**
-   * A guarded ruleset (`sel when …`) is parsed by the shared CSS builder, which
-   * has no `when` concept, so the Guard CST child folds into the body as the
-   * first rule — always a Paren/Condition/DefaultGuard. Lift it into the
-   * ruleset's `guard` field (rebuilt through the canonical Ruleset ctor so the
-   * guard is adopted) so it gates output instead of rendering as a `{ true }`
-   * body. Non-guarded rulesets never begin their body with one of these node
-   * types, so the leading-node check is unambiguous.
-   */
-  private _liftRulesetGuard(base: Ruleset, loc: LocationInfo): Ruleset {
-    const rules = (base as unknown as { rules?: unknown }).rules;
-    if (!Array.isArray(rules) || rules.length === 0) {
-      return base;
-    }
-    const first = rules[0] as { type?: string } | undefined;
-    if (first?.type !== 'Paren' && first?.type !== 'Condition' && first?.type !== 'DefaultGuard') {
-      return base;
-    }
-    return new Ruleset(
-      {
-        selector: (base as unknown as { selector: any }).selector,
-        rules: rules.slice(1) as any,
-        guard: first as any
-      },
-      undefined, loc
-    ) as unknown as Ruleset;
-  }
-
-  protected override _buildRuleset(
-    children: ReadonlyArray<Child>,
-    rawChildren: ReadonlyArray<{ _tag: string }>,
-    loc: LocationInfo
-  ) {
-    let base = super._buildRuleset(children, rawChildren, loc);
-    const selector = base.selector;
-    if (!selector) {
-      return base;
-    }
-    // The shared CSS builder has no notion of `when` guards, so the Guard CST
-    // child lands as the first body rule. A guarded ruleset (`sel when …`)
-    // always emits its guard as a leading Paren/Condition/DefaultGuard; lift it
-    // into the ruleset's `guard` field so it gates output instead of rendering.
-    base = this._liftRulesetGuard(base, loc);
-    if (typeof selector === 'string') {
-      return base;
-    }
-    if (this._selectorHasNestedExtend(selector as unknown as JessNode)) {
-      this._error(':extend() is not allowed inside a pseudo-class selector', loc.start);
-    }
-    const baseRules = Array.isArray(base.rules) ? base.rules as JessNode[] : [];
-    const baseGuard = (base as unknown as { guard?: unknown }).guard;
-    const withGuard = (rs: Ruleset): Ruleset => {
-      if (baseGuard !== undefined) {
-        (rs as unknown as { guard?: unknown }).guard = baseGuard;
-      }
-      return rs;
-    };
-
-    const extendKey = (e: JessNode): string => {
-      const ext = e as unknown as { target?: { valueOf?(): unknown }; flag?: unknown };
-      return `${String(ext.target?.valueOf?.() ?? ext.target)}:${ext.flag}`;
-    };
-
-    // Non-list: simple single-selector extraction.
-    if (!isSelectorListLike(selector)) {
-      const { cleanedSelector, extractedExtends } = this._extractExtendsFromSelector(
-        selector as unknown as JessNode, loc
-      );
-      if (extractedExtends.length === 0) {
-        return base;
-      }
-      return withGuard(new Ruleset(
-        { selector: cleanedSelector as any, rules: [...extractedExtends, ...baseRules] },
-        undefined, loc
-      )) as unknown as Ruleset;
-    }
-
-    // Selector list: extract extends per selector, then decide structure.
-    const perSelector: Array<{ clean: JessNode | string | undefined; extends: JessNode[] }> = [];
-    let anyExtends = false;
-    for (const item of selectorListItems(selector)) {
-      const { cleanedSelector: cs, extractedExtends: ee } = this._extractExtendsFromSelector(
-        item as unknown as JessNode, loc
-      );
-      perSelector.push({ clean: cs, extends: ee });
-      if (ee.length > 0) {
-        anyExtends = true;
-      }
-    }
-
-    if (!anyExtends) {
-      return base;
-    }
-
-    // If all selectors share identical extend sets → flat Ruleset, deduplicated extends.
-    const allExtendKeys = perSelector.map(s => s.extends.map(extendKey).sort().join('|'));
-    const allSame = allExtendKeys.every(k => k === allExtendKeys[0]!);
-
-    if (allSame) {
-      const uniqueExtends = perSelector[0]!.extends;
-      const cleanedItems = perSelector.map(s => s.clean).filter((c): c is JessNode | string => c !== undefined);
-      const combinedSel = cleanedItems.length === 1
-        ? cleanedItems[0]!
-        : this._makeSelectorList(cleanedItems as any, loc);
-      return withGuard(new Ruleset(
-        { selector: combinedSel as any, rules: [...uniqueExtends, ...baseRules] },
-        undefined, loc
-      )) as unknown as Ruleset;
-    }
-
-    // Different extends per selector → Rules wrapper with per-selector Extend nodes.
-    const wrapperRules: JessNode[] = [];
-    const cleanedItems: (JessNode | string)[] = [];
-    for (const { clean, extends: exts } of perSelector) {
-      for (const ext of exts) {
-        const extNode = ext as unknown as { target?: unknown; flag?: unknown };
-        wrapperRules.push(new Extend(
-          {
-            target: extNode.target as any,
-            flag: extNode.flag as any,
-            selector: clean as unknown as Selector
-          },
-          {}, loc
-        ) as unknown as JessNode);
-      }
-      if (clean !== undefined) {
-        cleanedItems.push(clean);
-      }
-    }
-
-    const combinedSel = cleanedItems.length === 1
-      ? cleanedItems[0]!
-      : this._makeSelectorList(cleanedItems as any, loc);
-
-    wrapperRules.push(withGuard(new Ruleset(
-      { selector: combinedSel as any, rules: baseRules },
-      undefined, loc
-    )) as unknown as JessNode);
-
-    return new Rules(wrapperRules as any, undefined, loc) as unknown as Ruleset;
-  }
-
-  private _extractExtendsFromSelector(
-    selector: JessNode | string | undefined,
-    loc: LocationInfo
-  ): { cleanedSelector: JessNode | string | undefined; extractedExtends: JessNode[] } {
-    if (!selector || typeof selector === 'string') {
-      return { cleanedSelector: selector, extractedExtends: [] };
-    }
-
-    // CompoundSelector: extract Extend nodes from .value[]
-    if (selector instanceof CompoundSelector) {
-      const extractedExtends: JessNode[] = [];
-      const newParts: any[] = [];
-      for (const part of selector.value) {
-        if (part instanceof Extend) {
-          extractedExtends.push(part as unknown as JessNode);
-        } else if (part instanceof List) {
-          // List of Extend nodes from multi-target :extend()
-          for (const item of (part as any).value ?? []) {
-            if (item instanceof Extend) {
-              extractedExtends.push(item as unknown as JessNode);
-            } else {
-              newParts.push(item);
-            }
-          }
-        } else {
-          newParts.push(part);
-        }
-      }
-      if (extractedExtends.length === 0) {
-        return { cleanedSelector: selector, extractedExtends: [] };
-      }
-      const cleanedSelector = newParts.length === 0
-        ? '&'
-        : newParts.length === 1
-          ? newParts[0] as JessNode | string
-          : new CompoundSelector(newParts, undefined, loc) as unknown as JessNode;
-      return { cleanedSelector, extractedExtends };
-    }
-
-    // ComplexSelector: recurse into its CompoundSelector components and pull out
-    // any trailing Extend / List<Extend> (the `:extend(...)` pseudo lives at the
-    // end of the complex selector — see grammar's ComplexSelector).
-    if (selector instanceof ComplexSelector) {
-      const allExtends: JessNode[] = [];
-      const newParts: any[] = [];
-      for (const part of selector.value) {
-        if (part instanceof Extend) {
-          allExtends.push(part as unknown as JessNode);
-        } else if (part instanceof List) {
-          for (const item of (part as any).value ?? []) {
-            if (item instanceof Extend) {
-              allExtends.push(item as unknown as JessNode);
-            } else {
-              newParts.push(item);
-            }
-          }
-        } else if (part instanceof CompoundSelector) {
-          const { cleanedSelector: cs, extractedExtends: ee } = this._extractExtendsFromSelector(part as unknown as JessNode, loc);
-          allExtends.push(...ee);
-          if (cs !== undefined) {
-            newParts.push(cs);
-          }
-        } else {
-          newParts.push(part);
-        }
-      }
-      if (allExtends.length === 0) {
-        return { cleanedSelector: selector, extractedExtends: [] };
-      }
-      const newComplex = newParts.length === 1
-        ? newParts[0] as JessNode | string
-        : new ComplexSelector(newParts as any, undefined, loc) as unknown as JessNode;
-      return { cleanedSelector: newComplex, extractedExtends: allExtends };
-    }
-
-    // Selector list node or parser-delivered array.
-    if (isSelectorListLike(selector)) {
-      const allExtends: JessNode[] = [];
-      const cleanedItems: (JessNode | string)[] = [];
-      let changed = false;
-      for (const item of selectorListItems(selector)) {
-        const { cleanedSelector: cs, extractedExtends: ee } = this._extractExtendsFromSelector(
-          item as unknown as JessNode, loc
-        );
-        allExtends.push(...ee);
-        if (ee.length > 0) {
-          changed = true;
-        }
-        if (cs !== undefined) {
-          cleanedItems.push(cs);
-        }
-      }
-      if (!changed) {
-        return { cleanedSelector: selector, extractedExtends: [] };
-      }
-      const newSel = cleanedItems.length === 1
-        ? cleanedItems[0]!
-        : this._makeSelectorList(cleanedItems as any, loc);
-      return { cleanedSelector: newSel as JessNode, extractedExtends: allExtends };
-    }
-
-    return { cleanedSelector: selector, extractedExtends: [] };
-  }
-
-  // -- Import helpers --------------------------------------------------------
-
-  private static _isCssUrl(url: string, opts: string[]): boolean {
-    if (opts.includes('inline') || opts.includes('less')) {
-      return false;
-    }
-    return url.endsWith('.css') || url.startsWith('http://') || url.startsWith('https://') || url.startsWith('//');
-  }
-
-  private _buildImportAtRuleFromPrelude(
-    children: ReadonlyArray<Child>,
-    raw: ReadonlyArray<{ _tag: string }>,
-    loc: LocationInfo,
-    name: string
-  ): JessNode {
-    const preludeText = this._source.slice(loc.start, loc.end);
-    const optMatch = /^\s*\(([^)]+)\)/.exec(preludeText.replace(/^@import\s*/, ''));
-    const opts: string[] = optMatch ? optMatch[1]!.split(',').map(s => s.trim()) : [];
-    const builtNodes = nodeChildren(children);
-    // `@import url("x.css")` parses the path as a Url node, `@import "x.css"` as a
-    // Quoted. The url() wrapper is part of the serialized path — keep it as the
-    // prelude for CSS imports (and strip the whole `url(...)`, not just its inner
-    // quotes, when extracting a trailing media query).
-    const urlNode = builtNodes.find(n => n.type === 'Url') as unknown as Url | undefined;
-    const quotedNode = builtNodes.find(n => n.type === 'Quoted') as unknown as Quoted | undefined;
-    let pathNode: Quoted | undefined;
-    if (quotedNode) {
-      // Reuse the built Quoted so an interpolated path (`@import "@{theme}.less"`)
-      // keeps its Interpolated value and resolves before import resolution — flattening
-      // it to `.valueOf()` would strip the `@{…}` references.
-      pathNode = new Quoted(quotedNode.value, { quote: quotedNode.quote ?? '"' }, loc);
-    } else {
-      // Fallback: extract path from preludeText (AtRuleStatement uses scanTo leaves)
-      const _qm = preludeText.match(/(['"])([^'"]+)\1/);
-      if (_qm) {
-        const quote: '"' | '\'' = _qm[1] === '\'' ? '\'' : '"';
-        const inner = _qm[2]!;
-        const innerNode = inner;
-        pathNode = new Quoted(innerNode, { quote }, loc);
-      }
-    }
-    let mediaNode: Node | undefined;
-    {
-      // Remove @name, (options), the path (url(...) or quoted), and 'as namespace'
-      // to find a trailing media query.
-      let rest = preludeText.replace(/^@-?[_a-zA-Z][-_a-zA-Z0-9]*\s*/, '');
-      rest = rest.replace(/^\([^)]*\)\s*/, '');
-      rest = urlNode
-        ? rest.replace(/url\(\s*(['"])[^'"]*\1\s*\)\s*/i, '')
-        : rest.replace(/(['"])[^'"]*\1\s*/, '');
-      rest = rest.replace(/\bas\s+[^\s;(]+\s*/g, '');
-      rest = rest.replace(/;\s*$/, '').trim();
-      if (rest) {
-        // Parse the trailing media query as a real media prelude (feature
-        // conditions become Paren(Declaration) etc.) so it re-serializes with
-        // normalized spacing (`(min-width:600px)` → `(min-width: 600px)`),
-        // matching Less. A bare keyword tail (`screen`) round-trips unchanged.
-        mediaNode = this._buildAtRulePrelude(rest, loc) as unknown as Node;
-      }
-    }
-    const pathMatch2 = /['"]([^'"]+)['"]/.exec(preludeText);
-    const pathStr = pathMatch2 ? pathMatch2[1] : '';
-    const isCssImport = pathStr ? LessGrammar._isCssUrl(pathStr, opts) : false;
-    // `(inline)` wins over `(css)`: even `@import (inline, css) "x"` must inject
-    // the target's raw text verbatim (StyleImport inline path), never emit a
-    // passthrough CSS `@import`.
-    if (!opts.includes('inline') && (isCssImport || opts.includes('css'))) {
-      const preludeItems: JessNode[] = [];
-      const pathPrelude = (urlNode ?? pathNode) as unknown as JessNode | undefined;
-      if (pathPrelude) {
-        preludeItems.push(pathPrelude);
-      }
-      // A plain (non-Less) import can carry a trailing media-query tail, same as
-      // the StyleImport `postlude` option below — don't drop it here.
-      if (mediaNode) {
-        preludeItems.push(mediaNode as unknown as JessNode);
-      }
-      let prelude: JessNode | string;
-      if (preludeItems.length === 1) {
-        prelude = preludeItems[0]!;
-      } else {
-        const joined = preludeItems.map(item => item.toTrimmedString()).join(' ');
-        // A multi-item prelude (path + trailing media/supports/layer tail) whose
-        // parts are ALL static (no `@{…}`/`$…` interpolation) is itself a static
-        // token: wrap it in an `Any` so it carries `F_STATIC` and the spine can
-        // fold the bodyless CSS `@import` statement inline (byte-identical — `Any`
-        // re-serializes its value, its `evalNode` is a no-op). A non-static part
-        // (interpolated path/media) keeps the raw string, deferring to eval where
-        // the interpolation resolves.
-        const allStatic = preludeItems.every(item => item.structuralStaticFlag());
-        prelude = allStatic ? (new Any(joined, undefined, loc) as unknown as JessNode) : joined;
-      }
-      return new AtRuleStatement({ name, prelude }, undefined, loc) as unknown as JessNode;
-    }
-    const isForward = name === '@-export';
-    const importType: 'import' | 'compose' = isForward ? 'compose' : 'import';
-    const importOpts: Record<string, unknown> = {
-      once: !opts.includes('multiple')
-    };
-    if (opts.includes('reference')) {
-      importOpts.reference = true;
-    }
-    if (opts.includes('multiple')) {
-      importOpts.multiple = true;
-    }
-    if (opts.includes('optional')) {
-      importOpts.optional = true;
-    }
-    if (opts.includes('inline')) {
-      importOpts.inline = true;
-    }
-    if (opts.includes('less')) {
-      importOpts.type = 'less';
-    }
-    if (mediaNode) {
-      importOpts.postlude = mediaNode;
-    }
-    if (isForward) {
-      importOpts.forward = true;
-    }
-    const nsMatch2 = /\bas\s+([^\s;(]+)/.exec(preludeText);
-    const namespace = nsMatch2?.[1];
-    const styleImportOptions: Record<string, unknown> = { type: importType, importOptions: importOpts };
-    if (namespace) {
-      styleImportOptions.namespace = namespace;
-    }
-    // A Less `@import (reference) url(https://…)` with an UNQUOTED url() has no
-    // Quoted path; StyleImport accepts a Url path directly, so fall back to the
-    // parsed Url node rather than leaving `path` undefined (it later derefs
-    // `this.path.eval`).
-    const path = pathNode ?? (urlNode as unknown as JessNode | undefined);
-    return new StyleImport(
-      { path: path as any },
-      styleImportOptions as any,
-      loc
-    ) as unknown as JessNode;
-  }
-
-  protected override _buildAtRuleBlock(children: ReadonlyArray<Child>, loc: LocationInfo) {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    const nameLf = ls[0];
-    const name = nameLf?.value ?? '';
-    const IMPORT_NAMES = ['@import', '@-import', '@-export'];
-    if (IMPORT_NAMES.includes(name)) {
-      return this._buildImportAtRuleFromPrelude(children, ls as any, loc, name);
-    }
-    const USE_NAMES = ['@use', '@-use'];
-    if (USE_NAMES.includes(name)) {
-      return this._buildUseAtRuleFromPrelude(children, loc, name);
-    }
-    // Reconstruct the prelude from source between the name keyword and the `{`,
-    // so a comment authored right after the name (`@keyframes /* c */ hover`) is
-    // kept — the prelude leaf itself starts at the first non-trivia token, past
-    // that comment. A trailing comment already sits inside the leaf. Falls back
-    // to the leaf value when spans are unavailable.
-    const nameSpan = (nameLf as unknown as { span?: Span })?.span;
-    const braceLf = ls.find(l => l.value === '{');
-    const braceStart = (braceLf as unknown as { span?: Span })?.span?.start;
-    let rawPreludeText: string | undefined;
-    if (nameSpan && typeof braceStart === 'number') {
-      const sliced = this._source.slice(nameSpan.end, braceStart).trim();
-      rawPreludeText = sliced.length > 0 ? sliced : undefined;
-    } else {
-      rawPreludeText = ls.slice(1).find(l => l.value !== '{' && l.value !== '}')?.value.trim();
-    }
-    return this._buildAtRuleFromParts(name, rawPreludeText, nodeChildren(children), loc);
-  }
-
-  /**
-   * Shared AtRule assembly used by both the flat `AtRuleBlock` builder and the
-   * structured, committed `QueryAtRuleBlock` builder. `preludeText` is the raw
-   * prelude source (already `{`/`}` stripped); routing it through
-   * `_buildAtRulePrelude` keeps the emitted AST identical regardless of which
-   * grammar rule matched.
-   */
-  private _buildAtRuleFromParts(
-    name: string,
-    preludeText: string | undefined,
-    ruleNodes: JessNode[],
-    loc: LocationInfo
-  ): JessNode {
-    const isNestable = (NESTABLE_AT_RULES as readonly string[]).includes(name);
-    const nestableOpts = isNestable ? { nestable: true } : undefined;
-    const nameNode = name;
-    const prelude = preludeText ? this._buildAtRulePrelude(preludeText, loc) : undefined;
-    return new AtRule(
-      { name: nameNode as any, prelude: prelude as any, rules: ruleNodes },
-      nestableOpts, loc
-    ) as unknown as JessNode;
-  }
-
-  /**
-   * Builder for the structured, committed `@media`/`@container`/`@supports`
-   * query block. The grammar rule parses the prelude with real query structure
-   * (so a stray/unbalanced bracket is rejected instead of swallowed) and commits
-   * on `expect('{')`, but the AST is reconstructed from the prelude source text
-   * via the shared `_buildAtRuleFromParts` path — so well-formed queries emit the
-   * exact same AtRule the flat `AtRuleBlock` builder would.
-   */
-  private _buildLessQueryAtRuleBlock(children: ReadonlyArray<Child>, raw: ReadonlyArray<{ _tag: string }>, loc: LocationInfo): JessNode {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    const name = ls[0]?.value ?? '';
-    const comps = spannedComponents(raw);
-    const keywordEnd = comps[0]?.span.end ?? loc.start;
-    const braceComp = comps.find(c => c.comp === '{');
-    const braceStart = braceComp?.span.start ?? loc.end;
-    const preludeText = this._source.slice(keywordEnd, braceStart).trim();
-    // `g.queryPrelude` parses the prelude into real node children (e.g. the
-    // `(max-width: 600px)` Paren), so `children` holds BOTH prelude nodes and
-    // body nodes. The prelude is reconstructed from source text above; the body
-    // is only the nodes that begin after the opening brace.
-    const bodyNodes = comps
-      .filter((c): c is Spanned & { comp: JessNode } => typeof c.comp !== 'string' && c.span.start >= braceStart)
-      .map(c => c.comp);
-    return this._buildAtRuleFromParts(name, preludeText || undefined, bodyNodes, loc);
-  }
-
-  private _buildAtRulePrelude(text: string, loc: LocationInfo): JessNode {
-    const singleVarRe = /^@(-?[_a-zA-Z\x80-￿][-_a-zA-Z0-9\x80-￿]*)$/;
-    const MEDIA_KEYWORDS = new Set(['and', 'or', 'not', 'only', 'all', 'print', 'screen', 'speech']);
-    const COMPARISON_OPS = new Set(['>', '<', '>=', '<=', '=', '!=']);
-
-    // `~"screen"` / `~'screen'` — an escaped string standing in for the whole
-    // query (lessMediaQueryFromString in the reference). Mirrors
-    // `_buildEscapedValue`: a Quoted with `escaped: true` so eval unwraps it to
-    // the literal content instead of quoted CSS.
-    const escapedStrRe = /^~(['"])([\s\S]*)\1$/;
-    const buildWord = (w: string): JessNode => {
-      const es = escapedStrRe.exec(w);
-      if (es) {
-        return this._buildEscapedQuoted(es[2]!, es[1] as '\'' | '"', loc);
-      }
-      const mv = singleVarRe.exec(w);
-      if (mv) {
-        return new Reference(mv[1]!, { type: 'index' as const, role: 'ident' as const }, loc) as unknown as JessNode;
-      }
-      if (MEDIA_KEYWORDS.has(w.toLowerCase())) {
-        return this._lessKeyword(w, loc) as unknown as JessNode;
-      }
-      if (COMPARISON_OPS.has(w)) {
-        return w as unknown as JessNode;
-      }
-      return this._lessKeyword(w, loc) as unknown as JessNode;
-    };
-
-    // `@var[key]` accessor in value position → Reference(target=Reference(var), key).
-    // (Authoritative accessor shape: lookupOrCall in productions/guards.ts; mirrors
-    // the top-level `varAccRe` branch in buildItem below.)
-    const varAccRe = /^@(-?[_a-zA-Z\x80-￿][-_a-zA-Z0-9\x80-￿]*)\[([^\]]*)\]$/;
-    const buildAccessor = (varName: string, accInner: string): JessNode => {
-      const varBase = new Reference(
-        { key: varName } as unknown as ReferenceValue, {}, loc
-      ) as unknown as JessNode;
-      const inner = accInner.trim();
-      let accKey: JessNode | string | number;
-      let accType: 'variable' | 'index';
-      if (inner === '') {
-        accKey = -1;
-        accType = 'index';
-      } else if (inner.startsWith('@')) {
-        accKey = inner.slice(1);
-        accType = 'variable';
-      } else {
-        accKey = new Quoted(inner, {}, loc) as unknown as JessNode;
-        accType = 'index';
-      }
-      return new Reference(
-        { target: varBase as any, key: accKey as any } as unknown as ReferenceValue,
-        { type: accType }, loc
-      ) as unknown as JessNode;
-    };
-
-    // Operator token in a prelude math expression (`(@some-var + 1)`). Kept simple:
-    // a `+ - * /` surrounded by whitespace (bare `-`/`+` glued to a following number
-    // is a signed operand, not a binary op — matches the value grammar's sumOp gate).
-    const prodOps = new Set(['*', '/']);
-    const buildFeatureValue = (raw: string): JessNode => {
-      const propVal = raw.trim();
-      // `~"…"` escaped string, bare `@var`, or `@var[key]` accessor.
-      if (escapedStrRe.test(propVal) || singleVarRe.test(propVal)) {
-        return buildWord(propVal);
-      }
-      const vam = varAccRe.exec(propVal);
-      if (vam) {
-        return buildAccessor(vam[1]!, vam[2] ?? '');
-      }
-      // A parenthesized math expression `(<expr>)` — fold `left op right …` into a
-      // left-associative Operation over References/Dimensions/Nums so eval computes
-      // it (`(@some-var + 1)` → `61px`). `* /` bind tighter than `+ -`.
-      const paren = /^\(([\s\S]*)\)$/.exec(propVal);
-      if (paren) {
-        const op = buildMathExpr(paren[1]!.trim());
-        if (op) {
-          return new Expression(op as unknown as Node, { parens: true } as any, loc) as unknown as JessNode;
-        }
-      }
-      // A `<ratio>` feature value (`aspect-ratio: 3/2`) serializes with spaces
-      // around the slash (`3 / 2`) — the slash is a ratio separator, not a
-      // division to evaluate. @see https://drafts.csswg.org/css-values-4/#ratios
-      const ratio = /^(\d+(?:\.\d+)?)\s*\/\s*(\d+(?:\.\d+)?)$/.exec(propVal);
-      if (ratio) {
-        return this._lessKeyword(`${ratio[1]} / ${ratio[2]}`, loc) as unknown as JessNode;
-      }
-      return this._lessKeyword(propVal, loc) as unknown as JessNode;
-    };
-
-    // Build a left-associative Operation tree from a flat `operand op operand …`
-    // math run, honoring `* /` over `+ -` precedence. Returns undefined if the run
-    // isn't a recognizable binary expression (caller falls back to a keyword).
-    const buildMathExpr = (expr: string): JessNode | undefined => {
-      // Split on whitespace; operators must be space-separated (`@some-var + 1`).
-      const parts = expr.split(/\s+/).filter(Boolean);
-      if (parts.length < 3 || parts.length % 2 === 0) {
-        return undefined;
-      }
-      const buildOperand = (t: string): JessNode | undefined => {
-        const es = escapedStrRe.exec(t);
-        if (es) {
-          return this._buildEscapedQuoted(es[2]!, es[1] as '\'' | '"', loc);
-        }
-        const mv = singleVarRe.exec(t);
-        if (mv) {
-          return new Reference(mv[1]!, { type: 'index' as const, role: 'ident' as const }, loc) as unknown as JessNode;
-        }
-        const va = varAccRe.exec(t);
-        if (va) {
-          return buildAccessor(va[1]!, va[2] ?? '');
-        }
-        const dim = /^([+-]?(?:\d*\.\d+|\d+))([_a-zA-Z%][-_a-zA-Z0-9%]*)?$/.exec(t);
-        if (dim) {
-          return dim[2]
-            ? new Dimension({ number: parseFloat(dim[1]!), unit: dim[2]! }, undefined, loc) as unknown as JessNode
-            : new Num(parseFloat(dim[1]!), undefined, loc) as unknown as JessNode;
-        }
-        return undefined;
-      };
-      // First fold `* /`, then `+ -`, over a flat operand/operator list.
-      const nodes: Array<JessNode | string | undefined> = parts.map((p, i) =>
-        i % 2 === 0 ? buildOperand(p) : (/^[-+*/]$/.test(p) ? p : undefined));
-      if (nodes.some(n => n === undefined)) {
-        return undefined;
-      }
-      const foldPass = (matchOp: (op: string) => boolean): boolean => {
-        for (let i = 1; i < nodes.length - 1; i += 2) {
-          const op = nodes[i] as string;
-          if (matchOp(op)) {
-            const left = nodes[i - 1] as JessNode;
-            const right = nodes[i + 1] as JessNode;
-            const combined = new Operation([left, op, right] as any, undefined, loc) as unknown as JessNode;
-            nodes.splice(i - 1, 3, combined);
-            return true;
-          }
-        }
-        return false;
-      };
-      while (foldPass(op => prodOps.has(op))) { /* fold products */ }
-      while (foldPass(op => op === '+' || op === '-')) { /* fold sums */ }
-      return nodes.length === 1 ? (nodes[0] as JessNode) : undefined;
-    };
-
-    const buildParen = (inner: string): JessNode => {
-      const trimmed = inner.trim();
-      const colonIdx = trimmed.indexOf(':');
-      if (colonIdx > 0 && !/[><=!]/.test(trimmed.slice(0, colonIdx))) {
-        const propName = trimmed.slice(0, colonIdx).trim();
-        const propVal = trimmed.slice(colonIdx + 1).trim();
-        // The value may be a bare `@var` (→ indexed Reference, matching
-        // atRulePreludeBareVariableAs:'index'), a `@var[key]` accessor, a `~"…"`
-        // escaped string, or a parenthesized math expression — all evaluated so
-        // the prelude renders computed values (Less 4.x parity).
-        const valueNode = buildFeatureValue(propVal);
-        // A custom-property style query — `@container style(--responsive: true)`.
-        // Less normalizes the feature to `name: value` (single space after the
-        // colon), NOT the verbatim custom-property spacing a `Declaration` would
-        // preserve, so model it as a query condition (`--name:` keyword + value).
-        // @see https://drafts.csswg.org/css-conditional-5/#style-container
-        if (propName.startsWith('--')) {
-          const qc = new QueryCondition(
-            [this._lessKeyword(`${propName}:`, loc), valueNode] as any, undefined, loc);
-          return new Paren(qc as any, undefined, loc) as unknown as JessNode;
-        }
-        const decl = new Declaration({ name: propName as any, value: valueNode as any }, undefined, loc);
-        return new Paren(decl as any, undefined, loc) as unknown as JessNode;
-      }
-      // Normalize interior whitespace of a range/comparison query so it renders
-      // canonically regardless of author spacing: no space after `(` or before
-      // `)`, and a single space around a comparison operator even when it is
-      // glued to an operand (`( width< 500px)` → `(width < 500px)`).
-      // @see https://drafts.csswg.org/mediaqueries-5/#mq-range-context
-      const normalized = trimmed
-        .replace(/\(\s+/g, '(')
-        .replace(/\s+\)/g, ')')
-        .replace(/\s*(<=|>=|!=|[<>=])\s*/g, ' $1 ')
-        .trim();
-      const words = normalized.split(/\s+/).filter(Boolean).map(w => buildWord(w));
-      const qc = new QueryCondition(words as any, undefined, loc);
-      return new Paren(qc as any, undefined, loc) as unknown as JessNode;
-    };
-
-    const tokenize = (t: string): JessNode[] => {
-      const tokens: JessNode[] = [];
-      let i = 0;
-      while (i < t.length) {
-        if (t[i] === '(') {
-          let depth = 1;
-          let j = i + 1;
-          while (j < t.length && depth > 0) {
-            if (t[j] === '(') {
-              depth++;
-            } else if (t[j] === ')') {
-              depth--;
-            }
-            j++;
-          }
-          tokens.push(buildParen(t.slice(i + 1, j - 1)));
-          i = j;
-        } else if (t[i] === '"' || t[i] === '\'' || (t[i] === '~' && (t[i + 1] === '"' || t[i + 1] === '\''))) {
-          // A quoted (optionally `~`-escaped) run is one token, even with spaces
-          // inside — matches the outer atPrelude scan, which already treats
-          // strings as atomic.
-          const start = i;
-          if (t[i] === '~') {
-            i++;
-          }
-          const quote = t[i]!;
-          i++;
-          while (i < t.length && t[i] !== quote) {
-            i++;
-          }
-          i = Math.min(i + 1, t.length);
-          tokens.push(buildWord(t.slice(start, i)));
-        } else if (/\s/.test(t[i]!)) {
-          i++;
-        } else {
-          let j = i;
-          while (j < t.length && !/\s/.test(t[j]!) && t[j] !== '(') {
-            j++;
-          }
-          tokens.push(buildWord(t.slice(i, j)));
-          i = j;
-        }
-      }
-      return tokens;
-    };
-
-    const splitCommas = (t: string): string[] => {
-      const parts: string[] = [];
-      let depth = 0;
-      let start = 0;
-      for (let i = 0; i < t.length; i++) {
-        if (t[i] === '(') {
-          depth++;
-        } else if (t[i] === ')') {
-          depth--;
-        } else if (t[i] === ',' && depth === 0) {
-          parts.push(t.slice(start, i).trim());
-          start = i + 1;
-        }
-      }
-      parts.push(t.slice(start).trim());
-      return parts.filter(Boolean);
-    };
-
-    // Regex: namespace path (#ns.sub or #ns > .sub), optional (args), optional [accessor]
-    const nsMediaRe = /^([#.][^(\[,\s]*)(\([^)]*\))?(\[[^\]]*\])?$/;
-    const buildItem = (t: string): JessNode => {
-      const trimmed = t.trim();
-      const mv = singleVarRe.exec(trimmed);
-      if (mv) {
-        const ref = new Reference(mv[1]!, { type: 'index' as const, role: 'ident' as const }, loc) as unknown as JessNode;
-        return new QueryCondition([ref] as any, undefined, loc) as unknown as JessNode;
-      }
-      // `@var[accessor]` prelude → Expression(Reference(target=Reference(var), key))
-      // (Authoritative accessor shape: lookupOrCall in productions/guards.ts.)
-      const varAccRe = /^@(-?[_a-zA-Z\x80-￿][-_a-zA-Z0-9\x80-￿]*)(\[([^\]]*)\])$/;
-      const vam = varAccRe.exec(trimmed);
-      if (vam) {
-        const varBase = new Reference(
-          { key: vam[1]! } as unknown as ReferenceValue, {}, loc
-        ) as unknown as JessNode;
-        const accInner = (vam[3] ?? '').trim();
-        let accKey: JessNode | string | number;
-        let accType: 'variable' | 'index';
-        if (accInner === '') {
-          accKey = -1;
-          accType = 'index';
-        } else if (accInner.startsWith('@')) {
-          accKey = accInner.slice(1);
-          accType = 'variable';
-        } else {
-          accKey = new Quoted(accInner, {}, loc) as unknown as JessNode;
-          accType = 'index';
-        }
-        const acc = new Reference(
-          { target: varBase as any, key: accKey as any } as unknown as ReferenceValue,
-          { type: accType }, loc
-        ) as unknown as JessNode;
-        return new Expression(acc as unknown as Node, undefined, loc) as unknown as JessNode;
-      }
-      const nsm = nsMediaRe.exec(trimmed);
-      if (nsm) {
-        const nsPath = nsm[1]!;
-        const argsText = nsm[2];
-        const accText = nsm[3];
-        // Build namespace reference: split compound selector path into segments
-        const segments = nsPath.match(/[#.][^#.]*/g) ?? [nsPath];
-        const nameKey: string | string[] = segments.length === 1 ? segments[0]! : segments;
-        const rawKey = segments.length > 1 ? nsPath : undefined;
-        let base: JessNode = new Reference(
-          { key: nameKey, ...(rawKey ? { rawKey } : {}) } as unknown as ReferenceValue,
-          { type: 'mixin-ruleset', role: 'name' } as any, loc
-        ) as unknown as JessNode;
-        if (argsText) {
-          const argsInner = argsText.slice(1, -1).trim();
-          let argsNode: JessNode | null = null;
-          if (argsInner) {
-            // Build accessor-style arg ref if it looks like .sel[]
-            const argRefMatch = /^([.#][^\[\]()\s]+)(\[([^\]]*)\])?$/.exec(argsInner);
-            if (argRefMatch) {
-              let argBase: JessNode = new Reference(
-                { key: argRefMatch[1]! } as unknown as ReferenceValue,
-                { role: 'name' } as any, loc
-              ) as unknown as JessNode;
-              if (argRefMatch[2] !== undefined) {
-                const argAcc = argRefMatch[3] ?? '';
-                const argKey: string | number = argAcc === '' ? -1 : argAcc;
-                argBase = new Reference(
-                  { target: argBase as any, key: argKey as any } as unknown as ReferenceValue,
-                  {}, loc
-                ) as unknown as JessNode;
-              }
-              argsNode = new List([argBase as unknown as Node] as any, undefined, loc) as unknown as JessNode;
-            }
-          }
-          const callPayload: Record<string, unknown> = { name: base };
-          if (argsNode) {
-            callPayload.args = argsNode;
-          }
-          base = new Call(callPayload as any, {}, loc) as unknown as JessNode;
-        }
-        if (accText) {
-          const inner = accText.slice(1, -1).trim();
-          const key: string | number = inner.startsWith('@') ? inner.slice(1) : (inner === '' ? -1 : inner);
-          base = new Reference(
-            { target: base as any, key: key as any } as unknown as ReferenceValue,
-            { type: 'variable' as const }, loc
-          ) as unknown as JessNode;
-        }
-        return new Expression(base as unknown as Node, undefined, loc) as unknown as JessNode;
-      }
-      const tokens = tokenize(t);
-      // A leading `<container-name>` — an identifier (or `@var`) separated from
-      // the following `<container-query>` by whitespace (`@container sidebar
-      // (min-width: 700px)`) — is NOT a query function token (`size(…)`), so the
-      // serializer keeps a space before the query group instead of gluing it.
-      // @see https://drafts.csswg.org/css-conditional-5/#container-condition
-      const nameMatch = /^(@?-?[_a-zA-Z\x80-\uffff][-_a-zA-Z0-9\x80-\uffff]*)\s+(?:\(|not(?![-\w]))/i.exec(trimmed);
-      const leadingContainerName = !!nameMatch
-        && tokens.length > 1
-        && !['not', 'and', 'or', 'only'].includes(nameMatch[1]!.replace(/^@/, '').toLowerCase());
-      return new QueryCondition(
-        tokens as any,
-        leadingContainerName ? { leadingContainerName: true } : undefined,
-        loc
-      ) as unknown as JessNode;
-    };
-
-    const commaItems = splitCommas(text);
-    if (commaItems.length === 1) {
-      return buildItem(commaItems[0]!);
-    }
-    return new List(commaItems.map(buildItem) as any, undefined, loc) as unknown as JessNode;
-  }
-
-  protected _buildAtRuleStatement(children: ReadonlyArray<Child>, loc: LocationInfo): JessNode {
-    const ls = children.filter((c): c is CSTLeaf => c._tag === 'leaf');
-    const name = ls[0]?.value ?? '';
-    const IMPORT_NAMES = ['@import', '@-import', '@-export'];
-    if (IMPORT_NAMES.includes(name)) {
-      return this._buildImportAtRuleFromPrelude(children, ls as any, loc, name);
-    }
-    const USE_NAMES = ['@use', '@-use'];
-    if (USE_NAMES.includes(name)) {
-      return this._buildUseAtRuleFromPrelude(children, loc, name);
-    }
-    return super._buildAtRuleStatement(children, loc) as unknown as JessNode;
-  }
-
-  private _buildUseAtRuleFromPrelude(
-    children: ReadonlyArray<Child>,
-    loc: LocationInfo,
-    name: string
-  ): JessNode {
-    const preludeText = this._source.slice(loc.start, loc.end);
-    const builtNodes = nodeChildren(children);
-    const quotedNode = builtNodes.find(n => n.type === 'Quoted') as unknown as { quote?: '"' | '\''; value?: unknown } | undefined;
-    let rawPath = '';
-    let pathNode: Quoted | undefined;
-    if (quotedNode) {
-      const quote = quotedNode.quote ?? '"';
-      const innerVal = quotedNode.value;
-      const inner = typeof innerVal === 'string'
-        ? innerVal
-        : (innerVal as any)?.value ?? String((innerVal as any)?.valueOf?.() ?? '');
-      rawPath = inner;
-      const innerNode = inner;
-      pathNode = new Quoted(innerNode, { quote }, loc);
-    } else {
-      // Fallback: extract from preludeText (AtRuleStatement uses scanTo, not Quoted node)
-      const qm = /(['"])((?:[^'"\\]|\\.)*)\1/.exec(preludeText);
-      if (qm) {
-        const quote: '"' | '\'' = qm[1] === '\'' ? '\'' : '"';
-        const inner = qm[2]!;
-        rawPath = inner;
-        const innerNode = inner;
-        pathNode = new Quoted(innerNode, { quote }, loc);
-      }
-    }
-    const nsMatch = /\bas\s+([^\s;]+)/.exec(preludeText);
-    const explicitNs = nsMatch?.[1];
-    const isJsFile = /\.[cm]?[jt]sx?$/.test(rawPath) || rawPath.startsWith('#');
-    if (isJsFile) {
-      let ns = explicitNs;
-      if (!ns) {
-        const base = rawPath.split('/').pop() ?? '';
-        ns = base.replace(/\.[^.]+$/, '').replace(/[^a-zA-Z0-9_$]/g, '_');
-      }
-      return new JsImport(
-        { path: pathNode as any },
-        { namespace: ns },
-        loc
-      ) as unknown as JessNode;
-    }
-    // Not a JS import - build plain AtRule/AtRuleStatement
-    const nameAny = name;
-    const preludeNode: JessNode | undefined = pathNode as unknown as JessNode | undefined;
-    return new AtRule(
-      { name: nameAny as any, prelude: preludeNode as any, rules: [] },
-      undefined, loc
-    ) as unknown as JessNode;
-  }
-
-  private _parenToArgs(paren: JessNode, loc: LocationInfo): JessNode | null {
-    // Convert Paren content to List of mixin args.
-    // Handles patterns like @foo: bar (keyword args) and bare values.
-    const inner = (paren as any).value ?? (paren as any).node;
-    if (!inner) {
-      return null;
-    }
-    const items: JessNode[] = [];
-    // Inner may be a component array (e.g. [Reference, ':', 'bar']) or legacy Sequence node.
-    const isSeq = inner && typeof inner === 'object' && inner.type === 'Sequence';
-    const isRawArray = Array.isArray(inner);
-    if (isSeq || isRawArray) {
-      const rawSeq: unknown[] = isSeq ? ((inner as any).value ?? []) : (inner as unknown[]);
-      // Normalize bare strings to Keyword nodes so both the ':' / @var
-      // detection and the value-node construction below operate on real nodes.
-      const seqItems: JessNode[] = rawSeq.map(it =>
-        typeof it === 'string'
-          ? (this._lessKeyword(it.trim(), loc) as unknown as JessNode)
-          : it as JessNode);
-      // Look for @var : value patterns
-      let j = 0;
-      while (j < seqItems.length) {
-        const item = seqItems[j]!;
-        // Check for Reference (potential @foo) followed by ':' and value
-        if (
-          item.type === 'Reference'
-          && j + 2 < seqItems.length
-          && (seqItems[j + 1] as any)?.value === ':'
-        ) {
-          const varName = (item as any).key ?? '';
-          const nameAny = varName;
-          const valNode = seqItems[j + 2]!;
-          const valueNode = this._isKeywordLike(valNode)
-            ? this._lessKeyword(String((valNode as any).value ?? '').trim(), loc) as unknown as JessNode
-            : this._lessKeyword(String((valNode as any).value ?? ''), loc) as unknown as JessNode;
-          const vd = new VarDeclaration(
-            { name: nameAny as any, value: valueNode } as any,
-            {} as VarDeclarationOptions,
-            loc
-          );
-          items.push(vd as unknown as JessNode);
-          j += 3;
-        } else {
-          items.push(item);
-          j++;
-        }
-      }
-    } else if (inner && (inner as any).type === 'List') {
-      // A comma/semicolon List as the direct paren content is the ARG SEPARATOR,
-      // not a single list-valued arg: `.mixin(10px, 10px)` is two args, so spread
-      // the list's items. (The `@var(...)` path splits on comma in
-      // `_buildRefCallArgs`; this mirrors it for the namespace/mixin call path
-      // where the grammar hands us a real List node.) Space-separated content
-      // arrives as a Sequence/single node and stays one arg.
-      for (const it of ((inner as any).value ?? []) as JessNode[]) {
-        items.push(it);
-      }
-    } else if (inner) {
-      const isEmptyInner = this._isEmptyKeywordLike(inner);
-      if (!isEmptyInner) {
-        items.push(inner as JessNode);
-      }
-    }
-    if (items.length === 0) {
-      return null;
-    }
-    return new List(items as any, undefined, loc) as unknown as JessNode;
-  }
-
-  private _tryParseNamespaceRef(
-    valItems: Spanned[],
-    loc: LocationInfo
-  ): JessNode | null {
-    // Check if this looks like a namespace selector reference/call
-    // Pattern: #id or .class, optionally followed by > .mixin, [accessor], ()
-    const isSel = (s: unknown): s is string =>
-      typeof s === 'string' && /^[#.]-?[_a-zA-Z\u0080-\uffff]/.test(s.trim());
-    const isCombinator = (s: unknown): s is string =>
-      typeof s === 'string' && /^[>+~|]$|^\|\|$/.test(String(s).trim());
-    const isJessNodeVal = (x: unknown): x is JessNode =>
-      !!x && typeof x === 'object' && 'type' in x;
-
-    // Quick check: does first item look like a selector segment?
-    const first = valItems[0]?.comp;
-    const isVarRef = (x: unknown): x is JessNode =>
-      !!x && typeof x === 'object' && (x as any).type === 'Reference';
-    if (!isSel(first) && !isVarRef(first)) {
-      return null;
-    }
-    // Must have at least one SquareParen accessor when starting with a variable ref
-    if (isVarRef(first) && valItems.length < 2) {
-      return null;
-    }
-    const hasSquareAfterVar = isVarRef(first) && valItems.slice(1).some(vi =>
-      isJessNodeVal(vi.comp) && (vi.comp as any).type === 'Paren' && (vi.comp as any)._options?.delimiter === 'square'
-    );
-    if (isVarRef(first) && !hasSquareAfterVar) {
-      return null;
-    }
-
-    // Parse selector chain with interleaved calls.
-    // Each "segment ()" pair becomes a Call; subsequent "> segment" chains further.
-    // e.g.: .a() > .b() => Call(name=Ref(target=Call(name=Ref(key=.a)) key=.b))
-    // e.g.: #ns > .mixin => Ref[role=name](key=['#ns', '.mixin'])
-    let i = 0;
-    let base: JessNode | null = null;
-    // Pending segments since the last call (or since start)
-    let pendingSegments: string[] = [];
-    let hasMidCall = false; // any () seen mid-chain
-
-    const flushPendingAsRef = (): JessNode => {
-      const k: string | string[] = pendingSegments.length === 1 ? pendingSegments[0]! : pendingSegments;
-      pendingSegments = [];
-      if (base === null) {
-        return new Reference(
-          { key: k } as unknown as ReferenceValue,
-          { type: 'mixin-ruleset', role: 'name' } as any, loc
-        ) as unknown as JessNode;
-      }
-      return new Reference(
-        { target: base as any, key: k } as unknown as ReferenceValue,
-        { type: 'mixin-ruleset', role: 'name' } as any, loc
-      ) as unknown as JessNode;
-    };
-
-    while (i < valItems.length) {
-      const c = valItems[i]!.comp;
-      if (isVarRef(c) && base === null && pendingSegments.length === 0) {
-        // Variable reference node (e.g. Reference('config')) as the base.
-        // Observed: for `@config[$@prop]` the grammar emits TWO items —
-        //   1. Reference(target=Reference('config'), key=Quoted('')) — a leaked
-        //      empty-accessor wrapper, and
-        //   2. a separate `[$@prop]` SquareParen that carries the real key.
-        // Strip the empty-key wrapper so the trailing SquareParen accessor applies
-        // to Reference('config'). (Authoritative shape: lookupOrCall in productions/guards.ts.)
-        const rv = c as any;
-        const isLeakedEmptyKey = rv.target !== undefined
-          && (rv.key === '' || rv.key === undefined
-            || (rv.key && typeof rv.key === 'object'
-              && rv.key.type === 'Quoted' && !String(rv.key.value ?? '').trim()));
-        base = isLeakedEmptyKey ? rv.target as JessNode : c as JessNode;
-        i++;
-      } else if (isSel(c)) {
-        // Split compound selectors like '#ns.breakpoint' → ['#ns', '.breakpoint']
-        const seg = (c as string).trim();
-        const splitSeg = seg.match(/[#.][^#.]*/g) ?? [seg];
-        for (const s of splitSeg) {
-          pendingSegments.push(s);
-        }
-        i++;
-      } else if (isCombinator(c) && i + 1 < valItems.length && isSel(valItems[i + 1]?.comp)) {
-        // Combinator between segments — skip
-        i++;
-      } else if (isJessNodeVal(c) && (c as any).type === 'Paren' && (c as any)._options?.delimiter === 'square') {
-        // Square paren: accessor on current base
-        if (pendingSegments.length > 0) {
-          base = flushPendingAsRef();
-        }
-        if (base === null) {
-          break;
-        }
-        const innerKey = this._decodeAccessorKey(c as JessNode, loc);
-        // A numeric accessor key (`foo[2]`, or `foo[]` → last, key -1) is an
-        // INDEX lookup, not a variable lookup. Dispatching it as `variable`
-        // sends `-1` through the variable resolver and fails with `'-1' is not
-        // defined`; `index` resolves it via `rules.at(-1)` (the last value).
-        base = new Reference(
-          { target: base as any, key: innerKey as any } as unknown as ReferenceValue,
-          { type: typeof innerKey === 'number' ? 'index' as const : 'variable' as const }, loc
-        ) as unknown as JessNode;
-        i++;
-      } else if (isJessNodeVal(c) && (c as any).type === 'Paren') {
-        // Round paren: flush pending segments as Reference (if any), then wrap in Call
-        if (pendingSegments.length === 0 && base === null) {
-          break;
-        } // unexpected ()
-        if (pendingSegments.length > 0) {
-          base = flushPendingAsRef();
-        }
-        // Extract args from the Paren's inner node (may be null for empty parens)
-        const argsNode = this._parenToArgs(c as JessNode, loc);
-        const callPayload: Record<string, unknown> = { name: base as any };
-        if (argsNode) {
-          callPayload.args = argsNode;
-        }
-        base = new Call(callPayload as any, {}, loc) as unknown as JessNode;
-        hasMidCall = true;
-        i++;
-      } else {
-        break;
-      }
-    }
-
-    // Must have consumed all valItems
-    if (i !== valItems.length) {
-      return null;
-    }
-    if (pendingSegments.length === 0 && base === null) {
-      return null;
-    }
-
-    // If we still have pending segments (no trailing call), flush them
-    if (pendingSegments.length > 0) {
-      base = flushPendingAsRef();
-    }
-
-    // Check source text for (args)[accessor] AFTER the last parsed item
-    // Process in order: (args) call → [accessor] → trailing ()
-    if (valItems.length > 0) {
-      const lastSpan = valItems[valItems.length - 1]!.span;
-      let afterVal = this._source.slice(lastSpan.end).trimStart();
-
-      // Step 1: Check for a trailing call (...) when grammar didn't catch it
-      if (!hasMidCall && afterVal.startsWith('(')) {
-        const closeIdx = afterVal.indexOf(')', 1);
-        if (closeIdx > 0) {
-          const callInner = afterVal.slice(1, closeIdx).trim();
-          afterVal = afterVal.slice(closeIdx + 1).trimStart();
-          // Build args from call content if non-empty
-          let argsNode: JessNode | null = null;
-          if (callInner) {
-            // Check for .selector[accessor] pattern in call args
-            const argRefMatch = /^([.#][^\[\]()\s]+)(\[([^\]]*)\])?$/.exec(callInner);
-            if (argRefMatch) {
-              const argSel = argRefMatch[1]!;
-              const argAccContent = argRefMatch[3]; // may be undefined or empty string
-              let argBase: JessNode = new Reference(
-                { key: argSel } as unknown as ReferenceValue,
-                { role: 'name' } as any, loc
-              ) as unknown as JessNode;
-              if (argRefMatch[2] !== undefined) {
-                const argAccKey: string | number = argAccContent === undefined || argAccContent === ''
-                  ? -1
-                  : (argAccContent.startsWith('@') ? argAccContent.slice(1) : argAccContent);
-                argBase = new Reference(
-                  { target: argBase as any, key: argAccKey as any } as unknown as ReferenceValue,
-                  {}, loc
-                ) as unknown as JessNode;
-              }
-              argsNode = new List([argBase as unknown as Node] as any, undefined, loc) as unknown as JessNode;
-            }
-          }
-          const callPayload: Record<string, unknown> = { name: base as any };
-          if (argsNode) {
-            callPayload.args = argsNode;
-          }
-          base = new Call(callPayload as any, {}, loc) as unknown as JessNode;
-        }
-      }
-
-      // Step 2: Check for [accessor] suffix
-      const accMatch = /^\[([^\]]*)\]/.exec(afterVal);
-      if (accMatch) {
-        const accText = accMatch[1]!.trim();
-        let accessorKey: JessNode | string | number;
-        if (accText === '') {
-          accessorKey = -1;
-        } else if (accText.startsWith('@')) {
-          accessorKey = accText.slice(1);
-        } else {
-          accessorKey = new Quoted(accText, {}, loc) as unknown as JessNode;
-        }
-        base = new Reference(
-          { target: base as any, key: accessorKey as any } as unknown as ReferenceValue,
-          {}, loc
-        ) as unknown as JessNode;
-        const afterAcc = afterVal.slice(accMatch[0].length).trimStart();
-        if (/^\(\s*\)/.test(afterAcc)) {
-          base = new Call({ name: base as any } as any, {}, loc) as unknown as JessNode;
-        }
-      } else if (!hasMidCall) {
-        // Step 3: Check for trailing () (simple empty call)
-        const callMatch = /^\(\s*\)/.exec(afterVal);
-        if (callMatch) {
-          base = new Call({ name: base as any } as any, {}, loc) as unknown as JessNode;
-        }
-      }
-    }
-
-    return base;
-  }
-
-  private _assembleLessValue(
-    valItems: Spanned[],
-    loc: LocationInfo
-  ): { value: JessNode | string } {
-    const parts: JessNode[] = [];
-    for (const item of valItems) {
-      const c = item.comp;
-      if (typeof c === 'string') {
-        if (c.trim()) {
-          parts.push(this._lessKeyword(c.trim(), loc) as unknown as JessNode);
-        }
-      } else {
-        parts.push(c as JessNode);
-      }
-    }
-    if (parts.length === 0) {
-      return { value: '' };
-    }
-    if (parts.length === 1) {
-      return { value: parts[0]! };
-    }
-    return { value: parts as unknown as JessNode };
-  }
-
-  /* eslint-enable @typescript-eslint/no-unsafe-type-assertion */
-}