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

package/src/productions/guards.ts

@@ -1,1066 +0,0 @@
-// @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.
-import type { RuleContext } from '../lessRecursiveParser.js';
-import type { TokenMap } from '../lessRecursiveParser.js';
-import type { IToken } from 'chevrotain';
-import { NoViableAltException } from 'chevrotain';
-import { productions as cssProductions } from '@jesscss/css-parser/jess';
-import {
-  type LocationInfo,
-  Node,
-  Any,
-  AtRuleStatement,
-  Condition,
-  type ConditionOperator,
-  DefaultGuard,
-  Paren,
-  List,
-  Sequence,
-  Call,
-  Reference,
-  Quoted,
-  Rest,
-  Nil,
-  VarDeclaration,
-  JsImport,
-  StyleImport,
-  type Url,
-  isNode,
-  N
-} from '@jesscss/core';
-import { getInterpolatedNode, getInterpolatedOrString } from '../utils.js';
-
-/** Use `any` for `this` to avoid structural incompatibility between LessRecursiveParser and CssRecursiveParser */
-type P = any;
-type ProductionRule = (...args: any[]) => any;
-
-function isScriptUsePath(path: string): boolean {
-  const filePart = path.replace(/[?#].*$/u, '');
-  return path === '#less'
-    || path.startsWith('#less/')
-    || /\.(?:js|mjs|cjs|ts|mts|cts|json)$/i.test(filePart);
-}
-
-function defaultNamespaceFromPath(path: string): string | undefined {
-  if (path === '#less') {
-    return 'less';
-  }
-  if (path.startsWith('#less/')) {
-    return path.split('/').filter(Boolean).pop();
-  }
-  const base = path.split('/').filter(Boolean).pop();
-  if (!base) {
-    return undefined;
-  }
-  const noExt = base.replace(/\.(less|css|jess|js|mjs|cjs|ts|mts|cts|json)$/i, '');
-  return noExt || undefined;
-}
-
-function getParenFrames(ctx: RuleContext | undefined): boolean[] {
-  return (ctx?.parenFrames as boolean[] | undefined) ?? [];
-}
-
-function isDefaultGuardCall(node: Node | undefined): node is Call {
-  if (!node || !isNode(node, N.Call)) {
-    return false;
-  }
-  const callName = node.name;
-  const callNameStr = String(
-    (typeof callName === 'object' && callName !== null && 'valueOf' in callName)
-      ? callName.valueOf()
-      : callName ?? ''
-  );
-  if (callNameStr === 'default' || callNameStr === '??') {
-    return true;
-  }
-  if (callName instanceof Reference) {
-    const key = callName.key;
-    const keyStr = String(
-      (typeof key === 'object' && key !== null && 'valueOf' in key)
-        ? key.valueOf()
-        : key ?? ''
-    );
-    return keyStr === 'default' || keyStr === '??';
-  }
-  return false;
-}
-
-// Save CSS production factory for super calls
-const cssUnknownAtRule = cssProductions.unknownAtRule;
-
-function isGuardComparisonToken(tt: unknown, T: TokenMap) {
-  return tt === T.CompareOperator
-    || tt === T.Eq
-    || tt === T.Gt
-    || tt === T.GtEq
-    || tt === T.GtEqAlias
-    || tt === T.Lt
-    || tt === T.LtEq
-    || tt === T.LtEqAlias;
-}
-
-function normalizeComparisonOperator(op: string): ConditionOperator {
-  switch (op) {
-    case '=>':
-    case '>=':
-      return '>=';
-    case '=<':
-    case '<=':
-      return '<=';
-    case '=':
-      return '=';
-    case '>':
-      return '>';
-    case '<':
-      return '<';
-    default:
-      return '=';
-  }
-}
-
-export function guard(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    $.CONSUME(T.When);
-    return $.OR([
-      {
-        GATE: () => !!ctx.inValueList,
-        ALT: () => $.SUBRULE($.comparison, { ARGS: [ctx] })
-      },
-      {
-        ALT: () => {
-          const node = $.SUBRULE($.guardOr, { ARGS: [{ ...ctx, allowComma: true }] });
-          return node;
-        }
-      }
-    ]);
-  };
-}
-
-/**
- * 'or' expression
- * Allows an (outer) comma like historical media queries
- */
-export function guardOr(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    $.startRule();
-
-    let left = $.SUBRULE($.guardAnd, { ARGS: [ctx] });
-    let right: Node | undefined;
-    $.MANY({
-      GATE: () => (ctx.allowComma && $.isType(T.Comma)) || $.isType(T.Or),
-      DEF: () => {
-        /**
-         * Nest expressions within expressions for correct
-         * order of operations.
-         */
-        $.OR([
-          { ALT: () => $.CONSUME(T.Comma) },
-          { ALT: () => $.CONSUME(T.Or) }
-        ]);
-        right = $.SUBRULE2($.guardAnd, { ARGS: [ctx] });
-        let location = $.endRule();
-        $.startRule();
-        left = new Condition(
-          [left, 'or', right!],
-          undefined,
-          location,
-          $.context
-        );
-      }
-    });
-    $.endRule();
-    return left;
-  };
-}
-
-export function guardDefault(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    let guard = $.OR([
-      { ALT: () => $.CONSUME(T.DefaultGuardIdent) },
-      { ALT: () => $.CONSUME(T.DefaultGuardFunc) }
-    ]);
-    if ($.RECORDING_PHASE) {
-      return;
-    }
-    ctx.hasDefault = true;
-    return new DefaultGuard(guard.image, undefined, $.getLocationInfo(guard));
-  };
-}
-
-/**
- * 'and' and 'or' expressions
- *
- *  In Media queries level 4, you cannot have
- *  `([expr]) or ([expr]) and ([expr])` because
- *  of evaluation order ambiguity.
- *  However, Less allows it.
- */
-export function guardAnd(this: P, T: TokenMap): ProductionRule {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    let left: Node;
-    $.MANY_SEP({
-      SEP: T.And,
-      DEF: () => {
-        let not: IToken | undefined;
-        $.OPTION(() => not = $.CONSUME(T.Not));
-        let allowComma = ctx.allowComma;
-        ctx.allowComma = false;
-        let right: Node;
-        try {
-          right = $.OR([
-            { ALT: () => $.SUBRULE($.guardInParens, { ARGS: [ctx] }) },
-            {
-              GATE: () => {
-                const tokenType = $.LA(1).tokenType;
-                return tokenType !== T.Not
-                  && tokenType !== T.DefaultGuardFunc
-                  && tokenType !== T.DefaultGuardIdent;
-              },
-              ALT: () => $.SUBRULE($.expressionSum, { ARGS: [ctx] })
-            }
-          ]);
-          $.OPTION2({
-            GATE: () => isGuardComparisonToken($.LA(1).tokenType, T),
-            DEF: () => {
-              const op = $.CONSUME(T.CompareOperator);
-              const compareRight = $.SUBRULE2($.expressionSum, { ARGS: [ctx] });
-              if (!$.RECORDING_PHASE) {
-                right = new Condition(
-                  [
-                    right,
-                    normalizeComparisonOperator(op.image),
-                    compareRight
-                  ],
-                  undefined,
-                  $.getLocationFromNodes([right, compareRight]),
-                  $.context
-                );
-              }
-            }
-          });
-        } finally {
-          ctx.allowComma = allowComma;
-        }
-        if (!$.RECORDING_PHASE) {
-          if (isDefaultGuardCall(right!)) {
-            ctx.hasDefault = true;
-            const location = Array.isArray(right!.location) && right!.location.length === 6
-              ? right!.location as LocationInfo
-              : undefined;
-            right = new DefaultGuard('default()', undefined, location);
-          }
-          if (not) {
-            let [,,, endOffset, endLine, endColumn] = right.location!;
-            let [startOffset, startLine, startColumn] = $.getLocationInfo(not);
-            right = new Condition(
-              [right],
-              { negate: true },
-              [startOffset!, startLine!, startColumn!, endOffset!, endLine!, endColumn!],
-              $.context
-            );
-          }
-          if (!left) {
-            left = right;
-            return;
-          }
-          left = new Condition(
-            [left, 'and', right],
-            undefined,
-            $.getLocationFromNodes([left, right]),
-            $.context
-          );
-        }
-      }
-    });
-    return left!;
-  };
-}
-
-export function guardInParens(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext) => {
-    $.startRule();
-    let node = $.OR([
-      { ALT: () => $.SUBRULE($.guardDefault, { ARGS: [ctx] }) },
-      {
-        ALT: () => {
-          $.CONSUME(T.LParen);
-          let node = $.SUBRULE($.guardInner, { ARGS: [ctx] });
-          $.CONSUME(T.RParen);
-          return node;
-        }
-      }
-    ]);
-
-    if (isDefaultGuardCall(node)) {
-      ctx.hasDefault = true;
-      const location = Array.isArray(node.location) && node.location.length === 6
-        ? node.location as LocationInfo
-        : undefined;
-      node = new DefaultGuard('default()', undefined, location);
-    }
-    node = node;
-    return new Paren(node, undefined, $.endRule(), $.context);
-  };
-}
-
-// The inner content of a guard inside parentheses
-export function guardInner(this: P, _T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    return $.SUBRULE($.guardOr, { ARGS: [ctx] });
-  };
-}
-
-export function guardWithConditionValue(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    if ($.isType(T.DefaultGuardIdent) || $.isType(T.DefaultGuardFunc)) {
-      $.OR([
-        { ALT: () => $.CONSUME(T.DefaultGuardIdent) },
-        { ALT: () => $.CONSUME(T.DefaultGuardFunc) }
-      ]);
-      return;
-    }
-    return $.SUBRULE($.guardInParens, { ARGS: [ctx] });
-  };
-}
-
-export function guardWithCondition(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    $.SUBRULE($.guardWithConditionValue, { ARGS: [ctx] });
-    $.AT_LEAST_ONE(() => {
-      $.OR([
-        { ALT: () => $.CONSUME(T.Or) },
-        { ALT: () => $.CONSUME(T.And) },
-        { ALT: () => $.CONSUME(T.Comma) }
-      ]);
-      $.SUBRULE2($.guardWithConditionValue, { ARGS: [ctx] });
-    });
-  };
-}
-
-/**
- * Currently, Less only allows a single comparison expression,
- * unlike Media Queries Level 4, which allows a left and right
- * comparison.
- */
-export function comparison(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    let left = $.SUBRULE($.expressionSum, { ARGS: [ctx] });
-    const op = $.CONSUME(T.CompareOperator);
-    let right = $.SUBRULE2($.expressionSum, { ARGS: [ctx] });
-    if (isDefaultGuardCall(right)) {
-      ctx.hasDefault = true;
-      const location = Array.isArray(right.location) && right.location.length === 6
-        ? right.location as LocationInfo
-        : undefined;
-      right = new DefaultGuard('default()', undefined, location);
-    }
-    left = new Condition(
-      [left, normalizeComparisonOperator(op.image), right],
-      undefined,
-      $.getLocationFromNodes([left, right]),
-      $.context
-    );
-    return left;
-  };
-}
-
-/**
- * Less (perhaps unwisely) allows bubbling of normally document-root
- * at-rules, so we need to override CSS here.
- */
-export function innerAtRule(this: P, _T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}): Node => {
-    return $.OR([
-      { ALT: () => $.SUBRULE($.mediaAtRule, { ARGS: [{ ...ctx, inner: true }] }) },
-      { ALT: () => $.SUBRULE($.supportsAtRule, { ARGS: [{ ...ctx, inner: true }] }) },
-      { ALT: () => $.SUBRULE($.layerAtRule, { ARGS: [{ ...ctx, inner: true }] }) },
-      { ALT: () => $.SUBRULE($.containerAtRule, { ARGS: [{ ...ctx, inner: true }] }) },
-      { ALT: () => $.SUBRULE($.keyframesAtRule, { ARGS: [{ ...ctx, inner: true }] }) },
-      { ALT: () => $.SUBRULE($.documentAtRule, { ARGS: [{ ...ctx, inner: true }] }) },
-      { ALT: () => $.SUBRULE($.importAtRule, { ARGS: [ctx] }) },
-      { ALT: () => $.SUBRULE($.pageAtRule, { ARGS: [ctx] }) },
-      { ALT: () => $.SUBRULE($.fontFaceAtRule, { ARGS: [ctx] }) },
-      { ALT: () => $.SUBRULE($.nestedAtRule, { ARGS: [ctx] }) },
-      { ALT: () => $.SUBRULE($.nonNestedAtRule, { ARGS: [ctx] }) },
-      { ALT: () => $.SUBRULE($.unknownAtRule, { ARGS: [{ ...ctx, inner: true }] }) }
-    ]);
-  };
-}
-
-/**
- * Less override: allow variable reference as the first segment of a layer-name
- * CSS: <ident> ('.' <ident>)*
- * Less: (<var-ref> | <ident>) ('.' <ident>)*
- */
-export function layerName(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    const preludeCtx: RuleContext = { ...ctx, atRulePreludeBareVariableAs: 'index' };
-    $.startRule();
-    let RECORDING_PHASE = $.RECORDING_PHASE;
-    let nodes: Node[];
-    if (!RECORDING_PHASE) {
-      nodes = [];
-    }
-
-    // First segment: variable reference or plain ident
-    const first = $.OR([
-      { ALT: () => $.SUBRULE($.valueReference, { ARGS: [preludeCtx] }) },
-      {
-        GATE: () => $.isType(T.Ident),
-        ALT: () => $.CONSUME(T.Ident)
-      }
-    ]);
-
-    if (!RECORDING_PHASE) {
-      if (first instanceof Node) {
-        nodes!.push(first);
-      } else {
-        nodes!.push($.processValueToken(first));
-      }
-    }
-
-    // Remaining segments: dot + ident (same as CSS)
-    $.MANY({
-      GATE: $.noSep.bind($),
-      DEF: () => {
-        const seg = $.CONSUME(T.DotName);
-        if (!RECORDING_PHASE) {
-          nodes!.push($.processValueToken(seg));
-        }
-      }
-    });
-
-    if (RECORDING_PHASE) {
-      return;
-    }
-    const loc = $.endRule();
-    return new Sequence(nodes!, undefined, loc, $.context);
-  };
-}
-
-/**
- * Less override: allow variable reference for @keyframes name
- * CSS: Ident | String
- * Less: valueReference | Ident | String
- */
-export function keyframesName(this: P, T: TokenMap): ProductionRule {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    const preludeCtx: RuleContext = { ...ctx, atRulePreludeBareVariableAs: 'index' };
-    let node: Node | undefined;
-    $.OR([
-      { ALT: () => node = $.SUBRULE($.valueReference, { ARGS: [preludeCtx] }) },
-      {
-        GATE: () => $.isType(T.Ident) && !$.isType(T.InterpolatedIdent),
-        ALT: () => {
-          const tok = $.CONSUME(T.Ident);
-          node = $.processValueToken(tok);
-        } },
-      { ALT: () => node = $.SUBRULE($.string, { ARGS: [] }) }
-    ]);
-    return node!;
-  };
-}
-
-/**
- * One of the rare rules that returns a token, because
- * other rules will transform it differently.
- */
-export function mixinName(this: P, T: TokenMap): ProductionRule {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    /** e.g. .mixin, #mixin */
-    let name = $.OR([
-      { ALT: () => $.CONSUME(T.HashName) },
-      { ALT: () => $.CONSUME(T.ColorIdentStart) },
-      { ALT: () => $.CONSUME(T.DotName) },
-      { ALT: () => $.CONSUME(T.InterpolatedIdent) },
-      { ALT: () => $.CONSUME(T.InterpolatedSelector) }
-    ]);
-    if ($.RECORDING_PHASE) {
-      return;
-    }
-    const asReference = ctx.asReference;
-    let nameNode: Node;
-    let nameValue = name.image;
-    let location = $.getLocationInfo(name);
-    if (nameValue.includes('@') || nameValue.includes('$')) {
-      const interpolated = getInterpolatedNode(nameValue, location, $.context);
-      nameNode = interpolated;
-      if (asReference) {
-        if (isNode(ctx.node, N.Reference) && ctx.node.options.type === 'mixin-ruleset') {
-          nameNode = new Reference({ target: ctx.node, key: interpolated }, { type: 'mixin-ruleset', role: 'name' }, location, $.context);
-        } else {
-          const target = ctx.node as Node | undefined;
-          nameNode = new Reference({ target: target instanceof Call ? target : target instanceof Reference ? target : undefined, key: interpolated }, { type: 'mixin-ruleset', role: 'name' }, location, $.context);
-        }
-      }
-    } else {
-      if (asReference) {
-        // If target is a Reference with matching type, merge keys instead of nesting
-        if (isNode(ctx.node, N.Reference) && ctx.node.options.type === 'mixin-ruleset') {
-          const existingKey = ctx.node.key;
-          const existingRawKey = ctx.node.rawKey;
-          let mergedKeys: string[];
-          if (Array.isArray(existingKey)) {
-            mergedKeys = [...existingKey];
-          } else {
-            mergedKeys = [String(existingKey)];
-          }
-          mergedKeys.push(nameValue);
-          const rawPrefix = Array.isArray(existingRawKey)
-            ? existingRawKey.join(' > ')
-            : typeof existingRawKey === 'string'
-              ? existingRawKey
-              : Array.isArray(existingKey)
-                ? existingKey.join(' > ')
-                : String(existingKey);
-          nameNode = new Reference(
-            {
-              key: mergedKeys.length === 1 ? mergedKeys[0]! : mergedKeys,
-              rawKey: `${rawPrefix} > ${nameValue}`
-            },
-            { type: 'mixin-ruleset', role: 'name' },
-            location,
-            $.context
-          );
-        } else {
-          const target = ctx.node as Node | undefined;
-          nameNode = new Reference({ target: target instanceof Call ? target : target instanceof Reference ? target : undefined, key: nameValue }, { type: 'mixin-ruleset', role: 'name' }, location, $.context);
-        }
-      } else {
-        nameNode = new Any(nameValue, { role: 'name' }, $.getLocationInfo(name), $.context);
-      }
-    }
-    return nameNode;
-  };
-}
-
-/**
- * Used within a value. These can be
- * chained more recursively, unlike
- * Less 1.x-4.x
- *   e.g. .mixin1() > .mixin2[@val1].ns() > .sub-mixin[@val2]
- *
- * This production intelligently decides whether to produce a Call or Reference
- * based on whether there are parentheses at the end:
- * - foo: #id; // Reference
- * - foo: .class; // Reference
- * - foo: #id > .scoped; // Reference
- * - foo: #id > .scoped(); // Call
- * - foo: #id[]; // Reference with accessor
- * - foo: #id > .scoped[foo]; // Reference with accessor
- * - foo: #id > .scoped[@ref](); // Call with accessor
- */
-export function mixinReference(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    let leftNode = $.SUBRULE($.mixinName, { ARGS: [{ ...ctx, asReference: true }] });
-
-    $.MANY({
-      GATE: () => {
-        let next = $.LA(1).tokenType;
-        return $.noSep() && (next === T.LParen || next === T.LSquare);
-      },
-      DEF: () => {
-        leftNode = $.SUBRULE($.lookupOrCall, { ARGS: [{ ...ctx, node: leftNode }] });
-      }
-    });
-
-    $.OPTION(() => {
-      $.OPTION2(() => $.CONSUME(T.Gt));
-      leftNode = $.SUBRULE($.mixinReference, { ARGS: [{ ...ctx, node: leftNode }] });
-    });
-
-    return leftNode;
-  };
-}
-
-export function mixinArgs(this: P, T: TokenMap): ProductionRule {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    let args: List | undefined;
-    // Check for whitespace before the opening paren (before consuming)
-    const hasWhitespace = !$.noSep();
-    const openingParenToken = hasWhitespace ? $.LA(1) : undefined;
-
-    $.CONSUME(T.LParen);
-    // Clear ctx.node when parsing arguments - arguments should start fresh, not inherit the parent node
-    // Calls intentionally push a `false` paren frame (matches `Call.evalNode`)
-    const argCtx: RuleContext = {
-      ...ctx,
-      node: undefined,
-      allowComma: false,
-      parenFrames: [...getParenFrames(ctx), false],
-      detachedRulesetUsage: ctx.isDefinition ? 'default-param' : 'mixin-arg'
-    };
-    if (!$.isType(T.RParen)) {
-      args = $.SUBRULE($.mixinArgList, { ARGS: [argCtx] });
-    }
-    $.CONSUME(T.RParen);
-
-    // Check for whitespace warning AFTER consuming closing paren
-    // Now we can check what comes next to determine if it's actually a definition
-    if (hasWhitespace && openingParenToken) {
-      const nextAfterParens = $.LA(1).tokenType;
-      const isActuallyDefinition = nextAfterParens === T.LCurly || nextAfterParens === T.When;
-      // Only warn if it's NOT a definition (i.e., it's a mixin call)
-      if (!isActuallyDefinition) {
-        $.warnDeprecation(
-          'Whitespace between a mixin name and parentheses for a mixin call is deprecated',
-          openingParenToken,
-          'mixin-call-whitespace'
-        );
-      }
-    }
-
-    return args;
-  };
-}
-
-export function lookupOrCall(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    $.startRule();
-    return $.OR([
-      {
-        ALT: () => {
-          let keyToken: IToken | undefined;
-          $.CONSUME(T.LSquare);
-          $.OPTION(() => keyToken = $.OR2([
-            { ALT: () => $.CONSUME(T.NestedReference) },
-            { ALT: () => $.CONSUME(T.AtKeyword) },
-            { ALT: () => $.CONSUME(T.PropertyReference) },
-            { ALT: () => $.CONSUME(T.InterpolatedIdent) },
-            {
-              GATE: () => !$.isType(T.NestedReference)
-                && !$.isType(T.AtKeyword)
-                && !$.isType(T.PropertyReference)
-                && !$.isType(T.InterpolatedIdent)
-                && $.isType(T.Ident),
-              ALT: () => $.CONSUME(T.Ident)
-            }
-          ]));
-          $.CONSUME(T.RSquare);
-          if ($.RECORDING_PHASE) {
-            return;
-          }
-          let ref: Reference;
-          const targetNode = ctx.node;
-          const target = targetNode instanceof Call ? targetNode : targetNode instanceof Reference ? targetNode : undefined;
-          if (keyToken) {
-            let tokenStr = keyToken.image;
-            let type: 'variable' | 'index' = tokenStr.startsWith('@') ? 'variable' : 'index';
-            if (keyToken.tokenType === T.NestedReference) {
-              tokenStr = keyToken.image;
-              if (!tokenStr.startsWith('$') && !tokenStr.startsWith('@')) {
-                tokenStr = '$' + tokenStr;
-              }
-            }
-            let rawResult = getInterpolatedOrString(tokenStr, $.getLocationInfo(keyToken), $.context);
-            let result: typeof rawResult | Quoted = rawResult;
-            if (type === 'index') {
-              result = new Quoted(rawResult, { quote: '\'' }, $.getLocationInfo(keyToken), $.context);
-            }
-
-            const targetType = isNode(target, N.Reference) ? target.options.type : undefined;
-            const shouldMergeKeys = targetType === 'mixin' || targetType === 'mixin-ruleset';
-            if (isNode(target, N.Reference) && target.options.type === type && typeof result === 'string' && shouldMergeKeys) {
-              const existingKey = target.key;
-              let mergedKeys: string[];
-              if (Array.isArray(existingKey)) {
-                mergedKeys = [...existingKey];
-              } else {
-                mergedKeys = [String(existingKey)];
-              }
-              mergedKeys.push(result);
-              ref = new Reference(
-                { key: mergedKeys.length === 1 ? mergedKeys[0]! : mergedKeys },
-                { type },
-                $.endRule(),
-                $.context
-              );
-            } else {
-              ref = new Reference({ target, key: result }, { type }, $.endRule(), $.context);
-            }
-          } else {
-            ref = new Reference({ target, key: -1 }, { type: 'index' }, $.endRule(), $.context);
-          }
-          /** Reference targets will technically precede the reference, so we need to update the location to the target start location */
-          if (target) {
-            let [targetStartOffset, targetStartLine, targetStartColumn] = target.location!;
-            ref.location.start = targetStartOffset;
-            ref.location[1] = targetStartLine;
-            ref.location[2] = targetStartColumn;
-          }
-          return ref;
-        }
-      },
-      {
-        ALT: () => {
-          let args = $.SUBRULE($.mixinArgs, { ARGS: [ctx] });
-          if ($.RECORDING_PHASE) {
-            return;
-          }
-          return new Call({ name: ctx.node!, args }, undefined, $.endRule(), $.context);
-        }
-      }
-    ]);
-  };
-}
-
-/**
- * @see https://lesscss.org/features/#mixins-feature-mixins-parametric-feature
- *
- * This rule is recursive to allow chevrotain-allstar (hopefully) to lookahead
- * and find semi-colon separators vs. commas.
- */
-export function mixinArgList(this: P, T: TokenMap): ProductionRule {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    $.startRule();
-    const first = $.SUBRULE($.mixinArg, { ARGS: [ctx] });
-
-    let commaNodes: Node[] | undefined = [first];
-    const semiNodes: Node[] = [];
-    let isSemiList = false;
-
-    const collapseCommaNodesIntoSemiNodes = (semi: IToken) => {
-      if (!commaNodes) {
-        return;
-      }
-      if (commaNodes.length > 1) {
-        const [head, ...rest] = commaNodes;
-        let hasDeclarations = false;
-        if (head instanceof VarDeclaration) {
-          const headValue = head.value instanceof Node ? head.value : undefined;
-          const nodes = headValue ? [headValue, ...rest] : [...rest];
-          hasDeclarations = rest.some(n => n instanceof VarDeclaration);
-          const value = new List(nodes, undefined, $.getLocationFromNodes(nodes), $.context);
-          semiNodes.push(new VarDeclaration({
-            name: head.name,
-            value,
-            important: head.important
-          }, head.options, head.location, $.context));
-        } else {
-          hasDeclarations = commaNodes.some(n => n instanceof VarDeclaration);
-          semiNodes.push(new List(commaNodes, undefined, $.getLocationFromNodes(commaNodes), $.context));
-        }
-        if (hasDeclarations) {
-          const indexOfSemi = $.input.indexOf(semi);
-          const previousToken = $.input[indexOfSemi - 1]!;
-          $.SAVE_ERROR(
-            new NoViableAltException(
-              'Cannot mix ; and , as delimiter types',
-              semi,
-              previousToken
-            )
-          );
-        }
-      } else {
-        semiNodes.push(commaNodes[0]!);
-      }
-      commaNodes = undefined;
-    };
-
-    while ($.isType(T.Comma) || $.isType(T.Semi)) {
-      if ($.isType(T.Comma)) {
-        const comma = $.CONSUME(T.Comma);
-        const node = $.SUBRULE2($.mixinArg, { ARGS: [ctx] });
-        if (commaNodes) {
-          commaNodes.push(node);
-        } else {
-          $.SAVE_ERROR(
-            new NoViableAltException(
-              'Cannot mix ; and , as delimiter types',
-              comma,
-              $.LA(0)
-            )
-          );
-          semiNodes.push(node);
-        }
-        continue;
-      }
-
-      const semi = $.CONSUME(T.Semi);
-      isSemiList = true;
-      collapseCommaNodesIntoSemiNodes(semi);
-
-      if ($.isType(T.RParen)) {
-        break;
-      }
-
-      const prevAllow = ctx.allowComma;
-      ctx.allowComma = true;
-      const node = $.SUBRULE3($.mixinArg, { ARGS: [ctx] });
-      ctx.allowComma = prevAllow;
-      semiNodes.push(node);
-    }
-
-    let location = $.endRule();
-    let nodes = isSemiList ? semiNodes : commaNodes!;
-    let sep: ';' | ',' = isSemiList ? ';' : ',';
-    const result: List = new List(nodes, { sep }, location, $.context);
-    return result;
-  };
-}
-
-/**
- * Less is more lenient about at-keywords. See lessTokens.ts for more details.
- */
-export function varName(this: P, T: TokenMap) {
-  const $ = this;
-  return () => {
-    // AtKeywordLessExtension is categorized as AtName in lessTokens.ts, so consuming
-    // AtName alone preserves behavior while avoiding OR ambiguity warnings.
-    return $.CONSUME(T.AtName);
-  };
-}
-
-/**
- * Originally, we were creating alternatives for mixin calls and mixin definitions
- * that could mostly overlap, which led to longer parsing. Instead, we parse
- * as if it could be either, and then we disambiguate at the end.
- */
-export function mixinArg(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    const firstToken = $.LA(1);
-    const atStart = $.matchToken(firstToken, T.AtName);
-    const tt2 = $.LA(2).tokenType;
-    const tt3 = $.LA(3).tokenType;
-    const hasWsAfterName = tt2 === T.WS;
-    const nextTokenType = hasWsAfterName ? tt3 : tt2;
-
-    if (atStart && nextTokenType === T.Ellipsis) {
-      $.startRule();
-      const name = $.CONSUME(T.AtName);
-      if (hasWsAfterName) {
-        $.CONSUME(T.WS);
-      }
-      $.CONSUME(T.Ellipsis);
-      if ($.RECORDING_PHASE) {
-        return;
-      }
-      return new Rest(name.image.slice(1), undefined, $.endRule(), $.context);
-    }
-
-    if (atStart && nextTokenType === T.Colon) {
-      $.startRule();
-      const name = $.CONSUME2(T.AtName);
-      if (hasWsAfterName) {
-        $.CONSUME2(T.WS);
-      }
-      $.CONSUME(T.Colon);
-      const value = $.SUBRULE3($.callArgument, { ARGS: [{ ...ctx, allowComma: !!ctx.allowComma, detachedRulesetUsage: 'default-param' }] });
-
-      const location = $.endRule();
-      if ($.RECORDING_PHASE) {
-        return;
-      }
-      return new VarDeclaration({
-        name: name.image.slice(1),
-        value
-      }, { paramVar: true }, location, $.context);
-    }
-
-    if (atStart && (nextTokenType === T.RParen || nextTokenType === T.Comma || nextTokenType === T.Semi)) {
-      $.startRule();
-      const name = $.CONSUME3(T.AtName);
-      if ($.RECORDING_PHASE) {
-        return;
-      }
-      const location = $.endRule();
-      if (ctx.isDefinition) {
-        return new VarDeclaration({
-          name: name.image.slice(1),
-          value: new Nil(undefined, undefined, location, $.context)
-        }, { paramVar: true }, location, $.context);
-      }
-      return new Any(name.image.slice(1), { role: 'name' }, location, $.context);
-    }
-
-    if ($.isType(T.Ellipsis)) {
-      const ellipsis = $.CONSUME2(T.Ellipsis);
-      return new Rest(undefined, undefined, $.getLocationInfo(ellipsis), $.context);
-    }
-
-    return $.SUBRULE($.callArgument, { ARGS: [ctx] });
-  };
-}
-
-export function callArgument(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    return $.OR([
-      {
-        GATE: () => $.isType(T.AnonMixinStart) || $.isType(T.LCurly),
-        ALT: () => $.SUBRULE($.anonymousMixinDefinition, { ARGS: [ctx] })
-      },
-      {
-        GATE: () => !ctx.allowComma,
-        ALT: () => $.SUBRULE($.valueSequence, { ARGS: [ctx] })
-      },
-      {
-        GATE: () => !!ctx.allowComma,
-        ALT: () => $.SUBRULE($.valueList, { ARGS: [ctx] })
-      }
-    ]);
-  };
-}
-
-/**
- * Override unknownAtRule to handle @-export for stylesheet forwarding.
- * @-export is like @-compose but with forward semantics and no `with` support.
- */
-export function unknownAtRule(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    const img = $.LA(1).image;
-    if (img === '@use' || img === '@-use') {
-      return $.SUBRULE($.useAtRule, { ARGS: [ctx] });
-    }
-    if (img === '@-export') {
-      return $.SUBRULE($.exportAtRule, { ARGS: [ctx] });
-    }
-    return cssUnknownAtRule.call($, T)(ctx);
-  };
-}
-
-/**
- * Parse Less v5 script-module imports.
- *
- * Stylesheet composition uses `@compose`; `@use` / `@-use` only become
- * JsImport nodes for script-style paths and aliases like `#less/math`.
- */
-export function useAtRule(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    $.startRule();
-    const name = $.CONSUME(T.AtName); // '@use' or '@-use'
-
-    const pathNode: Quoted = $.SUBRULE($.string, { ARGS: [ctx] });
-
-    let namespace: string | undefined;
-    $.OPTION({
-      GATE: () =>
-        $.LA(1).tokenType === T.PlainIdent
-        && $.LA(1).image === 'as',
-      DEF: () => {
-        $.CONSUME(T.PlainIdent);
-        $.OR2([
-          { ALT: () => {
-            namespace = $.CONSUME2(T.PlainIdent).image;
-          } },
-          { ALT: () => {
-            namespace = $.CONSUME(T.Star).image;
-          } }
-        ]);
-      }
-    });
-
-    $.CONSUME(T.Semi);
-
-    const location = $.endRule();
-    if ($.RECORDING_PHASE) {
-      return;
-    }
-
-    const rawPath = pathNode.valueOf();
-    if (isScriptUsePath(rawPath)) {
-      return new JsImport(
-        { path: pathNode },
-        { namespace: namespace ?? defaultNamespaceFromPath(rawPath) },
-        location,
-        $.context
-      );
-    }
-
-    const preludeNodes: Node[] = [pathNode];
-    if (namespace) {
-      preludeNodes.push(
-        new Any('as', { role: 'ident' }, undefined, $.context),
-        new Any(namespace, { role: namespace === '*' ? 'operator' : 'ident' }, undefined, $.context)
-      );
-    }
-    return new AtRuleStatement(
-      {
-        name: name.image,
-        prelude: new Sequence(preludeNodes, undefined, $.getLocationFromNodes(preludeNodes), $.context)
-      },
-      undefined,
-      location,
-      $.context
-    );
-  };
-}
-
-/**
- * Parse @-export './foo.jess' [as <namespace>]
- *
- * Creates a StyleImport with forward semantics (members not visible locally but transitive).
- * Does NOT support `with` (unlike @-compose).
- * Participates in evaldTrees caching like @-compose.
- */
-export function exportAtRule(this: P, T: TokenMap) {
-  const $ = this;
-  return (ctx: RuleContext = {}) => {
-    $.startRule();
-    $.CONSUME(T.AtKeyword); // '@-export'
-
-    // Parse the path (string or url)
-    const pathNode: Quoted | Url = $.OR([
-      { ALT: () => $.SUBRULE($.urlFunction, { ARGS: [ctx] }) },
-      { ALT: () => $.SUBRULE($.string, { ARGS: [ctx] }) }
-    ]);
-
-    // Optional "as <namespace>"
-    let namespace: string | undefined;
-    $.OPTION(() => {
-      const la = $.LA(1);
-      if (!((la.tokenType === T.PlainIdent || la.tokenType === T.Ident) && la.image === 'as')) {
-        return;
-      }
-      // Consume "as"
-      if ($.isType(T.Ident)) {
-        $.CONSUME(T.Ident);
-      } else {
-        $.CONSUME(T.PlainIdent);
-      }
-      // Consume namespace identifier
-      const nsTok: IToken = $.isType(T.Ident)
-        ? $.CONSUME(T.Ident)
-        : $.CONSUME(T.PlainIdent);
-      namespace = nsTok.image;
-    });
-
-    $.CONSUME(T.Semi);
-
-    const loc = $.endRule();
-    return new StyleImport(
-      { path: pathNode },
-      {
-        type: 'compose',
-        namespace,
-        importOptions: {
-          forward: true
-        }
-      },
-      loc,
-      $.context
-    );
-  };
-}