@jesscss/plugin-less-compat 2.0.0-alpha.6 → 2.0.0-alpha.8

package/lib/less-compat-structures.js

@@ -1,519 +1,374 @@
+import { t as LessAdapterBase } from "./less-adapter.js";
+//#region src/less-compat-structures.ts
 /**
- * Minimal Less.js-compatible structures for plugin compatibility
- * These are standalone implementations that don't require the actual Less.js library
- */
+* Minimal Less.js-compatible structures for plugin compatibility
+* These are standalone implementations that don't require the actual Less.js library
+*/
 /**
- * Less.js Visitor base class (minimal implementation)
- * Plugins expect this structure to exist
- */
-import { isLessProxy } from './transform/proxy.js';
-export class LessVisitor {
-    visitor;
-    // Track nodes being processed to prevent infinite recursion
-    processingNodes = new WeakSet();
-    constructor(visitor) {
-        this.visitor = visitor;
-        // Some plugins pass a visitor instance
-    }
-    /**
-     * Visit a node - handles both modern and legacy Less.js node types
-     * Supports Less.js v2 "Directive" nodes (mapped to AtRule)
-     *
-     * In Less.js v2, at-rules were called "Directive" instead of "AtRule".
-     * For compatibility, we route AtRule nodes to visitDirective() if that method exists,
-     * allowing v2 plugins to work with modern AtRule nodes.
-     */
-    visit(node, visitArgs) {
-        if (!node) {
-            return node;
-        }
-        if (!this.visitor) {
-            return node;
-        }
-        // Prevent infinite recursion - if we're already processing this node, skip
-        if (this.processingNodes.has(node)) {
-            return node;
-        }
-        // Mark as processing
-        this.processingNodes.add(node);
-        // Initialize visitArgs if not provided (Less.js pattern)
-        const args = visitArgs || { visitDeeper: true };
-        if (args.visitDeeper === undefined) {
-            args.visitDeeper = true;
-        }
-        const nodeType = node.type;
-        if (!nodeType || typeof nodeType !== 'string') {
-            // Fallback to generic visit if no type
-            if (typeof this.visitor.visit === 'function') {
-                const result = this.visitor.visit(node, args);
-                // Traverse children if visitDeeper is true
-                if (args.visitDeeper && node && node.accept) {
-                    node.accept(this);
-                }
-                return result;
-            }
-            return node;
-        }
-        // Less.js Visitor pattern: look for visit${NodeType} method
-        // e.g., visitRuleset, visitDeclaration, visitMedia, etc.
-        const visitMethodName = `visit${nodeType}`;
-        let result = node;
-        let visitMethod;
-        if (typeof this.visitor[visitMethodName] === 'function') {
-            visitMethod = this.visitor[visitMethodName];
-        }
-        else if (nodeType === 'Directive' || nodeType === 'AtRule') {
-            // Handle Less.js v2 legacy: Directive -> AtRule
-            // Also handle AtRule -> visitDirective for v2 plugin compatibility
-            // Check visitDirective first (v2 plugins), then visitAtRule (modern plugins)
-            if (typeof this.visitor.visitDirective === 'function') {
-                visitMethod = this.visitor.visitDirective;
-            }
-            else if (typeof this.visitor.visitAtRule === 'function') {
-                visitMethod = this.visitor.visitAtRule;
-            }
-        }
-        else if (nodeType === 'Rule') {
-            // Handle Less.js v2 legacy: Rule -> Declaration
-            if (typeof this.visitor.visitRule === 'function') {
-                visitMethod = this.visitor.visitRule;
-            }
-            else if (typeof this.visitor.visitDeclaration === 'function') {
-                visitMethod = this.visitor.visitDeclaration;
-            }
-        }
-        else if (nodeType === 'Reference') {
-            // Reference -> Variable mapping
-            if (typeof this.visitor.visitVariable === 'function') {
-                visitMethod = this.visitor.visitVariable;
-            }
-            else if (typeof this.visitor.visitReference === 'function') {
-                visitMethod = this.visitor.visitReference;
-            }
-        }
-        // Call the visit method if found
-        if (visitMethod) {
-            result = visitMethod.call(this.visitor, node, args);
-            // If visitor is replacing and returned a new node, use it
-            if (this.visitor.isReplacing && result !== undefined) {
-                node = result;
-            }
-        }
-        else if (typeof this.visitor.visit === 'function') {
-            // Fallback to generic visit method
-            result = this.visitor.visit(node, args);
-            if (this.visitor.isReplacing && result !== undefined) {
-                node = result;
-            }
-        }
-        // Less.js pattern: after calling visit method, traverse children if visitDeeper is true
-        // This matches Less.js Visitor.visit() behavior
-        // CRITICAL: Only call accept() on Less proxies, NOT on Jess nodes
-        // Jess nodes' accept() calls visitor.visit() which would cause infinite recursion
-        // Less proxies' accept() methods only traverse children, they don't call visitor.visit()
-        if (args.visitDeeper && node && node.accept) {
-            const isProxy = isLessProxy(node);
-            // Only call accept() if this is a Less proxy
-            // Less proxies have accept() that traverses children without calling visit()
-            if (isProxy) {
-                node.accept(this);
-            }
-            // If it's not a Less proxy (it's a Jess node), we should NOT call accept()
-            // because Jess's accept() calls visitor.visit() which would recurse
-            // Instead, the plugin visitor's visit() method handles Jess node traversal
-        }
-        // Note: We keep the node in processingNodes for the entire visitor lifetime
-        // to prevent re-processing. The WeakSet will be garbage collected when done.
-        return result;
-    }
-    /**
-     * Visit array of nodes
-     */
-    visitArray(nodes, visitArgs) {
-        if (!nodes) {
-            return nodes;
-        }
-        return nodes.map(node => this.visit(node, visitArgs));
-    }
-    /**
-     * Visit Directive node (Less.js v2 compatibility)
-     * Maps to AtRule for modern Less.js compatibility
-     */
-    visitDirective(node, visitArgs) {
-        // Convert Directive to AtRule-compatible format
-        // Less.js v2 used "Directive", modern versions use "AtRule"
-        if (node && node.type === 'Directive') {
-            // Try visitDirective first (v2 plugins)
-            if (this.visitor && typeof this.visitor.visitDirective === 'function') {
-                return this.visitor.visitDirective(node, visitArgs);
-            }
-            // Fallback to visitAtRule (modern plugins)
-            if (this.visitor && typeof this.visitor.visitAtRule === 'function') {
-                return this.visitor.visitAtRule(node, visitArgs);
-            }
-        }
-        // Default to regular visit
-        return this.visit(node, visitArgs);
-    }
-    /**
-     * Visit Rule node (Less.js v2 compatibility)
-     * Maps to Declaration for modern Less.js compatibility
-     */
-    visitRule(node, visitArgs) {
-        // Convert Rule to Declaration-compatible format
-        // Less.js v2 used "Rule", modern versions use "Declaration"
-        if (node && (node.type === 'Rule' || node.type === 'Declaration')) {
-            // Try visitRule first (v2 plugins)
-            if (this.visitor && typeof this.visitor.visitRule === 'function') {
-                return this.visitor.visitRule(node, visitArgs);
-            }
-            // Fallback to visitDeclaration (modern plugins)
-            if (this.visitor && typeof this.visitor.visitDeclaration === 'function') {
-                return this.visitor.visitDeclaration(node, visitArgs);
-            }
-        }
-        // Default to regular visit
-        return this.visit(node, visitArgs);
-    }
-}
+* Less.js Visitor base class (minimal implementation)
+* Plugins expect this structure to exist
+*/
+var LessVisitor = class {
+	processingNodes = /* @__PURE__ */ new WeakSet();
+	constructor(visitor) {
+		this.visitor = visitor;
+	}
+	/**
+	* Visit a node - handles both modern and legacy Less.js node types
+	* Supports Less.js v2 "Directive" nodes (mapped to AtRule)
+	*
+	* In Less.js v2, at-rules were called "Directive" instead of "AtRule".
+	* For compatibility, we route AtRule nodes to visitDirective() if that method exists,
+	* allowing v2 plugins to work with modern AtRule nodes.
+	*/
+	visit(node, visitArgs) {
+		if (!node) return node;
+		if (typeof node !== "object") return node;
+		if (!this.visitor) return node;
+		if (this.processingNodes.has(node)) return node;
+		this.processingNodes.add(node);
+		const args = visitArgs || { visitDeeper: true };
+		if (args.visitDeeper === void 0) args.visitDeeper = true;
+		const nodeType = node.type;
+		if (!nodeType || typeof nodeType !== "string") {
+			if (typeof this.visitor.visit === "function") {
+				const result = this.visitor.visit(node, args);
+				if (args.visitDeeper && node && node.accept) node.accept(this);
+				return result;
+			}
+			return node;
+		}
+		const visitMethodName = `visit${nodeType}`;
+		let result = node;
+		let visitMethod;
+		if (typeof this.visitor[visitMethodName] === "function") visitMethod = this.visitor[visitMethodName];
+		else if (nodeType === "Directive" || nodeType === "AtRule") {
+			if (typeof this.visitor.visitDirective === "function") visitMethod = this.visitor.visitDirective;
+			else if (typeof this.visitor.visitAtRule === "function") visitMethod = this.visitor.visitAtRule;
+		} else if (nodeType === "Rule") {
+			if (typeof this.visitor.visitRule === "function") visitMethod = this.visitor.visitRule;
+			else if (typeof this.visitor.visitDeclaration === "function") visitMethod = this.visitor.visitDeclaration;
+		} else if (nodeType === "Reference") {
+			if (typeof this.visitor.visitVariable === "function") visitMethod = this.visitor.visitVariable;
+			else if (typeof this.visitor.visitReference === "function") visitMethod = this.visitor.visitReference;
+		}
+		if (visitMethod) {
+			result = visitMethod.call(this.visitor, node, args);
+			if (this.visitor.isReplacing && result !== void 0) node = result;
+		} else if (typeof this.visitor.visit === "function") {
+			result = this.visitor.visit(node, args);
+			if (this.visitor.isReplacing && result !== void 0) node = result;
+		}
+		if (args.visitDeeper && node && node.accept) {
+			if (node instanceof LessAdapterBase) node.accept(this);
+		}
+		return result;
+	}
+	/**
+	* Visit array of nodes
+	*/
+	visitArray(nodes, visitArgs) {
+		if (!nodes) return nodes;
+		return nodes.map((node) => this.visit(node, visitArgs));
+	}
+	/**
+	* Visit Directive node (Less.js v2 compatibility)
+	* Maps to AtRule for modern Less.js compatibility
+	*/
+	visitDirective(node, visitArgs) {
+		if (node && node.type === "Directive") {
+			if (this.visitor && typeof this.visitor.visitDirective === "function") return this.visitor.visitDirective(node, visitArgs);
+			if (this.visitor && typeof this.visitor.visitAtRule === "function") return this.visitor.visitAtRule(node, visitArgs);
+		}
+		return this.visit(node, visitArgs);
+	}
+	/**
+	* Visit Rule node (Less.js v2 compatibility)
+	* Maps to Declaration for modern Less.js compatibility
+	*/
+	visitRule(node, visitArgs) {
+		if (node && (node.type === "Rule" || node.type === "Declaration")) {
+			if (this.visitor && typeof this.visitor.visitRule === "function") return this.visitor.visitRule(node, visitArgs);
+			if (this.visitor && typeof this.visitor.visitDeclaration === "function") return this.visitor.visitDeclaration(node, visitArgs);
+		}
+		return this.visit(node, visitArgs);
+	}
+};
 /**
- * Less.js PluginManager (minimal implementation)
- * Plugins use this to register visitors, pre/post processors, etc.
- */
-export class LessPluginManager {
-    less;
-    newFactory;
-    visitors = [];
-    preProcessors = [];
-    postProcessors = [];
-    constructor(less, newFactory) {
-        this.less = less;
-        this.newFactory = newFactory;
-        // Plugins expect this constructor signature
-    }
-    /**
-     * Add a visitor to the manager
-     */
-    addVisitor(visitor) {
-        this.visitors.push(visitor);
-    }
-    /**
-     * Remove a visitor
-     */
-    removeVisitor(visitor) {
-        const index = this.visitors.indexOf(visitor);
-        if (index > -1) {
-            this.visitors.splice(index, 1);
-        }
-    }
-    /**
-     * Add a pre-processor (runs before parsing)
-     */
-    addPreProcessor(preProcessor) {
-        this.preProcessors.push(preProcessor);
-    }
-    /**
-     * Add a post-processor (runs after compilation)
-     */
-    addPostProcessor(postProcessor) {
-        this.postProcessors.push(postProcessor);
-    }
-    /**
-     * Get all visitors
-     */
-    getVisitors() {
-        return this.visitors;
-    }
-    /**
-     * Get all pre-processors
-     */
-    getPreProcessors() {
-        return this.preProcessors;
-    }
-    /**
-     * Get all post-processors
-     */
-    getPostProcessors() {
-        return this.postProcessors;
-    }
-    /**
-     * Register a plugin (Less.js-compatible API)
-     * Some plugins use this method instead of install()
-     */
-    registerPlugin(plugin, _options) {
-        if (!plugin) {
-            return;
-        }
-        // If plugin has install method, call it first
-        // The install method may add the visitor itself via addVisitor()
-        if (typeof plugin.install === 'function') {
-            plugin.install(this.less, this, this.less.functions.functionRegistry);
-        }
-        // If plugin is a visitor and not already added, add it
-        // Check if it's already in the visitors array to avoid duplicates
-        const isVisitor = typeof plugin.visit === 'function' || typeof plugin.visitRuleset === 'function';
-        if (isVisitor && !this.visitors.includes(plugin)) {
-            this.addVisitor(plugin);
-        }
-    }
-}
+* Less.js PluginManager (minimal implementation)
+* Plugins use this to register visitors, pre/post processors, etc.
+*/
+var LessPluginManager = class {
+	visitors = [];
+	preProcessors = [];
+	postProcessors = [];
+	constructor(less, newFactory) {
+		this.less = less;
+		this.newFactory = newFactory;
+	}
+	/**
+	* Add a visitor to the manager
+	*/
+	addVisitor(visitor) {
+		this.visitors.push(visitor);
+	}
+	/**
+	* Remove a visitor
+	*/
+	removeVisitor(visitor) {
+		const index = this.visitors.indexOf(visitor);
+		if (index > -1) this.visitors.splice(index, 1);
+	}
+	/**
+	* Add a pre-processor (runs before parsing)
+	*/
+	addPreProcessor(preProcessor) {
+		this.preProcessors.push(preProcessor);
+	}
+	/**
+	* Add a post-processor (runs after compilation)
+	*/
+	addPostProcessor(postProcessor) {
+		this.postProcessors.push(postProcessor);
+	}
+	/**
+	* Get all visitors
+	*/
+	getVisitors() {
+		return this.visitors;
+	}
+	/**
+	* Get all pre-processors
+	*/
+	getPreProcessors() {
+		return this.preProcessors;
+	}
+	/**
+	* Get all post-processors
+	*/
+	getPostProcessors() {
+		return this.postProcessors;
+	}
+	/**
+	* Register a plugin (Less.js-compatible API)
+	* Some plugins use this method instead of install()
+	*/
+	registerPlugin(plugin, _options) {
+		if (!plugin) return;
+		if (typeof plugin.install === "function") plugin.install(this.less, this, this.less.functions.functionRegistry);
+		if ((typeof plugin.visit === "function" || typeof plugin.visitRuleset === "function") && !this.visitors.includes(plugin)) this.addVisitor(plugin);
+	}
+};
 /**
- * Less.js tree constructors (minimal implementations)
- * Plugins may access these via functionRegistry.Call, etc.
- */
-export const LessTreeConstructors = {
-    /**
-     * Anonymous node constructor
-     */
-    Anonymous: function (value, index, fileInfo) {
-        return {
-            type: 'Anonymous',
-            value,
-            index: index || 0,
-            fileInfo: fileInfo || {},
-            accept: function (visitor) {
-                return visitor.visit(this);
-            },
-            toCSS: function () {
-                return String(value);
-            }
-        };
-    },
-    /**
-     * Quoted node constructor
-     */
-    Quoted: function (quote, value, escaped, index, fileInfo) {
-        return {
-            type: 'Quoted',
-            quote,
-            value,
-            escaped: !!escaped,
-            index: index || 0,
-            fileInfo: fileInfo || {},
-            accept: function (visitor) {
-                return visitor.visit(this);
-            },
-            toCSS: function () {
-                return `${quote}${String(value)}${quote}`;
-            }
-        };
-    },
-    /**
-     * DetachedRuleset node constructor
-     * Used by some Less.js plugins (e.g. test-data/plugin-tree-nodes.js)
-     */
-    DetachedRuleset: function (ruleset) {
-        return {
-            type: 'DetachedRuleset',
-            ruleset,
-            accept: function (visitor) {
-                return visitor.visit(this);
-            }
-        };
-    },
-    /**
-     * Call node constructor
-     */
-    Call: function (name, args, index, fileInfo) {
-        return {
-            type: 'Call',
-            name,
-            args: args || [],
-            index: index || 0,
-            fileInfo: fileInfo || {},
-            value: null,
-            accept: function (visitor) {
-                return visitor.visit(this);
-            }
-        };
-    },
-    /**
-     * Variable node constructor
-     */
-    Variable: function (name, index, fileInfo) {
-        return {
-            type: 'Variable',
-            name,
-            index: index || 0,
-            fileInfo: fileInfo || {},
-            value: null,
-            accept: function (visitor) {
-                return visitor.visit(this);
-            }
-        };
-    },
-    /**
-     * VariableCall node constructor
-     */
-    VariableCall: function (name, index, fileInfo) {
-        return {
-            type: 'VariableCall',
-            name,
-            index: index || 0,
-            fileInfo: fileInfo || {},
-            value: null,
-            accept: function (visitor) {
-                return visitor.visit(this);
-            }
-        };
-    },
-    /**
-     * Ruleset node constructor
-     */
-    Ruleset: function (selectors, rules, strictImports, visibilityInfo, fileInfo) {
-        return {
-            type: 'Ruleset',
-            selectors: selectors || [],
-            rules: rules || [],
-            strictImports,
-            visibilityInfo,
-            fileInfo: fileInfo || {},
-            accept: function (visitor) {
-                return visitor.visit(this);
-            }
-        };
-    },
-    /**
-     * Declaration node constructor
-     */
-    Declaration: function (name, value, index, fileInfo, variable, important) {
-        return {
-            type: 'Declaration',
-            name,
-            value,
-            index: index || 0,
-            fileInfo: fileInfo || {},
-            variable: variable || false,
-            important: important || '',
-            accept: function (visitor) {
-                return visitor.visit(this);
-            }
-        };
-    },
-    /**
-     * Dimension node constructor
-     */
-    Dimension: function (value, unit) {
-        return {
-            type: 'Dimension',
-            value,
-            unit: unit || '',
-            accept: function (visitor) {
-                return visitor.visit(this);
-            }
-        };
-    },
-    /**
-     * Color node constructor
-     */
-    Color: function (rgb, alpha) {
-        return {
-            type: 'Color',
-            rgb: rgb || [0, 0, 0],
-            alpha: alpha !== undefined ? alpha : 1,
-            accept: function (visitor) {
-                return visitor.visit(this);
-            }
-        };
-    },
-    /**
-     * Directive node constructor (Less.js v2 compatibility)
-     * In Less.js v2, at-rules were called "Directive" instead of "AtRule"
-     * This creates an AtRule-compatible node for backward compatibility
-     */
-    Directive: function (name, value, rules, index, fileInfo) {
-        return {
-            type: 'Directive', // Keep type as 'Directive' for v2 compatibility
-            name: name || '',
-            value: value || null,
-            rules: rules || [],
-            index: index || 0,
-            fileInfo: fileInfo || {},
-            // Less.js v2 Directive had these methods
-            isCharset: function () {
-                return this.name === '@charset' || this.name === 'charset';
-            },
-            isRulesetLike: function () {
-                return this.rules && this.rules.length > 0;
-            },
-            accept: function (visitor) {
-                // Map visitDirective to visitAtRule for compatibility
-                if (visitor.visitDirective) {
-                    return visitor.visitDirective(this);
-                }
-                // Fallback to visitAtRule or generic visit
-                if (visitor.visitAtRule) {
-                    return visitor.visitAtRule(this);
-                }
-                return visitor.visit(this);
-            }
-        };
-    },
-    /**
-     * Rule node constructor (Less.js v2 compatibility)
-     * In Less.js v2, declarations were called "Rule" instead of "Declaration"
-     * This creates a Declaration-compatible node for backward compatibility
-     */
-    Rule: function (name, value, important, merge, index, fileInfo, inline, variable) {
-        return {
-            type: 'Rule', // Keep type as 'Rule' for v2 compatibility
-            name: name || '',
-            value: value || null,
-            important: important || '',
-            merge: merge || false,
-            index: index || 0,
-            fileInfo: fileInfo || {},
-            inline: inline || false,
-            variable: variable !== undefined ? variable : (name && name.charAt && name.charAt(0) === '@'),
-            accept: function (visitor) {
-                // Map visitRule to visitDeclaration for compatibility
-                if (visitor.visitRule) {
-                    return visitor.visitRule(this);
-                }
-                // Fallback to visitDeclaration or generic visit
-                if (visitor.visitDeclaration) {
-                    return visitor.visitDeclaration(this);
-                }
-                return visitor.visit(this);
-            }
-        };
-    }
+* Less.js tree constructors (minimal implementations)
+* Plugins may access these via functionRegistry.Call, etc.
+*/
+const LessTreeConstructors = {
+	Anonymous: function(value, index, fileInfo) {
+		return {
+			type: "Anonymous",
+			value,
+			index: index || 0,
+			fileInfo: fileInfo || {},
+			accept: function(visitor) {
+				return visitor.visit(this);
+			},
+			toCSS: function() {
+				return String(value);
+			}
+		};
+	},
+	Quoted: function(quote, value, escaped, index, fileInfo) {
+		return {
+			type: "Quoted",
+			quote,
+			value,
+			escaped: !!escaped,
+			index: index || 0,
+			fileInfo: fileInfo || {},
+			accept: function(visitor) {
+				return visitor.visit(this);
+			},
+			toCSS: function() {
+				return `${quote}${String(value)}${quote}`;
+			}
+		};
+	},
+	DetachedRuleset: function(ruleset) {
+		return {
+			type: "DetachedRuleset",
+			ruleset,
+			accept: function(visitor) {
+				return visitor.visit(this);
+			}
+		};
+	},
+	Call: function(name, args, index, fileInfo) {
+		return {
+			type: "Call",
+			name,
+			args: args || [],
+			index: index || 0,
+			fileInfo: fileInfo || {},
+			value: null,
+			accept: function(visitor) {
+				return visitor.visit(this);
+			}
+		};
+	},
+	Variable: function(name, index, fileInfo) {
+		return {
+			type: "Variable",
+			name,
+			index: index || 0,
+			fileInfo: fileInfo || {},
+			value: null,
+			accept: function(visitor) {
+				return visitor.visit(this);
+			}
+		};
+	},
+	VariableCall: function(name, index, fileInfo) {
+		return {
+			type: "VariableCall",
+			name,
+			index: index || 0,
+			fileInfo: fileInfo || {},
+			value: null,
+			accept: function(visitor) {
+				return visitor.visit(this);
+			}
+		};
+	},
+	Ruleset: function(selectors, rules, strictImports, visibilityInfo, fileInfo) {
+		return {
+			type: "Ruleset",
+			selectors: selectors || [],
+			rules: rules || [],
+			strictImports,
+			visibilityInfo,
+			fileInfo: fileInfo || {},
+			accept: function(visitor) {
+				return visitor.visit(this);
+			}
+		};
+	},
+	Declaration: function(name, value, index, fileInfo, variable, important) {
+		return {
+			type: "Declaration",
+			name,
+			value,
+			index: index || 0,
+			fileInfo: fileInfo || {},
+			variable: variable || false,
+			important: important || "",
+			accept: function(visitor) {
+				return visitor.visit(this);
+			}
+		};
+	},
+	Dimension: function(value, unit) {
+		return {
+			type: "Dimension",
+			value,
+			unit: unit || "",
+			accept: function(visitor) {
+				return visitor.visit(this);
+			}
+		};
+	},
+	Color: function(rgb, alpha) {
+		let rgbArray;
+		if (typeof rgb === "string") {
+			const hex = rgb.replace(/^#/, "");
+			rgbArray = (hex.length >= 6 ? hex.match(/.{2}/g) ?? [] : hex.split("").map((c) => c + c)).slice(0, 3).map((c) => parseInt(c, 16));
+		} else rgbArray = rgb || [
+			0,
+			0,
+			0
+		];
+		return {
+			type: "Color",
+			rgb: rgbArray,
+			alpha: alpha !== void 0 ? alpha : 1,
+			accept: function(visitor) {
+				return visitor.visit(this);
+			}
+		};
+	},
+	Directive: function(name, value, rules, index, fileInfo) {
+		return {
+			type: "Directive",
+			name: name || "",
+			value: value || null,
+			rules: rules || [],
+			index: index || 0,
+			fileInfo: fileInfo || {},
+			isCharset: function() {
+				return this.name === "@charset" || this.name === "charset";
+			},
+			isRulesetLike: function() {
+				return this.rules && this.rules.length > 0;
+			},
+			accept: function(visitor) {
+				if (visitor.visitDirective) return visitor.visitDirective(this);
+				if (visitor.visitAtRule) return visitor.visitAtRule(this);
+				return visitor.visit(this);
+			}
+		};
+	},
+	Rule: function(name, value, important, merge, index, fileInfo, inline, variable) {
+		return {
+			type: "Rule",
+			name: name || "",
+			value: value || null,
+			important: important || "",
+			merge: merge || false,
+			index: index || 0,
+			fileInfo: fileInfo || {},
+			inline: inline || false,
+			variable: variable !== void 0 ? variable : name && name.charAt && name.charAt(0) === "@",
+			accept: function(visitor) {
+				if (visitor.visitRule) return visitor.visitRule(this);
+				if (visitor.visitDeclaration) return visitor.visitDeclaration(this);
+				return visitor.visit(this);
+			}
+		};
+	}
 };
 /**
- * Create a Less.js-compatible mock object
- * This provides the minimal structure that plugins expect
- */
-export function createLessMock(functionRegistry) {
-    return {
-        visitors: {
-            Visitor: LessVisitor
-        },
-        functions: {
-            functionRegistry
-        },
-        tree: LessTreeConstructors,
-        PluginLoader: class {
-        },
-        // Minimal Less.js function API used by Less.js test plugins
-        // These return "Less-like" nodes; Jess-side wrappers convert them as needed.
-        dimension(value, unit) {
-            return LessTreeConstructors.Dimension(value, unit);
-        },
-        value(values) {
-            return values;
-        },
-        declaration(name, value) {
-            return LessTreeConstructors.Declaration(name, value);
-        },
-        ruleset(selector, rules) {
-            return LessTreeConstructors.Ruleset([selector], rules);
-        },
-        detachedruleset(rulesetLike) {
-            return LessTreeConstructors.DetachedRuleset(rulesetLike);
-        },
-        atrule(name, value) {
-            return { type: 'AtRule', name, value };
-        }
-    };
+* Create a Less.js-compatible mock object
+* This provides the minimal structure that plugins expect
+*/
+function createLessMock(functionRegistry) {
+	return {
+		visitors: { Visitor: LessVisitor },
+		functions: { functionRegistry },
+		tree: LessTreeConstructors,
+		PluginLoader: class {},
+		dimension(value, unit) {
+			return LessTreeConstructors.Dimension(value, unit);
+		},
+		value(values) {
+			return values;
+		},
+		declaration(name, value) {
+			return LessTreeConstructors.Declaration(name, value);
+		},
+		ruleset(selector, rules) {
+			return LessTreeConstructors.Ruleset([selector], rules);
+		},
+		detachedruleset(rulesetLike) {
+			return LessTreeConstructors.DetachedRuleset(rulesetLike);
+		},
+		atrule(name, value) {
+			return {
+				type: "AtRule",
+				name,
+				value
+			};
+		}
+	};
 }
-//# sourceMappingURL=less-compat-structures.js.map
+//#endregion
+export { LessPluginManager, LessTreeConstructors, LessVisitor, createLessMock };