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

package/lib/index.js

@@ -1,11 +1,801 @@
+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";
+import { LessPluginManager, LessTreeConstructors, LessVisitor, createLessMock } from "./less-compat-structures.js";
+import { createRequire } from "node:module";
+import * as fs from "node:fs";
+import path from "node:path";
+import { AbstractPlugin, Any, Declaration, Deprecation, Dimension, F_VISIBLE, JsFunction, Node, REMOVE, WARN, toDiagnostic } from "@jesscss/core";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region src/plugin-utils.ts
 /**
- * @jesscss/plugin-less-compat
- *
- * Less.js compatibility layer for Jess.
- * Enables Less.js plugins and visitors to work with Jess AST.
- */
-export { LessCompatPlugin, default as lessCompatPlugin } from './plugin.js';
-export { default } from './plugin.js';
-export * from './transform/index.js';
-export { isLessPlugin, isJessPlugin, filterPlugins } from './plugin-utils.js';
-//# sourceMappingURL=index.js.map
+* Detect if a plugin is a Less.js plugin
+*/
+function isLessPlugin(plugin) {
+	if (!plugin) return false;
+	if (typeof plugin.install === "function") return true;
+	if (typeof plugin === "function") {
+		if (typeof plugin.install === "function") return true;
+		if (plugin.prototype && typeof plugin.prototype.install === "function") return true;
+		try {
+			const instance = new plugin({});
+			if (instance && typeof instance.install === "function") return true;
+		} catch (e) {
+			try {
+				const instance = plugin({});
+				if (instance && typeof instance.install === "function") return true;
+				return true;
+			} catch (e2) {}
+		}
+	}
+	return false;
+}
+/**
+* Detect if a plugin is a Jess plugin
+*/
+function isJessPlugin(plugin) {
+	if (!plugin) return false;
+	if (typeof plugin === "object" && "name" in plugin && typeof plugin.name === "string") return true;
+	if (typeof plugin === "function") try {
+		const instance = plugin({});
+		if (instance && typeof instance === "object" && "name" in instance && typeof instance.name === "string") return true;
+	} catch (e) {}
+	return false;
+}
+/**
+* Filter and separate Less plugins from Jess plugins
+* This allows mixed plugin arrays to be handled correctly
+*/
+function filterPlugins(plugins) {
+	const lessPlugins = [];
+	const jessPlugins = [];
+	for (const plugin of plugins) if (isLessPlugin(plugin)) lessPlugins.push(plugin);
+	else if (isJessPlugin(plugin)) jessPlugins.push(plugin);
+	else lessPlugins.push(plugin);
+	return {
+		lessPlugins,
+		jessPlugins
+	};
+}
+//#endregion
+//#region src/plugin.ts
+const isThenable = (v) => !!v && (typeof v === "object" || typeof v === "function") && typeof v.then === "function";
+/**
+* Structural guard for Less/Jess nodes that expose an `eval(context)` method.
+* Used by the @plugin function wrappers to evaluate node arguments before
+* handing them to legacy Less plugin functions.
+*/
+const hasEvalMethod = (x) => !!x && (typeof x === "object" || typeof x === "function") && typeof x.eval === "function";
+/** Structural guard for nodes that expose a `removeFlag` mutator. */
+const hasRemoveFlag = (x) => !!x && typeof x.removeFlag === "function";
+const LESS_PLUGIN_JS_RUNTIME_MESSAGE = "Feature not supported. Install @jesscss/plugin-js to enable Less @plugin script execution.";
+const SCRIPT_MODULES_DISABLED_MESSAGE = "Less @plugin is disabled by disableScriptModules.";
+/**
+* Wrap a Less plugin function and add it to a Jess function registry.
+* Used so that deprecated @plugin-loaded functions register into the Rules that
+* contain the @plugin.
+* Conversion of Less return values to Jess uses the shared fromLessPluginReturnValue.
+*
+* @deprecated Legacy Less @plugin support. Prefer @use / @-use for script integration in .less files.
+*/
+function addToJessRegistry(jessRegistry, name, func) {
+	if (!jessRegistry || typeof jessRegistry.add !== "function") return;
+	try {
+		name = name.toLowerCase();
+		const wrapped = function(...args) {
+			const maybeEvaldArgs = args.map((arg) => {
+				if (arg instanceof Any || arg instanceof Declaration || arg instanceof Dimension) {}
+				if (hasEvalMethod(arg) && arg.evaluated !== true) try {
+					return arg.eval(this);
+				} catch {
+					return arg;
+				}
+				return arg;
+			});
+			const call = (finalArgs) => func.apply(this, finalArgs);
+			const result = maybeEvaldArgs.some(isThenable) ? Promise.all(maybeEvaldArgs.map((a) => isThenable(a) ? a : Promise.resolve(a))).then(call) : call(maybeEvaldArgs);
+			const statementContext = this?.caller?.parent?.type === "Rules";
+			const convertResult = (r) => fromLessPluginReturnValue(r, { statementContext });
+			return isThenable(result) ? result.then(convertResult) : convertResult(result);
+		};
+		Object.assign(wrapped, func);
+		jessRegistry.add(name, wrapped);
+	} catch (e) {}
+}
+/**
+* Wrap a Less 4.x-style custom function (as registered through
+* `less.functions.functionRegistry.add`) and add it to a Jess function registry.
+*
+* Unlike {@link addToJessRegistry}, the evaluated arguments are converted to
+* Less-shaped nodes via `toLessNode` before the function runs. Less 4.x custom
+* functions receive `less.tree.*` values (with `.value`, `.unit`, `.rgb`, …),
+* not raw Jess nodes, so this conversion is required for parity.
+*/
+function addRootFunctionToJessRegistry(jessRegistry, name, func) {
+	if (!jessRegistry || typeof jessRegistry.add !== "function") return;
+	name = name.toLowerCase();
+	const wrapped = function(...args) {
+		const evaldArgs = args.map((arg) => {
+			if (hasEvalMethod(arg) && arg.evaluated !== true) try {
+				return arg.eval(this);
+			} catch {
+				return arg;
+			}
+			return arg;
+		});
+		const call = (finalArgs) => {
+			const lessArgs = finalArgs.map((a) => a instanceof Node ? toLessNode(a) : a);
+			return func.apply(this, lessArgs);
+		};
+		const statementContext = this?.caller?.parent?.type === "Rules";
+		const convertResult = (r) => fromLessPluginReturnValue(r, { statementContext });
+		const result = evaldArgs.some(isThenable) ? Promise.all(evaldArgs.map((a) => isThenable(a) ? a : Promise.resolve(a))).then(call) : call(evaldArgs);
+		return isThenable(result) ? result.then(convertResult) : convertResult(result);
+	};
+	Object.assign(wrapped, func);
+	jessRegistry.add(name, wrapped);
+}
+/**
+* Plugin that enables Less.js compatibility by transforming
+* Jess nodes to Less-compatible format for visitor processing.
+*/
+var LessCompatPlugin = class extends AbstractPlugin {
+	name = "less-compat";
+	_cachedVisitor;
+	_lessPluginManager;
+	_currentFilePath;
+	_jessFunctionRegistry;
+	_context;
+	/** Trees whose root scope already received the configured root functions. */
+	_fnRegisteredTrees = /* @__PURE__ */ new WeakSet();
+	constructor(opts = {}) {
+		super();
+		this.opts = opts;
+	}
+	/**
+	* 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 run early by default
+	* - addPreProcessor() - these run early
+	* - addPostProcessor() - these run on serialized CSS after render
+	*/
+	get beforeEvalVisitor() {
+		if (!this._cachedVisitor) this._cachedVisitor = this.visitor;
+		return this._cachedVisitor;
+	}
+	/**
+	* Less post-processors operate on final CSS, not on the preRenderVisitor tree hook.
+	*/
+	get postEvalVisitor() {}
+	runPostProcessors(css, extra = {}) {
+		return (this._lessPluginManager?.getPostProcessors() || []).reduce((current, processor) => {
+			if (!processor || typeof processor.process !== "function") return current;
+			try {
+				const output = processor.process(current, extra);
+				return typeof output === "string" ? output : current;
+			} catch (error) {
+				throw error;
+			}
+		}, css);
+	}
+	setCurrentFilePath(filePath) {
+		this._currentFilePath = filePath;
+	}
+	setContext(context) {
+		this._context = context;
+		try {
+			const root = context?.root;
+			if (root && typeof root.setFunctionBinding === "function" && typeof root.findFunction === "function") this._jessFunctionRegistry = this.createJessFunctionBindingRegistry(root);
+		} catch {}
+	}
+	createJessFunctionBindingRegistry(root) {
+		return {
+			add(name, func) {
+				const lowerName = name.toLowerCase();
+				const jsFunc = func instanceof JsFunction ? func : new JsFunction({
+					name: lowerName,
+					fn: func
+				});
+				if (!jsFunc.name) jsFunc.name = lowerName;
+				root.setFunctionBinding(lowerName, jsFunc);
+			},
+			get(name) {
+				const fn = root.findFunction(name.toLowerCase());
+				return fn instanceof JsFunction ? fn : void 0;
+			}
+		};
+	}
+	hasConfiguredBeforeEvalWork() {
+		return !!this.opts.plugins?.length || !!this.opts.visitors?.length;
+	}
+	sourceMayContainPluginDirective(tree) {
+		if (!tree) return false;
+		const source = tree._treeContext?.file?.source;
+		if (typeof source === "string" && source.includes("@plugin")) return true;
+		return this.treeContainsPluginDirective(tree);
+	}
+	treeContainsPluginDirective(node, depth = 0) {
+		if (!node || typeof node !== "object" || depth > 32) return false;
+		const candidate = node;
+		const type = candidate.type;
+		if (type === "AtRule" || type === "AtRuleStatement" || type === "Directive") {
+			const name = candidate.name;
+			let nameValue;
+			if (typeof name === "string") nameValue = name;
+			else if (name && typeof name === "object") {
+				const inner = name.value;
+				if (typeof inner === "string") nameValue = inner;
+			}
+			if (nameValue === "@plugin" || nameValue === "plugin") return true;
+		}
+		const rules = candidate.rules;
+		if (Array.isArray(rules)) {
+			for (const child of rules) if (this.treeContainsPluginDirective(child, depth + 1)) return true;
+		}
+		return false;
+	}
+	warnForPluginDirective(node) {
+		const context = this._context;
+		if (!context || !Array.isArray(context.warnings)) return;
+		const deprecation = Deprecation.fromId("less-plugin") ?? Deprecation.userAuthored;
+		context.warnings.push(toDiagnostic(WARN.deprecated({
+			node,
+			filePath: this._currentFilePath,
+			meta: {
+				what: "@plugin",
+				use: "@use / @-use",
+				deprecation
+			},
+			note: "In .less files compiled through the Less CLI compatibility path, migrate script integration to @use / @-use."
+		})));
+	}
+	markPluginDirectiveInvisible(node) {
+		const jessNode = node instanceof LessAdapterBase ? node.jessNode : node;
+		if (hasRemoveFlag(jessNode)) jessNode.removeFlag(F_VISIBLE);
+	}
+	registerDenoLessPluginFunctions(jessRegistry, functions) {
+		if (!jessRegistry || typeof jessRegistry.add !== "function") return;
+		for (const [name, fn] of Object.entries(functions)) jessRegistry.add(name.toLowerCase(), async function(...args) {
+			const context = this;
+			return fn(...await Promise.all(args.map(async (arg) => {
+				if (hasEvalMethod(arg) && arg.evaluated !== true) {
+					const out = arg.eval(context);
+					return isThenable(out) ? await out : out;
+				}
+				return arg;
+			})));
+		});
+	}
+	loadLessPluginFileWithDeno(fullPath, targetJessRegistry) {
+		const finish = async (plugin) => {
+			if (!plugin || typeof plugin.importLessPlugin !== "function") return false;
+			if (this._context?.plugins && !this._context.plugins.includes(plugin)) this._context.plugins.push(plugin);
+			const loaded = await plugin.importLessPlugin(fullPath);
+			this.registerDenoLessPluginFunctions(targetJessRegistry ?? this._jessFunctionRegistry, loaded.functions ?? {});
+			return true;
+		};
+		const ext = path.extname(fullPath);
+		const existingPlugin = [...this._context?.plugins ?? [], ...this.opts.plugins ?? []].find((plugin) => plugin?.supportedExtensions?.includes(ext) && typeof plugin.importLessPlugin === "function");
+		if (existingPlugin) return finish(existingPlugin);
+		const loader = this._context?.opts?.loadPluginForExtension;
+		if (!loader) return false;
+		const load = loader(ext);
+		return isThenable(load) ? Promise.resolve(load).then(finish) : finish(load);
+	}
+	beforeEvalVisitorForTree(tree) {
+		this.registerRootFunctions(tree);
+		if (!this.hasConfiguredBeforeEvalWork() && !this.sourceMayContainPluginDirective(tree)) return;
+		return this.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.
+	*/
+	registerRootFunctions(tree) {
+		const fns = this.opts.functions;
+		if (!fns) return;
+		if (!tree || typeof tree.setFunctionBinding !== "function" || typeof tree.findFunction !== "function") return;
+		if (this._fnRegisteredTrees.has(tree)) return;
+		this._fnRegisteredTrees.add(tree);
+		const registry = this.createJessFunctionBindingRegistry(tree);
+		for (const [name, fn] of Object.entries(fns)) if (typeof fn === "function") addRootFunctionToJessRegistry(registry, name, fn);
+	}
+	/**
+	* Filter and separate Less plugins from Jess plugins
+	* This allows mixed plugin arrays to be handled correctly
+	*
+	* @deprecated Use filterPlugins from './plugin-utils.js' instead
+	*/
+	static filterLessPlugins(plugins) {
+		return filterPlugins(plugins);
+	}
+	/**
+	* Return a visitor that wraps Less visitors
+	*
+	* This visitor intercepts each node, converts it to Less format,
+	* runs the Less visitors, and converts back if modified.
+	*/
+	get visitor() {
+		const cacheMap = this.opts.cache !== false ? /* @__PURE__ */ new WeakMap() : void 0;
+		const LessVisitor$1 = LessVisitor;
+		const LessPluginManagerClass = LessPluginManager;
+		const lessVisitorInstances = [];
+		let pluginManagerRef = null;
+		let mockLessRef = null;
+		const createUnknownTreeConstructor = (type) => {
+			return function(...args) {
+				return {
+					value: null,
+					type,
+					name: args[0] || "",
+					args: args.slice(1) || [],
+					index: 0,
+					fileInfo: {},
+					accept: function(visitor) {
+						return visitor.visit(this);
+					}
+				};
+			};
+		};
+		const attachFunctionRegistrySurface = (registry) => {
+			for (const [name, ctor] of Object.entries(LessTreeConstructors)) Object.defineProperty(registry, name, {
+				value: ctor,
+				enumerable: false,
+				configurable: true,
+				writable: true
+			});
+			for (const name of [
+				"Alpha",
+				"Assignment",
+				"Condition",
+				"Expression",
+				"Value"
+			]) if (!(name in registry)) Object.defineProperty(registry, name, {
+				value: createUnknownTreeConstructor(name),
+				enumerable: false,
+				configurable: true,
+				writable: true
+			});
+			return registry;
+		};
+		function* createVisitorIterator() {
+			let index = 0;
+			while (index < lessVisitorInstances.length) {
+				yield lessVisitorInstances[index];
+				index++;
+			}
+		}
+		let currentRealRegistry = this._jessFunctionRegistry;
+		const createFunctionRegistry = () => {
+			const data = {};
+			let base = null;
+			return attachFunctionRegistrySurface({
+				get _data() {
+					return data;
+				},
+				get _base() {
+					return base;
+				},
+				set _base(v) {
+					base = v;
+				},
+				add(name, func) {
+					name = name.toLowerCase();
+					data[name] = func;
+					if (currentRealRegistry) addToJessRegistry(currentRealRegistry, name, func);
+				},
+				addMultiple(functions) {
+					Object.keys(functions).forEach((name) => {
+						this.add(name, functions[name]);
+					});
+				},
+				get(name) {
+					name = name.toLowerCase();
+					if (data[name]) return data[name];
+					if (base) return base.get(name);
+					if (currentRealRegistry) try {
+						return currentRealRegistry.get(name);
+					} catch (_e) {}
+				},
+				getLocalFunctions() {
+					return { ...data };
+				},
+				inherit() {
+					const child = createFunctionRegistry();
+					child._base = this;
+					return child;
+				},
+				create(base) {
+					const newRegistry = createFunctionRegistry();
+					newRegistry._base = base;
+					return newRegistry;
+				}
+			});
+		};
+		/**
+		* Create a mock function registry that forwards add/addMultiple/get to the given
+		* Jess registry. Used when loading @plugin scripts so functions register into the
+		* Rules that contain the @plugin directive.
+		*/
+		const createScopedFunctionRegistry = (jessRegistry) => {
+			const data = {};
+			return attachFunctionRegistrySurface({
+				add(name, func) {
+					name = name.toLowerCase();
+					data[name] = func;
+					addToJessRegistry(jessRegistry, name, func);
+				},
+				addMultiple(functions) {
+					Object.keys(functions).forEach((name) => {
+						this.add(name, functions[name]);
+					});
+				},
+				get(name) {
+					name = name.toLowerCase();
+					if (data[name]) return data[name];
+					try {
+						return jessRegistry?.get?.(name);
+					} catch {
+						return;
+					}
+				}
+			});
+		};
+		const functionRegistry = createFunctionRegistry();
+		const mockLess = createLessMock(functionRegistry);
+		const pluginManager = new LessPluginManagerClass(mockLess, true);
+		this._lessPluginManager = pluginManager;
+		const loadPluginSource = (fullPath, registerPlugin, targetJessRegistry) => {
+			const contents = fs.readFileSync(fullPath, "utf8");
+			const localModule = { exports: {} };
+			const functions = targetJessRegistry != null ? createScopedFunctionRegistry(targetJessRegistry) : functionRegistry;
+			new Function("module", "require", "registerPlugin", "functions", "tree", "less", "fileInfo", contents)(localModule, createRequire(fullPath), registerPlugin, functions, LessTreeConstructors, mockLess, { filename: fullPath });
+			return {
+				module: localModule.exports,
+				registered: null
+			};
+		};
+		const requirePluginFile = (fullPath, targetJessRegistry) => {
+			const registeredPlugins = [];
+			const registerPlugin = (plugin) => {
+				registeredPlugins.push(plugin);
+			};
+			const loaded = loadPluginSource(fullPath, registerPlugin, targetJessRegistry);
+			return {
+				module: loaded.module,
+				registered: registeredPlugins.length > 0 ? registeredPlugins[registeredPlugins.length - 1] : loaded.registered
+			};
+		};
+		pluginManagerRef = pluginManager;
+		mockLessRef = mockLess;
+		if (this.opts.plugins?.length) {
+			const { lessPlugins } = filterPlugins(this.opts.plugins);
+			if (lessPlugins.length > 0) {
+				const visitorsBefore = pluginManager.visitors ? [...pluginManager.visitors] : [];
+				const processedPlugins = [];
+				lessPlugins.forEach((plugin) => {
+					if (!plugin) return;
+					if (typeof plugin === "function") try {
+						const pluginInstance = new plugin({});
+						if (pluginInstance) processedPlugins.push(pluginInstance);
+						else try {
+							const pluginInstance2 = plugin({});
+							if (pluginInstance2) processedPlugins.push(pluginInstance2);
+							else processedPlugins.push(plugin);
+						} catch (_e2) {
+							processedPlugins.push(plugin);
+						}
+					} catch (_e) {
+						try {
+							const pluginInstance = plugin({});
+							if (pluginInstance) processedPlugins.push(pluginInstance);
+							else processedPlugins.push(plugin);
+						} catch (_e2) {
+							processedPlugins.push(plugin);
+						}
+					}
+					else processedPlugins.push(plugin);
+				});
+				processedPlugins.forEach((plugin) => {
+					if (!plugin) return;
+					try {
+						const wrappedVisitor = new LessVisitor$1(plugin);
+						lessVisitorInstances.push(wrappedVisitor);
+					} catch (e) {}
+					if (typeof plugin.install === "function") plugin.install(mockLess, pluginManager, mockLess.functions.functionRegistry);
+					else if (typeof plugin === "function") if (plugin.prototype && typeof plugin.prototype.install === "function") try {
+						const pluginInstance = new plugin({});
+						if (pluginInstance && typeof pluginInstance.install === "function") pluginInstance.install(mockLess, pluginManager, mockLess.functions.functionRegistry);
+					} catch (_e) {
+						try {
+							const pluginInstance = plugin({});
+							if (pluginInstance && typeof pluginInstance.install === "function") pluginInstance.install(mockLess, pluginManager, mockLess.functions.functionRegistry);
+							else if (pluginInstance) lessVisitorInstances.push(new LessVisitor$1(pluginInstance));
+						} catch (_e2) {
+							lessVisitorInstances.push(new LessVisitor$1(plugin));
+						}
+					}
+					else try {
+						const pluginInstance = plugin({});
+						if (pluginInstance && typeof pluginInstance.install === "function") pluginInstance.install(mockLess, pluginManager, mockLess.functions.functionRegistry);
+						else if (pluginInstance) lessVisitorInstances.push(new LessVisitor$1(pluginInstance));
+					} catch (_e2) {
+						lessVisitorInstances.push(new LessVisitor$1(plugin));
+					}
+					else lessVisitorInstances.push(new LessVisitor$1(plugin));
+				});
+				if (pluginManager.visitors && pluginManager.visitors.length > visitorsBefore.length) {
+					const newVisitors = pluginManager.visitors.slice(visitorsBefore.length);
+					lessVisitorInstances.push(...newVisitors.map((v) => {
+						if (v instanceof LessVisitor$1) return v;
+						return new LessVisitor$1(v);
+					}));
+				}
+			}
+		}
+		/** @deprecated Less.js Visitor API - Direct visitor support for Less.js compatibility */
+		if (this.opts.visitors?.length) this.opts.visitors.forEach((visitorImpl) => {
+			if (visitorImpl instanceof LessVisitor$1) lessVisitorInstances.push(visitorImpl);
+			else lessVisitorInstances.push(new LessVisitor$1(visitorImpl));
+		});
+		const processing = /* @__PURE__ */ new WeakSet();
+		let insideLessTraversal = false;
+		const processedPluginDirectives = /* @__PURE__ */ new WeakSet();
+		const visitor = {
+			atRule: (node, _ctx) => {
+				if (node && (node.type === "AtRule" || node.type === "AtRuleStatement" || node.type === "Directive")) {
+					const atRuleName = node.name ?? node.value?.name;
+					let nameValue;
+					if (typeof atRuleName === "string") nameValue = atRuleName;
+					else if (atRuleName?.value) nameValue = atRuleName.value;
+					else if (typeof atRuleName?.valueOf === "function") {
+						const value = atRuleName.valueOf();
+						if (typeof value === "string") nameValue = value;
+					}
+					if (nameValue === "plugin" || nameValue === "@plugin") {
+						const rawDirective = node instanceof LessAdapterBase ? node.jessNode : node;
+						const pluginDirectiveNode = typeof rawDirective === "object" && rawDirective !== null ? rawDirective : {};
+						if (processedPluginDirectives.has(pluginDirectiveNode)) return node;
+						processedPluginDirectives.add(pluginDirectiveNode);
+						this.warnForPluginDirective(rawDirective);
+						if (this._context?.opts?.disableScriptModules || this._context?.opts?.disablePluginRule) throw new Error(SCRIPT_MODULES_DISABLED_MESSAGE);
+						const baseDir = this._currentFilePath ? path.dirname(this._currentFilePath) : void 0;
+						const prelude = node.prelude ?? node.value?.prelude ?? node.value;
+						let pluginPath;
+						let pluginOptions;
+						if (prelude) {
+							const isObjectLike = (value) => typeof value === "object" && value !== null;
+							const hasValueOf = (value) => isObjectLike(value) && typeof value.valueOf === "function";
+							const valueOfString = (value, trim = false) => {
+								if (!hasValueOf(value)) return;
+								const output = value.valueOf();
+								return typeof output === "string" ? trim ? output.trim() : output : void 0;
+							};
+							const stringFromNodeValue = (value) => {
+								if (typeof value === "string") return value;
+								const valueResult = valueOfString(value);
+								if (valueResult !== void 0) return valueResult;
+								if (isObjectLike(value) && typeof value.value === "string") return value.value;
+							};
+							const extractStringValue = (node) => {
+								if (!node) return;
+								if (typeof node === "string") return node;
+								if (!isObjectLike(node)) return;
+								if (node.type === "Quoted" && node.value) {
+									const value = stringFromNodeValue(node.value);
+									if (value !== void 0) return value;
+									return valueOfString(node);
+								}
+								if (node.type === "Url" && node.value) {
+									const value = stringFromNodeValue(node.value);
+									if (value !== void 0) return value;
+									if (isObjectLike(node.value) && node.value.type === "Quoted") return extractStringValue(node.value);
+									return valueOfString(node);
+								}
+								return valueOfString(node, true);
+							};
+							if (typeof prelude === "string") pluginPath = prelude;
+							else if (prelude.type === "Quoted" || prelude.type === "Url") pluginPath = extractStringValue(prelude);
+							else if (prelude.type === "Sequence" && Array.isArray(prelude.value)) for (let i = 0; i < prelude.value.length; i++) {
+								const item = prelude.value[i];
+								const extracted = extractStringValue(item);
+								if (item && extracted !== void 0) {
+									pluginPath = extracted;
+									if (i > 0) {
+										const prevItem = prelude.value[i - 1];
+										if (prevItem && prevItem.type === "Paren" && prevItem.value) {
+											const optionsValue = prevItem.value.valueOf ? prevItem.value.valueOf() : prevItem.value.toString();
+											if (typeof optionsValue === "string") pluginOptions = optionsValue.trim();
+										} else if (prevItem && typeof prevItem.valueOf === "function") {
+											const optionsValue = prevItem.valueOf();
+											if (typeof optionsValue === "string" && optionsValue.includes("=")) pluginOptions = optionsValue.trim();
+										}
+									}
+									if (pluginPath) break;
+								}
+							}
+							else if (prelude.type === "Expression" && prelude.value) {
+								const values = Array.isArray(prelude.value) ? prelude.value : [prelude.value];
+								for (let i = 0; i < values.length; i++) {
+									const item = values[i];
+									const extracted = extractStringValue(item);
+									if (item && extracted !== void 0) {
+										pluginPath = extracted;
+										if (i > 0) {
+											const prevItem = values[i - 1];
+											if (prevItem && prevItem.type === "Paren" && prevItem.value) {
+												const optionsValue = prevItem.value.valueOf ? prevItem.value.valueOf() : prevItem.value.toString();
+												if (typeof optionsValue === "string") pluginOptions = optionsValue.trim();
+											}
+										}
+										if (pluginPath) break;
+									}
+								}
+							} else if (prelude.type === "List" && prelude.value) {
+								const items = Array.isArray(prelude.value) ? prelude.value : [prelude.value];
+								for (let i = 0; i < items.length; i++) {
+									const item = items[i];
+									const extracted = extractStringValue(item);
+									if (item && extracted !== void 0) {
+										pluginPath = extracted;
+										if (i > 0) {
+											const prevItem = items[i - 1];
+											if (prevItem && prevItem.type === "Paren" && prevItem.value) {
+												const optionsValue = prevItem.value.valueOf ? prevItem.value.valueOf() : prevItem.value.toString();
+												if (typeof optionsValue === "string") pluginOptions = optionsValue.trim();
+											}
+										}
+										if (pluginPath) break;
+									}
+								}
+							} else if (prelude.value && typeof prelude.value === "string") pluginPath = prelude.value;
+							if (!pluginPath && typeof prelude.valueOf === "function") {
+								const fallbackValue = prelude.valueOf();
+								if (typeof fallbackValue === "string") pluginPath = fallbackValue;
+							}
+						}
+						if (pluginPath) {
+							if (typeof pluginPath === "string") pluginPath = pluginPath.trim().replace(/^["']|["']$/g, "").trim();
+							else pluginPath = String(pluginPath).trim().replace(/^["']|["']$/g, "").trim();
+							const isExplicitLocalPath = pluginPath.startsWith(".") || pluginPath.startsWith("/") || pluginPath.includes("/") || pluginPath.includes(path.sep);
+							const localBasePath = baseDir && !path.isAbsolute(pluginPath) ? path.resolve(baseDir, pluginPath) : path.isAbsolute(pluginPath) ? pluginPath : void 0;
+							let resolvedLocalPluginFile;
+							if (localBasePath) resolvedLocalPluginFile = [
+								localBasePath,
+								`${localBasePath}.js`,
+								`${localBasePath}.cjs`,
+								`${localBasePath}.mjs`
+							].find((p) => fs.existsSync(p));
+							const isLocalPath = isExplicitLocalPath || !!resolvedLocalPluginFile;
+							if (isLocalPath && (!pluginManagerRef || !mockLessRef)) throw new Error(LESS_PLUGIN_JS_RUNTIME_MESSAGE);
+							if (pluginManagerRef && mockLessRef) try {
+								let scopeRules = node instanceof LessAdapterBase ? node.jessNode : node;
+								while (scopeRules && scopeRules.type !== "Rules") scopeRules = scopeRules.parent;
+								if (scopeRules && typeof scopeRules.setFunctionBinding === "function" && typeof scopeRules.findFunction === "function") if (!scopeRules.parent) currentRealRegistry = this._jessFunctionRegistry;
+								else currentRealRegistry = this.createJessFunctionBindingRegistry(scopeRules);
+								else currentRealRegistry = this._jessFunctionRegistry;
+								let pluginInstance = null;
+								if (this.opts.pluginRegistry && this.opts.pluginRegistry[pluginPath]) {
+									const pluginFactory = this.opts.pluginRegistry[pluginPath];
+									pluginInstance = typeof pluginFactory === "function" ? pluginFactory() : pluginFactory;
+								} else if (isLocalPath && resolvedLocalPluginFile) {
+									const loadedWithDeno = this.loadLessPluginFileWithDeno(resolvedLocalPluginFile, currentRealRegistry);
+									if (isThenable(loadedWithDeno)) return loadedWithDeno.then((loaded) => {
+										if (!loaded) throw new Error(LESS_PLUGIN_JS_RUNTIME_MESSAGE);
+										this.markPluginDirectiveInvisible(node);
+										return node;
+									});
+									if (!loadedWithDeno) throw new Error(LESS_PLUGIN_JS_RUNTIME_MESSAGE);
+								} else if (isLocalPath) throw new Error(LESS_PLUGIN_JS_RUNTIME_MESSAGE);
+								else if (!isLocalPath && this.opts.autoLoadPlugins !== false) {
+									const packageNamesToTry = ["less-plugin-", ""].map((prefix) => prefix + pluginPath);
+									let loaded = false;
+									if (this.opts.nodeModulesPlugin) for (const packageName of packageNamesToTry) {
+										const resolvedPath = this.opts.nodeModulesPlugin.resolvePackage(packageName);
+										if (resolvedPath) try {
+											const { module: pluginModule, registered } = requirePluginFile(resolvedPath, currentRealRegistry);
+											let PluginClass = pluginModule.default || pluginModule;
+											pluginInstance = registered || PluginClass;
+											loaded = true;
+											break;
+										} catch {}
+									}
+									if (!loaded) for (const fullName of packageNamesToTry) try {
+										if (typeof __require !== "undefined") {
+											const { module: pluginModule, registered } = requirePluginFile(fullName, currentRealRegistry);
+											let PluginClass = pluginModule.default || pluginModule;
+											pluginInstance = registered || PluginClass;
+											loaded = true;
+											break;
+										}
+									} catch (e) {
+										if (e.code !== "MODULE_NOT_FOUND") {}
+									}
+								}
+								if (pluginInstance) {
+									if (typeof pluginInstance === "function") try {
+										pluginInstance = new pluginInstance();
+									} catch {}
+									if (pluginOptions && typeof pluginInstance.setOptions === "function") try {
+										pluginInstance.setOptions(pluginOptions);
+									} catch {}
+									const visitorsBefore = pluginManagerRef.visitors.length;
+									pluginManagerRef.registerPlugin(pluginInstance);
+									if (pluginOptions && typeof pluginInstance.setOptions === "function") try {
+										pluginInstance.setOptions(pluginOptions);
+									} catch {}
+									if (pluginManagerRef.visitors.length > visitorsBefore) {
+										const newVisitors = pluginManagerRef.visitors.slice(visitorsBefore);
+										lessVisitorInstances.push(...newVisitors.map((v) => {
+											if (v instanceof LessVisitor$1) return v;
+											return new LessVisitor$1(v);
+										}));
+									}
+								}
+							} catch (e) {
+								if (e instanceof Error && e.message === LESS_PLUGIN_JS_RUNTIME_MESSAGE) throw e;
+							}
+						}
+						this.markPluginDirectiveInvisible(node);
+					}
+				}
+				return node;
+			},
+			visit: (node) => {
+				if (!node) return node;
+				const jessNode = node instanceof LessAdapterBase ? node.jessNode : node;
+				if (typeof jessNode !== "object" || jessNode === null) return node;
+				if ((node.type === "AtRule" || node.type === "AtRuleStatement" || node.type === "Directive") && visitor.atRule) {
+					const atRuleResult = visitor.atRule(node, void 0);
+					if (atRuleResult && typeof atRuleResult !== "symbol" && atRuleResult !== node) {
+						node = atRuleResult;
+						if ((node instanceof LessAdapterBase ? node.jessNode : node) !== jessNode) {}
+					}
+				}
+				if (insideLessTraversal) return node;
+				if (processing.has(jessNode)) return node;
+				processing.add(jessNode);
+				try {
+					const lessNode = toLessNode(jessNode, { cache: cacheMap });
+					insideLessTraversal = true;
+					try {
+						let result = lessNode;
+						if (lessVisitorInstances.length > 0) {
+							const visitorIterator = createVisitorIterator();
+							let iteratorResult = visitorIterator.next();
+							let iterationCount = 0;
+							while (!iteratorResult.done) {
+								iterationCount++;
+								if (iterationCount > 100) break;
+								result = iteratorResult.value.visit(result);
+								if (result === void 0) return REMOVE;
+								iteratorResult = visitorIterator.next();
+							}
+						}
+						if (result !== lessNode) {
+							const converted = fromLessNode(result, { cache: cacheMap });
+							return converted !== jessNode ? converted : jessNode;
+						}
+						return jessNode;
+					} finally {
+						insideLessTraversal = false;
+					}
+				} finally {}
+			}
+		};
+		return visitor;
+	}
+};
+/**
+* Create a Less.js compatibility plugin
+*/
+const lessCompatPlugin = (opts) => {
+	return new LessCompatPlugin(opts);
+};
+//#endregion
+export { LessAdapterBase, LessCompatPlugin, LessTreeConstructors, createLessAdapter, createLessMock, lessCompatPlugin as default, lessCompatPlugin, filterPlugins, fromLessNode, fromLessPluginReturnValue, fromLessTree, getLessTypeIndex, isJessPlugin, isLessPlugin, mapJessTypeToLessType, mapLessTypeToJessType, toLessNode, toLessTree };