@jesscss/less-parser 1.0.8-alpha.6 → 2.0.0-alpha.2

package/lib/lessTokens.js

@@ -1,155 +1,249 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tokens = exports.Fragments = void 0;
-const css_parser_1 = require("@jesscss/css-parser");
-exports.Fragments = [...css_parser_1.Fragments];
-exports.Tokens = [...css_parser_1.Tokens];
-exports.Fragments.unshift(['lineComment', '\\/\\/[^\\n\\r]*']);
-exports.Fragments.push(['interpolated', '[@$]\\{({{ident}})\\}']);
-exports.Fragments.forEach(fragment => {
-    if (fragment[0].indexOf('wsorcomment') !== -1) {
-        fragment[1] = '(?:({{ws}})|({{comment}})|({{lineComment}}))';
-    }
-});
-/** Keyed by what to insert after */
-const merges = {
-    Assign: [
-        { name: 'Ampersand', pattern: /&/, categories: ['Selector'] },
-        { name: 'Ellipsis', pattern: /\.\.\./ }
-    ],
-    PlainIdent: [
-        { name: 'Interpolated', pattern: css_parser_1.LexerType.NA },
-        {
-            name: 'InterpolatedIdent',
-            pattern: ['{{interpolated}}', css_parser_1.groupCapture],
-            categories: ['Interpolated', 'Selector'],
-            start_chars_hint: ['@', '$']
-        },
+import { rawCssFragments, rawCssTokens, LexerType, groupCapture, SKIPPED_LABEL } from '@jesscss/css-parser';
+function $preBuildFragments() {
+    const fragments = rawCssFragments();
+    fragments.unshift(['lineComment', '\\/\\/[^\\n\\r]*']);
+    fragments.push(['interpolated', '[@$]\\{(?:{{nmchar}}*)\\}']);
+    return fragments;
+}
+function $preBuildTokens() {
+    const tokens = rawCssTokens();
+    /**
+     * Keyed by what to insert after
+     *
+     * @todo - Move merge utility to css-parser
+    */
+    const merges = {
+        Assign: [
+            {
+                name: 'Ellipsis',
+                pattern: /\.\.\./,
+                categories: ['BlockMarker']
+            },
+            /**
+             * Less's historical parser unfortunately allows
+             * at-keywords that are not valid in CSS. One is
+             * that Less allows at-keywords to begin with numbers.
+             * Another is that it allows an at-rule that only
+             * contains a single dash. So we capture this as
+             * a separate token.
+             *
+             * We also do this later in the token stack so that we
+             * don't accidentally grab something like
+             * @-webkit-keyframes while looking for @-.
+             */
+            {
+                name: 'AtKeywordLessExtension',
+                pattern: '@(?:-|\\d(?:{{nmchar}})*)',
+                categories: ['BlockMarker', 'AtName']
+            }
+        ],
+        PlainIdent: [
+            { name: 'Interpolated', pattern: LexerType.NA },
+            {
+                name: 'LineComment',
+                pattern: '{{lineComment}}',
+                label: SKIPPED_LABEL
+            },
+            { name: 'PlusAssign', pattern: '\\+{{whitespace}}*:', categories: ['BlockMarker', 'Assign'] },
+            {
+                name: 'UnderscoreAssign',
+                pattern: '\\+{{whitespace}}*_{{whitespace}}*:',
+                categories: ['BlockMarker', 'Assign']
+            },
+            { name: 'AnonMixinStart', pattern: /[.#]\(/, categories: ['BlockMarker'] },
+            { name: 'GtEqAlias', pattern: /=>/, categories: ['CompareOperator'] },
+            { name: 'LtEqAlias', pattern: /=</, categories: ['CompareOperator'] },
+            {
+                name: 'Extend',
+                pattern: /:extend\(/,
+                categories: ['BlockMarker']
+            },
+            {
+                name: 'VarOrProp',
+                pattern: LexerType.NA
+            },
+            {
+                name: 'NestedReference',
+                pattern: ['([@$]+{{ident}}?){2,}', groupCapture],
+                start_chars_hint: ['@', '$'],
+                categories: ['VarOrProp'],
+                line_breaks: true
+            },
+            {
+                name: 'PropertyReference',
+                pattern: '\\${{ident}}',
+                categories: ['VarOrProp']
+            },
+            /** Can be used in unit function or mod operation */
+            {
+                name: 'Percent',
+                pattern: /%/
+            },
+            {
+                name: 'DefaultGuardIdent',
+                pattern: /default/,
+                longer_alt: 'PlainIdent',
+                categories: ['Ident']
+            },
+            {
+                name: 'DefaultGuardFunc',
+                pattern: /default(?:\(\))/
+            }
+        ],
+        Ampersand: [
+            {
+                name: 'AmpersandExtend',
+                pattern: /&:extend\(/,
+                categories: ['BlockMarker']
+            },
+            {
+                name: 'AllFlag',
+                pattern: /!all/,
+                categories: ['BlockMarker']
+            }
+        ],
+        UrlStart: [
+            /**
+             * Keywords that we don't identify as idents
+             * should be manually added to other places where an ident is valid.
+             */
+            {
+                name: 'When',
+                pattern: /when/i,
+                longer_alt: 'PlainIdent',
+                categories: ['BlockMarker']
+            },
+            {
+                name: 'FormatFunction',
+                pattern: /%\(/,
+                categories: ['BlockMarker', 'FunctionStart']
+            },
+            {
+                name: 'IfFunction',
+                pattern: /if\(/,
+                categories: ['BlockMarker', 'FunctionStart']
+            },
+            {
+                name: 'BooleanFunction',
+                pattern: /boolean\(/,
+                categories: ['BlockMarker', 'FunctionStart']
+            },
+            {
+                name: 'JavaScript',
+                pattern: /~?`[^`]*`/,
+                line_breaks: true
+            }
+        ],
         /**
-         * Unfortunately, there's grammatical ambiguity between
-         * interpolated props and a naked interpolated selector name,
-         * making this awkward token necessary.
+         * These need to be after any keywords, so that
+         * keywords with a longer_alt of `PlainIdent`
+         * aren't captured first.
          */
-        {
-            name: 'InterpolatedSelector',
-            pattern: ['[.#:]{{interpolated}}', css_parser_1.groupCapture],
-            categories: ['Interpolated', 'Selector'],
-            start_chars_hint: ['.', '#', ':']
-        },
-        { name: 'PlusAssign', pattern: '\\+{{whitespace}}*:', categories: ['BlockMarker', 'Assign'] },
-        {
-            name: 'UnderscoreAssign',
-            pattern: '\\+{{whitespace}}*_{{whitespace}}*:',
-            categories: ['BlockMarker', 'Assign']
-        },
-        { name: 'AnonMixinStart', pattern: /[.#]\(/, categories: ['BlockMarker'] },
-        { name: 'GtEqAlias', pattern: /=>/, categories: ['CompareOperator'] },
-        { name: 'LtEqAlias', pattern: /=</, categories: ['CompareOperator'] },
-        {
-            name: 'Extend',
-            pattern: /:extend\(/,
-            categories: ['BlockMarker']
-        },
-        {
-            name: 'When',
-            pattern: /when/,
-            longer_alt: 'PlainIdent',
-            categories: ['BlockMarker']
-        },
-        {
-            name: 'VarOrProp',
-            pattern: css_parser_1.LexerType.NA
-        },
-        {
-            name: 'NestedReference',
-            pattern: ['([@$]+{{ident}}?){2,}', css_parser_1.groupCapture],
-            start_chars_hint: ['@', '$'],
-            categories: ['VarOrProp']
-        },
-        {
-            name: 'PropertyReference',
-            pattern: '\\$-?{{ident}}',
-            categories: ['VarOrProp']
+        Signed: [
+            {
+                name: 'InterpolatedIdent',
+                /**
+                 * Must contain one `@{}`
+                 * It's too expensive for Chevrotain to capture groups here,
+                 * so we'll extract the interpolated values later.
+                 */
+                pattern: '(?:{{ident}}|-)?{{interpolated}}(?:{{interpolated}}|{{nmchar}})*',
+                categories: ['Interpolated', 'Selector', 'Ident']
+            },
+            {
+                name: 'InterpolatedCustomProperty',
+                /**
+                 * Must contain one `@{}`
+                 * It's too expensive for Chevrotain to capture groups here,
+                 * so we'll extract the interpolated values later.
+                 */
+                pattern: '--{{ident}}?{{interpolated}}(?:{{interpolated}}|{{nmchar}})*',
+                categories: ['Interpolated']
+            },
+            /**
+           * Unfortunately, there's grammatical ambiguity between
+           * interpolated props and a naked interpolated selector name,
+           * making this awkward token necessary.
+           */
+            {
+                name: 'InterpolatedSelector',
+                pattern: ['[.#]{{ident}}?{{interpolated}}(?:{{interpolated}}|{{nmchar}})*', groupCapture],
+                categories: ['Interpolated', 'Selector'],
+                start_chars_hint: ['.', '#'],
+                line_breaks: true
+            }
+        ]
+    };
+    let defaultTokens = tokens.modes.Default.slice();
+    let tokenLength = defaultTokens.length;
+    for (let i = 0; i < tokenLength; i++) {
+        let token = defaultTokens[i];
+        const { name } = token;
+        const copyToken = () => {
+            token = structuredClone(token);
+        };
+        let alterations = true;
+        switch (name) {
+            /**
+             * Less / Sass Ampersand is slightly different
+             * from CSS Nesting in that it concatenates, so we
+             * need to gobble up the rest of the identifier
+             * if present.
+             */
+            case 'Ampersand':
+                copyToken();
+                /**
+                 * Captures not just ampersands, but "ampersand merges", where
+                 * the intent of the author was to merge the parent selector with a token
+                 * suffix or prefix.
+                 *
+                 * e.g.
+                 *   1. &-foo
+                 *   2. &(foo)
+                 *   3. &1
+                 *   4. .foo-&
+                 */
+                token.pattern = '(?:[.#](?:{{ident}}-)?&|&)(?:\\((?:[.#]|{{nmchar}}|&)+\\)|{{nmchar}}*)';
+                token.start_chars_hint = ['&', '.', '#'];
+                break;
+            case 'DotName':
+            case 'HashName':
+                copyToken();
+                token.longer_alt = 'Ampersand';
+                break;
+            case 'Divide':
+                copyToken();
+                token.pattern = /\.?\//;
+                break;
+            case 'SingleQuoteStart':
+                copyToken();
+                token.pattern = /~?'/;
+                break;
+            case 'DoubleQuoteStart':
+                copyToken();
+                token.pattern = /~?"/;
+                break;
+            default:
+                alterations = false;
         }
-    ],
-    // AtMedia: [
-    //   {
-    //     name: 'AtPlugin',
-    //     pattern: /@plugin/,
-    //     longer_alt: 'AtKeyword',
-    //     categories: ['BlockMarker', 'AtName']
-    //   }
-    // ],
-    PlainFunction: [
-        /** Can be used in unit function */
-        {
-            name: 'Percent',
-            pattern: /%/
-        },
-        {
-            name: 'FormatFunction',
-            pattern: /%\(/,
-            categories: ['BlockMarker', 'Function']
-        },
-        {
-            name: 'IfFunction',
-            pattern: /if\(/,
-            categories: ['BlockMarker', 'Function']
-        },
-        {
-            name: 'BooleanFunction',
-            pattern: /boolean\(/,
-            categories: ['BlockMarker', 'Function']
+        if (alterations) {
+            defaultTokens[i] = token;
         }
-    ],
-    Uri: [
-        {
-            name: 'JavaScript',
-            pattern: /`[^`]*`/,
-            group: css_parser_1.LexerType.SKIPPED,
-            line_breaks: true
+        // @ts-expect-error - Suppress index warning
+        const merge = merges[name];
+        if (merge) {
+            /** Insert after current token */
+            defaultTokens = defaultTokens.slice(0, i + 1).concat(merge, defaultTokens.slice(i + 1));
+            tokens.modes.Default = defaultTokens;
+            const mergeLength = merge.length;
+            tokenLength += mergeLength;
+            i += mergeLength;
         }
-    ]
-};
-let tokenLength = exports.Tokens.length;
-for (let i = 0; i < tokenLength; i++) {
-    let token = exports.Tokens[i];
-    let { name, categories } = token;
-    const copyToken = () => {
-        token = Object.assign({}, token);
-        categories = categories ? categories.slice(0) : [];
-    };
-    let alterations = true;
-    switch (name) {
-        // Removed in Less v5
-        // case 'Divide':
-        //   copyToken()
-        //   token.pattern = /\.?\//
-        //   break
-        case 'StringLiteral':
-            copyToken();
-            token.pattern = '~?{{string1}}|~?{{string2}}';
-            break;
-        case 'CustomProperty':
-            copyToken();
-            token.pattern = '--(?:{{nmstart}}{{nmchar}}*)?';
-            break;
-        case 'AtKeyword':
-            copyToken();
-            token.categories = categories.concat(['VarOrProp']);
-            break;
-        default:
-            alterations = false;
-    }
-    if (alterations) {
-        exports.Tokens[i] = token;
-    }
-    const merge = merges[name];
-    if (merge) {
-        /** Insert after current token */
-        exports.Tokens = exports.Tokens.slice(0, i + 1).concat(merge, exports.Tokens.slice(i + 1));
-        const mergeLength = merge.length;
-        tokenLength += mergeLength;
-        i += mergeLength;
     }
+    return tokens;
 }
+export const Fragments = $preBuildFragments();
+export const Tokens = $preBuildTokens();
+export const lessFragments = () => Fragments;
+export const lessTokens = () => Tokens;
+//# sourceMappingURL=lessTokens.js.map

package/lib/lessTokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lessTokens.js","sourceRoot":"","sources":["../src/lessTokens.ts"],"names":[],"mappings":"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"}

package/lib/productions.d.ts

@@ -0,0 +1,181 @@
+import { type LessActionsParser as P, type TokenMap, type RuleContext } from './lessActionsParser.js';
+import { type IToken } from 'chevrotain';
+import { type AltContext } from '@jesscss/css-parser';
+import { Node, Block, Any, Ruleset, List, Sequence, Call, Paren, Quoted, AtRule, Mixin, Condition, VarDeclaration, DefaultGuard, StyleImport, Expression, SelectorCapture, CompoundSelector, Rules, Nil, Collection, type Selector, type SimpleSelector } from '@jesscss/core';
+/** Charset moved within `main` (explained in that rule) */
+export declare function stylesheet(this: P, T: TokenMap): (options?: Record<string, any>) => Node<unknown, import("core/lib/tree/node-base.js").NodeOptions> | undefined;
+export declare function main(this: P, T: TokenMap): (ctx?: RuleContext) => Rules | undefined;
+export declare function declarationList(this: P, T: TokenMap): (ctx?: RuleContext) => Rules | undefined;
+export declare function declaration(this: P, T: TokenMap): (ctx?: RuleContext) => import("@jesscss/core").CustomDeclaration | undefined;
+export declare function mediaInParens(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+export declare function containerInParens(this: P, _T: TokenMap, _alt?: AltContext): (ctx?: RuleContext) => any;
+export declare function mfValue(this: P, _T: TokenMap): (ctx?: RuleContext) => any;
+export declare function mfNonIdentifierValue(this: P, T: TokenMap, _alt?: AltContext): (ctx?: RuleContext) => any;
+export declare function wrappedDeclarationList(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+export declare function qualifiedRuleBody(this: P, T: TokenMap): (ctx?: RuleContext) => Ruleset<{
+    selector: Selector<any, import("core/lib/tree/node-base.js").NodeOptions>;
+    rules: any;
+    guard: Condition | undefined;
+}> | undefined;
+export declare function qualifiedRule(this: P, _T: TokenMap, altContext?: AltContext): (ctx?: RuleContext) => any;
+/**
+ * In order to not do any backtracking, anything with a class or id selector start
+ * will end up here, and everything else will be shunted to the qualified rule.
+ */
+export declare function mixinOrQualifiedRule(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+/**
+ * We need to now handle a returned `Extend` node from the complexSelector rule
+ */
+export declare function relativeSelector(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+export declare function compoundSelector(this: P, T: TokenMap): (ctx?: RuleContext) => CompoundSelector | SimpleSelector<any, import("core/lib/tree/node-base.js").NodeOptions> | undefined;
+/**
+ * Extended with :extend
+ */
+export declare function complexSelector(this: P, T: TokenMap): (ctx?: RuleContext) => Selector<any, import("core/lib/tree/node-base.js").NodeOptions>;
+/**
+ * &:extend(...) statement ending with a semicolon.
+ * This is the only valid standalone extend statement in Less.
+ */
+export declare function ampersandExtend(this: P, T: TokenMap): (ctx?: RuleContext) => Nil | undefined;
+export declare function extend(this: P, T: TokenMap): (ctx?: RuleContext) => void;
+export declare function simpleSelector(this: P, T: TokenMap): (ctx?: RuleContext) => Node<unknown, import("core/lib/tree/node-base.js").NodeOptions> | undefined;
+export declare function anonymousMixinDefinition(this: P, T: TokenMap): (ctx?: RuleContext) => Mixin | Collection | undefined;
+/**
+ * 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 declare function importAtRule(this: P, T: TokenMap): (ctx?: RuleContext) => AtRule | StyleImport | undefined;
+/** Less variables */
+export declare function varDeclarationOrCall(this: P, T: TokenMap): (ctx?: RuleContext) => Expression | VarDeclaration | undefined;
+export declare function selectorCapture(this: P, T: TokenMap): (ctx?: RuleContext) => SelectorCapture | undefined;
+export declare function valueSequence(this: P, _T: TokenMap): (ctx?: RuleContext) => Node<unknown, import("core/lib/tree/node-base.js").NodeOptions> | Sequence | undefined;
+export declare function squareValue(this: P, T: TokenMap): (ctx?: RuleContext) => Block | undefined;
+/**
+ * In CSS, would be a single value.
+ * In Less, these are math expressions which
+ * represent a single value. During AST construction,
+ * these will be grouped by order of operations.
+ */
+export declare function expressionSum(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+export declare function expressionProduct(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+export declare function expressionValue(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+/**
+ * Add interpolation
+ */
+export declare function nthValue(this: P, T: TokenMap): (ctx?: import("@jesscss/css-parser").RuleContext) => Any<"any"> | undefined;
+export declare function knownFunctions(this: P, T: TokenMap): (ctx?: import("@jesscss/css-parser").RuleContext) => any;
+/**
+ * Override CSS calc() parsing so we can maintain parse-time `calcFrames`.
+ * This is the parse-time analogue of `Call.evalNode`'s calcFrames++/--.
+ */
+export declare function calcFunction(this: P, T: TokenMap): (ctx?: RuleContext) => Call | undefined;
+export declare function ifFunction(this: P, T: TokenMap): (ctx?: RuleContext) => Call | undefined;
+export declare function booleanFunction(this: P, T: TokenMap): (ctx?: RuleContext) => Expression | undefined;
+/** At AST time, join comma-lists together if separated by semis */
+export declare function varReference(this: P, T: TokenMap): (ctx?: RuleContext) => Node<unknown, import("core/lib/tree/node-base.js").NodeOptions> | undefined;
+export declare function valueReference(this: P, _T: TokenMap): (ctx?: RuleContext) => any;
+export declare function functionCall(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+export declare function functionCallArgs(this: P, T: TokenMap): (ctx?: RuleContext) => List<Node<unknown, import("core/lib/tree/node-base.js").NodeOptions>> | undefined;
+export declare function value(this: P, T: TokenMap): (ctx?: RuleContext) => Node<unknown, import("core/lib/tree/node-base.js").NodeOptions> | undefined;
+export declare function string(this: P, T: TokenMap): (_ctx?: RuleContext) => Quoted | undefined;
+export declare function mathValue(this: P, T: TokenMap): (ctx?: import("@jesscss/css-parser").RuleContext) => Node<unknown, import("core/lib/tree/node-base.js").NodeOptions> | undefined;
+/** @todo - add interpolation */
+export declare function guard(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+/**
+ * 'or' expression
+ * Allows an (outer) comma like historical media queries
+ */
+export declare function guardOr(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+export declare function guardDefault(this: P, T: TokenMap): (ctx?: RuleContext) => DefaultGuard | undefined;
+/**
+ * '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 declare function guardAnd(this: P, T: TokenMap): (ctx?: RuleContext) => Node<unknown, import("core/lib/tree/node-base.js").NodeOptions>;
+export declare function guardInParens(this: P, T: TokenMap): (ctx: RuleContext) => Paren | undefined;
+export declare function guardInner(this: P, _T: TokenMap): (ctx?: RuleContext) => any;
+export declare function guardWithConditionValue(this: P, T: TokenMap): (ctx?: RuleContext) => void;
+export declare function guardWithCondition(this: P, T: TokenMap): (ctx?: RuleContext) => void;
+/**
+ * Currently, Less only allows a single comparison expression,
+ * unlike Media Queries Level 4, which allows a left and right
+ * comparison.
+ */
+export declare function comparison(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+/**
+ * Less (perhaps unwisely) allows bubling of normally document-root
+ * at-rules, so we need to override CSS here.
+ */
+export declare function innerAtRule(this: P, T: TokenMap): (ctx?: import("@jesscss/css-parser").RuleContext) => any;
+/**
+ * Less override: allow variable reference as the first segment of a layer-name
+ * CSS: <ident> ('.' <ident>)*
+ * Less: (<var-ref> | <ident>) ('.' <ident>)*
+ */
+export declare function layerName(this: P, T: TokenMap): (ctx?: RuleContext) => Sequence | undefined;
+/**
+ * Less override: allow variable reference for @keyframes name
+ * CSS: Ident | String
+ * Less: valueReference | Ident | String
+ */
+export declare function keyframesName(this: P, T: TokenMap): (ctx?: RuleContext) => Node<unknown, import("core/lib/tree/node-base.js").NodeOptions>;
+/**
+ * One of the rare rules that returns a token, because
+ * other rules will transform it differently.
+ */
+export declare function mixinName(this: P, T: TokenMap): (ctx?: RuleContext) => Node<unknown, import("core/lib/tree/node-base.js").NodeOptions> | undefined;
+/**
+ * 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 declare function mixinReference(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+export declare function mixinArgs(this: P, T: TokenMap): (ctx?: RuleContext) => List<Node<unknown, import("core/lib/tree/node-base.js").NodeOptions>> | undefined;
+export declare function lookupOrCall(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+/**
+ * @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 declare function mixinArgList(this: P, T: TokenMap): (ctx?: RuleContext) => List<Node<unknown, import("core/lib/tree/node-base.js").NodeOptions>> | undefined;
+/**
+ * Less is more lenient about at-keywords. See lessTokens.ts for more details.
+ */
+export declare function varName(this: P, T: TokenMap): () => IToken;
+/**
+ * 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 declare function mixinArg(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+export declare function callArgument(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+/**
+ * Override unknownAtRule to handle @-export for stylesheet forwarding.
+ * @-export is like @-compose but with forward semantics and no `with` support.
+ */
+export declare function unknownAtRule(this: P, T: TokenMap): (ctx?: RuleContext) => any;
+/**
+ * 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 declare function exportAtRule(this: P, T: TokenMap): (ctx?: RuleContext) => StyleImport | undefined;