@jesscss/plugin-less-compat 2.0.0-alpha.5 → 2.0.0-alpha.7

package/lib/nodes/at-rule.d.ts

@@ -1,6 +1,2 @@
-import { AtRule } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess AtRule to a Less-compatible AtRule
- */
-export declare function transformAtRuleToLess(jessAtRule: AtRule, cache?: WeakMap<any, any>): LessNode;
+import { AtRule, Node } from '@jesscss/core';
+export declare const transformAtRuleToLess: (jessNode: AtRule, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/attribute-selector.d.ts

@@ -1,6 +1,2 @@
-import { AttributeSelector } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess AttributeSelector to a Less-compatible Attribute
- */
-export declare function transformAttributeSelectorToLess(jessAttr: AttributeSelector, cache?: WeakMap<any, any>): LessNode;
+import { AttributeSelector, Node } from '@jesscss/core';
+export declare const transformAttributeSelectorToLess: (jessNode: AttributeSelector, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/call.d.ts

@@ -1,6 +1,2 @@
-import { Call } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Call to a Less-compatible Call or MixinCall
- */
-export declare function transformCallToLess(jessCall: Call, cache?: WeakMap<any, any>): LessNode;
+import { Call, Node } from '@jesscss/core';
+export declare const transformCallToLess: (jessNode: Call, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/color.d.ts

@@ -1,6 +1,2 @@
 import { Color } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Color to a Less-compatible Color
- */
-export declare function transformColorToLess(jessColor: Color, cache?: WeakMap<any, any>): LessNode;
+export declare const transformColorToLess: (jessNode: Color, cache?: WeakMap<import("@jesscss/core").Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/combinator.d.ts

@@ -1,6 +1,2 @@
 import { Combinator } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Combinator to a Less-compatible Combinator
- */
-export declare function transformCombinatorToLess(jessCombinator: Combinator, cache?: WeakMap<any, any>): LessNode;
+export declare const transformCombinatorToLess: (jessNode: Combinator, cache?: WeakMap<import("@jesscss/core").Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/comment.d.ts

@@ -1,6 +1,2 @@
 import { Comment } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Comment to a Less-compatible Comment
- */
-export declare function transformCommentToLess(jessComment: Comment, cache?: WeakMap<any, any>): LessNode;
+export declare const transformCommentToLess: (jessNode: Comment, cache?: WeakMap<import("@jesscss/core").Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/condition.d.ts

@@ -1,6 +1,2 @@
-import { Condition } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Condition to a Less-compatible Condition
- */
-export declare function transformConditionToLess(jessCondition: Condition, cache?: WeakMap<any, any>): LessNode;
+import { Condition, Node } from '@jesscss/core';
+export declare const transformConditionToLess: (jessNode: Condition, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/declaration.d.ts

@@ -1,6 +1,2 @@
-import { Declaration } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Declaration to a Less-compatible Declaration
- */
-export declare function transformDeclarationToLess(jessDeclaration: Declaration, cache?: WeakMap<any, any>): LessNode;
+import { Declaration, Node } from '@jesscss/core';
+export declare const transformDeclarationToLess: (jessNode: Declaration<import("@jesscss/core").DeclarationOptions>, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/dimension.d.ts

@@ -1,6 +1,2 @@
 import { Dimension, Num } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Dimension or Num to a Less-compatible Dimension
- */
-export declare function transformDimensionToLess(jessDimension: Dimension | Num, cache?: WeakMap<any, any>): LessNode;
+export declare const transformDimensionToLess: (jessNode: Dimension | Num, cache?: WeakMap<import("@jesscss/core").Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/expression.d.ts

@@ -1,6 +1,2 @@
-import { Expression } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Expression to a Less-compatible Expression
- */
-export declare function transformExpressionToLess(jessExpression: Expression, cache?: WeakMap<any, any>): LessNode;
+import { Expression, Node } from '@jesscss/core';
+export declare const transformExpressionToLess: (jessNode: Expression, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/extend.d.ts

@@ -1,6 +1,2 @@
 import { Extend } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Extend to a Less-compatible Extend
- */
-export declare function transformExtendToLess(jessExtend: Extend, cache?: WeakMap<any, any>): LessNode;
+export declare const transformExtendToLess: (jessNode: Extend, cache?: WeakMap<import("@jesscss/core").Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/import.d.ts

@@ -1,6 +1,2 @@
-import { StyleImport } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess StyleImport to a Less-compatible Import
- */
-export declare function transformImportToLess(jessImport: StyleImport, cache?: WeakMap<any, any>): LessNode;
+import { StyleImport, Node } from '@jesscss/core';
+export declare const transformImportToLess: (jessNode: StyleImport, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/keyword.d.ts

@@ -1,6 +1,2 @@
 import { Keyword } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Keyword to a Less-compatible Keyword
- */
-export declare function transformKeywordToLess(jessKeyword: Keyword, cache?: WeakMap<any, any>): LessNode;
+export declare const transformKeywordToLess: (jessNode: Keyword, cache?: WeakMap<import("@jesscss/core").Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/list.d.ts

@@ -1,6 +1,3 @@
-import { List } from '@jesscss/core';
+import { List, Node } from '@jesscss/core';
 import type { LessNode } from '../types.js';
-/**
- * Transform a Jess List to a Less-compatible Value
- */
-export declare function transformListToLess(jessList: List, cache?: WeakMap<any, any>): LessNode;
+export declare const transformListToLess: (jessNode: List, cache?: WeakMap<Node, LessNode>) => LessNode;

package/lib/nodes/mixin.d.ts

@@ -1,6 +1,2 @@
-import { Mixin } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Mixin to a Less-compatible MixinDefinition
- */
-export declare function transformMixinToLess(jessMixin: Mixin, cache?: WeakMap<any, any>): LessNode;
+import { Mixin, Node } from '@jesscss/core';
+export declare const transformMixinToLess: (jessNode: Mixin, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/negative.d.ts

@@ -1,6 +1,2 @@
-import { Negative } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Negative to a Less-compatible Negative
- */
-export declare function transformNegativeToLess(jessNegative: Negative, cache?: WeakMap<any, any>): LessNode;
+import { Negative, Node } from '@jesscss/core';
+export declare const transformNegativeToLess: (jessNode: Negative, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/operation.d.ts

@@ -1,6 +1,2 @@
-import { Operation } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Operation to a Less-compatible Operation
- */
-export declare function transformOperationToLess(jessOperation: Operation, cache?: WeakMap<any, any>): LessNode;
+import { Operation, Node } from '@jesscss/core';
+export declare const transformOperationToLess: (jessNode: Operation, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/paren.d.ts

@@ -1,6 +1,2 @@
-import { Paren } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Paren to a Less-compatible Paren
- */
-export declare function transformParenToLess(jessParen: Paren, cache?: WeakMap<any, any>): LessNode;
+import { Paren, Node } from '@jesscss/core';
+export declare const transformParenToLess: (jessNode: Paren, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/quoted.d.ts

@@ -1,6 +1,2 @@
 import { Quoted } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Quoted to a Less-compatible Quoted
- */
-export declare function transformQuotedToLess(jessQuoted: Quoted, cache?: WeakMap<any, any>): LessNode;
+export declare const transformQuotedToLess: (jessNode: Quoted, cache?: WeakMap<import("@jesscss/core").Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/reference.d.ts

@@ -1,9 +1,2 @@
 import { Reference } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Reference to a Less-compatible Variable, Property, or VariableCall
- *
- * Jess has unified Reference with options.type
- * Less has separate Variable, Property, and VariableCall nodes
- */
-export declare function transformReferenceToLess(jessReference: Reference, cache?: WeakMap<any, any>): LessNode;
+export declare const transformReferenceToLess: (jessNode: Reference, cache?: WeakMap<import("@jesscss/core").Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/ruleset.d.ts

@@ -1,6 +1,2 @@
-import { Ruleset } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Ruleset to a Less-compatible Ruleset
- */
-export declare function transformRulesetToLess(jessRuleset: Ruleset, cache?: WeakMap<any, any>): LessNode;
+import { Ruleset, Node } from '@jesscss/core';
+export declare const transformRulesetToLess: (jessNode: Ruleset, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/selector.d.ts

@@ -1,8 +1,3 @@
-import { Selector, SelectorList } from '@jesscss/core';
+import { Node, type SelectorLike } from '@jesscss/core';
 import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Selector to a Less-compatible Selector
- *
- * Less Selector is an array of Element nodes
- */
-export declare function transformSelectorToLess(jessSelector: Selector | SelectorList, cache?: WeakMap<any, any>): LessNode;
+export declare function transformSelectorToLess(sel: SelectorLike, cache?: WeakMap<Node, unknown>): LessNode;

package/lib/nodes/sequence.d.ts

@@ -1,9 +1,2 @@
-import { Sequence } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Sequence (space-separated value list) to a Less-compatible Expression.
- *
- * This is critical for Less plugins that traverse into declaration values (e.g. preEval visitors
- * that rewrite variables inside custom properties).
- */
-export declare function transformSequenceToLess(jessSequence: Sequence, cache?: WeakMap<any, any>): LessNode;
+import { Sequence, Node } from '@jesscss/core';
+export declare const transformSequenceToLess: (jessNode: Sequence, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/url.d.ts

@@ -1,6 +1,2 @@
 import { Url } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess Url to a Less-compatible URL
- */
-export declare function transformUrlToLess(jessUrl: Url, cache?: WeakMap<any, any>): LessNode;
+export declare const transformUrlToLess: (jessNode: Url, cache?: WeakMap<import("@jesscss/core").Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/nodes/var-declaration.d.ts

@@ -1,6 +1,2 @@
-import { VarDeclaration } from '@jesscss/core';
-import type { LessNode } from '../types.js';
-/**
- * Transform a Jess VarDeclaration to a Less-compatible Assignment
- */
-export declare function transformVarDeclarationToLess(jessVarDecl: VarDeclaration, cache?: WeakMap<any, any>): LessNode;
+import { VarDeclaration, Node } from '@jesscss/core';
+export declare const transformVarDeclarationToLess: (jessNode: VarDeclaration, cache?: WeakMap<Node, import("../types.js").LessNode>) => import("../types.js").LessNode;

package/lib/plugin.d.ts

@@ -1,7 +1,14 @@
-import { AbstractPlugin, type Plugin, type Visitor } from '@jesscss/core';
+import { AbstractPlugin, type PluginInterface, type PluginVisitor, type Rules } from '@jesscss/core';
 import type { LessVisitor } from './types.js';
 import { NodeModulesPlugin } from '@jesscss/plugin-node-modules';
 export interface LessCompatPluginOptions {
+    /**
+     * Less 4.x custom functions registered through the root
+     * `less.functions.functionRegistry.add/addMultiple` API. Keyed by function
+     * name; each is bridged onto every compiled tree's root scope so calls resolve
+     * during evaluation, exactly like the built-in Less functions.
+     */
+    functions?: Record<string, (...args: any[]) => any>;
     /**
      * Less.js plugins - these will have their install() method called to extract visitors.
      * Can be mixed with Jess plugins - Less plugins will be handled by this compat layer,
@@ -16,16 +23,20 @@ export interface LessCompatPluginOptions {
     /** Enable conversion caching (default: true) */
     cache?: boolean;
     /**
-     * Plugin registry for @plugin directive support.
+     * Plugin registry for deprecated @plugin directive support.
      * Maps plugin names/paths to plugin instances or factory functions.
      * Used when processing @plugin directives in the source.
+     *
+     * @deprecated Less @plugin is deprecated. Prefer @use / @-use for script integration in .less files.
      */
     pluginRegistry?: Record<string, any>;
     /**
-     * Enable auto-loading of plugins by name (Less.js 4.x CLI behavior).
+     * Enable auto-loading of deprecated @plugin plugins by name (Less.js 4.x CLI behavior).
      * When true (default), @plugin directives will attempt to require/import
      * plugins by their npm package name (e.g., "less-plugin-autoprefix").
      * Set to false to disable and only use pluginRegistry.
+     *
+     * @deprecated Less @plugin is deprecated. Prefer @use / @-use for script integration in .less files.
      */
     autoLoadPlugins?: boolean;
     /**
@@ -46,26 +57,43 @@ export declare class LessCompatPlugin extends AbstractPlugin {
     private _lessPluginManager?;
     private _currentFilePath?;
     private _jessFunctionRegistry?;
+    private _context?;
+    /** Trees whose root scope already received the configured root functions. */
+    private _fnRegisteredTrees;
     constructor(opts?: LessCompatPluginOptions);
     /**
-     * Return the visitor as a preEval visitor so it runs before evaluation.
-     * This ensures @plugin directives are processed early, allowing their visitors
-     * to run on subsequent nodes during the preEval phase.
+     * Return the visitor through the early visitor hook so it runs before
+     * evaluation. This keeps Less plugin visitors and preprocessors early without
+     * bringing back a public node preparation pass.
      *
      * Less plugins can register visitors via:
-     * - addVisitor() - these will run during preEval (default)
-     * - addPreProcessor() - these will run during preEval
-     * - addPostProcessor() - these will run during postEval (after evaluation)
+     * - addVisitor() - these run early by default
+     * - addPreProcessor() - these run early
+     * - addPostProcessor() - these run on serialized CSS after render
      */
-    get preEvalVisitor(): Visitor | Visitor[] | undefined;
+    get beforeEvalVisitor(): PluginInterface['beforeEvalVisitor'];
     /**
-     * Return postEval visitors from Less plugins that registered via addPostProcessor.
-     * These visitors will run after node.eval() completes.
+     * Less post-processors operate on final CSS, not on the preRenderVisitor tree hook.
      */
-    get postEvalVisitor(): undefined;
+    get postEvalVisitor(): PluginInterface['postEvalVisitor'];
     runPostProcessors(css: string, extra?: Record<string, any>): string;
     setCurrentFilePath(filePath: string): void;
     setContext(context: any): void;
+    private createJessFunctionBindingRegistry;
+    private hasConfiguredBeforeEvalWork;
+    private sourceMayContainPluginDirective;
+    private treeContainsPluginDirective;
+    private warnForPluginDirective;
+    private markPluginDirectiveInvisible;
+    private registerDenoLessPluginFunctions;
+    private loadLessPluginFileWithDeno;
+    beforeEvalVisitorForTree(tree: Rules): PluginInterface['beforeEvalVisitor'];
+    /**
+     * Register the configured Less 4.x root functions onto a parsed tree's root
+     * scope, using the same `setFunctionBinding` mechanism the Less plugin uses
+     * for built-ins. Idempotent per tree.
+     */
+    private registerRootFunctions;
     /**
      * Filter and separate Less plugins from Jess plugins
      * This allows mixed plugin arrays to be handled correctly
@@ -74,7 +102,7 @@ export declare class LessCompatPlugin extends AbstractPlugin {
      */
     static filterLessPlugins(plugins: any[]): {
         lessPlugins: any[];
-        jessPlugins: import("@jesscss/core").PluginInterface[];
+        jessPlugins: PluginInterface[];
     };
     /**
      * Return a visitor that wraps Less visitors
@@ -82,11 +110,11 @@ export declare class LessCompatPlugin extends AbstractPlugin {
      * This visitor intercepts each node, converts it to Less format,
      * runs the Less visitors, and converts back if modified.
      */
-    get visitor(): Visitor | Visitor[] | undefined;
+    get visitor(): PluginVisitor | PluginVisitor[] | undefined;
 }
 /**
  * Create a Less.js compatibility plugin
  */
-declare const lessCompatPlugin: Plugin;
+declare const lessCompatPlugin: (opts?: LessCompatPluginOptions) => LessCompatPlugin;
 export default lessCompatPlugin;
 export { lessCompatPlugin };

package/lib/transform/adapter.d.ts

@@ -0,0 +1,31 @@
+import { Node } from '@jesscss/core';
+import { type LessAdapterField } from './less-adapter.js';
+import type { LessNode } from '../types.js';
+type NodeTransformer<T extends Node> = (jessNode: T, cache?: WeakMap<Node, LessNode>) => LessNode;
+type AcceptFn<T extends Node> = (node: T, visitor: {
+    visitArray?: (nodes: LessNode[]) => void;
+    visit?: (node: LessNode) => unknown;
+}, cache?: WeakMap<Node, unknown>) => T | unknown;
+export interface NodeAdapter<T extends Node> {
+    lessType?: string | ((node: T) => string);
+    fields: Record<string, LessAdapterField<T>>;
+    accept?: AcceptFn<T>;
+}
+/**
+ * Create a NodeTransformer from a declarative adapter definition.
+ *
+ * - `type` and `typeIndex` are auto-mapped.
+ * - If no `accept` is provided, leaf behavior (return self) is used.
+ * - Field lookups are dispatched from the `fields` record.
+ */
+export declare function createFromAdapter<T extends Node>(adapter: NodeAdapter<T>): NodeTransformer<T>;
+export declare function selfVisitAccept<T extends Node>(): AcceptFn<T>;
+/**
+ * Accept helper: traverse child nodes via visitor.visitArray.
+ */
+export declare function childrenAccept<T extends Node>(getChildren: (node: T, cache?: WeakMap<Node, unknown>) => Node[]): AcceptFn<T>;
+/**
+ * Accept helper: traverse a single child node.
+ */
+export declare function singleChildAccept<T extends Node>(getChild: (node: T) => Node | undefined): AcceptFn<T>;
+export {};

package/lib/transform/index.cjs

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_less_adapter = require("../less-adapter.cjs");
+const require_transform = require("../transform.cjs");
+exports.LessAdapterBase = require_less_adapter.LessAdapterBase;
+exports.createLessAdapter = require_less_adapter.createLessAdapter;
+exports.fromLessNode = require_transform.fromLessNode;
+exports.fromLessPluginReturnValue = require_transform.fromLessPluginReturnValue;
+exports.fromLessTree = require_transform.fromLessTree;
+exports.getLessTypeIndex = require_less_adapter.getLessTypeIndex;
+exports.mapJessTypeToLessType = require_less_adapter.mapJessTypeToLessType;
+exports.mapLessTypeToJessType = require_less_adapter.mapLessTypeToJessType;
+exports.toLessNode = require_transform.toLessNode;
+exports.toLessTree = require_transform.toLessTree;

package/lib/transform/index.d.ts

@@ -3,5 +3,5 @@
  */
 export { toLessNode, toLessTree, type ToLessOptions } from './to-less.js';
 export { fromLessNode, fromLessPluginReturnValue, fromLessTree, type FromLessOptions } from './from-less.js';
-export { createLessProxy, isLessProxy, getJessNodeFromProxy } from './proxy.js';
+export { createLessAdapter, LessAdapterBase } from './less-adapter.js';
 export { mapJessTypeToLessType, mapLessTypeToJessType, getLessTypeIndex } from './type-map.js';

package/lib/transform/index.js

@@ -1,8 +1,3 @@
-/**
- * Transformation utilities for converting between Jess and Less AST nodes
- */
-export { toLessNode, toLessTree } from './to-less.js';
-export { fromLessNode, fromLessPluginReturnValue, fromLessTree } from './from-less.js';
-export { createLessProxy, isLessProxy, getJessNodeFromProxy } from './proxy.js';
-export { mapJessTypeToLessType, mapLessTypeToJessType, getLessTypeIndex } from './type-map.js';
-//# sourceMappingURL=index.js.map
+import { a as mapJessTypeToLessType, i as getLessTypeIndex, n as createLessAdapter, o as mapLessTypeToJessType, t as LessAdapterBase } from "../less-adapter.js";
+import { a as fromLessTree, i as fromLessPluginReturnValue, n as toLessTree, r as fromLessNode, t as toLessNode } from "../transform.js";
+export { LessAdapterBase, createLessAdapter, fromLessNode, fromLessPluginReturnValue, fromLessTree, getLessTypeIndex, mapJessTypeToLessType, mapLessTypeToJessType, toLessNode, toLessTree };

package/lib/transform/less-adapter.d.ts

@@ -0,0 +1,29 @@
+import { Node } from '@jesscss/core';
+declare const LESS_ADAPTER_SYMBOL: unique symbol;
+declare const JESS_NODE_SYMBOL: unique symbol;
+export declare const IS_ADAPTING_SYMBOL: unique symbol;
+export type LessAdapterField<T extends Node> = ((node: T, cache?: WeakMap<Node, unknown>) => unknown) | {
+    get: (node: T, cache?: WeakMap<Node, unknown>) => unknown;
+    set?: (node: T, value: unknown, cache?: WeakMap<Node, unknown>) => void;
+    enumerable?: boolean;
+};
+export interface LessAdapterDefinition<T extends Node> {
+    lessType?: string | ((node: T) => string);
+    fields?: Record<string, LessAdapterField<T>>;
+    accept?: (node: T, visitor: any, cache?: WeakMap<Node, unknown>) => any;
+}
+export type LessAdapterInstance<T extends Node = Node> = LessAdapterBase<T> & {
+    type: string;
+    typeIndex: number | undefined;
+    accept(visitor: unknown): T | unknown;
+};
+export declare class LessAdapterBase<T extends Node = Node> {
+    readonly [LESS_ADAPTER_SYMBOL] = true;
+    readonly [JESS_NODE_SYMBOL]: T;
+    readonly ['__jessNode']: T;
+    constructor(node: T);
+    get jessNode(): T;
+}
+export declare function createLessAdapter<T extends Node>(jessNode: T, definition: LessAdapterDefinition<T>, cache?: WeakMap<Node, unknown>): LessAdapterInstance<T>;
+export declare function isAdaptingNode(node: Node): boolean;
+export {};