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

package/lib/transform.js

@@ -0,0 +1,1015 @@
+import { a as mapJessTypeToLessType, n as createLessAdapter, r as isAdaptingNode, t as LessAdapterBase } from "./less-adapter.js";
+import { Ampersand, Any, BasicSelector, Collection, Color, ColorFormat, Combinator, ComplexSelector, CompoundSelector, Declaration, Dimension, ExtendFlag, Interpolated, Nil, Node, Num, Quoted, Rules, Selector, SelectorList, isStringCombinator, sourceSpanOf } from "@jesscss/core";
+//#region src/transform/adapter.ts
+/**
+* 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.
+*/
+function createFromAdapter(adapter) {
+	return (jessNode, cache) => {
+		return createLessAdapter(jessNode, {
+			lessType: adapter.lessType ?? ((node) => mapJessTypeToLessType(node.type)),
+			fields: adapter.fields,
+			accept: adapter.accept
+		}, cache);
+	};
+}
+function selfVisitAccept() {
+	return (node) => {
+		return node;
+	};
+}
+/**
+* Accept helper: traverse child nodes via visitor.visitArray.
+*/
+function childrenAccept(getChildren) {
+	return (node, visitor, cache) => {
+		const children = getChildren(node, cache);
+		if (children.length > 0) {
+			const lessChildren = children.map((child) => toLessNode(child, { cache })).filter((child) => child != null);
+			if (lessChildren.length > 0) {
+				if (visitor.visitArray) visitor.visitArray(lessChildren);
+				else for (const child of lessChildren) if (child?.accept) child.accept(visitor);
+			}
+		}
+		return node;
+	};
+}
+/**
+* Accept helper: traverse a single child node.
+*/
+function singleChildAccept(getChild) {
+	return (node, visitor, cache) => {
+		const child = getChild(node);
+		if (child instanceof Node) {
+			const lessChild = toLessNode(child, { cache });
+			if (lessChild?.accept) lessChild.accept(visitor);
+			else if (lessChild && visitor.visitArray) visitor.visitArray([lessChild]);
+			else if (lessChild && visitor.visit) visitor.visit(lessChild);
+		}
+		return node;
+	};
+}
+//#endregion
+//#region src/nodes/selector.ts
+/**
+* Flatten a hierarchical Jess selector into Less's flat Element array.
+* Less expects: Element[] where each Element has { combinator, value }
+* Jess now models complex selectors as an interleaved stream of selector
+* components and explicit combinators. Less still expects flat Elements with
+* the combinator attached to the following selector component.
+*/
+function flattenSelectorToElements(selector, cache) {
+	const elements = [];
+	if (typeof selector === "string") {
+		elements.push(createElementAdapter(selector, createLessCombinator(""), cache));
+		return elements;
+	}
+	if (Array.isArray(selector)) {
+		const first = selector[0];
+		return first !== void 0 ? flattenSelectorToElements(first, cache) : [];
+	}
+	if (selector instanceof SelectorList) {
+		const selectorListValue = selector.value;
+		if (selectorListValue.length > 0 && selectorListValue[0]) return flattenSelectorToElements(selectorListValue[0], cache);
+		return [];
+	}
+	if (selector instanceof ComplexSelector) {
+		const components = selector.value;
+		let nextCombinatorValue = "";
+		for (let i = 0; i < components.length; i++) {
+			const component = components[i];
+			if (!component) continue;
+			if (component instanceof Combinator) {
+				nextCombinatorValue = component.value;
+				continue;
+			}
+			if (typeof component === "string" && isStringCombinator(component)) {
+				nextCombinatorValue = component;
+				continue;
+			}
+			if (component instanceof CompoundSelector) {
+				const compoundValue = component.value;
+				for (let j = 0; j < compoundValue.length; j++) {
+					const simple = compoundValue[j];
+					if (!simple) continue;
+					const elementCombinator = createLessCombinator(j === 0 ? nextCombinatorValue : "");
+					elements.push(createElementAdapter(simple, elementCombinator, cache));
+				}
+			} else if (typeof component === "string") {
+				const elementCombinator = createLessCombinator(nextCombinatorValue);
+				elements.push(createElementAdapter(component, elementCombinator, cache));
+			} else if (component instanceof BasicSelector || component instanceof Ampersand) {
+				const elementCombinator = createLessCombinator(nextCombinatorValue);
+				elements.push(createElementAdapter(component, elementCombinator, cache));
+			} else if (component instanceof Node) {
+				const elementCombinator = createLessCombinator(nextCombinatorValue);
+				elements.push(createElementAdapter(component, elementCombinator, cache));
+			}
+			nextCombinatorValue = "";
+		}
+	} else if (selector instanceof CompoundSelector) {
+		const compoundSelValue = selector.value;
+		for (let i = 0; i < compoundSelValue.length; i++) {
+			const basic = compoundSelValue[i];
+			if (!basic) continue;
+			const combinator = createLessCombinator(i === 0 ? "" : "");
+			elements.push(createElementAdapter(basic, combinator, cache));
+		}
+	} else if (selector instanceof BasicSelector || selector instanceof Ampersand) elements.push(createElementAdapter(selector, createLessCombinator(""), cache));
+	return elements;
+}
+function createLessCombinator(value) {
+	return {
+		type: "Combinator",
+		typeIndex: void 0,
+		value,
+		emptyOrWhitespace: value === "" || value === " ",
+		accept() {
+			return value;
+		}
+	};
+}
+function createElementAdapter(basic, combinator, cache) {
+	if (typeof basic === "string") return {
+		type: "Element",
+		typeIndex: void 0,
+		combinator,
+		value: basic,
+		isVariable: false,
+		accept(visitor) {
+			if (combinator && visitor.visit) visitor.visit(combinator);
+			return basic;
+		}
+	};
+	const adapter = createLessAdapter(basic, {
+		lessType: "Element",
+		fields: {
+			combinator: () => combinator,
+			value: (target) => "value" in target ? target.value : void 0,
+			isVariable: () => false
+		},
+		accept: (target, visitor) => {
+			if (combinator && visitor.visit) visitor.visit(combinator);
+			const value = "value" in target ? target.value : void 0;
+			if (value && typeof value === "object" && value instanceof Node) {
+				const lessValue = toLessNode(value, { cache });
+				if (lessValue && visitor.visit) visitor.visit(lessValue);
+			}
+			return target;
+		}
+	});
+	if (cache) cache.set(basic, adapter);
+	return adapter;
+}
+function transformSelectorToLess(sel, cache) {
+	const elements = flattenSelectorToElements(sel, cache);
+	if (typeof sel === "string" || Array.isArray(sel)) return {
+		type: "Selector",
+		typeIndex: void 0,
+		elements,
+		length: elements.length,
+		accept(visitor) {
+			if (visitor.visitArray) visitor.visitArray(elements);
+			return sel;
+		}
+	};
+	const adapter = createLessAdapter(sel, {
+		lessType: "Selector",
+		fields: {
+			elements: () => elements,
+			length: () => elements.length
+		},
+		accept: (node, visitor) => {
+			if (visitor.visitArray) visitor.visitArray(elements);
+			else if (visitor.visit) for (const element of elements) visitor.visit(element);
+			else for (const element of elements) if (element?.accept) element.accept(visitor);
+			return node;
+		}
+	}, cache);
+	for (let i = 0; i < elements.length; i++) Object.defineProperty(adapter, String(i), {
+		enumerable: true,
+		configurable: true,
+		get: () => elements[i]
+	});
+	return adapter;
+}
+//#endregion
+//#region src/nodes/ruleset.ts
+/**
+* Return a Ruleset's child rules as a flat array.
+*
+* Core's `Ruleset.rules` is normally a plain `Node[]` (the parser delivers an
+* array), but a caller may also construct a Ruleset with a `Rules` wrapper node
+* as its body (`new Ruleset({ rules: new Rules([...]) })`). The wrapper is stored
+* as-is now that the old factory-side unwrap was removed, so read its `.rules`.
+*/
+function ruleList(rs) {
+	const rules = rs.rules;
+	if (rules instanceof Rules) return rules.rules;
+	if (Array.isArray(rules)) return rules;
+	return [];
+}
+const transformRulesetToLess = createFromAdapter({
+	fields: {
+		selectors: (rs, cache) => {
+			const selector = rs.selector;
+			if (selector instanceof Nil) return [];
+			if (!selector) return [];
+			if (selector instanceof SelectorList) return selector.value.filter((s) => s instanceof Selector).map((s) => transformSelectorToLess(s, cache));
+			return [transformSelectorToLess(selector, cache)];
+		},
+		rules: (rs, cache) => {
+			return ruleList(rs).map((r) => toLessNode(r, { cache }));
+		}
+	},
+	accept: (ruleset, visitor, cache) => {
+		const selector = ruleset.selector;
+		const rules = ruleList(ruleset);
+		if (selector && !(selector instanceof Nil)) if (selector instanceof SelectorList) {
+			const lessSelectors = selector.value.filter((s) => s instanceof Selector).map((s) => toLessNode(s, { cache }));
+			if (visitor.visitArray) visitor.visitArray(lessSelectors);
+			else for (const ls of lessSelectors) if (ls?.accept) ls.accept(visitor);
+		} else {
+			const lessSelector = transformSelectorToLess(selector, cache);
+			if (lessSelector) {
+				if (visitor.visitArray) visitor.visitArray([lessSelector]);
+				else if (lessSelector.accept) lessSelector.accept(visitor);
+			}
+		}
+		if (rules.length > 0) {
+			const lessRules = rules.map((r) => toLessNode(r, { cache }));
+			if (visitor.visitArray) visitor.visitArray(lessRules);
+			else for (const lr of lessRules) if (lr?.accept) lr.accept(visitor);
+		}
+	}
+});
+//#endregion
+//#region src/transform/from-less.ts
+/**
+* Convert a Less node back to a Jess node
+*
+* @param lessNode - The Less node to convert
+* @param options - Conversion options
+* @returns A Jess node
+*/
+function fromLessNode(lessNode, options) {
+	if (!lessNode) return lessNode;
+	const cache = options?.cache || /* @__PURE__ */ new WeakMap();
+	if (cache.has(lessNode)) {
+		const cached = cache.get(lessNode);
+		if (cached) return cached;
+	}
+	if (lessNode instanceof LessAdapterBase) {
+		cache.set(lessNode, lessNode.jessNode);
+		return lessNode.jessNode;
+	}
+	if (lessNode && typeof lessNode === "object" && "__jessNode" in lessNode) return lessNode.__jessNode;
+	if (lessNode && typeof lessNode === "object" && typeof lessNode.type === "string") {
+		if (lessNode.type === "Quoted") {
+			const quote = lessNode.quote === "'" || lessNode.quote === "\"" ? lessNode.quote : "\"";
+			const out = new Quoted(typeof lessNode.value === "string" ? lessNode.value : String(lessNode.value), {
+				quote,
+				escaped: !!lessNode.escaped
+			});
+			cache.set(lessNode, out);
+			return out;
+		}
+		if (lessNode.type === "Anonymous") {
+			const out = new Any(typeof lessNode.value === "string" ? lessNode.value : String(lessNode.value));
+			cache.set(lessNode, out);
+			return out;
+		}
+		if (lessNode.type === "Dimension" || lessNode.type === "Num") {
+			const out = new Dimension({
+				number: typeof lessNode.value === "number" ? lessNode.value : Number(lessNode.value),
+				unit: (typeof lessNode.unit === "string" ? lessNode.unit : "") || void 0
+			});
+			cache.set(lessNode, out);
+			return out;
+		}
+		if (lessNode.type === "Color") {
+			const [r = 0, g = 0, b = 0] = Array.isArray(lessNode.rgb) ? lessNode.rgb : [
+				0,
+				0,
+				0
+			];
+			const alpha = typeof lessNode.alpha === "number" ? lessNode.alpha : 1;
+			const out = new Color({
+				rgb: [
+					r,
+					g,
+					b
+				],
+				alpha
+			}, { format: ColorFormat.HEX });
+			cache.set(lessNode, out);
+			return out;
+		}
+		if (lessNode.type === "Declaration" || lessNode.type === "Rule") {
+			const prop = String(lessNode.name ?? "");
+			const val = lessNode.value;
+			const decl = new Declaration({
+				name: prop,
+				value: new Any(val && typeof val === "object" && typeof val.value === "string" ? val.value : String(val ?? ""))
+			});
+			cache.set(lessNode, decl);
+			return decl;
+		}
+		if (lessNode.type === "DetachedRuleset") {
+			const ruleset = lessNode.ruleset;
+			const rules = ruleset && Array.isArray(ruleset.rules) ? ruleset.rules : [];
+			const nodes = [];
+			for (const rr of rules) if (rr && typeof rr === "object" && (rr.type === "Declaration" || rr.type === "Rule")) {
+				const prop = String(rr.name ?? "");
+				const val = rr.value;
+				const decl = new Declaration({
+					name: prop,
+					value: new Any(val && typeof val === "object" && typeof val.value === "string" ? val.value : String(val ?? ""))
+				});
+				nodes.push(decl);
+			}
+			const out = new Collection(nodes);
+			cache.set(lessNode, out);
+			return out;
+		}
+		if (lessNode.type === "AtRule") {
+			const n = String(lessNode.name ?? "");
+			const line = `${n} ${String(lessNode.value ?? "")};`;
+			const out = n === "@charset" ? new Any(line, { role: "charset" }) : new Any(line);
+			cache.set(lessNode, out);
+			return out;
+		}
+	}
+	throw new Error(`Cannot convert Less node back to Jess: ${lessNode?.type || "unknown type"}. Less visitors should not create new nodes, only modify existing ones.`);
+}
+/**
+* Convert a Less plugin function return value to a Jess node.
+* Handles primitives (number, boolean), Less nodes (via fromLessNode), and toCSS() objects.
+* Use this for @plugin-loaded function results so conversion is centralized here.
+*/
+function fromLessPluginReturnValue(value, options) {
+	if (value === null || value === void 0) return;
+	if (typeof value === "number") return new Any(String(value));
+	if (value === true || value === false) {
+		if (options?.statementContext) return;
+		return new Any(String(value));
+	}
+	if (typeof value === "object" && value !== null) {
+		if ("type" in value && typeof value.type === "string") return fromLessNode(value, options);
+		if ("toCSS" in value && typeof value.toCSS === "function") try {
+			const css = value.toCSS();
+			return new Any(typeof css === "string" ? css : String(css));
+		} catch {}
+	}
+	if (value instanceof Node) return value;
+	return new Any(String(value));
+}
+/**
+* Convert an entire Less tree back to Jess Rules
+*
+* @param lessTree - The Less tree to convert
+* @param options - Conversion options
+* @returns A Jess Rules tree
+*/
+function fromLessTree(lessTree, _options) {
+	if (lessTree instanceof LessAdapterBase && lessTree.jessNode instanceof Rules) return lessTree.jessNode;
+	throw new Error("Cannot convert Less tree back to Jess Rules");
+}
+//#endregion
+//#region src/nodes/declaration.ts
+const transformDeclarationToLess = createFromAdapter({
+	fields: {
+		name: {
+			get: (d) => d.name,
+			set: (d, value) => {
+				d.name = value instanceof Interpolated ? value : String(value);
+			}
+		},
+		value: {
+			get: (d, cache) => {
+				const value = d.value;
+				return value instanceof Node ? toLessNode(value, { cache }) : value;
+			},
+			set: (d, value) => {
+				const node = value instanceof Node ? value : fromLessNode(value);
+				d.adopt(node);
+				d.value = node;
+			}
+		},
+		important: (d) => d.important || false,
+		variable: (d) => d.options?.assign !== void 0,
+		merge: () => false
+	},
+	accept: (decl, visitor, cache) => {
+		const value = decl.value;
+		if (value instanceof Node) {
+			const lessValue = toLessNode(value, { cache });
+			if (lessValue?.accept) lessValue.accept(visitor);
+			else if (lessValue && visitor.visitArray) visitor.visitArray([lessValue]);
+			else if (lessValue && visitor.visit) visitor.visit(lessValue);
+		}
+		return decl;
+	}
+});
+//#endregion
+//#region src/nodes/mixin.ts
+const transformMixinToLess = createFromAdapter({
+	fields: {
+		name: (m) => m.name,
+		params: (m, cache) => {
+			const params = m.params;
+			return params instanceof Node ? toLessNode(params, { cache }) : params;
+		},
+		rules: (m, cache) => {
+			return m.rules.map((r) => toLessNode(r, { cache }));
+		},
+		condition: (m, cache) => {
+			const guard = m.guard;
+			return guard instanceof Node ? toLessNode(guard, { cache }) : guard;
+		}
+	},
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/dimension.ts
+const transformDimensionToLess = createFromAdapter({ fields: {
+	value: (d) => d.number,
+	unit: (d) => d instanceof Num ? "" : d.unit || ""
+} });
+//#endregion
+//#region src/nodes/color.ts
+const transformColorToLess = createFromAdapter({ fields: {
+	rgb: (c) => c.rgb || [
+		0,
+		0,
+		0
+	],
+	alpha: (c) => c._alpha,
+	value: (c) => {
+		const rgb = c.rgb;
+		const alpha = c._alpha;
+		if (rgb && alpha !== void 0 && alpha < 1) return `rgba(${rgb[0]}, ${rgb[1]}, ${rgb[2]}, ${alpha})`;
+		if (rgb) return `#${rgb.map((v) => {
+			const numericValue = Array.isArray(v) ? v[0] : v;
+			return Math.round(numericValue).toString(16).padStart(2, "0");
+		}).join("")}`;
+		return "";
+	}
+} });
+//#endregion
+//#region src/nodes/operation.ts
+const transformOperationToLess = createFromAdapter({
+	fields: {
+		op: (o) => o.operator || "",
+		operands: (o, cache) => {
+			const operands = [];
+			const { left, right } = o;
+			if (left instanceof Node) operands.push(left);
+			if (right instanceof Node) operands.push(right);
+			return operands.map((n) => toLessNode(n, { cache }));
+		}
+	},
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/expression.ts
+const transformExpressionToLess = createFromAdapter({
+	fields: { value: (e, cache) => {
+		const value = e.value;
+		if (value instanceof Node) return [toLessNode(value, { cache })];
+		return [value];
+	} },
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/sequence.ts
+const transformSequenceToLess = createFromAdapter({
+	fields: {
+		value: (seq, cache) => (seq.value ?? []).map((item) => item instanceof Node ? toLessNode(item, { cache }) : item).filter((item) => item != null),
+		length: (seq) => (seq.value ?? []).filter((v) => v != null).length
+	},
+	accept: (seq, visitor, cache) => {
+		const raw = seq.value ?? [];
+		if (!Array.isArray(raw) || raw.length === 0) return seq;
+		for (let i = 0; i < raw.length; i++) {
+			const item = raw[i];
+			if (item == null) continue;
+			const lessItem = item instanceof Node ? toLessNode(item, { cache }) : item;
+			if (!lessItem || typeof visitor?.visit !== "function") continue;
+			const visited = visitor.visit(lessItem);
+			if (visited && visited !== lessItem && typeof visited === "object" && "type" in visited) try {
+				const jessReplacement = fromLessNode(visited, { cache: /* @__PURE__ */ new WeakMap() });
+				if (item instanceof Node) jessReplacement.inherit(item);
+				seq.adopt(jessReplacement);
+				seq.value[i] = jessReplacement;
+			} catch {}
+		}
+		return seq;
+	}
+});
+//#endregion
+//#region src/nodes/quoted.ts
+const transformQuotedToLess = createFromAdapter({
+	fields: {
+		value: (q) => {
+			const value = q.value;
+			if (typeof value === "string") return value;
+			if (value instanceof Any) return value.value;
+			if (value instanceof Interpolated) return String(value.source);
+			return String(value);
+		},
+		quote: (q) => q.quote || "\"",
+		escaped: (q) => q.escaped === true
+	},
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/url.ts
+const transformUrlToLess = createFromAdapter({
+	fields: { value: (u, cache) => {
+		const value = u.value;
+		return value instanceof Quoted ? toLessNode(value, { cache }) : value;
+	} },
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/comment.ts
+const transformCommentToLess = createFromAdapter({
+	fields: {
+		value: (c) => c.value,
+		silent: () => false
+	},
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/at-rule.ts
+const transformAtRuleToLess = createFromAdapter({
+	fields: {
+		name: (a) => a.name,
+		value: (a, cache) => {
+			const prelude = a.prelude;
+			return prelude instanceof Node ? toLessNode(prelude, { cache }) : prelude;
+		},
+		rules: (a, cache) => {
+			const rules = a.rules;
+			return rules ? rules.map((r) => toLessNode(r, { cache })) : [];
+		}
+	},
+	accept: childrenAccept((a) => {
+		const rules = a.rules;
+		return rules.length ? [...rules] : [];
+	})
+});
+//#endregion
+//#region src/nodes/import.ts
+const transformImportToLess = createFromAdapter({
+	fields: {
+		path: (imp, cache) => {
+			const path = imp.path;
+			return path instanceof Node ? toLessNode(path, { cache }) : path;
+		},
+		options: (imp) => imp.options?.importOptions || {},
+		currentFileInfo: () => ({}),
+		index: (imp) => sourceSpanOf(imp)?.start
+	},
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/extend.ts
+const transformExtendToLess = createFromAdapter({
+	fields: {
+		selector: (e, cache) => {
+			const selector = e.selector;
+			return selector instanceof Selector ? toLessNode(selector, { cache }) : selector;
+		},
+		option: (e) => e.flag === ExtendFlag.Exact ? "exact" : "all",
+		index: (e) => sourceSpanOf(e)?.start
+	},
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/condition.ts
+const transformConditionToLess = createFromAdapter({
+	fields: {
+		op: (c) => c.operator || "",
+		lvalue: (c, cache) => {
+			const left = c.left;
+			return left instanceof Node ? toLessNode(left, { cache }) : left;
+		},
+		rvalue: (c, cache) => {
+			const right = c.right;
+			return right instanceof Node ? toLessNode(right, { cache }) : right;
+		},
+		negate: (c) => c.negate
+	},
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/paren.ts
+const transformParenToLess = createFromAdapter({
+	fields: { value: (p, cache) => {
+		const value = p.value;
+		return value instanceof Node ? toLessNode(value, { cache }) : value;
+	} },
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/negative.ts
+const transformNegativeToLess = createFromAdapter({
+	fields: { value: (n, cache) => {
+		const value = n.value;
+		return value instanceof Node ? toLessNode(value, { cache }) : value;
+	} },
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/list.ts
+function getFilteredValue(list, cache) {
+	const data = list.value;
+	if (Array.isArray(data)) return data.map((item) => {
+		if (!item) return null;
+		if (item instanceof Node) return toLessNode(item, { cache }) || null;
+		return item;
+	}).filter((item) => item != null);
+	if (data != null) {
+		if (data && typeof data === "object" && "type" in data) {
+			const lessValue = toLessNode(data, { cache });
+			return lessValue ? [lessValue] : [];
+		}
+		return [data];
+	}
+	return [];
+}
+const transformListToLess = createFromAdapter({
+	fields: {
+		value: (l, cache) => getFilteredValue(l, cache),
+		length: (l, cache) => getFilteredValue(l, cache).length
+	},
+	accept: (list, visitor, cache) => {
+		const value = list.value;
+		if (Array.isArray(value) && value.length > 0) {
+			const lessItems = value.map((item) => item instanceof Node ? toLessNode(item, { cache }) : item).filter((item) => item != null);
+			if (lessItems.length > 0) {
+				if (visitor.visitArray) visitor.visitArray(lessItems);
+				else for (const li of lessItems) if (li?.accept) li.accept(visitor);
+			}
+		}
+		return list;
+	}
+});
+//#endregion
+//#region src/nodes/var-declaration.ts
+const transformVarDeclarationToLess = createFromAdapter({
+	fields: {
+		name: {
+			get: (v) => v.name,
+			set: (v, value) => {
+				v.name = value instanceof Interpolated ? value : String(value);
+			}
+		},
+		value: {
+			get: (v, cache) => {
+				const value = v.value;
+				return value instanceof Node ? toLessNode(value, { cache }) : value;
+			},
+			set: (v, value) => {
+				const node = value instanceof Node ? value : fromLessNode(value);
+				v.adopt(node);
+				v.value = node;
+			}
+		},
+		index: (v) => sourceSpanOf(v)?.start
+	},
+	accept: singleChildAccept((v) => {
+		const value = v.value;
+		return value instanceof Node ? value : void 0;
+	})
+});
+//#endregion
+//#region src/nodes/keyword.ts
+const transformKeywordToLess = createFromAdapter({
+	fields: { value: (k) => k.value },
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/combinator.ts
+const transformCombinatorToLess = createFromAdapter({ fields: { value: (c) => c.value } });
+//#endregion
+//#region src/nodes/attribute-selector.ts
+const transformAttributeSelectorToLess = createFromAdapter({
+	fields: {
+		key: (a, cache) => {
+			const name = a.name;
+			return name instanceof Node ? toLessNode(name, { cache }) : name;
+		},
+		op: (a) => a.op || "",
+		value: (a, cache) => {
+			const value = a.attributeValue;
+			return value instanceof Node ? toLessNode(value, { cache }) : value;
+		}
+	},
+	accept: selfVisitAccept()
+});
+//#endregion
+//#region src/nodes/call.ts
+const transformCallToLess = createFromAdapter({
+	fields: {
+		name: (c) => c.name,
+		args: (c, cache) => {
+			const args = c.args;
+			if (!args) return [];
+			return args.value.map((arg) => arg instanceof Node ? toLessNode(arg, { cache }) : arg);
+		},
+		index: (c) => sourceSpanOf(c)?.start
+	},
+	accept: childrenAccept((c) => {
+		const argsValue = c.args?.value;
+		return argsValue?.length ? argsValue.filter((a) => a instanceof Node) : [];
+	})
+});
+//#endregion
+//#region src/nodes/reference.ts
+const transformReferenceToLess = createFromAdapter({
+	lessType: (ref) => {
+		const refType = ref.options?.type || "variable";
+		if (refType === "property") return "Property";
+		if (refType === "function" || refType === "mixin") return "VariableCall";
+		return "Variable";
+	},
+	fields: {
+		name: (ref) => {
+			const refType = ref.options?.type || "variable";
+			const lessType = refType === "property" ? "Property" : refType === "function" || refType === "mixin" ? "VariableCall" : "Variable";
+			const key = ref.key;
+			if (typeof key === "string") {
+				if (lessType === "Variable" && !key.startsWith("@")) return `@${key}`;
+				return key;
+			}
+			return String(key);
+		},
+		value: (ref) => {
+			const refType = ref.options?.type || "variable";
+			if (refType === "function" || refType === "mixin") return ref;
+		},
+		index: (ref) => sourceSpanOf(ref)?.start,
+		currentFileInfo: () => ({})
+	}
+});
+//#endregion
+//#region src/nodes/index.ts
+function isRuleset(node) {
+	return node.type === "Ruleset";
+}
+function isDeclaration(node) {
+	return node.type === "Declaration";
+}
+function isMixin(node) {
+	return node.type === "Mixin";
+}
+function isDimension(node) {
+	return node.type === "Dimension";
+}
+function isNum(node) {
+	return node.type === "Num";
+}
+function isColor(node) {
+	return node.type === "Color";
+}
+function isOperation(node) {
+	return node.type === "Operation";
+}
+function isExpression(node) {
+	return node.type === "Expression";
+}
+function isSequence(node) {
+	return node.type === "Sequence";
+}
+function isQuoted(node) {
+	return node.type === "Quoted";
+}
+function isUrl(node) {
+	return node.type === "Url";
+}
+function isComment(node) {
+	return node.type === "Comment";
+}
+function isAtRule(node) {
+	return node.type === "AtRule";
+}
+function isStyleImport(node) {
+	return node.type === "StyleImport";
+}
+function isExtend(node) {
+	return node.type === "Extend";
+}
+function isCondition(node) {
+	return node.type === "Condition";
+}
+function isParen(node) {
+	return node.type === "Paren";
+}
+function isNegative(node) {
+	return node.type === "Negative";
+}
+function isList(node) {
+	return node.type === "List";
+}
+function isVarDeclaration(node) {
+	return node.type === "VarDeclaration";
+}
+function isKeyword(node) {
+	return node.type === "Keyword";
+}
+function isCombinator(node) {
+	return node.type === "Combinator";
+}
+function isAttributeSelector(node) {
+	return node.type === "AttributeSelector";
+}
+function isCall(node) {
+	return node.type === "Call";
+}
+function isSelector(node) {
+	return node.type === "SelectorList" || node.type === "ComplexSelector" || node.type === "CompoundSelector" || node.type === "BasicSelector";
+}
+function isReference(node) {
+	return node.type === "Reference";
+}
+/**
+* Registry of node transformers
+*/
+const transformers = /* @__PURE__ */ new Map();
+transformers.set("Ruleset", (node, cache) => {
+	if (isRuleset(node)) return transformRulesetToLess(node, cache);
+	throw new Error(`Expected Ruleset node, got ${node.type}`);
+});
+transformers.set("Declaration", (node, cache) => {
+	if (isDeclaration(node)) return transformDeclarationToLess(node, cache);
+	throw new Error(`Expected Declaration node, got ${node.type}`);
+});
+transformers.set("Mixin", (node, cache) => {
+	if (isMixin(node)) return transformMixinToLess(node, cache);
+	throw new Error(`Expected Mixin node, got ${node.type}`);
+});
+transformers.set("Dimension", (node, cache) => {
+	if (isDimension(node)) return transformDimensionToLess(node, cache);
+	throw new Error(`Expected Dimension node, got ${node.type}`);
+});
+transformers.set("Num", (node, cache) => {
+	if (isNum(node)) return transformDimensionToLess(node, cache);
+	throw new Error(`Expected Num node, got ${node.type}`);
+});
+transformers.set("Color", (node, cache) => {
+	if (isColor(node)) return transformColorToLess(node, cache);
+	throw new Error(`Expected Color node, got ${node.type}`);
+});
+transformers.set("Operation", (node, cache) => {
+	if (isOperation(node)) return transformOperationToLess(node, cache);
+	throw new Error(`Expected Operation node, got ${node.type}`);
+});
+transformers.set("Expression", (node, cache) => {
+	if (isExpression(node)) return transformExpressionToLess(node, cache);
+	throw new Error(`Expected Expression node, got ${node.type}`);
+});
+transformers.set("Sequence", (node, cache) => {
+	if (isSequence(node)) return transformSequenceToLess(node, cache);
+	throw new Error(`Expected Sequence node, got ${node.type}`);
+});
+transformers.set("Quoted", (node, cache) => {
+	if (isQuoted(node)) return transformQuotedToLess(node, cache);
+	throw new Error(`Expected Quoted node, got ${node.type}`);
+});
+transformers.set("Url", (node, cache) => {
+	if (isUrl(node)) return transformUrlToLess(node, cache);
+	throw new Error(`Expected Url node, got ${node.type}`);
+});
+transformers.set("Comment", (node, cache) => {
+	if (isComment(node)) return transformCommentToLess(node, cache);
+	throw new Error(`Expected Comment node, got ${node.type}`);
+});
+transformers.set("AtRule", (node, cache) => {
+	if (isAtRule(node)) return transformAtRuleToLess(node, cache);
+	throw new Error(`Expected AtRule node, got ${node.type}`);
+});
+transformers.set("StyleImport", (node, cache) => {
+	if (isStyleImport(node)) return transformImportToLess(node, cache);
+	throw new Error(`Expected StyleImport node, got ${node.type}`);
+});
+transformers.set("Extend", (node, cache) => {
+	if (isExtend(node)) return transformExtendToLess(node, cache);
+	throw new Error(`Expected Extend node, got ${node.type}`);
+});
+transformers.set("Condition", (node, cache) => {
+	if (isCondition(node)) return transformConditionToLess(node, cache);
+	throw new Error(`Expected Condition node, got ${node.type}`);
+});
+transformers.set("Paren", (node, cache) => {
+	if (isParen(node)) return transformParenToLess(node, cache);
+	throw new Error(`Expected Paren node, got ${node.type}`);
+});
+transformers.set("Negative", (node, cache) => {
+	if (isNegative(node)) return transformNegativeToLess(node, cache);
+	throw new Error(`Expected Negative node, got ${node.type}`);
+});
+transformers.set("List", (node, cache) => {
+	if (isList(node)) return transformListToLess(node, cache);
+	throw new Error(`Expected List node, got ${node.type}`);
+});
+transformers.set("VarDeclaration", (node, cache) => {
+	if (isVarDeclaration(node)) return transformVarDeclarationToLess(node, cache);
+	throw new Error(`Expected VarDeclaration node, got ${node.type}`);
+});
+transformers.set("Keyword", (node, cache) => {
+	if (isKeyword(node)) return transformKeywordToLess(node, cache);
+	throw new Error(`Expected Keyword node, got ${node.type}`);
+});
+transformers.set("Combinator", (node, cache) => {
+	if (isCombinator(node)) return transformCombinatorToLess(node, cache);
+	throw new Error(`Expected Combinator node, got ${node.type}`);
+});
+transformers.set("AttributeSelector", (node, cache) => {
+	if (isAttributeSelector(node)) return transformAttributeSelectorToLess(node, cache);
+	throw new Error(`Expected AttributeSelector node, got ${node.type}`);
+});
+transformers.set("Call", (node, cache) => {
+	if (isCall(node)) return transformCallToLess(node, cache);
+	throw new Error(`Expected Call node, got ${node.type}`);
+});
+transformers.set("SelectorList", (node, cache) => {
+	if (isSelector(node)) return transformSelectorToLess(node, cache);
+	throw new Error(`Expected Selector node, got ${node.type}`);
+});
+transformers.set("ComplexSelector", (node, cache) => {
+	if (isSelector(node)) return transformSelectorToLess(node, cache);
+	throw new Error(`Expected Selector node, got ${node.type}`);
+});
+transformers.set("CompoundSelector", (node, cache) => {
+	if (isSelector(node)) return transformSelectorToLess(node, cache);
+	throw new Error(`Expected Selector node, got ${node.type}`);
+});
+transformers.set("BasicSelector", (node, cache) => {
+	if (isSelector(node)) return transformSelectorToLess(node, cache);
+	throw new Error(`Expected Selector node, got ${node.type}`);
+});
+transformers.set("Reference", (node, cache) => {
+	if (isReference(node)) return transformReferenceToLess(node, cache);
+	throw new Error(`Expected Reference node, got ${node.type}`);
+});
+/**
+* Get the transformer for a Jess node type
+*/
+function getTransformer(nodeType) {
+	return transformers.get(nodeType);
+}
+//#endregion
+//#region src/transform/to-less.ts
+/**
+* Convert a Jess node to a Less-compatible adapter
+*
+* @param jessNode - The Jess node to convert
+* @param options - Conversion options
+* @returns A Less-compatible adapter node
+*/
+function toLessNode(jessNode, options) {
+	if (!jessNode) return jessNode;
+	const cache = options?.cache || /* @__PURE__ */ new WeakMap();
+	if (cache.has(jessNode)) return cache.get(jessNode);
+	if (isAdaptingNode(jessNode)) return jessNode;
+	const transformer = getTransformer(jessNode.type);
+	if (transformer) return transformer(jessNode, cache);
+	return createLessAdapter(jessNode, {
+		lessType: mapJessTypeToLessType(jessNode.type),
+		fields: { value: (target) => {
+			if (!("value" in target) || target.value === void 0) return;
+			const nodeValue = target.value;
+			if (nodeValue instanceof Node) return toLessNode(nodeValue, options);
+			if (Array.isArray(nodeValue)) return nodeValue.map((item) => item instanceof Node ? toLessNode(item, options) : item);
+			if (typeof nodeValue === "object" && nodeValue !== null) {
+				const converted = {};
+				for (const [key, val] of Object.entries(nodeValue)) if (val instanceof Node) converted[key] = toLessNode(val, options);
+				else if (Array.isArray(val)) converted[key] = val.map((item) => item instanceof Node ? toLessNode(item, options) : item);
+				else converted[key] = val;
+				return converted;
+			}
+			return nodeValue;
+		} },
+		accept: (target) => target
+	}, cache);
+}
+/**
+* Convert an entire Jess Rules tree to Less-compatible format
+*
+* @param jessRules - The Jess Rules tree to convert
+* @param options - Conversion options
+* @returns A Less-compatible tree
+*/
+function toLessTree(jessRules, options) {
+	if (jessRules instanceof Rules) return toLessNode(jessRules, options);
+	return toLessNode(jessRules, options);
+}
+//#endregion
+export { fromLessTree as a, fromLessPluginReturnValue as i, toLessTree as n, fromLessNode as r, toLessNode as t };