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

package/src/productions/selectors.ts

@@ -0,0 +1,1309 @@
+/* eslint-disable -- Retired Chevrotain parser; not linted (see @ts-nocheck below). */
+// @ts-nocheck — Retired Chevrotain parser. Uses the legacy 6-tuple `.location`
+// shape removed from Node in the provenance-side-table refactor; the functional
+// Parséman grammar (grammar-rules.ts + builders.ts) is the maintained parser.
+// Not type-checked.
+// Selector-related production rules for LessRecursiveParser
+// Converted from Chevrotain-based productions.ts lines 1145-2060
+
+import type { RuleContext, ExtendTarget, TokenMap } from '../lessRecursiveParser.js';
+import type { IToken, IOrAlt } from 'chevrotain';
+import {
+  Node,
+  Ampersand,
+  Block,
+  Any,
+  type LocationInfo,
+  type TreeContext,
+  BasicSelector,
+  Combinator,
+  type Combinators,
+  List,
+  Sequence,
+  Call,
+  Quoted,
+  AtRule,
+  AtRuleStatement,
+  Interpolated,
+  InterpolatedSelector,
+  AttributeSelector,
+  Reference,
+  Extend,
+  Mixin,
+  VarDeclaration,
+  Declaration,
+  Expression,
+  SelectorCapture,
+  ComplexSelector,
+  CompoundSelector,
+  Selector,
+  SelectorList,
+  Url,
+  Nil,
+  Collection,
+  type ComplexSelectorValue,
+  type ComplexSelectorComponent,
+  type SimpleSelector,
+  isNode,
+  N,
+  StyleImport
+} from '@jesscss/core';
+
+import { createInterpolatedReference, getInterpolatedNode, getInterpolatedOrString } from '../utils.js';
+import { all } from 'known-css-properties';
+
+/** Use `any` for `this` to avoid structural incompatibility between LessRecursiveParser and CssRecursiveParser */
+type P = any;
+type Alt = IOrAlt<any>[];
+type AltContext = (ctx?: RuleContext) => Alt;
+type ProductionRule = (...args: any[]) => any;
+const COMBINATORS = new Set<string>([' ', '>', '+', '~', '|', '||']);
+
+function toCombinator(image: string): Combinators {
+  if (COMBINATORS.has(image)) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return image as Combinators;
+  }
+  throw new Error(`Unexpected selector combinator "${image}".`);
+}
+
+type ComplexSelectorComponentNode = Exclude<ComplexSelectorComponent, string>;
+
+function isComplexSelectorComponentNode(node: Node | undefined): node is ComplexSelectorComponentNode {
+  return node instanceof Call
+    || (node instanceof Selector
+      && !(node instanceof SelectorList)
+      && !(node instanceof ComplexSelector));
+}
+
+export function attributeSelector(this: P, T: TokenMap, valueAlt?: AltContext) {
+  const $ = this;
+
+  valueAlt ??= () => [
+    {
+      GATE: () => !$.isType(T.InterpolatedIdent),
+      ALT: () => {
+        const token = $.CONSUME5(T.Ident);
+        if ($.RECORDING_PHASE) {
+          return;
+        }
+        return new Any(token.image, { role: 'ident' }, $.getLocationInfo(token), $.context);
+      }
+    },
+    {
+      GATE: () => $.isType(T.InterpolatedIdent),
+      ALT: () => {
+        const token = $.CONSUME(T.InterpolatedIdent);
+        if ($.RECORDING_PHASE) {
+          return;
+        }
+        const match = /([$@])\{([^}]+)\}/.exec(token.image);
+        if (match && match[0] === token.image) {
+          return createInterpolatedReference(
+            match[1]!,
+            match[2]!,
+            $.getLocationInfo(token),
+            $.context
+          );
+        }
+        const result = getInterpolatedOrString(token.image, $.getLocationInfo(token), $.context);
+        return typeof result === 'string'
+          ? new Any(result, { role: 'ident' }, $.getLocationInfo(token), $.context)
+          : result;
+      }
+    },
+    { ALT: () => $.SUBRULE($.string) }
+  ];
+
+  return (ctx: RuleContext = {}) => {
+    const RECORDING_PHASE = $.RECORDING_PHASE;
+    $.startRule();
+
+    $.CONSUME2(T.LSquare);
+    const key: Any = $.SUBRULE2($.attributeName);
+    let op: IToken | undefined;
+    let value: Node | undefined;
+    let mod: IToken | undefined;
+    $.OPTION(() => {
+      op = $.OR([
+        { ALT: () => $.CONSUME4(T.Eq) },
+        { ALT: () => $.CONSUME6(T.AttrMatch) }
+      ]);
+      value = $.OR2(valueAlt!(ctx));
+    });
+    $.OPTION2(() => mod = $.CONSUME7(T.AttrFlag));
+    $.CONSUME8(T.RSquare);
+
+    if (!RECORDING_PHASE) {
+      const location = $.endRule();
+      return new AttributeSelector({
+        name: key.valueOf(),
+        op: op?.image,
+        value,
+        mod: mod?.image
+      }, undefined, location, $.context);
+    }
+  };
+}
+
+// ── Helper: getAmpersandTemplateValue ────────────────────────────────
+
+function getAmpersandTemplateValue(image: string): string | undefined {
+  if (image === '&') {
+    return undefined;
+  }
+  if (image.startsWith('&')) {
+    return image.slice(1) || undefined;
+  }
+  if (image.includes('&')) {
+    return image;
+  }
+  return undefined;
+}
+
+// ── Helper: wrapOuterExpressionIfNeeded ──────────────────────────────
+// Imported from root.ts where it's defined.
+import { wrapOuterExpressionIfNeeded } from './root.js';
+
+// ── Helper: groupExtendsByTargetAndFlag ──────────────────────────────
+
+const { isArray } = Array;
+type ExtendSelectorKind = 'simple' | 'basic' | 'pseudo' | 'complex' | 'compound';
+
+function getAllowedExtendSelectors(context: TreeContext): ExtendSelectorKind[] | undefined {
+  const val: ExtendSelectorKind[] | undefined = context.opts.allowExtendSelectors;
+  return val;
+}
+
+function findDisallowedExtendSelector(selector: Selector | string, allowed?: readonly ExtendSelectorKind[]): { kind: ExtendSelectorKind; selector: Selector } | undefined {
+  // A bare-string selector (strings-not-nodes) is a plain simple selector — not a
+  // disallowed extend target.
+  if (typeof selector === 'string') {
+    return undefined;
+  }
+  if (!allowed) {
+    return undefined;
+  }
+  if (isNode(selector, N.SelectorList)) {
+    for (const item of selector.value) {
+      const disallowed = findDisallowedExtendSelector(item, allowed);
+      if (disallowed) {
+        return disallowed;
+      }
+    }
+    return undefined;
+  }
+  const kinds: ExtendSelectorKind[] = isNode(selector, N.BasicSelector)
+    ? ['simple', 'basic']
+    : isNode(selector, N.PseudoSelector)
+      ? ['simple', 'pseudo']
+      : isNode(selector, N.CompoundSelector)
+        ? ['compound']
+        : isNode(selector, N.ComplexSelector)
+          ? ['complex']
+          : ['simple'];
+  if (kinds.some(kind => allowed.includes(kind))) {
+    return undefined;
+  }
+  return {
+    kind: kinds[0]!,
+    selector
+  };
+}
+
+function formatAllowedExtendSelectors(allowed: readonly ExtendSelectorKind[]) {
+  if (allowed.length === 0) {
+    return 'no selector kinds';
+  }
+  if (allowed.length === 1) {
+    return `${allowed[0]} value`;
+  }
+  const head = allowed.slice(0, -1).join(', ');
+  return `${head}, or ${allowed[allowed.length - 1]} value`;
+}
+
+function validateExtendTarget($: P, selector: Selector, source: ':extend()' | '&:extend()') {
+  const allowed = getAllowedExtendSelectors($.context);
+  const disallowed = findDisallowedExtendSelector(selector, allowed);
+  if (!disallowed || !allowed) {
+    return;
+  }
+  throw new Error(
+    `${source} only allows ${formatAllowedExtendSelectors(allowed)}, but found ${disallowed.kind} selector "${disallowed.selector.valueOf()}".`
+  );
+}
+
+/**
+ * Groups extends by target (using valueOf()) and flag.
+ * Returns an array of grouped Extend nodes where extends with the same target and flag
+ * are combined into a single Extend node with a SelectorList of all matching value.
+ *
+ * @todo Group complex value into selector lists
+ */
+function groupExtendsByTargetAndFlag(
+  extendNodes: Extend[]
+): Array<Extend | Extend[]> {
+  // Group extends by target and flag
+  const groups = new Map<string, Extend | Extend[]>();
+
+  for (const ext of extendNodes) {
+    const { target, flag = 1 } = ext; // ExtendFlag.Exact = 1
+    // Create a key from target valueOf() and flag
+    const key = `${target.valueOf()}|${flag}`;
+
+    let group = groups.get(key);
+    if (!group) {
+      groups.set(key, ext);
+    } else if (isArray(group)) {
+      group.push(ext);
+    } else {
+      groups.set(key, [group, ext]);
+    }
+  }
+
+  return Array.from(groups.values());
+}
+
+// ── Helper: mergeExtends ─────────────────────────────────────────────
+
+function mergeExtends(
+  selector: Selector | undefined,
+  extendTargets: ExtendTarget[],
+  location: LocationInfo,
+  context: TreeContext,
+  flag: IToken | undefined
+): Extend | Extend[] {
+  let extendNodes: Extend[] | undefined;
+  let currentTarget = extendTargets[0]!.target;
+  let currentFlag = (extendTargets[0]!.flag ?? flag) ? 0 : 1; // ExtendFlag.All = 0, ExtendFlag.Exact = 1
+  let currentNode = new Extend({
+    selector,
+    target: currentTarget,
+    flag: currentFlag
+  }, undefined, location, context);
+  const flushCurrent = (): void => {
+    (extendNodes ??= []).push(currentNode);
+  };
+  for (let i = 1; i < extendTargets.length; i++) {
+    let ext = extendTargets[i]!;
+    let thisFlag = (ext.flag ?? flag) ? 0 : 1;
+    /**
+     * Merge extends. We do this instead of merging earlier so that
+     * selector lists with different flags are not merged.
+     */
+    if (thisFlag === currentFlag) {
+      const { target } = currentNode;
+      let nextTarget: Selector;
+      if (!(target instanceof SelectorList)) {
+        nextTarget = new SelectorList([target, ext.target], undefined, location, context);
+      } else {
+        nextTarget = new SelectorList([...target.value, ext.target], undefined, location, context);
+      }
+      currentNode = new Extend({
+        selector,
+        target: nextTarget,
+        flag: currentFlag
+      }, undefined, location, context);
+    } else {
+      flushCurrent();
+      currentFlag = thisFlag;
+      currentTarget = ext.target;
+      currentNode = new Extend({
+        selector,
+        target: currentTarget,
+        flag: currentFlag
+      }, undefined, location, context);
+    }
+  };
+  if (!extendNodes) {
+    return currentNode;
+  }
+  flushCurrent();
+  if (extendNodes.length === 1) {
+    return extendNodes[0]!;
+  }
+  return extendNodes;
+}
+
+function extendWithSelector(node: Extend, selector: Selector | undefined, location: LocationInfo | undefined, context: TreeContext): Extend {
+  return new Extend({
+    selector,
+    target: node.target,
+    namespace: node.namespace,
+    flag: node.flag
+  }, undefined, location, context);
+}
+
+// ── Helper: isSelectorLikeListItem / isLegacySelectorLikeValue ───────
+
+/** True for a node that could be one item in the old unquoted selector list (e.g. .a or #id). */
+function isSelectorLikeListItem(node: Node): boolean {
+  if (node.type === 'SelectorCapture' || isNode(node, N.Call)) {
+    return false;
+  }
+  if (isNode(node, N.Reference)) {
+    return node.options.type === 'mixin-ruleset';
+  }
+  if (node instanceof List) {
+    return node.value.length > 0 && node.value.every(isSelectorLikeListItem);
+  }
+  if (node instanceof Sequence) {
+    return node.value.length > 0 && node.value.every(isSelectorLikeListItem);
+  }
+  return false;
+}
+
+/** True only for the legacy unquoted selector-list form (e.g. @var: .a, .b, .c), not @var: .a; */
+function isLegacySelectorLikeValue(node: Node): boolean {
+  if (node.type === 'SelectorCapture' || isNode(node, N.Call)) {
+    return false;
+  }
+  if (isNode(node, N.Reference)) {
+    return false;
+  }
+  if (node instanceof List) {
+    return node.value.length > 1 && node.value.every(isSelectorLikeListItem);
+  }
+  if (node instanceof Sequence) {
+    return node.value.length > 1 && node.value.every(isSelectorLikeListItem);
+  }
+  return false;
+}
+
+// ══════════════════════════════════════════════════════════════════════
+// PRODUCTION RULES
+// ══════════════════════════════════════════════════════════════════════
+
+/**
+ * We need to now handle a returned `Extend` node from the complexSelector rule
+ */
+export function relativeSelector(this: P, T: TokenMap) {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    return $.OR([
+      {
+        ALT: () => {
+          let co = $.CONSUME(T.Combinator);
+          let node: ComplexSelector | Extend = $.SUBRULE2($.complexSelector, { ARGS: [ctx] });
+          if ($.RECORDING_PHASE) {
+            return node;
+          }
+
+          let combinator = new Combinator(toCombinator(co.image), undefined, $.getLocationInfo(co), $.context);
+          let targetNode =
+            node instanceof Extend
+              ? node.selector
+              : node;
+          if (targetNode instanceof ComplexSelector) {
+            const nodes = [combinator, ...targetNode.value] as ComplexSelectorValue;
+            const complex = new ComplexSelector(nodes, undefined, $.getLocationFromNodes(nodes), $.context);
+            if (node instanceof Extend) {
+              const location = node.location.length === 6
+                ? ([...node.location] as LocationInfo)
+                : undefined;
+              if (location) {
+                location[0] = co.startOffset!;
+                location[1] = co.startLine!;
+                location[2] = co.startColumn!;
+              }
+              node = extendWithSelector(node, complex, location, $.context);
+            } else {
+              node = complex;
+            }
+          } else {
+            if (!isComplexSelectorComponentNode(targetNode)) {
+              const targetType = typeof targetNode === 'string' ? 'string' : (targetNode as Node | undefined)?.type ?? 'none';
+              throw new Error(`Expected selector component after relative combinator; got ${targetType}.`);
+            }
+            let nodes = [combinator, targetNode];
+            let complex = new ComplexSelector(nodes, undefined, $.getLocationFromNodes(nodes), $.context);
+            if (node instanceof Extend) {
+              const location = node.location.length === 6
+                ? ([...node.location] as LocationInfo)
+                : undefined;
+              if (location) {
+                location[0] = co.startOffset!;
+                location[1] = co.startLine!;
+                location[2] = co.startColumn!;
+              }
+              node = extendWithSelector(node, complex, location, $.context);
+            } else {
+              node = complex;
+            }
+          }
+          return node;
+        }
+      },
+      {
+        ALT: () => $.SUBRULE3($.complexSelector, { ARGS: [ctx] })
+      }
+    ]);
+  };
+}
+
+export function forgivingSelectorList(this: P, T: TokenMap) {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    const RECORDING_PHASE = $.RECORDING_PHASE;
+    $.startRule();
+
+    let sequences: ComplexSelector[] | undefined;
+    let i = 0;
+
+    if (!RECORDING_PHASE) {
+      sequences = [];
+    }
+
+    $.AT_LEAST_ONE_SEP({
+      SEP: T.Comma,
+      DEF: () => {
+        const selector = $.SUBRULE($.relativeSelector, { ARGS: [ctx] });
+        if (!RECORDING_PHASE) {
+          i++;
+          if (i === 1 && ctx.qualifiedRule) {
+            sequences!.push(selector);
+          } else {
+            sequences!.push(selector);
+          }
+        }
+      }
+    });
+
+    if (RECORDING_PHASE) {
+      return;
+    }
+    const location = $.endRule();
+    if (sequences!.length === 1) {
+      return sequences![0];
+    }
+    return new SelectorList(sequences!, undefined, location, $.context);
+  };
+}
+
+export function selectorList(this: P, T: TokenMap) {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    const RECORDING_PHASE = $.RECORDING_PHASE;
+    $.startRule();
+
+    let sequences: ComplexSelector[] | undefined;
+    let i = 0;
+
+    if (!RECORDING_PHASE) {
+      sequences = [];
+    }
+
+    $.AT_LEAST_ONE_SEP({
+      SEP: T.Comma,
+      DEF: () => {
+        const selector = $.SUBRULE2($.complexSelector, { ARGS: [ctx] });
+        if (!RECORDING_PHASE) {
+          i++;
+          if (i === 1 && ctx.qualifiedRule) {
+            sequences!.push(selector);
+          } else {
+            sequences!.push(selector);
+          }
+        }
+      }
+    });
+
+    if (RECORDING_PHASE) {
+      return;
+    }
+    const location = $.endRule();
+    if (sequences!.length === 1) {
+      return sequences![0];
+    }
+    return new SelectorList(sequences!, undefined, location, $.context);
+  };
+}
+
+export function compoundSelector(this: P, T: TokenMap): ProductionRule {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    /**
+        A sequence of simple value that are not separated by
+        a combinator.
+          .e.g. `a#selected`
+      */
+    // compoundSelector
+    //   : simpleSelector+
+    //   ;
+    let RECORDING_PHASE = $.RECORDING_PHASE;
+    let value: SimpleSelector[];
+    if (!RECORDING_PHASE) {
+      value = [];
+    }
+    let sel: SimpleSelector = $.SUBRULE($.simpleSelector, { ARGS: [ctx] });
+    if (!RECORDING_PHASE) {
+      value!.push(sel);
+    }
+    $.MANY({
+      /** Make sure we don't ignore space combinators */
+      GATE: () => !$.hasWS() && !(ctx.inExtend && $.isType(T.All)),
+      DEF: () => {
+        let sel: SimpleSelector = $.SUBRULE2($.simpleSelector, { ARGS: [ctx] });
+        if (!RECORDING_PHASE) {
+          value!.push(sel);
+        }
+      }
+    });
+    if (RECORDING_PHASE) {
+      return;
+    }
+    if (value!.length === 1) {
+      return value![0]!;
+    }
+    return new CompoundSelector(value!, undefined, $.getLocationFromNodes(value!), $.context);
+  };
+}
+
+/**
+ * Extended with :extend
+ */
+export function complexSelector(this: P, T: TokenMap): ProductionRule {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    const RECORDING_PHASE = $.RECORDING_PHASE;
+    $.startRule();
+
+    let value: ComplexSelectorValue | undefined;
+    if (!RECORDING_PHASE) {
+      const first: ComplexSelectorComponent = $.SUBRULE($.compoundSelector, { ARGS: [ctx] });
+      value = [first];
+    } else {
+      $.SUBRULE($.compoundSelector, { ARGS: [ctx] });
+    }
+
+    $.MANY({
+      GATE: () => {
+        if (ctx.inExtend && $.isType(T.All)) {
+          return false;
+        }
+        return $.hasWS() || $.isType(T.Combinator);
+      },
+      DEF: () => {
+        let co: IToken | undefined;
+        let combinator: Combinator | undefined;
+
+        $.OPTION(() => {
+          co = $.CONSUME(T.Combinator);
+        });
+
+        if (!RECORDING_PHASE) {
+          if (co) {
+            const coImg = toCombinator(co.image);
+            combinator = new Combinator(coImg, undefined, $.getLocationInfo(co), $.context);
+          } else {
+            const ws = $.claimSpaceCombinator($.LA(1).startOffset);
+            combinator = new Combinator(' ', undefined, ws ? $.getLocationInfo(ws) : undefined, $.context);
+          }
+        }
+
+        const compound: ComplexSelectorComponent = $.SUBRULE2($.compoundSelector, { ARGS: [ctx] });
+        if (!RECORDING_PHASE) {
+          value!.push(combinator!, compound);
+        }
+      }
+    });
+
+    let selector: Selector | undefined;
+    if (!RECORDING_PHASE) {
+      const location = $.endRule();
+      selector = value!.length === 1
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        ? value![0] as Selector | undefined
+        : new ComplexSelector(value!, undefined, location, $.context);
+    }
+
+    let flag: IToken | undefined;
+
+    /** Inside :extend(...), only consume the optional trailing "all" keyword. */
+    $.OPTION2({
+      GATE: () => !!ctx.inExtend && $.isType(T.All),
+      DEF: () => {
+        flag = $.CONSUME(T.All);
+      }
+    });
+
+    /**
+     * Outside :extend(...), only enter the extend production when the next token
+     * is actually :extend(. Do not commit based on context alone.
+     */
+    $.OPTION3({
+      GATE: () => !ctx.inExtend && !!ctx.qualifiedRule && $.isType(T.Extend),
+      DEF: () => {
+        const initialSelector = ctx.selector;
+        if (!RECORDING_PHASE) {
+          ctx.selector = selector;
+        }
+        try {
+          $.SUBRULE($.extend, { ARGS: [ctx] });
+        } finally {
+          ctx.selector = initialSelector;
+        }
+      }
+    });
+
+    if (ctx.inExtend) {
+      validateExtendTarget($, selector!, ':extend()');
+      (ctx.extendTargets ??= []).push({ selector: ctx.selector, target: selector!, flag });
+    }
+
+    return selector;
+  };
+}
+
+/**
+ * &:extend(...) statement ending with a semicolon.
+ * This is the only valid standalone extend statement in Less.
+ */
+export function ampersandExtend(this: P, T: TokenMap) {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    $.startRule();
+
+    $.CONSUME(T.Ampersand);
+    $.CONSUME(T.Extend);
+    ctx.inExtend = true;
+    $.SUBRULE($.selectorList, { ARGS: [ctx] });
+    ctx.inExtend = false;
+    let extendTargets = ctx.extendTargets!;
+    let flag = $.OPTION(() => $.CONSUME(T.AllFlag));
+    $.CONSUME(T.RParen);
+    $.CONSUME(T.Semi);
+
+    let location = $.endRule();
+    if (!$.RECORDING_PHASE) {
+      let result = mergeExtends(undefined, extendTargets, location, $.context, flag);
+      /** We've converted these extend targets to nodes, so we can reset extend targets */
+      ctx.extendTargets = undefined;
+      if (ctx.extendNodes) {
+        if (isArray(result)) {
+          ctx.extendNodes = [...ctx.extendNodes, ...result];
+        } else {
+          ctx.extendNodes.push(result);
+        }
+      } else {
+        if (isArray(result)) {
+          ctx.extendNodes = result;
+        } else {
+          ctx.extendNodes = [result];
+        }
+      }
+      // Return Nil instead of the extend node - extends are handled via ctx.extendNodes
+      // pathway to avoid duplicates (cssMain collects returned nodes into rules.rules).
+      // Nil is needed because undefined confuses cssMain (treats it as semicolon).
+      return new Nil(undefined, undefined, location, $.context);
+    }
+  };
+}
+
+export function extend(this: P, T: TokenMap) {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    $.startRule();
+    $.CONSUME(T.Extend);
+
+    ctx.inExtend = true;
+    $.SUBRULE($.selectorList, { ARGS: [ctx] });
+    let extendTargets = ctx.extendTargets;
+    ctx.inExtend = false;
+
+    let selector = ctx.selector;
+    let flag = $.OPTION(() => $.CONSUME(T.AllFlag));
+    $.CONSUME(T.RParen);
+
+    let location = $.endRule();
+    if (!$.RECORDING_PHASE) {
+      // When .c:extend(...) is parsed, selector is .c
+      // The extend will be processed in qualifiedRuleBody where selector: undefined is set
+      // for extends that stay inside the ruleset (not bubbled)
+      // Bubbled extends keep their selector and get it set correctly in qualifiedRule
+      let merged = mergeExtends(selector, extendTargets!, location, $.context, flag);
+      /**
+       * If we don't have as many extends as we have value, we need a way to signal
+       * that these should be bumped above the ruleset.
+       */
+      /** We've converted these extend targets to nodes, so we can reset extend targets */
+      ctx.extendTargets = undefined;
+      if (ctx.extendNodes) {
+        if (isArray(merged)) {
+          ctx.extendNodes = [...ctx.extendNodes, ...merged];
+        } else {
+          ctx.extendNodes.push(merged);
+        }
+      } else {
+        if (isArray(merged)) {
+          ctx.extendNodes = merged;
+        } else {
+          ctx.extendNodes = [merged];
+        }
+      }
+    }
+  };
+}
+
+export function simpleSelector(this: P, T: TokenMap): ProductionRule {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    let selectorAlt: Alt = [
+      {
+        GATE: () => (
+          (!ctx.inExtend || $.LA(1).tokenType !== T.All)
+          && $.LA(1).tokenType !== T.InterpolatedIdent
+        ),
+        /**
+         * In Less/Sass (and now CSS), the first inner selector can be an identifier
+         */
+        ALT: () => $.CONSUME(T.Ident)
+      },
+      {
+        /**
+         * Unlike CSS Nesting, Less allows outer qualified rules
+         * to have `&`, and it is just silently absorbed if there
+         * is no parent selector.
+         */
+        ALT: () => {
+          let amp = $.CONSUME(T.Ampersand);
+          const value = getAmpersandTemplateValue(amp.image);
+          return new Ampersand({ appendValue: value }, undefined, $.getLocationInfo(amp), $.context);
+        }
+      },
+      {
+        ALT: () => {
+          $.startRule();
+          $.CONSUME(T.AmpersandLParen);
+          const parts: string[] = [];
+          let sawQuoted = false;
+          $.MANY(() => {
+            $.OR2([
+              {
+                GATE: () => $.isType(T.QuoteStart),
+                ALT: () => {
+                  const quoted: Quoted = $.SUBRULE($.string, { ARGS: [ctx] });
+                  parts.push(quoted.valueOf());
+                  sawQuoted = true;
+                }
+              },
+              {
+                GATE: () => $.isType(T.WS),
+                ALT: () => {
+                  parts.push($.CONSUME(T.WS).image);
+                }
+              },
+              {
+                ALT: () => {
+                  parts.push($.CONSUME(T.AmpersandTemplateContents).image);
+                }
+              }
+            ]);
+          });
+          $.CONSUME(T.AmpersandTemplateEnd);
+          const location = $.endRule();
+          const value = parts.join('');
+          const appendValue = sawQuoted && value === ''
+            ? ''
+            : value === 'nil'
+              ? ''
+              : value;
+          return new Ampersand({ appendValue }, undefined, location, $.context);
+        }
+      },
+      { ALT: () => $.CONSUME(T.InterpolatedIdent) },
+      { ALT: () => $.CONSUME(T.InterpolatedSelector) },
+      { ALT: () => $.SUBRULE($.classSelector, { ARGS: [ctx] }) },
+      { ALT: () => $.SUBRULE($.idSelector, { ARGS: [ctx] }) },
+      { ALT: () => $.CONSUME(T.Star) },
+      { ALT: () => {
+        let initialIsQualifiedRule = ctx.qualifiedRule;
+        ctx.qualifiedRule = false;
+        /** Make sure we prevent things like :extend() inside pseudo-value */
+        try {
+          let pseudo = $.SUBRULE($.pseudoSelector, { ARGS: [ctx] });
+          return pseudo;
+        } finally {
+          ctx.qualifiedRule = initialIsQualifiedRule;
+        }
+      } },
+      /** @todo - replicate this fix we made with the Jess parser
+       *
+       * { ALT: () => $.attributeSelector(ctx, () => [
+      {
+        ALT: () => {
+          let token = $.CONSUME($.T.InterpolatedIdent);
+          let location = $.getLocationInfo(token);
+          let image = token.image;
+          let match = interpolatedRegex.exec(image);
+          interpolatedRegex.lastIndex = 0;
+          if (match && match[0] === image) {
+            return new Reference(
+              { key: new Keyword(match[2]!, undefined, location, $.context) },
+              { type: 'index' },
+              location,
+              $.context
+            );
+          }
+          return getInterpolatedNode(image, location, $.context);
+        }
+      },
+      */
+      { ALT: () => $.SUBRULE($.attributeSelector, { ARGS: [ctx] }) },
+      /** Supports keyframes value */
+      { ALT: () => $.CONSUME(T.DimensionInt) },
+      { ALT: () => $.CONSUME(T.DimensionNum) }
+    ];
+
+    let selector = $.OR(selectorAlt);
+
+    if ($.isToken(selector)) {
+      if (selector.tokenType.name === 'Ampersand') {
+        const value = getAmpersandTemplateValue(selector.image);
+        return new Ampersand({ appendValue: value }, undefined, $.getLocationInfo(selector), $.context);
+      }
+      if (
+        selector.tokenType.name === 'InterpolatedSelector'
+        || selector.tokenType.name === 'InterpolatedIdent'
+      ) {
+        // Create an InterpolatedSelector wrapper for interpolated value
+        let nameValue = selector.image;
+        let interpolatedNode = getInterpolatedNode(nameValue, $.getLocationInfo(selector), $.context);
+
+        return new InterpolatedSelector(interpolatedNode, undefined, $.getLocationInfo(selector), $.context);
+      }
+      return new BasicSelector(selector.image, undefined, $.getLocationInfo(selector), $.context);
+    }
+    const result: Node = selector;
+    return result;
+  };
+}
+
+export function anonymousMixinDefinition(this: P, T: TokenMap) {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    $.startRule();
+    let params: List | undefined;
+    let anonToken: IToken | undefined;
+    $.OPTION(() => {
+      anonToken = $.CONSUME(T.AnonMixinStart);
+      $.OPTION2(() => {
+        params = $.SUBRULE($.mixinArgList, { ARGS: [{ ...ctx, isDefinition: true }] });
+      });
+      $.CONSUME(T.RParen);
+    });
+    let rules = $.SUBRULE($.wrappedDeclarationList, { ARGS: [ctx] });
+
+    if ($.RECORDING_PHASE) {
+      return;
+    }
+
+    // Set rulesVisibility for detached rulesets based on leakyScope
+    // Less, for whatever reason, has slightly different lookup rules for
+    // "detached rulesets".
+
+    // Parse as Anonymous mixin
+    if (!rules.options.rulesVisibility) {
+      rules.options.rulesVisibility = {};
+    }
+    if ($.leakyScope) {
+      rules.options.rulesVisibility.Mixin = 'public';
+      rules.options.rulesVisibility.VarDeclaration = 'private';
+    } else {
+      rules.options.rulesVisibility.Mixin = 'private';
+      rules.options.rulesVisibility.VarDeclaration = 'private';
+    }
+
+    if (!anonToken) {
+      /** To Less, this is a "detached ruleset" */
+      // Check if this should be parsed as Collection or Rules
+      const shouldBeCollection = (() => {
+        let properties: Declaration[] = [];
+        for (const node of rules.rules) {
+          if (node.type === 'Declaration') {
+            properties.push(node);
+          } else if (node.type === 'Comment' || node.type === 'VarDeclaration') {
+            continue;
+          } else {
+            /** Not a valid collection, parse as anonymous mixin */
+            return false;
+          }
+        }
+
+        if (properties.length === 0) {
+          /** If just var declarations and/or comments, parse as collection */
+          return true;
+        }
+
+        const validPropertyCount = properties.filter((decl) => {
+          const { name } = decl;
+          const propName = typeof name === 'string' ? name : name?.valueOf();
+          if (!propName) {
+            return false;
+          }
+          // Skip custom properties (--*)
+          if (propName.startsWith('--')) {
+            return true; // Custom properties are always valid
+          }
+          return all.includes(propName);
+        }).length;
+
+        // Majority means more than 50%
+        const majorityValid = validPropertyCount > properties.length / 2;
+        /** If this looks like mostly CSS properties, parse as mixin instead */
+        return !majorityValid;
+      })();
+
+      const usage = (ctx as RuleContext).detachedRulesetUsage ?? 'none';
+      const forceMixinForDynamicUsage =
+        usage === 'function-arg'
+        || usage === 'mixin-arg'
+        || usage === 'default-param';
+      const shouldBeCollectionFinal = shouldBeCollection && !forceMixinForDynamicUsage;
+      if (shouldBeCollectionFinal) {
+        return new Collection(rules.rules, rules.options, $.endRule(), $.context);
+      }
+    }
+
+    // If anonToken exists, it's an anonymous mixin with (optional) parameters, return as Mixin
+    return new Mixin({ params, rules: rules.rules }, undefined, $.endRule(), $.context);
+  };
+}
+
+/**
+ * Mostly copied from css importAtRule, but it maps
+ * differently to Jess nodes depending on if it's meant
+ * to be a Jess-style import or just an at-rule
+ */
+export function importAtRule(this: P, T: TokenMap) {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    const isCssUrl = (url: string, options: string[]) => {
+      if (options.includes('inline')) {
+        return false;
+      }
+      const lower = url.toLowerCase();
+      const forcedLess = options.includes('less');
+      if (forcedLess) {
+        return false;
+      }
+      if (options.includes('css')) {
+        return true;
+      }
+      if (/\.css([?#].*)?$/.test(lower)) {
+        return true;
+      }
+      if (/\.less([?#].*)?$/.test(lower)) {
+        return false;
+      }
+      // Remote imports default to CSS.
+      if (lower.startsWith('http://') || lower.startsWith('https://') || lower.startsWith('//')) {
+        return true;
+      }
+      return false;
+    };
+
+    $.startRule();
+
+    let name = $.CONSUME(T.AtImport);
+
+    let options: string[] = [];
+
+    $.OPTION(() => {
+      $.CONSUME(T.LParen);
+      $.AT_LEAST_ONE_SEP({
+        SEP: T.Comma,
+        DEF: () => {
+          let opt = $.CONSUME(T.PlainIdent);
+          options.push(opt.image);
+        }
+      });
+      $.CONSUME(T.RParen);
+    });
+
+    let urlNode: Quoted | Url = $.OR([
+      { ALT: () => $.SUBRULE($.urlFunction, { ARGS: [ctx] }) },
+      { ALT: () => $.SUBRULE($.string, { ARGS: [ctx] }) }
+    ]);
+
+    let extraNodes: Node[] | undefined;
+    $.OPTION2(() => {
+      extraNodes = $.SUBRULE($.importPostlude, { ARGS: [{}] });
+    });
+
+    $.CONSUME(T.Semi);
+
+    if (!$.RECORDING_PHASE) {
+      let isAtRule: boolean | undefined;
+      let postludeNode: Node | undefined;
+
+      let url = urlNode.valueOf();
+      isAtRule = isCssUrl(url, options);
+
+      let preludeNodes: Node[] = [urlNode];
+
+      if (extraNodes && extraNodes.length) {
+        if (isAtRule) {
+          isAtRule = true;
+          for (const n of extraNodes) {
+            preludeNodes.push(n);
+          }
+        } else {
+          const postludeLoc = $.getLocationFromNodes(extraNodes);
+          postludeNode = new Sequence(extraNodes, undefined, postludeLoc, $.context);
+        }
+      }
+
+      let location = $.endRule();
+      if (isAtRule) {
+        const prelude = new Sequence(preludeNodes, undefined, $.getLocationFromNodes(preludeNodes), $.context);
+        const atRule = new AtRuleStatement({
+          name: name.image,
+          prelude: prelude
+        }, undefined, location, $.context);
+        return atRule;
+      }
+
+      return new StyleImport({
+        path: urlNode
+      }, {
+        type: 'import',
+        importOptions: {
+          type: options.includes('less') ? 'less' : undefined,
+          reference: options.includes('reference'),
+          once: !options.includes('multiple'),
+          multiple: options.includes('multiple'),
+          optional: options.includes('optional'),
+          inline: options.includes('inline'),
+          postlude: postludeNode
+        }
+      }, location, $.context);
+    }
+  };
+}
+
+/** Less variables */
+export function varDeclarationOrCall(this: P, T: TokenMap) {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    $.startRule();
+
+    let name = $.SUBRULE($.varName, { ARGS: [{}] });
+    let value: Node | undefined;
+    let args: List | undefined;
+    let important: IToken | undefined;
+
+    $.OR([
+      {
+        /**
+         * This is a variable declaration
+         * Disallows `@atrule :foo;` because it resembles a pseudo-selector
+         */
+        ALT: () => {
+          $.CONSUME(T.Colon);
+          return $.OR2([
+            {
+              GATE: () => {
+                const type = $.LA(1).tokenType;
+                return type === T.AnonMixinStart || type === T.LCurly;
+              },
+              ALT: () => {
+                value = $.SUBRULE($.anonymousMixinDefinition, { ARGS: [ctx] });
+                $.OPTION(() => $.CONSUME(T.Semi));
+                return value;
+              }
+            },
+            {
+              GATE: () => {
+                const type = $.LA(1).tokenType;
+                return type !== T.AnonMixinStart && type !== T.LCurly;
+              },
+              ALT: () => {
+                value = $.SUBRULE($.valueList, { ARGS: [{ ...ctx, allowMixinCallWithoutAccessor: true }] });
+                $.OPTION2(() => {
+                  important = $.CONSUME(T.Important);
+                });
+                return value;
+              }
+            }
+          ]);
+        }
+      },
+      /** This is a variable call. Allow optional whitespace between name and (. */
+      {
+        GATE: () => $.isType(T.LParen),
+        /**
+         * This is a change from Less 1.x-4.x
+         * e.g.
+         * ```
+         * @dr: #(@var1, @var2) {
+         *   // ...
+         * }
+         * @dr(arg1, arg2);
+         */
+        ALT: () => {
+          args = $.SUBRULE($.mixinArgs, { ARGS: [ctx] });
+          return args;
+        }
+      }
+    ]);
+
+    let location = $.endRule();
+    if ($.RECORDING_PHASE) {
+      return;
+    }
+    let nameVal = getInterpolatedOrString(name!.image);
+    let nameNode: Any | Interpolated;
+    if (!(nameVal instanceof Interpolated)) {
+      nameNode = new Any(nameVal, { role: 'ident' }, $.getLocationInfo(name!), $.context);
+    } else {
+      nameNode = nameVal;
+    }
+    /** An anonymous mixin call */
+    if (!value) {
+      // When @variable() is called, look up the variable first
+      // The variable's value (which may be a Call node) will be executed
+      const nameRef = new Reference({ key: nameNode }, { type: 'variable', role: 'name' });
+      // Pass markImportant in options if !important is present
+      const callOptions = important ? { markImportant: true } : undefined;
+      const callNode = new Call({ name: nameRef, args }, callOptions, location, $.context);
+      // Clear important since it's now on the Call
+      if (important) {
+        important = undefined;
+      }
+      // Variable calls are expressions at the outermost level (but not parenthesized).
+      // e.g. `$media()`, NOT `$(media())`
+      return new Expression(callNode, undefined, location, $.context);
+    }
+
+    // If the value is a Call node and we have !important, set markImportant on the Call
+    // instead of on the VarDeclaration (mixin call semantics)
+    if (important && value instanceof Call) {
+      value.options = value.options || {};
+      value.options.markImportant = true;
+      important = undefined;
+    }
+
+    if (value && isLegacySelectorLikeValue(value)) {
+      const varName = String(nameNode.valueOf());
+      $.warnDeprecation(
+        `Unquoted selector capture in '${varName}' is no longer supported. Use '*[ ... ]' (e.g. ${varName}: *[.a, .b]).`,
+        $.LA(1),
+        'unquoted-selector-capture'
+      );
+    }
+
+    return new VarDeclaration({
+      name: nameNode instanceof Any ? String(nameNode.valueOf()) : nameNode,
+      value: value,
+      important: important ? new Any(important.image, { role: 'flag' }, $.getLocationInfo(important), $.context) : undefined
+    }, undefined, location, $.context);
+  };
+}
+
+export function selectorCapture(this: P, T: TokenMap) {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    $.startRule();
+    $.CONSUME(T.Star);
+    // Use $.OR with a gate for a positive assertion
+    const selector = $.OR([
+      {
+        GATE: $.noSep.bind($),
+        ALT: () => {
+          $.CONSUME(T.LSquare);
+          const selector = $.SUBRULE($.forgivingSelectorList, { ARGS: [{ ...ctx, inner: true }] });
+          $.CONSUME(T.RSquare);
+          return selector;
+        }
+      }
+    ]);
+
+    const location = $.endRule();
+    if ($.RECORDING_PHASE) {
+      return;
+    }
+    return new SelectorCapture(
+      selector,
+      undefined,
+      location,
+      $.context
+    );
+  };
+}
+
+export function valueSequence(this: P, _T: TokenMap): ProductionRule {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    const RECORDING_PHASE = $.RECORDING_PHASE;
+    $.startRule();
+    let nodes: Node[] | undefined;
+    if (!RECORDING_PHASE) {
+      nodes = [];
+    }
+
+    {
+      const exprCtx: RuleContext = { ...ctx, wrapInExpression: true };
+      let value = $.SUBRULE2($.expressionSum, { ARGS: [exprCtx] });
+      if (!RECORDING_PHASE) {
+        value = wrapOuterExpressionIfNeeded.call($, value, exprCtx);
+        nodes!.push(value);
+      }
+    }
+
+    $.MANY(() => {
+      const exprCtx: RuleContext = { ...ctx, wrapInExpression: true };
+      let value = $.SUBRULE3($.expressionSum, { ARGS: [exprCtx] });
+      if (!RECORDING_PHASE) {
+        value = wrapOuterExpressionIfNeeded.call($, value, exprCtx);
+        nodes!.push(value);
+      }
+    });
+
+    if (RECORDING_PHASE) {
+      return;
+    }
+
+    let location = $.endRule();
+    if (nodes!.length === 1) {
+      const single = nodes![0]!;
+      return single;
+    }
+    const seq = new Sequence(nodes!, undefined, location, $.context);
+    return seq;
+  };
+}
+
+export function squareValue(this: P, T: TokenMap) {
+  const $ = this;
+  return (ctx: RuleContext = {}) => {
+    $.startRule();
+    $.CONSUME(T.LSquare);
+    let node: Node = $.OR([
+      {
+        GATE: () => !$.looseMode,
+        ALT: () => {
+          let ident = $.CONSUME(T.Ident);
+          return new Any(ident.image, { role: 'ident' }, $.getLocationInfo(ident), $.context);
+        }
+      },
+      {
+        GATE: () => !!$.looseMode,
+        ALT: () => {
+          let nodes: Node[] = [];
+          $.MANY(() => {
+            let node = $.SUBRULE($.anyInnerValue, { ARGS: [ctx] });
+            const wrapped = node;
+            nodes.push(wrapped);
+          });
+          const seq = new Sequence(nodes, undefined, $.getLocationFromNodes(nodes), $.context);
+          return seq;
+        }
+      }
+    ]);
+    $.CONSUME(T.RSquare);
+    let location = $.endRule();
+    const blk = new Block(node, { type: 'square' }, location, $.context);
+    return blk;
+  };
+}