@zeng-alt/vue-spel-query-builder 1.0.0

package/dist/index.esm

@@ -0,0 +1,3095 @@
+import { SpelExpressionEvaluator, StandardContext } from "spel2js";
+import { Fragment, Transition, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, h, inject, isRef, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, renderList, resolveComponent, shallowRef, toDisplayString, toRaw, unref, watch, watchEffect, withCtx, withDirectives, withModifiers } from "vue";
+import { basicSetup } from "codemirror";
+import { Compartment, EditorState, StateEffect } from "@codemirror/state";
+import { EditorView, crosshairCursor, drawSelection, dropCursor, highlightActiveLine, highlightActiveLineGutter, highlightSpecialChars, hoverTooltip, keymap, lineNumbers, placeholder, rectangularSelection } from "@codemirror/view";
+import { defaultKeymap, history, historyKeymap, indentWithTab } from "@codemirror/commands";
+import { HighlightStyle, StreamLanguage, bracketMatching, foldGutter, indentOnInput, indentUnit, syntaxHighlighting } from "@codemirror/language";
+import { tags } from "@lezer/highlight";
+import { autocompletion, closeBrackets, closeBracketsKeymap, completionKeymap } from "@codemirror/autocomplete";
+import { NConfigProvider, darkTheme, lightTheme } from "naive-ui";
+//#region src/spel-service.ts
+var SpelService = class {
+	context = null;
+	setContext(authentication, principal) {
+		this.context = StandardContext.create(authentication, principal);
+	}
+	getContext() {
+		return this.context;
+	}
+	compile(expression) {
+		return SpelExpressionEvaluator.compile(expression);
+	}
+	eval(expression, locals) {
+		return SpelExpressionEvaluator.eval(expression, this.getContext(), locals);
+	}
+};
+var spelService = new SpelService();
+//#endregion
+//#region node_modules/.pnpm/vue-codemirror@6.1.1_codemirror@6.0.2_vue@3.5.34_typescript@6.0.3_/node_modules/vue-codemirror/dist/vue-codemirror.esm.js
+/*!
+* VueCodemirror v6.1.1
+* Copyright (c) Surmon. All rights reserved.
+* Released under the MIT License.
+* Surmon
+*/
+var h$1 = Object.freeze({
+	autofocus: !1,
+	disabled: !1,
+	indentWithTab: !0,
+	tabSize: 2,
+	placeholder: "",
+	autoDestroy: !0,
+	extensions: [basicSetup]
+}), y = Symbol("vue-codemirror-global-config");
+var O, j = function(e) {
+	var t = e.onUpdate, n = e.onChange, o = e.onFocus, r = e.onBlur, u = function(e, t) {
+		var n = {};
+		for (var o in e) Object.prototype.hasOwnProperty.call(e, o) && t.indexOf(o) < 0 && (n[o] = e[o]);
+		if (null != e && "function" == typeof Object.getOwnPropertySymbols) {
+			var r = 0;
+			for (o = Object.getOwnPropertySymbols(e); r < o.length; r++) t.indexOf(o[r]) < 0 && Object.prototype.propertyIsEnumerable.call(e, o[r]) && (n[o[r]] = e[o[r]]);
+		}
+		return n;
+	}(e, [
+		"onUpdate",
+		"onChange",
+		"onFocus",
+		"onBlur"
+	]);
+	return EditorState.create({
+		doc: u.doc,
+		selection: u.selection,
+		extensions: (Array.isArray(u.extensions) ? u.extensions : [u.extensions]).concat([EditorView.updateListener.of((function(e) {
+			t(e), e.docChanged && n(e.state.doc.toString(), e), e.focusChanged && (e.view.hasFocus ? o(e) : r(e));
+		}))])
+	});
+}, S = function(e) {
+	var t = new Compartment();
+	return {
+		compartment: t,
+		run: function(n) {
+			t.get(e.state) ? e.dispatch({ effects: t.reconfigure(n) }) : e.dispatch({ effects: StateEffect.appendConfig.of(t.of(n)) });
+		}
+	};
+}, x = function(e, t) {
+	var n = S(e), o = n.compartment, r = n.run;
+	return function(n) {
+		var u = o.get(e.state);
+		r((null != n ? n : u !== t) ? t : []);
+	};
+}, C = {
+	type: Boolean,
+	default: void 0
+}, D = {
+	autofocus: C,
+	disabled: C,
+	indentWithTab: C,
+	tabSize: Number,
+	placeholder: String,
+	style: Object,
+	autoDestroy: C,
+	phrases: Object,
+	root: Object,
+	extensions: Array,
+	selection: Object
+}, U = { modelValue: {
+	type: String,
+	default: ""
+} }, w = Object.assign(Object.assign({}, D), U);
+(function(e) {
+	e.Change = "change", e.Update = "update", e.Focus = "focus", e.Blur = "blur", e.Ready = "ready", e.ModelUpdate = "update:modelValue";
+})(O || (O = {}));
+var z = {};
+z[O.Change] = function(e, t) {
+	return !0;
+}, z[O.Update] = function(e) {
+	return !0;
+}, z[O.Focus] = function(e) {
+	return !0;
+}, z[O.Blur] = function(e) {
+	return !0;
+}, z[O.Ready] = function(e) {
+	return !0;
+};
+var B = {};
+B[O.ModelUpdate] = z[O.Change];
+var F = Object.assign(Object.assign({}, z), B), T = defineComponent({
+	name: "VueCodemirror",
+	props: Object.assign({}, w),
+	emits: Object.assign({}, F),
+	setup: function(t, s) {
+		var f = shallowRef(), d = shallowRef(), C = shallowRef(), D = Object.assign(Object.assign({}, h$1), inject(y, {})), U = computed((function() {
+			var e = {};
+			return Object.keys(toRaw(t)).forEach((function(n) {
+				var o;
+				"modelValue" !== n && (e[n] = null !== (o = t[n]) && void 0 !== o ? o : D[n]);
+			})), e;
+		}));
+		return onMounted((function() {
+			var e;
+			d.value = j({
+				doc: t.modelValue,
+				selection: U.value.selection,
+				extensions: null !== (e = D.extensions) && void 0 !== e ? e : [],
+				onFocus: function(e) {
+					return s.emit(O.Focus, e);
+				},
+				onBlur: function(e) {
+					return s.emit(O.Blur, e);
+				},
+				onUpdate: function(e) {
+					return s.emit(O.Update, e);
+				},
+				onChange: function(e, n) {
+					e !== t.modelValue && (s.emit(O.Change, e, n), s.emit(O.ModelUpdate, e, n));
+				}
+			}), C.value = function(e) {
+				return new EditorView(Object.assign({}, e));
+			}({
+				state: d.value,
+				parent: f.value,
+				root: U.value.root
+			});
+			var n = function(e) {
+				var t = function() {
+					return e.state.doc.toString();
+				}, n = S(e).run, o = x(e, [EditorView.editable.of(!1), EditorState.readOnly.of(!0)]), r = x(e, keymap.of([indentWithTab])), u = S(e).run, a = S(e).run, i = S(e).run, c = S(e).run;
+				return {
+					focus: function() {
+						return e.focus();
+					},
+					getDoc: t,
+					setDoc: function(n) {
+						n !== t() && e.dispatch({ changes: {
+							from: 0,
+							to: e.state.doc.length,
+							insert: n
+						} });
+					},
+					reExtensions: n,
+					toggleDisabled: o,
+					toggleIndentWithTab: r,
+					setTabSize: function(e) {
+						u([EditorState.tabSize.of(e), indentUnit.of(" ".repeat(e))]);
+					},
+					setPhrases: function(e) {
+						a([EditorState.phrases.of(e)]);
+					},
+					setPlaceholder: function(e) {
+						i(placeholder(e));
+					},
+					setStyle: function(e) {
+						void 0 === e && (e = {}), c(EditorView.theme({ "&": Object.assign({}, e) }));
+					}
+				};
+			}(C.value);
+			watch((function() {
+				return t.modelValue;
+			}), (function(e) {
+				e !== n.getDoc() && n.setDoc(e);
+			})), watch((function() {
+				return t.extensions;
+			}), (function(e) {
+				return n.reExtensions(e || []);
+			}), { immediate: !0 }), watch((function() {
+				return U.value.disabled;
+			}), (function(e) {
+				return n.toggleDisabled(e);
+			}), { immediate: !0 }), watch((function() {
+				return U.value.indentWithTab;
+			}), (function(e) {
+				return n.toggleIndentWithTab(e);
+			}), { immediate: !0 }), watch((function() {
+				return U.value.tabSize;
+			}), (function(e) {
+				return n.setTabSize(e);
+			}), { immediate: !0 }), watch((function() {
+				return U.value.phrases;
+			}), (function(e) {
+				return n.setPhrases(e || {});
+			}), { immediate: !0 }), watch((function() {
+				return U.value.placeholder;
+			}), (function(e) {
+				return n.setPlaceholder(e);
+			}), { immediate: !0 }), watch((function() {
+				return U.value.style;
+			}), (function(e) {
+				return n.setStyle(e);
+			}), { immediate: !0 }), U.value.autofocus && n.focus(), s.emit(O.Ready, {
+				state: d.value,
+				view: C.value,
+				container: f.value
+			});
+		})), onBeforeUnmount((function() {
+			U.value.autoDestroy && C.value && function(e) {
+				e.destroy();
+			}(C.value);
+		})), function() {
+			return h("div", {
+				class: "v-codemirror",
+				style: { display: "contents" },
+				ref: f
+			});
+		};
+	}
+});
+//#endregion
+//#region src/utils/index.ts
+function generateId() {
+	return `node_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+function validateSpelExpression(expression) {
+	try {
+		spelService.compile(expression);
+		return { valid: true };
+	} catch (error) {
+		return {
+			valid: false,
+			error: error instanceof Error ? error.message : "Invalid SpEL expression"
+		};
+	}
+}
+function evalSpelExpression(expression, locals) {
+	try {
+		spelService.setContext();
+		return spelService.eval(expression, locals);
+	} catch (error) {
+		console.error("SpEL evaluation error:", error);
+		return null;
+	}
+}
+/**
+* 将 RuleNode 树转换为 SpEL 表达式字符串
+*/
+function ruleNodeToSpel(node) {
+	if (node.type === "condition") {
+		if (!node.left || !node.comparator) return "";
+		let leftExpr = formatExpression(node.left);
+		if (node.listFilter && node.listFilter.comparator) {
+			const { comparator, fieldPath, value } = node.listFilter;
+			let target = "#this";
+			if (fieldPath) target = `${fieldPath}`;
+			switch (comparator) {
+				case "isEmpty":
+					leftExpr = `${leftExpr}.?[${target} == null || ${target}.isEmpty()]`;
+					break;
+				case "isNotEmpty":
+					leftExpr = `${leftExpr}.?[${target} != null && !${target}.isEmpty()]`;
+					break;
+				case "isNull":
+					leftExpr = `${leftExpr}.?[${target} == null]`;
+					break;
+				case "isNotNull":
+					leftExpr = `${leftExpr}.?[${target} != null]`;
+					break;
+				default: {
+					const filterVal = value ? formatExpression(value) : "";
+					leftExpr = `${leftExpr}.?[${target} ${comparator} ${filterVal}]`;
+					break;
+				}
+			}
+		}
+		if (node.comparator.startsWith("count ")) {
+			leftExpr = `${leftExpr}.size()`;
+			const rightExpr = node.right ? formatExpression(node.right) : "";
+			const op = node.comparator.replace("count ", "");
+			return `${leftExpr} ${op} ${rightExpr}`;
+		}
+		const rightExpr = node.right ? formatExpression(node.right) : "";
+		switch (node.comparator) {
+			case "==": return `${leftExpr} == ${rightExpr}`;
+			case "!=": return `${leftExpr} != ${rightExpr}`;
+			case ">": return `${leftExpr} > ${rightExpr}`;
+			case ">=": return `${leftExpr} >= ${rightExpr}`;
+			case "<": return `${leftExpr} < ${rightExpr}`;
+			case "<=": return `${leftExpr} <= ${rightExpr}`;
+			case "isEmpty": return `${leftExpr} == null || ${leftExpr}.isEmpty()`;
+			case "isNotEmpty": return `${leftExpr} != null && !${leftExpr}.isEmpty()`;
+			case "isNull": return `${leftExpr} == null`;
+			case "isNotNull": return `${leftExpr} != null`;
+			case "count ==": return `${leftExpr}.size() == ${rightExpr}`;
+			case "count !=": return `${leftExpr}.size() != ${rightExpr}`;
+			case "count <": return `${leftExpr}.size() < ${rightExpr}`;
+			case "count <=": return `${leftExpr}.size() <= ${rightExpr}`;
+			case "count >": return `${leftExpr}.size() > ${rightExpr}`;
+			case "count >=": return `${leftExpr}.size() >= ${rightExpr}`;
+			default: return `${leftExpr} ${node.comparator} ${rightExpr}`;
+		}
+	}
+	if (node.type === "group" && node.children?.length) {
+		const childExps = node.children.map(ruleNodeToSpel).filter((exp) => exp.trim() !== "");
+		if (childExps.length === 0) return "";
+		if (childExps.length === 1) return node.operator === "not" ? `!(${childExps[0]})` : childExps[0] || "";
+		const separator = node.operator === "or" ? " || " : " && ";
+		const combined = `(${childExps.join(separator)})`;
+		return node.operator === "not" ? `!${combined}` : combined;
+	}
+	return "";
+}
+/**
+* 格式化 Expression 为 SpEL 字符串
+* - 字面量：'字符串'，数字不加引号（这里简单处理，所有字面量加单引号，数字可后续增强）
+* - 字段：直接使用路径
+* - 函数：base.method(arg1, arg2, ...)
+*/
+function formatExpression(expr) {
+	if (!expr) return "";
+	switch (expr.type) {
+		case "literal": return formatLiteral(expr.value);
+		case "field": return expr.path;
+		case "function": {
+			const base = expr.call.base ? formatExpression(expr.call.base) : "";
+			if (base) return `${base}.${format(expr.call.method, expr.call.args.map(formatExpression))}`;
+			return `${format(expr.call.method, expr.call.args.map(formatExpression))}`;
+		}
+		default: return "";
+	}
+}
+function format(template, args) {
+	return template.replace(/\{(\d+)\}/g, (_, index) => {
+		return args[index] ?? "";
+	});
+}
+/**
+* 格式化字面量：字符串用单引号包裹并转义，数字/布尔不加引号
+*/
+function formatLiteral(value) {
+	if (value === "" || value === void 0 || value === null) return "''";
+	if (/^-?\d+(\.\d+)?$/.test(value)) return value;
+	if (value === "true" || value === "false") return value;
+	if (value.charAt(0) === "'" && value.charAt(value.length - 1) === "'") return value;
+	return `'${value}'`;
+}
+/**
+* 创建一个新的空白条件节点
+*/
+function createEmptyCondition() {
+	return {
+		id: generateId(),
+		type: "condition",
+		left: {
+			type: "field",
+			path: ""
+		},
+		comparator: "=="
+	};
+}
+/**
+* 创建一个新的空白分组节点
+*/
+function createEmptyGroup(operator = "and") {
+	return {
+		id: generateId(),
+		type: "group",
+		operator,
+		children: []
+	};
+}
+//#endregion
+//#region src/composables/useSpelEditor.ts
+function useSpelEditor(props, emit) {
+	const internalValue = ref(props.modelValue);
+	const isFocused = ref(false);
+	const validation = ref({ valid: true });
+	const heightStyle = computed(() => {
+		if (typeof props.height === "number") return { height: `${props.height}px` };
+		return { height: props.height || "400px" };
+	});
+	const handleInput = (value) => {
+		internalValue.value = value;
+		emit("update:modelValue", value);
+		emit("change", value);
+	};
+	const handleValidate = async () => {
+		validation.value = validateSpelExpression(internalValue.value);
+		emit("validate", validation.value.valid, validation.value.error);
+		return validation.value.valid;
+	};
+	const run = async () => {
+		try {
+			const expression = internalValue.value;
+			spelService.setContext(props.authentication, props.principal);
+			const result = spelService.eval(expression, props.locals);
+			emit("run", result, void 0);
+			return result;
+		} catch (error) {
+			emit("run", void 0, getErrorMessage(error) || "执行表达式时发生错误");
+			return;
+		}
+	};
+	const getErrorMessage = (error) => {
+		if (typeof error === "object" && error !== null && "message" in error) return String(error.message);
+		return String(error);
+	};
+	const setValue = (value) => {
+		internalValue.value = value;
+		emit("update:modelValue", value);
+	};
+	const getValue = () => internalValue.value;
+	watch(() => props.modelValue, (newValue) => {
+		internalValue.value = newValue;
+	});
+	return {
+		internalValue,
+		isFocused,
+		validation,
+		heightStyle,
+		handleInput,
+		handleValidate,
+		setValue,
+		getValue,
+		run
+	};
+}
+//#endregion
+//#region src/composables/useRuleTree.ts
+function useRuleTree(props, emit) {
+	const getSpelExpression = () => {
+		return ruleNodeToSpel(props.modelValue);
+	};
+	const setSpelExpression = (_expression) => {
+		console.warn("SpEL parsing to RuleTree is not implemented yet");
+	};
+	const addCondition = (parentId) => {
+		const newNode = createEmptyCondition();
+		const updateNode = (node) => {
+			if (node.id === parentId && node.children) return {
+				...node,
+				children: [...node.children, newNode]
+			};
+			if (node.children) return {
+				...node,
+				children: node.children.map(updateNode)
+			};
+			return node;
+		};
+		const newValue = updateNode(props.modelValue);
+		emit("update:modelValue", newValue);
+		emit("change", newValue);
+	};
+	const addGroup = (parentId, operator = "and") => {
+		const newNode = createEmptyGroup(operator);
+		const updateNode = (node) => {
+			if (node.id === parentId && node.children) return {
+				...node,
+				children: [...node.children, newNode]
+			};
+			if (node.children) return {
+				...node,
+				children: node.children.map(updateNode)
+			};
+			return node;
+		};
+		const newValue = updateNode(props.modelValue);
+		emit("update:modelValue", newValue);
+		emit("change", newValue);
+	};
+	const removeNode = (nodeId) => {
+		const updateNode = (node) => {
+			if (node.id === nodeId) return null;
+			if (node.children) {
+				const filteredChildren = node.children.map(updateNode).filter((n) => n !== null);
+				return {
+					...node,
+					children: filteredChildren
+				};
+			}
+			return node;
+		};
+		const newValue = updateNode(props.modelValue);
+		if (newValue) {
+			emit("update:modelValue", newValue);
+			emit("change", newValue);
+		}
+	};
+	const updateNode = (nodeId, updates) => {
+		const doUpdate = (node) => {
+			if (node.id === nodeId) return {
+				...node,
+				...updates
+			};
+			if (node.children) return {
+				...node,
+				children: node.children.map(doUpdate)
+			};
+			return node;
+		};
+		const newValue = doUpdate(props.modelValue);
+		emit("update:modelValue", newValue);
+		emit("change", newValue);
+	};
+	const validate = () => {
+		try {
+			if (!getSpelExpression().trim()) return false;
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	const run = (props, sepl) => {
+		spelService.setContext(props.authentication, props.principal);
+		return spelService.eval(sepl, props.locals);
+	};
+	return {
+		getSpelExpression,
+		setSpelExpression,
+		addCondition,
+		addGroup,
+		removeNode,
+		updateNode,
+		validate,
+		run
+	};
+}
+//#endregion
+//#region src/components/SpelEditor/spel-theme.ts
+/**
+* 编辑器主题色板
+*/
+var DARK = {
+	editorBg: "#1a1a2e",
+	gutterBg: "#16213e",
+	gutterBorder: "#3e4451",
+	gutterFg: "#5c6370",
+	contentFg: "#e5e5e5",
+	activeLine: "rgba(97,175,239,.08)",
+	activeGutter: "rgba(97,175,239,.12)",
+	selectionBg: "rgba(97,175,239,.3)",
+	cursor: "#61afef",
+	matchBracket: "#e5c07b",
+	matchBracketBg: "rgba(229,192,107,.15)",
+	keyword: "#c678dd",
+	operator: "#e06c75",
+	string: "#98c379",
+	number: "#d19a66",
+	atom: "#d19a66",
+	variable: "#61afef",
+	definition: "#e6c07b",
+	property: "#98c379",
+	comment: "#5c6370",
+	acBg: "#21252b",
+	acBorder: "#3e4451",
+	acScrollThumb: "#4b5263",
+	acItemFg: "#abb2bf",
+	acItemHoverBg: "rgba(97,175,239,.2)",
+	acIconVar: "#61afef",
+	acIconVarBg: "#1d3d55",
+	acIconProp: "#98c379",
+	acIconPropBg: "#1a3322",
+	acIconKey: "#c678dd",
+	acIconKeyBg: "#2d1a3d",
+	acIconFn: "#e5c07b",
+	acIconFnBg: "#3a2c0a",
+	acLabel: "#e5c07b",
+	acLabelHover: "#f5d88a",
+	acDetail: "#5c6370",
+	acDetailHover: "#9da5b4",
+	acDetailBorder: "#3e4451",
+	ttBg: "#1c2028",
+	ttBorder: "#4b5263",
+	ttFg: "#abb2bf",
+	ttLabelFg: "#61afef",
+	ttDivider: "#3e4451",
+	ttCodeBg: "#0d1117",
+	ttCodeFg: "#98c379",
+	ttCodeBorder: "#3e4451",
+	badgeVarBg: "#1a3a52",
+	badgeVarFg: "#61afef",
+	badgePropBg: "#1a3b24",
+	badgePropFg: "#98c379",
+	badgeKeyBg: "#2d1a3d",
+	badgeKeyFg: "#c678dd",
+	badgeFnBg: "#3b2e0a",
+	badgeFnFg: "#e5c07b",
+	headerFrom: "#4338ca",
+	headerTo: "#7c3aed",
+	errBg: "rgba(127,29,29,.7)",
+	errBorder: "#991b1b",
+	errFg: "#fca5a5"
+};
+var LIGHT = {
+	editorBg: "#fafafa",
+	gutterBg: "#f0f0f0",
+	gutterBorder: "#d1d5db",
+	gutterFg: "#9ca3af",
+	contentFg: "#1f2937",
+	activeLine: "rgba(59,130,246,.06)",
+	activeGutter: "rgba(59,130,246,.1)",
+	selectionBg: "rgba(59,130,246,.2)",
+	cursor: "#2563eb",
+	matchBracket: "#d97706",
+	matchBracketBg: "rgba(217,119,6,.12)",
+	keyword: "#7c3aed",
+	operator: "#dc2626",
+	string: "#16a34a",
+	number: "#d97706",
+	atom: "#d97706",
+	variable: "#2563eb",
+	definition: "#b45309",
+	property: "#0f766e",
+	comment: "#6b7280",
+	acBg: "#ffffff",
+	acBorder: "#e5e7eb",
+	acScrollThumb: "#d1d5db",
+	acItemFg: "#374151",
+	acItemHoverBg: "rgba(59,130,246,.1)",
+	acIconVar: "#2563eb",
+	acIconVarBg: "#dbeafe",
+	acIconProp: "#0f766e",
+	acIconPropBg: "#ccfbf1",
+	acIconKey: "#7c3aed",
+	acIconKeyBg: "#ede9fe",
+	acIconFn: "#b45309",
+	acIconFnBg: "#fef3c7",
+	acLabel: "#92400e",
+	acLabelHover: "#78350f",
+	acDetail: "#9ca3af",
+	acDetailHover: "#6b7280",
+	acDetailBorder: "#e5e7eb",
+	ttBg: "#ffffff",
+	ttBorder: "#e5e7eb",
+	ttFg: "#4b5563",
+	ttLabelFg: "#2563eb",
+	ttDivider: "#e5e7eb",
+	ttCodeBg: "#f3f4f6",
+	ttCodeFg: "#16a34a",
+	ttCodeBorder: "#d1d5db",
+	badgeVarBg: "#dbeafe",
+	badgeVarFg: "#1d4ed8",
+	badgePropBg: "#d1fae5",
+	badgePropFg: "#065f46",
+	badgeKeyBg: "#ede9fe",
+	badgeKeyFg: "#6d28d9",
+	badgeFnBg: "#fef3c7",
+	badgeFnFg: "#92400e",
+	headerFrom: "#6366f1",
+	headerTo: "#a855f7",
+	errBg: "rgba(254,242,242,.95)",
+	errBorder: "#fca5a5",
+	errFg: "#dc2626"
+};
+/**
+* 创建语法高亮样式（随主题响应式重建）
+*/
+function createSpelHighlightStyle(T) {
+	return HighlightStyle.define([
+		{
+			tag: tags.keyword,
+			color: T.keyword
+		},
+		{
+			tag: tags.operator,
+			color: T.operator
+		},
+		{
+			tag: tags.string,
+			color: T.string
+		},
+		{
+			tag: tags.number,
+			color: T.number
+		},
+		{
+			tag: tags.bool,
+			color: T.atom
+		},
+		{
+			tag: tags.null,
+			color: T.atom
+		},
+		{
+			tag: tags.atom,
+			color: T.atom
+		},
+		{
+			tag: tags.variableName,
+			color: T.variable
+		},
+		{
+			tag: tags.special(tags.variableName),
+			color: T.variable
+		},
+		{
+			tag: tags.definition(tags.variableName),
+			color: T.definition
+		},
+		{
+			tag: tags.propertyName,
+			color: T.property
+		},
+		{
+			tag: tags.comment,
+			color: T.comment,
+			fontStyle: "italic"
+		}
+	]);
+}
+/**
+* 创建编辑器 UI 主题（随主题响应式重建）
+*/
+function createSpelTheme(T, isDark, fontSize) {
+	return EditorView.theme({
+		"&": {
+			height: "100%",
+			backgroundColor: T.editorBg
+		},
+		".cm-scroller": {
+			overflow: "auto",
+			backgroundColor: T.editorBg,
+			fontFamily: "'Fira Code','JetBrains Mono','Monaco','Consolas',monospace",
+			fontSize: `${fontSize}px`
+		},
+		".cm-content": {
+			caretColor: T.cursor,
+			color: T.contentFg,
+			padding: "12px"
+		},
+		".cm-line": {
+			color: T.contentFg,
+			padding: "2px 0"
+		},
+		".cm-cursor": {
+			borderLeftColor: T.cursor,
+			borderLeftWidth: "2px"
+		},
+		".cm-selectionBackground": { backgroundColor: `${T.selectionBg} !important` },
+		"&.cm-focused .cm-selectionBackground": { backgroundColor: `${T.selectionBg} !important` },
+		".cm-activeLine": { backgroundColor: T.activeLine },
+		".cm-gutters": {
+			backgroundColor: T.gutterBg,
+			borderRight: `1px solid ${T.gutterBorder}`,
+			minWidth: "48px"
+		},
+		".cm-lineNumbers .cm-gutterElement": {
+			color: T.gutterFg,
+			padding: "0 12px",
+			fontSize: "12px"
+		},
+		".cm-activeLineGutter": { backgroundColor: T.activeGutter },
+		".cm-matchingBracket": {
+			color: `${T.matchBracket} !important`,
+			backgroundColor: T.matchBracketBg,
+			fontWeight: "bold"
+		}
+	}, { dark: isDark });
+}
+//#endregion
+//#region src/components/SpelEditor/spel-completions.ts
+function buildEntries(authentication, principal, locals) {
+	const list = [];
+	if (authentication) {
+		list.push({
+			label: "authentication",
+			type: "variable",
+			detail: "用户认证信息",
+			desc: "存储当前登录用户的认证信息。",
+			extra: "authentication.name / authentication.roles"
+		});
+		for (const key of Object.keys(authentication)) {
+			list.push({
+				label: `authentication.${key}`,
+				type: "property",
+				detail: "authentication 属性",
+				desc: `authentication 对象的 ${key} 属性`
+			});
+			const val = authentication[key];
+			if (val && typeof val === "object" && !Array.isArray(val)) for (const sub of Object.keys(val)) list.push({
+				label: `authentication.${key}.${sub}`,
+				type: "property",
+				detail: "嵌套属性",
+				desc: `authentication.${key} 的 ${sub} 属性`
+			});
+		}
+	}
+	if (principal) {
+		list.push({
+			label: "principal",
+			type: "variable",
+			detail: "基础变量信息",
+			desc: "业务主体对象。",
+			extra: "principal.id / principal.status"
+		});
+		for (const key of Object.keys(principal)) {
+			list.push({
+				label: `principal.${key}`,
+				type: "property",
+				detail: "principal 属性",
+				desc: `principal 对象的 ${key} 属性`
+			});
+			const val = principal[key];
+			if (val && typeof val === "object" && !Array.isArray(val)) for (const sub of Object.keys(val)) list.push({
+				label: `principal.${key}.${sub}`,
+				type: "property",
+				detail: "嵌套属性",
+				desc: `principal.${key} 的 ${sub} 属性`
+			});
+		}
+	}
+	if (locals) for (const key of Object.keys(locals)) {
+		list.push({
+			label: `#${key}`,
+			type: "variable",
+			detail: "locals 变量",
+			desc: "用户自定义本地变量。",
+			extra: `#${key}`
+		});
+		const val = locals[key];
+		if (val && typeof val === "object" && !Array.isArray(val)) for (const sub of Object.keys(val)) list.push({
+			label: `#${key}.${sub}`,
+			type: "property",
+			detail: `#${key} 属性`,
+			desc: `#${key} 的 ${sub} 属性`
+		});
+	}
+	[
+		{
+			label: "true",
+			detail: "布尔值",
+			desc: "布尔真值。",
+			extra: "principal.active == true"
+		},
+		{
+			label: "false",
+			detail: "布尔值",
+			desc: "布尔假值。",
+			extra: "principal.deleted == false"
+		},
+		{
+			label: "null",
+			detail: "空值",
+			desc: "表示空引用。",
+			extra: "principal.owner != null"
+		},
+		{
+			label: "and",
+			detail: "逻辑与",
+			desc: "逻辑与 &&。",
+			extra: "a > 0 and b > 0"
+		},
+		{
+			label: "or",
+			detail: "逻辑或",
+			desc: "逻辑或 ||。",
+			extra: "a == 1 or b == 1"
+		},
+		{
+			label: "not",
+			detail: "逻辑非",
+			desc: "逻辑非 !。",
+			extra: "not principal.deleted"
+		}
+	].forEach((k) => list.push({
+		...k,
+		type: "keyword"
+	}));
+	[
+		{
+			label: "contains",
+			detail: "包含判断",
+			desc: "字符串或集合包含判断。",
+			extra: "principal.name.contains('admin')"
+		},
+		{
+			label: "startsWith",
+			detail: "前缀匹配",
+			desc: "字符串前缀匹配。",
+			extra: "principal.code.startsWith('ORD')"
+		},
+		{
+			label: "endsWith",
+			detail: "后缀匹配",
+			desc: "字符串后缀匹配。",
+			extra: "principal.file.endsWith('.pdf')"
+		},
+		{
+			label: "matches",
+			detail: "正则匹配",
+			desc: "正则表达式匹配。",
+			extra: "principal.phone.matches('1[3-9]\\\\\\\\d{9}')"
+		},
+		{
+			label: "isEmpty",
+			detail: "判断为空",
+			desc: "字符串或集合长度是否为 0。",
+			extra: "principal.tags.isEmpty()"
+		},
+		{
+			label: "size()",
+			detail: "集合长度",
+			desc: "返回集合的元素数量。",
+			extra: "principal.items.size() > 0"
+		},
+		{
+			label: "length()",
+			detail: "字符串长度",
+			desc: "返回字符串的字符数量。",
+			extra: "principal.name.length() > 2"
+		}
+	].forEach((f) => list.push({
+		...f,
+		type: "function"
+	}));
+	return list;
+}
+function buildTypeMap(authentication, principal, locals) {
+	const map = {};
+	function walk(obj, prefix) {
+		if (!obj || typeof obj !== "object") return;
+		for (const key of Object.keys(obj)) {
+			const fp = prefix ? `${prefix}.${key}` : key;
+			const val = obj[key];
+			if (val === null || val === void 0) map[fp] = "null";
+			else if (Array.isArray(val)) map[fp] = "array";
+			else if (typeof val === "object") {
+				map[fp] = "object";
+				walk(val, fp);
+			} else map[fp] = typeof val;
+		}
+	}
+	if (authentication) walk(authentication, "authentication");
+	if (principal) walk(principal, "principal");
+	if (locals) for (const key of Object.keys(locals)) {
+		const fp = `#${key}`;
+		const val = locals[key];
+		if (val === null || val === void 0) map[fp] = "null";
+		else if (Array.isArray(val)) map[fp] = "array";
+		else if (typeof val === "object") {
+			map[fp] = "object";
+			walk(val, fp);
+		} else map[fp] = typeof val;
+	}
+	return map;
+}
+function buildElementFields(obj) {
+	if (!obj || typeof obj !== "object") return [];
+	return Object.keys(obj).map((key) => {
+		const val = obj[key];
+		const f = {
+			label: key,
+			value: key,
+			type: "null"
+		};
+		if (val === null || val === void 0) f.type = "null";
+		else if (Array.isArray(val)) {
+			f.type = "array";
+			if (val.length > 0) {
+				f.elementType = typeof val[0];
+				if (typeof val[0] === "object" && val[0] !== null) f.elementFields = buildElementFields(val[0]);
+			} else f.elementType = "string";
+		} else if (typeof val === "object") {
+			f.type = "object";
+			f.children = buildElementFields(val);
+		} else f.type = typeof val;
+		return f;
+	});
+}
+function buildArrayMeta(authentication, principal, locals) {
+	const meta = {};
+	function walkArr(obj, prefix) {
+		if (!obj || typeof obj !== "object") return;
+		for (const key of Object.keys(obj)) {
+			const fp = prefix ? `${prefix}.${key}` : key;
+			const val = obj[key];
+			if (Array.isArray(val)) if (val.length > 0 && typeof val[0] === "object" && val[0] !== null) meta[fp] = {
+				elementType: "object",
+				elementFields: buildElementFields(val[0])
+			};
+			else if (val.length > 0) meta[fp] = { elementType: typeof val[0] };
+			else meta[fp] = { elementType: "string" };
+			else if (typeof val === "object" && val !== null) walkArr(val, fp);
+		}
+	}
+	if (authentication) walkArr(authentication, "authentication");
+	if (principal) walkArr(principal, "principal");
+	if (locals) for (const key of Object.keys(locals)) {
+		const fp = `#${key}`;
+		const val = locals[key];
+		if (Array.isArray(val)) if (val.length > 0 && typeof val[0] === "object" && val[0] !== null) meta[fp] = {
+			elementType: "object",
+			elementFields: buildElementFields(val[0])
+		};
+		else if (val.length > 0) meta[fp] = { elementType: typeof val[0] };
+		else meta[fp] = { elementType: "string" };
+		else if (typeof val === "object" && val !== null) walkArr(val, fp);
+	}
+	return meta;
+}
+function buildStringMethodEntries() {
+	return [
+		{
+			label: "length",
+			type: "property",
+			detail: "字符串长度",
+			desc: "返回字符串的字符数量。",
+			extra: "principal.name.length"
+		},
+		{
+			label: "isEmpty()",
+			type: "function",
+			detail: "判断为空",
+			desc: "判断长度是否为 0。",
+			extra: "principal.name.isEmpty()"
+		},
+		{
+			label: "toUpperCase()",
+			type: "function",
+			detail: "转大写",
+			desc: "将字符串转换为大写。",
+			extra: "principal.name.toUpperCase()"
+		},
+		{
+			label: "toLowerCase()",
+			type: "function",
+			detail: "转小写",
+			desc: "将字符串转换为小写。",
+			extra: "principal.name.toLowerCase()"
+		},
+		{
+			label: "trim()",
+			type: "function",
+			detail: "去除空格",
+			desc: "去除字符串首尾空白字符。",
+			extra: "principal.name.trim()"
+		},
+		{
+			label: "substring(x)",
+			type: "function",
+			detail: "子串截取(1参)",
+			desc: "从指定位置截取。",
+			extra: "principal.name.substring(3)"
+		},
+		{
+			label: "substring(x,y)",
+			type: "function",
+			detail: "子串截取(2参)",
+			desc: "从起始截取到结束。",
+			extra: "principal.name.substring(0, 3)"
+		},
+		{
+			label: "replace(x,y)",
+			type: "function",
+			detail: "字符串替换",
+			desc: "替换字符。",
+			extra: "principal.name.replace('old', 'new')"
+		},
+		{
+			label: "startsWith(x)",
+			type: "function",
+			detail: "前缀匹配",
+			desc: "是否以指定前缀开头。",
+			extra: "principal.code.startsWith('ORD')"
+		},
+		{
+			label: "endsWith(x)",
+			type: "function",
+			detail: "后缀匹配",
+			desc: "是否以指定后缀结尾。",
+			extra: "principal.file.endsWith('.pdf')"
+		},
+		{
+			label: "contains(x)",
+			type: "function",
+			detail: "包含判断",
+			desc: "是否包含指定子串。",
+			extra: "principal.name.contains('value')"
+		},
+		{
+			label: "indexOf(x)",
+			type: "function",
+			detail: "查找索引",
+			desc: "返回首次位置。",
+			extra: "principal.name.indexOf('a')"
+		},
+		{
+			label: "charAt(x)",
+			type: "function",
+			detail: "获取字符",
+			desc: "返回指定位置字符。",
+			extra: "principal.name.charAt(0)"
+		}
+	];
+}
+function buildArrayMethodEntries(am) {
+	const r = [{
+		label: "size()",
+		type: "function",
+		detail: "集合大小",
+		desc: "返回数组元素数量。",
+		extra: "...roles.size() > 0"
+	}, {
+		label: "contains(x)",
+		type: "function",
+		detail: "包含判断",
+		desc: "数组是否包含指定元素。",
+		extra: "...roles.contains('admin')"
+	}];
+	if (am?.elementType === "object" && am.elementFields) {
+		r.push({
+			label: "?[field == x]",
+			type: "function",
+			detail: "过滤-对象数组",
+			desc: `可用字段：${am.elementFields.map((f) => f.label).join(", ")}`,
+			extra: `...roles.?[${am.elementFields[0]?.label ?? "field"} == value]`
+		});
+		r.push({
+			label: "![field]",
+			type: "function",
+			detail: "投影-提取字段",
+			desc: "从对象数组中提取指定字段。",
+			extra: "...roles.![code]"
+		});
+		for (const f of am.elementFields) r.push({
+			label: `[0].${f.label}`,
+			type: "property",
+			detail: "数组元素字段",
+			desc: `元素 ${f.label}，类型 ${f.type}`,
+			extra: `...roles[0].${f.label}`
+		});
+	} else r.push({
+		label: "?[#this == x]",
+		type: "function",
+		detail: "过滤-基本类型数组",
+		desc: `元素类型: ${am?.elementType ?? "string"}`,
+		extra: "...roles.?[#this == 'value']"
+	});
+	return r;
+}
+function buildFilterFieldEntries(fields, prefix = "") {
+	return fields.map((f) => ({
+		label: f.label,
+		type: "property",
+		detail: f.type === "array" ? `array<${f.elementType ?? "?"}>` : f.type === "object" ? "object" : f.type,
+		desc: f.type === "object" ? `对象 ${f.label}` : f.type === "array" ? `数组 ${f.label}` : `字段 ${f.label}`,
+		extra: `...?[${prefix ? `${prefix}.` : ""}${f.label} ...]`
+	}));
+}
+function resolveFieldPath(fields, path) {
+	const parts = path.split(".");
+	let cur = null;
+	let pool = fields;
+	for (const part of parts) {
+		cur = pool.find((f) => f.label === part) ?? null;
+		if (!cur) return null;
+		if (cur.type === "object" && cur.children) pool = cur.children;
+		else if (cur.type === "array" && cur.elementFields) pool = cur.elementFields;
+		else if (cur.type === "array") return cur;
+	}
+	return cur;
+}
+//#endregion
+//#region src/components/SpelEditor/spel-autocomplete-style.ts
+var ID = "spel-autocomplete-style";
+function injectAutocompleteStyle(T) {
+	let el = document.getElementById(ID);
+	if (!el) {
+		el = document.createElement("style");
+		el.id = ID;
+		document.head.appendChild(el);
+	}
+	el.textContent = [
+		`.cm-tooltip-autocomplete { background:${T.acBg}!important; border:1px solid ${T.acBorder}!important; border-radius:8px!important; }`,
+		`.cm-tooltip-autocomplete .cm-completionItem { display:flex!important; gap:8px!important; padding:7px 10px!important; cursor:pointer!important; color:${T.acItemFg}!important; }`,
+		`.cm-tooltip-autocomplete .cm-completionItem:hover { background:${T.acItemHoverBg}!important; }`,
+		`.cm-completionIcon.cm-variable { background:${T.acIconVarBg}; color:${T.acIconVar}; }`,
+		`.cm-completionIcon.cm-property { background:${T.acIconPropBg}; color:${T.acIconProp}; }`,
+		`.cm-completionLabel { font-family:'Fira Code',monospace!important; font-size:13px!important; color:${T.acLabel}!important; }`,
+		`.cm-completionDetail { margin-left:auto!important; font-size:11px!important; color:${T.acDetail}!important; border-left:1px solid ${T.acDetailBorder}!important; }`
+	].join("\n");
+}
+function getTokenAt(doc, pos) {
+	const line = doc.sliceString(Math.max(0, pos - 100), Math.min(doc.length, pos + 100));
+	const off = Math.min(pos, 100);
+	let s = off;
+	while (s > 0) {
+		const c = line[s - 1];
+		if (!c || !/[#\w.]/.test(c)) break;
+		s--;
+	}
+	let e = off;
+	while (e < line.length) {
+		const c = line[e];
+		if (!c || !/[\w.(]/.test(c)) break;
+		e++;
+	}
+	const text = line.slice(s, e).replace(/\(.*$/, "");
+	if (!text) return null;
+	return {
+		from: pos - (off - s),
+		to: pos + (e - off),
+		text
+	};
+}
+//#endregion
+//#region src/components/SpelEditor/spel-parser.ts
+/**
+* SpEL StreamLanguage 解析器
+* 用于语法高亮、括号匹配等
+*/
+var SPEL_KEYWORDS = new Set([
+	"true",
+	"false",
+	"null",
+	"and",
+	"or",
+	"not",
+	"instanceof",
+	"matches",
+	"new",
+	"div",
+	"mod"
+]);
+var SPEL_BUILTIN_FNS = new Set([
+	"contains",
+	"startsWith",
+	"endsWith",
+	"isEmpty",
+	"size",
+	"length",
+	"substring",
+	"toUpperCase",
+	"toLowerCase",
+	"trim"
+]);
+var spelLanguage = StreamLanguage.define({
+	name: "spel",
+	startState: () => ({}),
+	token(stream) {
+		if (stream.eatSpace()) return null;
+		const ch = stream.peek();
+		if (stream.match("//")) {
+			stream.skipToEnd();
+			return "comment";
+		}
+		if (ch === "\"" || ch === "'") {
+			const q = stream.next();
+			if (!q) return null;
+			let esc = false;
+			while (!stream.eol()) {
+				const c = stream.next();
+				if (!c) break;
+				if (esc) {
+					esc = false;
+					continue;
+				}
+				if (c === "\\") {
+					esc = true;
+					continue;
+				}
+				if (c === q) break;
+			}
+			return "string";
+		}
+		if (ch && /\d/.test(ch)) {
+			stream.match(/^\d+(\.\d+)?([eE][+-]?\d+)?/);
+			return "number";
+		}
+		if (ch === "#") {
+			stream.next();
+			stream.match(/^[a-zA-Z_]\w*/);
+			return "variable-2";
+		}
+		if (ch && /[a-zA-Z_$]/.test(ch)) {
+			stream.match(/^[a-zA-Z_$]\w*/);
+			const word = stream.current();
+			if (SPEL_KEYWORDS.has(word)) return "keyword";
+			if (SPEL_BUILTIN_FNS.has(word)) return "def";
+			if (stream.match(/^\s*\(/, false)) return "def";
+			return "variable";
+		}
+		if (ch === ".") {
+			stream.next();
+			if (stream.match(/^[a-zA-Z_]\w*/)) return "property";
+			return "operator";
+		}
+		if (ch && /[=!<>&|+\-*/%^~?:]/.test(ch)) {
+			stream.match(/^(===|!==|==|!=|<=|>=|&&|\|\||[=!<>&|+\-*/%^~?:])/);
+			return "operator";
+		}
+		stream.next();
+		return null;
+	}
+});
+//#endregion
+//#region src/components/SpelEditor/spel-autocomplete-tooltip.ts
+function buildHoverTooltipDom(entry, T) {
+	const badge = {
+		variable: {
+			bg: T.badgeVarBg,
+			fg: T.badgeVarFg,
+			text: "VAR"
+		},
+		property: {
+			bg: T.badgePropBg,
+			fg: T.badgePropFg,
+			text: "PROP"
+		},
+		keyword: {
+			bg: T.badgeKeyBg,
+			fg: T.badgeKeyFg,
+			text: "KEY"
+		},
+		function: {
+			bg: T.badgeFnBg,
+			fg: T.badgeFnFg,
+			text: "FN"
+		}
+	}[entry.type] ?? {
+		bg: T.acBg,
+		fg: T.acItemFg,
+		text: ""
+	};
+	const root = document.createElement("div");
+	Object.assign(root.style, {
+		padding: "12px 14px",
+		minWidth: "240px",
+		maxWidth: "320px",
+		background: T.ttBg,
+		border: `1px solid ${T.ttBorder}`,
+		borderRadius: "8px",
+		boxShadow: "0 8px 32px rgba(0,0,0,.18)",
+		fontFamily: "'Fira Code','JetBrains Mono','Consolas',monospace",
+		fontSize: "12px",
+		lineHeight: "1.6",
+		color: T.ttFg
+	});
+	const h = document.createElement("div");
+	Object.assign(h.style, {
+		display: "flex",
+		alignItems: "center",
+		justifyContent: "space-between",
+		gap: "8px",
+		marginBottom: "8px"
+	});
+	const lb = document.createElement("span");
+	lb.textContent = entry.label;
+	Object.assign(lb.style, {
+		fontWeight: "600",
+		fontSize: "13px",
+		color: T.ttLabelFg
+	});
+	const be = document.createElement("span");
+	be.textContent = badge.text;
+	Object.assign(be.style, {
+		flexShrink: "0",
+		fontSize: "10px",
+		fontWeight: "700",
+		padding: "2px 6px",
+		borderRadius: "3px",
+		background: badge.bg,
+		color: badge.fg
+	});
+	h.appendChild(lb);
+	h.appendChild(be);
+	const dv = document.createElement("div");
+	Object.assign(dv.style, {
+		height: "1px",
+		background: T.ttDivider,
+		marginBottom: "8px"
+	});
+	const dc = document.createElement("div");
+	dc.textContent = entry.desc;
+	Object.assign(dc.style, {
+		fontSize: "12px",
+		color: T.ttFg,
+		lineHeight: "1.65"
+	});
+	root.appendChild(h);
+	root.appendChild(dv);
+	root.appendChild(dc);
+	if (entry.extra) {
+		const ex = document.createElement("div");
+		ex.textContent = entry.extra;
+		Object.assign(ex.style, {
+			marginTop: "8px",
+			padding: "6px 8px",
+			background: T.ttCodeBg,
+			borderRadius: "4px",
+			fontSize: "11px",
+			color: T.ttCodeFg,
+			borderLeft: `2px solid ${T.ttCodeBorder}`
+		});
+		root.appendChild(ex);
+	}
+	return root;
+}
+//#endregion
+//#region src/components/SpelEditor/spel-autocomplete-ext.ts
+function buildExtensions(T, isDark, fontSize, source, tooltip) {
+	return [
+		lineNumbers(),
+		highlightActiveLineGutter(),
+		highlightSpecialChars(),
+		history(),
+		foldGutter(),
+		drawSelection(),
+		dropCursor(),
+		EditorState.allowMultipleSelections.of(true),
+		indentOnInput(),
+		bracketMatching(),
+		closeBrackets(),
+		rectangularSelection(),
+		crosshairCursor(),
+		highlightActiveLine(),
+		keymap.of([
+			...closeBracketsKeymap,
+			...defaultKeymap,
+			...historyKeymap,
+			...completionKeymap
+		]),
+		spelLanguage,
+		syntaxHighlighting(createSpelHighlightStyle(T)),
+		autocompletion({
+			override: [source],
+			defaultKeymap: true,
+			closeOnBlur: false,
+			activateOnTyping: true
+		}),
+		tooltip,
+		createSpelTheme(T, isDark, fontSize),
+		EditorView.lineWrapping
+	];
+}
+//#endregion
+//#region src/components/SpelEditor/SpelEditor.vue?vue&type=script&setup=true&lang.ts
+var SpelEditor_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "SpelEditor",
+	props: {
+		modelValue: {},
+		authentication: {},
+		principal: {},
+		locals: {},
+		disabled: { type: Boolean },
+		readonly: { type: Boolean },
+		height: {},
+		theme: { default: "dark" },
+		size: { default: "small" }
+	},
+	emits: [
+		"update:modelValue",
+		"change",
+		"validate",
+		"run"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const { internalValue, validation, handleInput, handleValidate, setValue, getValue, run } = useSpelEditor(props, __emit);
+		const cmRef = ref();
+		const focus = () => cmRef.value?.view?.focus();
+		__expose({
+			getValue,
+			setValue,
+			validate: handleValidate,
+			run,
+			focus
+		});
+		const isDark = computed(() => (props.theme ?? "dark") === "dark");
+		const T$1 = computed(() => isDark.value ? DARK : LIGHT);
+		watch(isDark, () => injectAutocompleteStyle(T$1.value), { immediate: true });
+		const sz = computed(() => props.size ?? "small");
+		const sf = {
+			tiny: 12,
+			small: 13,
+			medium: 14,
+			large: 15
+		};
+		const editorFontSize = computed(() => sf[sz.value]);
+		const cl = (m) => computed(() => m[sz.value] ?? m.small ?? "");
+		const hPC = cl({
+			tiny: "px-2 py-1",
+			small: "px-4 py-2",
+			medium: "px-5 py-2.5",
+			large: "px-6 py-3"
+		});
+		const hTC = cl({
+			tiny: "text-xs",
+			small: "text-sm",
+			medium: "text-base",
+			large: "text-lg"
+		});
+		const cStyle = computed(() => {
+			if (typeof props.height === "number") return { height: `${props.height}px` };
+			if (props.height) return { height: props.height };
+			return { minHeight: "200px" };
+		});
+		const A = () => props.authentication, B = () => props.principal, L = () => props.locals;
+		const toO = (e, p) => {
+			const l = p.toLowerCase();
+			return e.filter((x) => x.label.toLowerCase().startsWith(l)).map((x) => ({
+				label: x.label,
+				type: x.type,
+				detail: x.detail
+			}));
+		};
+		function fieldO(r, pfx, part) {
+			if (r.type === "object" && r.children) return toO(buildFilterFieldEntries(r.children, pfx), part);
+			if (r.type === "string") return toO(buildStringMethodEntries(), part);
+			if (r.type === "array") {
+				if (r.elementFields) return toO(buildFilterFieldEntries(r.elementFields, pfx), part);
+				return toO(buildArrayMethodEntries({ elementType: r.elementType ?? "string" }), part);
+			}
+			return [];
+		}
+		function filterCtx(ap, inside, pos) {
+			const meta = buildArrayMeta(A(), B(), L())[ap];
+			if (!meta) return null;
+			const di = inside.lastIndexOf(".");
+			if (di >= 0) {
+				const pfx = inside.slice(0, di);
+				const part = inside.slice(di + 1);
+				if (pfx === "#this") {
+					if (meta.elementType === "string") return {
+						from: pos - part.length,
+						options: toO(buildStringMethodEntries(), part)
+					};
+					if (meta.elementType === "array") return {
+						from: pos - part.length,
+						options: toO(buildArrayMethodEntries({ elementType: meta.elementType }), part)
+					};
+				}
+				if (meta.elementType === "object" && meta.elementFields) {
+					const r = resolveFieldPath(meta.elementFields, pfx);
+					if (r) return {
+						from: pos - part.length,
+						options: fieldO(r, pfx, part)
+					};
+				}
+			} else {
+				const all = [];
+				if (meta.elementType === "object" && meta.elementFields) all.push(...buildFilterFieldEntries(meta.elementFields));
+				all.push({
+					label: "#this",
+					type: "variable",
+					detail: meta.elementType ?? "any",
+					desc: "当前数组元素",
+					extra: ""
+				});
+				return {
+					from: pos - inside.length,
+					options: toO(all, inside)
+				};
+			}
+			return null;
+		}
+		const completionSource = (ctx) => {
+			const word = ctx.matchBefore(/[#a-zA-Z_][\w#.]*/);
+			const pos = ctx.pos;
+			const before = ctx.state.sliceDoc(Math.max(0, pos - 200), pos);
+			const lm = before.match(/('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*")\.([\w]*)$/);
+			if (lm) return {
+				from: pos - (lm[2]?.length ?? 0),
+				options: toO(buildStringMethodEntries(), lm[2] ?? "")
+			};
+			const fm = before.match(/(\w+(?:\.\w+)*)\.([?!])[[]([^[\]]*)$/);
+			if (fm) {
+				const r = filterCtx(fm[1], fm[3], pos);
+				if (r) return r;
+			}
+			if (!word || word.from === word.to && !ctx.explicit) return null;
+			const text = word.text;
+			const di = text.lastIndexOf(".");
+			if (di > 0) {
+				const base = text.slice(0, di);
+				const part = text.slice(di + 1);
+				const type = buildTypeMap(A(), B(), L())[base];
+				if (type === "string") return {
+					from: word.from + di + 1,
+					options: toO(buildStringMethodEntries(), part)
+				};
+				if (type === "array") {
+					const am = buildArrayMeta(A(), B(), L())[base];
+					return {
+						from: word.from + di + 1,
+						options: toO(buildArrayMethodEntries(am), part)
+					};
+				}
+			}
+			const lower = text.toLowerCase();
+			return {
+				from: word.from,
+				options: buildEntries(A(), B(), L()).filter((e) => e.label.toLowerCase().startsWith(lower)).map((e) => ({
+					label: e.label,
+					type: e.type,
+					detail: e.detail,
+					apply: (v) => v.dispatch({ changes: {
+						from: word.from,
+						to: word.to,
+						insert: e.label
+					} })
+				}))
+			};
+		};
+		const spelHoverTooltip = computed(() => hoverTooltip((view, pos) => {
+			const token = getTokenAt(view.state.doc, pos);
+			if (!token) return null;
+			const entry = buildEntries(A(), B(), L()).find((e) => e.label === token.text);
+			if (!entry) return null;
+			return {
+				pos: token.from,
+				end: token.to,
+				above: true,
+				create: () => ({ dom: buildHoverTooltipDom(entry, T$1.value) })
+			};
+		}, { hoverTime: 300 }));
+		const extensions = computed(() => buildExtensions(T$1.value, isDark.value, editorFontSize.value, completionSource, spelHoverTooltip.value));
+		watch(() => props.modelValue, (nv) => {
+			if (!cmRef.value?.view) return;
+			const view = cmRef.value.view;
+			if (view.state.doc.toString() !== nv) view.dispatch({ changes: {
+				from: 0,
+				to: view.state.doc.length,
+				insert: nv
+			} });
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				class: normalizeClass(["spel-editor-wrap rounded-lg overflow-hidden shadow-lg", [isDark.value ? "border-gray-700" : "border-gray-200", `size--${sz.value}`]]),
+				style: normalizeStyle([cStyle.value, {
+					borderWidth: "1px",
+					borderStyle: "solid"
+				}])
+			}, [
+				createElementVNode("div", {
+					class: normalizeClass(["flex items-center justify-between select-none", unref(hPC)]),
+					style: normalizeStyle({ background: `linear-gradient(to right, ${T$1.value.headerFrom}, ${T$1.value.headerTo})` })
+				}, [createElementVNode("span", { class: normalizeClass(["flex items-center gap-2 text-white font-medium", unref(hTC)]) }, [..._cache[1] || (_cache[1] = [createElementVNode("svg", {
+					class: "w-4 h-4",
+					fill: "none",
+					stroke: "currentColor",
+					viewBox: "0 0 24 24"
+				}, [createElementVNode("path", {
+					"stroke-linecap": "round",
+					"stroke-linejoin": "round",
+					"stroke-width": "2",
+					d: "M10 20l4-16m4 4l4 4-4 4M6 16l-4-4 4-4"
+				})], -1), createTextVNode(" SpEL Editor ", -1)])], 2), _cache[2] || (_cache[2] = createElementVNode("span", { class: "flex items-center gap-1.5" }, [
+					createElementVNode("span", { class: "w-2.5 h-2.5 rounded-full bg-red-400/80" }),
+					createElementVNode("span", { class: "w-2.5 h-2.5 rounded-full bg-yellow-400/80" }),
+					createElementVNode("span", { class: "w-2.5 h-2.5 rounded-full bg-green-400/80" })
+				], -1))], 6),
+				createVNode(unref(T), {
+					ref_key: "cmRef",
+					ref: cmRef,
+					modelValue: unref(internalValue),
+					"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(internalValue) ? internalValue.value = $event : null),
+					extensions: extensions.value,
+					autofocus: false,
+					"indent-with-tab": true,
+					"tab-size": 2,
+					class: "spel-cm-wrap",
+					onChange: unref(handleInput)
+				}, null, 8, [
+					"modelValue",
+					"extensions",
+					"onChange"
+				]),
+				createVNode(Transition, { name: "spel-err" }, {
+					default: withCtx(() => [!unref(validation).valid ? (openBlock(), createElementBlock("div", {
+						key: 0,
+						class: "flex items-center gap-2 px-4 py-2 text-sm border-t",
+						style: normalizeStyle({
+							background: T$1.value.errBg,
+							borderColor: T$1.value.errBorder,
+							color: T$1.value.errFg
+						})
+					}, [_cache[3] || (_cache[3] = createElementVNode("svg", {
+						class: "w-4 h-4 shrink-0",
+						fill: "none",
+						stroke: "currentColor",
+						viewBox: "0 0 24 24"
+					}, [createElementVNode("path", {
+						"stroke-linecap": "round",
+						"stroke-linejoin": "round",
+						"stroke-width": "2",
+						d: "M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"
+					})], -1)), createTextVNode(" " + toDisplayString(unref(validation).error), 1)], 4)) : createCommentVNode("", true)]),
+					_: 1
+				})
+			], 6);
+		};
+	}
+});
+//#endregion
+//#region \0plugin-vue:export-helper
+var _plugin_vue_export_helper_default = (sfc, props) => {
+	const target = sfc.__vccOpts || sfc;
+	for (const [key, val] of props) target[key] = val;
+	return target;
+};
+//#endregion
+//#region src/components/SpelEditor/SpelEditor.vue
+var SpelEditor_default = /* @__PURE__ */ _plugin_vue_export_helper_default(SpelEditor_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-cb26e4f6"]]);
+//#endregion
+//#region src/components/RuleTree/ExpressionEditor.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$1 = { class: "flex items-center gap-1" };
+var _hoisted_2$1 = {
+	key: 0,
+	class: "text-gray-400 font-mono text-sm"
+};
+var _hoisted_3$1 = {
+	key: 0,
+	class: "text-gray-400 font-mono text-sm"
+};
+//#endregion
+//#region src/components/RuleTree/ExpressionEditor.vue
+var ExpressionEditor_default = /* @__PURE__ */ defineComponent({
+	__name: "ExpressionEditor",
+	props: {
+		modelValue: { default: () => ({
+			type: "field",
+			path: ""
+		}) },
+		fieldOptions: {},
+		disabled: { type: Boolean },
+		allowLiteral: {
+			type: Boolean,
+			default: true
+		},
+		allowFunction: {
+			type: Boolean,
+			default: true
+		},
+		baseTypeFilter: {},
+		forceNumberInput: { type: Boolean },
+		size: { default: "small" }
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { emit: __emit }) {
+		const FUNCTIONS = [
+			{
+				label: "length",
+				value: "length",
+				argumentCount: 0,
+				hasBase: true,
+				baseType: "string",
+				returnType: "number"
+			},
+			{
+				label: "size()",
+				value: "size()",
+				argumentCount: 0,
+				hasBase: true,
+				baseType: "collection",
+				returnType: "number"
+			},
+			{
+				label: "toUpperCase()",
+				value: "toUpperCase()",
+				argumentCount: 0,
+				hasBase: true,
+				baseType: "string",
+				returnType: "string"
+			},
+			{
+				label: "toLowerCase()",
+				value: "toLowerCase()",
+				argumentCount: 0,
+				hasBase: true,
+				baseType: "string",
+				returnType: "string"
+			},
+			{
+				label: "trim()",
+				value: "trim()",
+				argumentCount: 0,
+				hasBase: true,
+				baseType: "string",
+				returnType: "string"
+			},
+			{
+				label: "abs()",
+				value: "abs()",
+				argumentCount: 0,
+				hasBase: true,
+				baseType: "number",
+				returnType: "number"
+			},
+			{
+				label: "round()",
+				value: "round()",
+				argumentCount: 0,
+				hasBase: true,
+				baseType: "number",
+				returnType: "number"
+			},
+			{
+				label: "substring(x)",
+				value: "substring({0})",
+				argumentCount: 1,
+				hasBase: true,
+				baseType: "string",
+				returnType: "string"
+			},
+			{
+				label: "substring(x, y)",
+				value: "substring({0}, {1})",
+				argumentCount: 2,
+				hasBase: true,
+				baseType: "string",
+				returnType: "string"
+			},
+			{
+				label: "replace()",
+				value: "replace({0}, {1})",
+				argumentCount: 2,
+				hasBase: true,
+				baseType: "string",
+				returnType: "string"
+			},
+			{
+				label: "startsWith()",
+				value: "startsWith({0})",
+				argumentCount: 1,
+				hasBase: true,
+				baseType: "string",
+				returnType: "boolean"
+			},
+			{
+				label: "endsWith()",
+				value: "endsWith({0})",
+				argumentCount: 1,
+				hasBase: true,
+				baseType: "string",
+				returnType: "boolean"
+			},
+			{
+				label: "contains()",
+				value: "contains({0})",
+				argumentCount: 1,
+				hasBase: true,
+				baseType: "string",
+				returnType: "boolean"
+			},
+			{
+				label: "indexOf()",
+				value: "indexOf({0})",
+				argumentCount: 1,
+				hasBase: true,
+				baseType: "string",
+				returnType: "number"
+			},
+			{
+				label: "charAt()",
+				value: "charAt({0})",
+				argumentCount: 1,
+				hasBase: true,
+				baseType: "string",
+				returnType: "string"
+			},
+			{
+				label: "now()",
+				value: "now()",
+				argumentCount: 0,
+				hasBase: false,
+				returnType: "date"
+			},
+			{
+				label: "random()",
+				value: "random()",
+				argumentCount: 0,
+				hasBase: false,
+				returnType: "number"
+			},
+			{
+				label: "currentUser()",
+				value: "currentUser()",
+				argumentCount: 0,
+				hasBase: false,
+				returnType: "string"
+			}
+		];
+		const fullFunctionOptions = FUNCTIONS.map((f) => ({
+			label: f.label,
+			value: f.value
+		}));
+		const props = __props;
+		const emit = __emit;
+		const typeOptions = computed(() => {
+			const ops = [{
+				label: "字段",
+				value: "field"
+			}];
+			if (props.allowLiteral) ops.push({
+				label: "值",
+				value: "literal"
+			});
+			if (props.allowFunction) ops.push({
+				label: "方法",
+				value: "function"
+			});
+			return ops;
+		});
+		const currentType = computed(() => props.modelValue.type);
+		const currentFunctionDef = computed(() => {
+			if (props.modelValue.type !== "function") return null;
+			const funcExpr = props.modelValue;
+			return FUNCTIONS.find((f) => f.value === funcExpr.call.method) ?? null;
+		});
+		function filterFieldTree(opts, typeFilter) {
+			if (!typeFilter) return opts;
+			return opts.reduce((acc, opt) => {
+				if (opt.children && opt.children.length > 0) {
+					const filteredChildren = filterFieldTree(opt.children, typeFilter);
+					if (filteredChildren.length > 0) acc.push({
+						...opt,
+						children: filteredChildren
+					});
+				} else if (opt.type === typeFilter) acc.push(opt);
+				return acc;
+			}, []);
+		}
+		const filteredFieldOptions = computed(() => {
+			return filterFieldTree(props.fieldOptions ?? [], props.baseTypeFilter);
+		});
+		const filteredFunctionOptions = computed(() => {
+			if (!props.baseTypeFilter) return fullFunctionOptions;
+			return FUNCTIONS.filter((f) => f.returnType === props.baseTypeFilter).map((f) => ({
+				label: f.label,
+				value: f.value
+			}));
+		});
+		function setType(type) {
+			if (type === "literal") emit("update:modelValue", {
+				type: "literal",
+				value: ""
+			});
+			else if (type === "field") emit("update:modelValue", {
+				type: "field",
+				path: ""
+			});
+			else emit("update:modelValue", {
+				type: "function",
+				call: {
+					method: "",
+					base: void 0,
+					args: []
+				}
+			});
+		}
+		function updateLiteral(value) {
+			emit("update:modelValue", {
+				type: "literal",
+				value
+			});
+		}
+		function updateFieldPath(path) {
+			emit("update:modelValue", {
+				type: "field",
+				path
+			});
+		}
+		function updateCall(partial) {
+			if (props.modelValue.type !== "function") return;
+			emit("update:modelValue", {
+				...props.modelValue,
+				call: {
+					...props.modelValue.call,
+					...partial
+				}
+			});
+		}
+		function onMethodChange(method) {
+			const def = FUNCTIONS.find((f) => f.value === method);
+			if (!def) return;
+			const args = Array.from({ length: def.argumentCount }, () => ({
+				type: "literal",
+				value: ""
+			}));
+			emit("update:modelValue", {
+				type: "function",
+				call: {
+					method,
+					base: def.hasBase ? {
+						type: "field",
+						path: ""
+					} : void 0,
+					args
+				}
+			});
+		}
+		function updateArg(index, expr) {
+			if (props.modelValue.type !== "function") return;
+			const args = [...props.modelValue.call.args];
+			args[index] = expr;
+			emit("update:modelValue", {
+				...props.modelValue,
+				call: {
+					...props.modelValue.call,
+					args
+				}
+			});
+		}
+		const literalPlaceholder = computed(() => {
+			if (props.baseTypeFilter) return `输入${props.baseTypeFilter}值…`;
+			return "输入值…";
+		});
+		const safeLiteralValue = computed(() => {
+			if (props.modelValue.type === "literal") return props.modelValue.value;
+			return "";
+		});
+		watchEffect(() => {
+			if (props.forceNumberInput && props.modelValue.type !== "literal") emit("update:modelValue", {
+				type: "literal",
+				value: ""
+			});
+		});
+		return (_ctx, _cache) => {
+			const _component_n_input_number = resolveComponent("n-input-number");
+			const _component_n_select = resolveComponent("n-select");
+			const _component_n_input = resolveComponent("n-input");
+			const _component_n_cascader = resolveComponent("n-cascader");
+			const _component_ExpressionEditor = resolveComponent("ExpressionEditor", true);
+			return openBlock(), createElementBlock("div", _hoisted_1$1, [__props.forceNumberInput ? (openBlock(), createBlock(_component_n_input_number, {
+				key: 0,
+				value: safeLiteralValue.value !== "" ? Number(safeLiteralValue.value) : null,
+				placeholder: "数字…",
+				size: __props.size,
+				disabled: __props.disabled,
+				class: "!w-[120px]",
+				"onUpdate:value": _cache[0] || (_cache[0] = (v) => updateLiteral(String(v ?? "")))
+			}, null, 8, [
+				"value",
+				"size",
+				"disabled"
+			])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [createVNode(_component_n_select, {
+				value: currentType.value,
+				options: typeOptions.value,
+				size: __props.size,
+				class: "!w-[72px]",
+				disabled: __props.disabled,
+				"onUpdate:value": setType
+			}, null, 8, [
+				"value",
+				"options",
+				"size",
+				"disabled"
+			]), __props.modelValue.type === "literal" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [__props.forceNumberInput ? (openBlock(), createBlock(_component_n_input_number, {
+				key: 0,
+				value: Number(__props.modelValue.value),
+				placeholder: "数字…",
+				size: __props.size,
+				disabled: __props.disabled,
+				class: "!w-[110px]",
+				"onUpdate:value": _cache[1] || (_cache[1] = (v) => updateLiteral(String(v ?? "")))
+			}, null, 8, [
+				"value",
+				"size",
+				"disabled"
+			])) : (openBlock(), createBlock(_component_n_input, {
+				key: 1,
+				value: __props.modelValue.value,
+				placeholder: literalPlaceholder.value,
+				size: __props.size,
+				disabled: __props.disabled,
+				class: "!w-[120px]",
+				"onUpdate:value": updateLiteral
+			}, null, 8, [
+				"value",
+				"placeholder",
+				"size",
+				"disabled"
+			]))], 64)) : __props.modelValue.type === "field" ? (openBlock(), createBlock(_component_n_cascader, {
+				key: 1,
+				value: __props.modelValue.path,
+				options: filteredFieldOptions.value,
+				placeholder: "选择字段…",
+				size: __props.size,
+				disabled: __props.disabled,
+				class: "!w-[160px]",
+				clearable: "",
+				"check-strategy": "child",
+				"onUpdate:value": updateFieldPath
+			}, null, 8, [
+				"value",
+				"options",
+				"size",
+				"disabled"
+			])) : __props.modelValue.type === "function" ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
+				createVNode(_component_n_select, {
+					value: __props.modelValue.call.method,
+					options: filteredFunctionOptions.value,
+					placeholder: "方法…",
+					size: __props.size,
+					disabled: __props.disabled,
+					class: "!w-[130px]",
+					"onUpdate:value": onMethodChange
+				}, null, 8, [
+					"value",
+					"options",
+					"size",
+					"disabled"
+				]),
+				_cache[3] || (_cache[3] = createElementVNode("span", { class: "text-gray-400 font-mono text-sm" }, "(", -1)),
+				currentFunctionDef.value?.hasBase && __props.modelValue.call.base ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [createVNode(_component_ExpressionEditor, {
+					"model-value": __props.modelValue.call.base,
+					"field-options": filteredFieldOptions.value,
+					"base-type-filter": currentFunctionDef.value?.baseType,
+					disabled: __props.disabled,
+					"onUpdate:modelValue": _cache[2] || (_cache[2] = (v) => updateCall({ base: v }))
+				}, null, 8, [
+					"model-value",
+					"field-options",
+					"base-type-filter",
+					"disabled"
+				]), __props.modelValue.call.args.length > 0 ? (openBlock(), createElementBlock("span", _hoisted_2$1, ",")) : createCommentVNode("", true)], 64)) : createCommentVNode("", true),
+				(openBlock(true), createElementBlock(Fragment, null, renderList(__props.modelValue.call.args, (arg, index) => {
+					return openBlock(), createElementBlock(Fragment, { key: "arg" + index }, [index > 0 || (currentFunctionDef.value?.hasBase ? true : index > 0) ? (openBlock(), createElementBlock("span", _hoisted_3$1, ",")) : createCommentVNode("", true), createVNode(_component_ExpressionEditor, {
+						"model-value": arg,
+						"field-options": filteredFieldOptions.value,
+						disabled: __props.disabled,
+						"onUpdate:modelValue": (v) => updateArg(index, v)
+					}, null, 8, [
+						"model-value",
+						"field-options",
+						"disabled",
+						"onUpdate:modelValue"
+					])], 64);
+				}), 128)),
+				_cache[4] || (_cache[4] = createElementVNode("span", { class: "text-gray-400 font-mono text-sm" }, ")", -1))
+			], 64)) : createCommentVNode("", true)], 64))]);
+		};
+	}
+});
+//#endregion
+//#region src/components/RuleTree/RuleTreeNode.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "expr-chip expr-chip--field font-mono text-[11px] flex-1 min-w-0" };
+var _hoisted_2 = {
+	key: 0,
+	class: "expr-chip expr-chip--op text-[11px] font-semibold flex-shrink-0"
+};
+var _hoisted_3 = {
+	key: 1,
+	class: "expr-chip expr-chip--val font-mono text-[11px] flex-1 min-w-0"
+};
+var _hoisted_4 = {
+	key: 2,
+	class: "text-[11px] tracking-widest text-placeholder"
+};
+var _hoisted_5 = {
+	key: 1,
+	class: "text-xs italic text-placeholder"
+};
+var _hoisted_6 = { class: "flex items-start gap-2 flex-wrap" };
+var _hoisted_7 = { class: "expr-block" };
+var _hoisted_8 = { class: "expr-block__body" };
+var _hoisted_9 = { class: "expr-block" };
+var _hoisted_10 = { class: "expr-block__body" };
+var _hoisted_11 = {
+	key: 0,
+	class: "expr-block"
+};
+var _hoisted_12 = { class: "expr-block__body" };
+var _hoisted_13 = {
+	key: 0,
+	class: "flex items-start gap-2 flex-wrap"
+};
+var _hoisted_14 = { class: "expr-block" };
+var _hoisted_15 = { class: "expr-block__body" };
+var _hoisted_16 = {
+	key: 1,
+	class: "flex items-center gap-1.5 px-2 py-1.5 rounded preview-block"
+};
+var _hoisted_17 = { class: "text-[11px] leading-none preview-code" };
+var _hoisted_18 = { class: "preview-left" };
+var _hoisted_19 = {
+	key: 0,
+	class: "mx-1 preview-op"
+};
+var _hoisted_20 = {
+	key: 1,
+	class: "preview-right"
+};
+var _hoisted_21 = {
+	key: 0,
+	class: "group-connector"
+};
+var _hoisted_22 = { class: "flex items-center gap-2 mb-2" };
+var _hoisted_23 = { class: "op-toggle" };
+var _hoisted_24 = ["disabled", "onClick"];
+var _hoisted_25 = { class: "flex items-center gap-1" };
+var _hoisted_26 = { class: "relative pl-5" };
+var _hoisted_27 = {
+	key: 0,
+	class: "group-vline"
+};
+var _hoisted_28 = { class: "flex flex-col gap-1.5" };
+var _hoisted_29 = {
+	key: 1,
+	class: "flex flex-col items-center justify-center py-6 rounded-md border border-dashed empty-state"
+};
+//#endregion
+//#region src/components/RuleTree/RuleTreeNode.vue
+var RuleTreeNode_default = /* @__PURE__ */ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "RuleTreeNode",
+	props: {
+		node: {},
+		authentication: {},
+		principal: {},
+		locals: {},
+		disabled: { type: Boolean },
+		level: {},
+		theme: { default: "light" },
+		size: { default: "small" }
+	},
+	emits: [
+		"add-condition",
+		"add-group",
+		"remove-node",
+		"update-node"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const level = props.level ?? 0;
+		const isEditing = ref(false);
+		const handleAddCondition = () => emit("add-condition", props.node.id);
+		const handleAddGroup = () => emit("add-group", props.node.id);
+		const handleRemove = () => emit("remove-node", props.node.id);
+		function handleUpdate(updates) {
+			emit("update-node", props.node.id, updates);
+		}
+		const fieldOptions = computed(() => {
+			const result = [];
+			if (props.authentication) result.push(...buildFieldOptions(props.authentication, "authentication"));
+			if (props.principal) result.push(...buildFieldOptions(props.principal, "principal"));
+			if (props.locals) result.push(...buildFieldOptions(props.locals, "#"));
+			return result;
+		});
+		function buildFieldOptions(obj, prefix = "") {
+			const options = [];
+			for (const [key, value] of Object.entries(obj)) {
+				const fullPath = prefix ? prefix === "#" ? `#${key}` : `${prefix}.${key}` : key;
+				if (Array.isArray(value)) {
+					const elementType = value.length > 0 ? typeof value[0] : "number";
+					const option = {
+						label: key,
+						value: fullPath,
+						type: "array",
+						elementType
+					};
+					if (elementType === "object" && value.length > 0 && value[0] && !Array.isArray(value[0])) option.elementChildren = buildFieldOptions(value[0], "");
+					options.push(option);
+				} else if (value && typeof value === "object" && !Array.isArray(value)) options.push({
+					label: key,
+					value: fullPath,
+					type: "object",
+					children: buildFieldOptions(value, fullPath)
+				});
+				else options.push({
+					label: key,
+					value: fullPath,
+					type: typeof value
+				});
+			}
+			return options;
+		}
+		const logicalOperatorOptions = [
+			{
+				label: "且",
+				value: "and"
+			},
+			{
+				label: "或",
+				value: "or"
+			},
+			{
+				label: "非",
+				value: "not"
+			}
+		];
+		const currentOperator = computed(() => props.node.operator ?? "and");
+		function getDetailedType(val) {
+			if (val === null || val === void 0) return "null";
+			if (Array.isArray(val)) return "array";
+			const t = typeof val;
+			if (t === "object") return "object";
+			return t;
+		}
+		const leftType = ref(null);
+		watchEffect(() => {
+			if (props.node.type !== "condition" || !props.node.left) {
+				leftType.value = null;
+				return;
+			}
+			const exprStr = formatExpression(props.node.left);
+			if (!exprStr) {
+				leftType.value = null;
+				return;
+			}
+			try {
+				spelService.setContext(props.authentication, props.principal);
+				leftType.value = getDetailedType(spelService.eval(exprStr, props.locals));
+			} catch {
+				leftType.value = null;
+			}
+		});
+		function getComparatorsForType(type) {
+			const base = [
+				{
+					label: "==",
+					value: "=="
+				},
+				{
+					label: "!=",
+					value: "!="
+				},
+				{
+					label: "isNull",
+					value: "isNull"
+				},
+				{
+					label: "isNotNull",
+					value: "isNotNull"
+				}
+			];
+			if (!type) return [
+				...base,
+				{
+					label: ">",
+					value: ">"
+				},
+				{
+					label: ">=",
+					value: ">="
+				},
+				{
+					label: "<",
+					value: "<"
+				},
+				{
+					label: "<=",
+					value: "<="
+				},
+				{
+					label: "isEmpty",
+					value: "isEmpty"
+				},
+				{
+					label: "isNotEmpty",
+					value: "isNotEmpty"
+				}
+			];
+			switch (type) {
+				case "number": return [
+					...base,
+					{
+						label: ">",
+						value: ">"
+					},
+					{
+						label: ">=",
+						value: ">="
+					},
+					{
+						label: "<",
+						value: "<"
+					},
+					{
+						label: "<=",
+						value: "<="
+					}
+				];
+				case "string": return [
+					...base,
+					{
+						label: "isEmpty",
+						value: "isEmpty"
+					},
+					{
+						label: "isNotEmpty",
+						value: "isNotEmpty"
+					}
+				];
+				case "boolean": return base;
+				case "array": return [
+					{
+						label: "count ==",
+						value: "count =="
+					},
+					{
+						label: "count !=",
+						value: "count !="
+					},
+					{
+						label: "count <",
+						value: "count <"
+					},
+					{
+						label: "count <=",
+						value: "count <="
+					},
+					{
+						label: "count >",
+						value: "count >"
+					},
+					{
+						label: "count >=",
+						value: "count >="
+					},
+					...base
+				];
+				case "object":
+				case "null": return [
+					...base,
+					{
+						label: "isEmpty",
+						value: "isEmpty"
+					},
+					{
+						label: "isNotEmpty",
+						value: "isNotEmpty"
+					}
+				];
+				default: return base;
+			}
+		}
+		const availableComparators = computed(() => getComparatorsForType(leftType.value));
+		watchEffect(() => {
+			if (props.node.type !== "condition") return;
+			const allowed = availableComparators.value.map((c) => c.value);
+			if (props.node.comparator && !allowed.includes(props.node.comparator)) handleUpdate({ comparator: "" });
+		});
+		function findFieldOption(path, options) {
+			for (const opt of options) {
+				if (opt.value === path) return opt;
+				if (opt.children) {
+					const found = findFieldOption(path, opt.children);
+					if (found) return found;
+				}
+			}
+			return null;
+		}
+		const currentArrayFieldOption = computed(() => {
+			if (props.node.type !== "condition" || props.node.left?.type !== "field") return null;
+			return findFieldOption(props.node.left.path, fieldOptions.value);
+		});
+		const listElementType = computed(() => {
+			const opt = currentArrayFieldOption.value;
+			if (opt?.type === "array") return opt.elementType ?? "number";
+			return null;
+		});
+		function findElementFieldType(path, children) {
+			for (const child of children) {
+				if (child.value === path) return child.type;
+				if (child.children) {
+					const found = findElementFieldType(path, child.children);
+					if (found) return found;
+				}
+			}
+		}
+		const selectedElementFieldType = computed(() => {
+			const opt = currentArrayFieldOption.value;
+			const fieldPath = props.node.listFilter?.fieldPath;
+			if (!opt || !opt.elementChildren || !fieldPath) return void 0;
+			return findElementFieldType(fieldPath, opt.elementChildren);
+		});
+		const listFilterComparators = computed(() => {
+			if (listElementType.value === "object") {
+				const fieldType = selectedElementFieldType.value;
+				if (!fieldType) return [];
+				return getComparatorsForType(fieldType);
+			}
+			return getComparatorsForType(listElementType.value);
+		});
+		const hasFilterValue = computed(() => {
+			const comp = props.node.listFilter?.comparator;
+			if (!comp) return false;
+			return ![
+				"isEmpty",
+				"isNotEmpty",
+				"isNull",
+				"isNotNull"
+			].includes(comp);
+		});
+		watch(() => props.node.left, () => {
+			if (props.node.listFilter) handleUpdate({ listFilter: void 0 });
+		});
+		function updateListFilter(partial) {
+			handleUpdate({ listFilter: {
+				...props.node.listFilter || { comparator: "" },
+				...partial
+			} });
+		}
+		function updateListFilterField(fieldPath) {
+			updateListFilter({
+				fieldPath,
+				comparator: ""
+			});
+		}
+		function updateListFilterComparator(comp) {
+			const needsValue = ![
+				"isEmpty",
+				"isNotEmpty",
+				"isNull",
+				"isNotNull"
+			].includes(comp);
+			const partial = { comparator: comp };
+			if (!needsValue) partial.value = void 0;
+			else if (!props.node.listFilter?.value) partial.value = {
+				type: "literal",
+				value: "",
+				literalType: listElementType.value === "object" ? selectedElementFieldType.value === "number" ? "number" : "string" : listElementType.value === "number" ? "number" : "string"
+			};
+			updateListFilter(partial);
+		}
+		function updateListFilterValue(val) {
+			const valueType = listElementType.value === "object" ? selectedElementFieldType.value === "number" ? "number" : "string" : listElementType.value === "number" ? "number" : "string";
+			updateListFilter({ value: {
+				type: "literal",
+				value: String(val ?? ""),
+				literalType: valueType
+			} });
+		}
+		const isCountOperator = computed(() => props.node.comparator?.startsWith("count ") ?? false);
+		const hasValueInput = computed(() => {
+			return !!props.node.comparator && ![
+				"isEmpty",
+				"isNotEmpty",
+				"isNull",
+				"isNotNull"
+			].includes(props.node.comparator);
+		});
+		const isConfigured = computed(() => {
+			if (props.node.type !== "condition") return false;
+			return !!(props.node.left && props.node.comparator);
+		});
+		const summaryExpression = computed(() => {
+			if (props.node.type !== "condition") return {
+				left: "",
+				op: "",
+				right: ""
+			};
+			let leftStr = formatExpression(props.node.left);
+			if (props.node.listFilter && props.node.listFilter.comparator) {
+				const { comparator, fieldPath, value } = props.node.listFilter;
+				let target = "#this";
+				if (fieldPath) target = `#this.${fieldPath}`;
+				switch (comparator) {
+					case "isEmpty":
+						leftStr = `${leftStr}.?[${target} == null || ${target}.isEmpty()]`;
+						break;
+					case "isNotEmpty":
+						leftStr = `${leftStr}.?[${target} != null && !${target}.isEmpty()]`;
+						break;
+					case "isNull":
+						leftStr = `${leftStr}.?[${target} == null]`;
+						break;
+					case "isNotNull":
+						leftStr = `${leftStr}.?[${target} != null]`;
+						break;
+					default: {
+						const filterVal = value ? formatExpression(value) : "";
+						leftStr = `${leftStr}.?[${target} ${comparator} ${filterVal}]`;
+						break;
+					}
+				}
+			}
+			const op = props.node.comparator ?? "";
+			if (op.startsWith("count ")) leftStr = `${leftStr}.size()`;
+			return {
+				left: leftStr,
+				op,
+				right: props.node.right ? formatExpression(props.node.right) : ""
+			};
+		});
+		function handleOperatorChange(value) {
+			handleUpdate({ operator: value });
+		}
+		function updateLeft(expr) {
+			handleUpdate({ left: expr });
+		}
+		function updateRight(expr) {
+			handleUpdate({ right: expr });
+		}
+		function updateComparator(value) {
+			handleUpdate({ comparator: value });
+		}
+		function toggleEdit() {
+			if (!props.disabled) isEditing.value = !isEditing.value;
+		}
+		function closeEdit() {
+			isEditing.value = false;
+		}
+		const vClickOutside = {
+			mounted(el, binding) {
+				const handler = (event) => {
+					const target = event.target;
+					if (target.closest(".n-cascader-menu") || target.closest(".n-popover-shared") || target.closest(".v-binder-follower-content")) return;
+					if (!el.contains(target) && el !== target) binding.value(event);
+				};
+				el.__clickOutsideHandler = handler;
+				document.addEventListener("click", handler, true);
+			},
+			unmounted(el) {
+				document.removeEventListener("click", el.__clickOutsideHandler, true);
+				delete el.__clickOutsideHandler;
+			}
+		};
+		const listFilterLiteralValue = computed(() => {
+			const val = props.node.listFilter?.value;
+			if (val && val.type === "literal") return val.value;
+			return "";
+		});
+		return (_ctx, _cache) => {
+			const _component_n_button = resolveComponent("n-button");
+			const _component_n_select = resolveComponent("n-select");
+			const _component_n_input_number = resolveComponent("n-input-number");
+			const _component_n_input = resolveComponent("n-input");
+			const _component_n_cascader = resolveComponent("n-cascader");
+			const _component_RuleTreeNode = resolveComponent("RuleTreeNode", true);
+			return __props.node.type === "condition" ? withDirectives((openBlock(), createElementBlock("div", {
+				key: 0,
+				class: normalizeClass(["rounded-md border overflow-hidden transition-all duration-150", [
+					`theme--${props.theme}`,
+					`size--${__props.size}`,
+					isEditing.value ? "is-editing" : "is-idle",
+					__props.disabled ? "opacity-60 pointer-events-none" : ""
+				]])
+			}, [createElementVNode("div", {
+				class: "group/row flex items-center gap-1.5 px-2.5 min-h-[34px] cursor-pointer select-none overflow-hidden",
+				onClick: toggleEdit
+			}, [
+				_cache[10] || (_cache[10] = createElementVNode("span", { class: "i-carbon:rule text-[11px] flex-shrink-0 icon-muted" }, null, -1)),
+				isConfigured.value ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+					createElementVNode("span", _hoisted_1, toDisplayString(summaryExpression.value.left || "?"), 1),
+					summaryExpression.value.op ? (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(summaryExpression.value.op), 1)) : createCommentVNode("", true),
+					summaryExpression.value.right ? (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(summaryExpression.value.right), 1)) : hasValueInput.value ? (openBlock(), createElementBlock("span", _hoisted_4, "···")) : createCommentVNode("", true)
+				], 64)) : (openBlock(), createElementBlock("span", _hoisted_5, "点击配置条件…")),
+				createVNode(_component_n_button, {
+					class: "!ml-auto opacity-0 group-hover/row:opacity-100 transition-opacity duration-100 flex-shrink-0",
+					text: "",
+					size: __props.size,
+					type: "error",
+					disabled: __props.disabled,
+					onClick: withModifiers(handleRemove, ["stop"])
+				}, {
+					icon: withCtx(() => [..._cache[9] || (_cache[9] = [createElementVNode("span", { class: "i-carbon:close text-xs" }, null, -1)])]),
+					_: 1
+				}, 8, ["size", "disabled"])
+			]), createVNode(Transition, { name: "slide-down" }, {
+				default: withCtx(() => [isEditing.value ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: "edit-panel border-t px-3 py-3 space-y-2",
+					onClick: _cache[4] || (_cache[4] = withModifiers(() => {}, ["stop"]))
+				}, [
+					createElementVNode("div", _hoisted_6, [
+						createElementVNode("div", _hoisted_7, [_cache[11] || (_cache[11] = createElementVNode("div", { class: "expr-block__label" }, "左侧", -1)), createElementVNode("div", _hoisted_8, [createVNode(ExpressionEditor_default, {
+							"model-value": __props.node.left ?? {
+								type: "field",
+								path: ""
+							},
+							"field-options": fieldOptions.value,
+							disabled: __props.disabled,
+							"allow-literal": false,
+							size: __props.size,
+							"onUpdate:modelValue": updateLeft
+						}, null, 8, [
+							"model-value",
+							"field-options",
+							"disabled",
+							"size"
+						])])]),
+						createElementVNode("div", _hoisted_9, [_cache[12] || (_cache[12] = createElementVNode("div", { class: "expr-block__label" }, "操作符", -1)), createElementVNode("div", _hoisted_10, [createVNode(_component_n_select, {
+							value: __props.node.comparator,
+							options: availableComparators.value,
+							placeholder: "…",
+							disabled: __props.disabled,
+							size: __props.size,
+							class: "!w-[108px]",
+							"onUpdate:value": updateComparator
+						}, null, 8, [
+							"value",
+							"options",
+							"disabled",
+							"size"
+						])])]),
+						hasValueInput.value ? (openBlock(), createElementBlock("div", _hoisted_11, [_cache[13] || (_cache[13] = createElementVNode("div", { class: "expr-block__label" }, "右侧", -1)), createElementVNode("div", _hoisted_12, [isCountOperator.value ? (openBlock(), createBlock(ExpressionEditor_default, {
+							key: 0,
+							"model-value": __props.node.right ?? {
+								type: "literal",
+								value: "",
+								literalType: "number"
+							},
+							"force-number-input": true,
+							disabled: __props.disabled,
+							size: __props.size,
+							"onUpdate:modelValue": updateRight
+						}, null, 8, [
+							"model-value",
+							"disabled",
+							"size"
+						])) : (openBlock(), createBlock(ExpressionEditor_default, {
+							key: 1,
+							"model-value": __props.node.right ?? {
+								type: "literal",
+								value: "",
+								literalType: "string"
+							},
+							"field-options": fieldOptions.value,
+							disabled: __props.disabled,
+							"allow-literal": true,
+							size: __props.size,
+							"onUpdate:modelValue": updateRight
+						}, null, 8, [
+							"model-value",
+							"field-options",
+							"disabled",
+							"size"
+						]))])])) : createCommentVNode("", true)
+					]),
+					leftType.value === "array" ? (openBlock(), createElementBlock("div", _hoisted_13, [createElementVNode("div", _hoisted_14, [_cache[16] || (_cache[16] = createElementVNode("div", { class: "expr-block__label" }, "列表过滤", -1)), createElementVNode("div", _hoisted_15, [listElementType.value !== "object" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+						_cache[14] || (_cache[14] = createElementVNode("span", { class: "text-xs mr-1 text-secondary" }, "#this", -1)),
+						createVNode(_component_n_select, {
+							value: __props.node.listFilter?.comparator ?? "",
+							options: listFilterComparators.value,
+							placeholder: "操作符",
+							size: __props.size,
+							class: "!w-[80px]",
+							disabled: __props.disabled,
+							"onUpdate:value": updateListFilterComparator
+						}, null, 8, [
+							"value",
+							"options",
+							"size",
+							"disabled"
+						]),
+						hasFilterValue.value ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [listElementType.value === "number" ? (openBlock(), createBlock(_component_n_input_number, {
+							key: 0,
+							value: listFilterLiteralValue.value !== "" ? Number(listFilterLiteralValue.value) : null,
+							size: __props.size,
+							class: "!w-[100px]",
+							disabled: __props.disabled,
+							"onUpdate:value": _cache[0] || (_cache[0] = (v) => updateListFilterValue(v ?? 0))
+						}, null, 8, [
+							"value",
+							"size",
+							"disabled"
+						])) : (openBlock(), createBlock(_component_n_input, {
+							key: 1,
+							value: listFilterLiteralValue.value,
+							size: __props.size,
+							class: "!w-[120px]",
+							disabled: __props.disabled,
+							placeholder: "文本…",
+							"onUpdate:value": _cache[1] || (_cache[1] = (v) => updateListFilterValue(v))
+						}, null, 8, [
+							"value",
+							"size",
+							"disabled"
+						]))], 64)) : createCommentVNode("", true)
+					], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+						_cache[15] || (_cache[15] = createElementVNode("span", { class: "text-xs mr-1 text-secondary" }, "#this.", -1)),
+						createVNode(_component_n_cascader, {
+							value: __props.node.listFilter?.fieldPath,
+							options: currentArrayFieldOption.value?.elementChildren ?? [],
+							placeholder: "选择字段",
+							size: __props.size,
+							class: "!w-[140px]",
+							disabled: __props.disabled,
+							"check-strategy": "child",
+							"onUpdate:value": updateListFilterField
+						}, null, 8, [
+							"value",
+							"options",
+							"size",
+							"disabled"
+						]),
+						selectedElementFieldType.value ? (openBlock(), createBlock(_component_n_select, {
+							key: 0,
+							value: __props.node.listFilter?.comparator ?? "",
+							options: listFilterComparators.value,
+							placeholder: "操作符",
+							size: __props.size,
+							class: "!w-[80px]",
+							disabled: __props.disabled,
+							"onUpdate:value": updateListFilterComparator
+						}, null, 8, [
+							"value",
+							"options",
+							"size",
+							"disabled"
+						])) : createCommentVNode("", true),
+						hasFilterValue.value && selectedElementFieldType.value ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [selectedElementFieldType.value === "number" ? (openBlock(), createBlock(_component_n_input_number, {
+							key: 0,
+							value: listFilterLiteralValue.value !== "" ? Number(listFilterLiteralValue.value) : null,
+							size: __props.size,
+							class: "!w-[100px]",
+							disabled: __props.disabled,
+							"onUpdate:value": _cache[2] || (_cache[2] = (v) => updateListFilterValue(v ?? 0))
+						}, null, 8, [
+							"value",
+							"size",
+							"disabled"
+						])) : (openBlock(), createBlock(_component_n_input, {
+							key: 1,
+							value: listFilterLiteralValue.value,
+							size: __props.size,
+							class: "!w-[120px]",
+							disabled: __props.disabled,
+							placeholder: "文本…",
+							"onUpdate:value": _cache[3] || (_cache[3] = (v) => updateListFilterValue(v))
+						}, null, 8, [
+							"value",
+							"size",
+							"disabled"
+						]))], 64)) : createCommentVNode("", true)
+					], 64))])])])) : createCommentVNode("", true),
+					isConfigured.value ? (openBlock(), createElementBlock("div", _hoisted_16, [_cache[17] || (_cache[17] = createElementVNode("span", { class: "i-carbon:code text-xs flex-shrink-0 icon-muted" }, null, -1)), createElementVNode("code", _hoisted_17, [
+						createElementVNode("span", _hoisted_18, toDisplayString(summaryExpression.value.left || "…"), 1),
+						summaryExpression.value.op ? (openBlock(), createElementBlock("span", _hoisted_19, toDisplayString(summaryExpression.value.op), 1)) : createCommentVNode("", true),
+						summaryExpression.value.right ? (openBlock(), createElementBlock("span", _hoisted_20, toDisplayString(summaryExpression.value.right), 1)) : createCommentVNode("", true)
+					])])) : createCommentVNode("", true)
+				])) : createCommentVNode("", true)]),
+				_: 1
+			})], 2)), [[vClickOutside, closeEdit]]) : (openBlock(), createElementBlock("div", {
+				key: 1,
+				class: normalizeClass(["relative group-root", [
+					`theme--${props.theme}`,
+					`size--${__props.size}`,
+					unref(level) > 0 ? "ml-4" : ""
+				]])
+			}, [
+				unref(level) > 0 ? (openBlock(), createElementBlock("div", _hoisted_21)) : createCommentVNode("", true),
+				createElementVNode("div", _hoisted_22, [
+					createElementVNode("div", _hoisted_23, [(openBlock(), createElementBlock(Fragment, null, renderList(logicalOperatorOptions, (opt) => {
+						return createElementVNode("button", {
+							key: opt.value,
+							class: normalizeClass(["op-toggle__btn", {
+								"op-toggle__btn--and": currentOperator.value === "and" && opt.value === "and",
+								"op-toggle__btn--or": currentOperator.value === "or" && opt.value === "or",
+								"op-toggle__btn--not": currentOperator.value === "not" && opt.value === "not",
+								"op-toggle__btn--off": currentOperator.value !== opt.value
+							}]),
+							disabled: __props.disabled,
+							onClick: ($event) => handleOperatorChange(opt.value)
+						}, toDisplayString(opt.label), 11, _hoisted_24);
+					}), 64))]),
+					_cache[24] || (_cache[24] = createElementVNode("div", { class: "flex-1" }, null, -1)),
+					createElementVNode("div", _hoisted_25, [
+						createVNode(_component_n_button, {
+							class: "action-btn",
+							size: __props.size,
+							disabled: __props.disabled,
+							onClick: handleAddCondition
+						}, {
+							icon: withCtx(() => [..._cache[18] || (_cache[18] = [createElementVNode("span", { class: "i-carbon:add text-xs" }, null, -1)])]),
+							default: withCtx(() => [_cache[19] || (_cache[19] = createTextVNode("条件", -1))]),
+							_: 1
+						}, 8, ["size", "disabled"]),
+						createVNode(_component_n_button, {
+							class: "action-btn",
+							size: __props.size,
+							disabled: __props.disabled,
+							onClick: handleAddGroup
+						}, {
+							icon: withCtx(() => [..._cache[20] || (_cache[20] = [createElementVNode("span", { class: "i-carbon:folder-add text-xs" }, null, -1)])]),
+							default: withCtx(() => [_cache[21] || (_cache[21] = createTextVNode("分组", -1))]),
+							_: 1
+						}, 8, ["size", "disabled"]),
+						unref(level) > 0 ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [_cache[23] || (_cache[23] = createElementVNode("div", { class: "w-px h-4 mx-0.5 divider" }, null, -1)), createVNode(_component_n_button, {
+							size: __props.size,
+							quaternary: "",
+							circle: "",
+							type: "error",
+							disabled: __props.disabled,
+							onClick: handleRemove
+						}, {
+							icon: withCtx(() => [..._cache[22] || (_cache[22] = [createElementVNode("span", { class: "i-carbon:trash-can text-sm" }, null, -1)])]),
+							_: 1
+						}, 8, ["size", "disabled"])], 64)) : createCommentVNode("", true)
+					])
+				]),
+				createElementVNode("div", _hoisted_26, [__props.node.children && __props.node.children.length > 0 ? (openBlock(), createElementBlock("div", _hoisted_27)) : createCommentVNode("", true), createElementVNode("div", _hoisted_28, [__props.node.children && __props.node.children.length > 0 ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(__props.node.children, (child) => {
+					return openBlock(), createElementBlock("div", {
+						key: child.id,
+						class: "relative"
+					}, [_cache[25] || (_cache[25] = createElementVNode("div", { class: "group-hline" }, null, -1)), createVNode(_component_RuleTreeNode, {
+						node: child,
+						authentication: __props.authentication,
+						principal: __props.principal,
+						locals: __props.locals,
+						disabled: __props.disabled,
+						level: unref(level) + 1,
+						theme: props.theme,
+						size: __props.size,
+						onAddCondition: _cache[5] || (_cache[5] = (id) => _ctx.$emit("add-condition", id)),
+						onAddGroup: _cache[6] || (_cache[6] = (id) => _ctx.$emit("add-group", id)),
+						onRemoveNode: _cache[7] || (_cache[7] = (id) => _ctx.$emit("remove-node", id)),
+						onUpdateNode: _cache[8] || (_cache[8] = (id, updates) => _ctx.$emit("update-node", id, updates))
+					}, null, 8, [
+						"node",
+						"authentication",
+						"principal",
+						"locals",
+						"disabled",
+						"level",
+						"theme",
+						"size"
+					])]);
+				}), 128)) : (openBlock(), createElementBlock("div", _hoisted_29, [..._cache[26] || (_cache[26] = [createElementVNode("span", { class: "i-carbon:add-alt text-xl mb-1 icon-muted" }, null, -1), createElementVNode("p", { class: "text-[11px] text-placeholder" }, "暂无条件，点击右上方按钮添加", -1)])]))])])
+			], 2));
+		};
+	}
+}), [["__scopeId", "data-v-41249d75"]]);
+//#endregion
+//#region src/components/RuleTree/RuleTree.vue
+var RuleTree_default = /* @__PURE__ */ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "RuleTree",
+	props: {
+		modelValue: {},
+		authentication: {},
+		principal: {},
+		locals: {},
+		disabled: { type: Boolean },
+		theme: { default: "light" },
+		size: { default: "small" }
+	},
+	emits: ["update:modelValue", "change"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const { getSpelExpression, setSpelExpression, addCondition, addGroup, removeNode, updateNode, validate } = useRuleTree(props, __emit);
+		__expose({
+			getSpelExpression,
+			setSpelExpression,
+			validate
+		});
+		const currentTheme = computed(() => props.theme === "dark" ? darkTheme : lightTheme);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(NConfigProvider), { theme: currentTheme.value }, {
+				default: withCtx(() => [createElementVNode("div", { class: normalizeClass(["rule-tree-container", [`theme--${props.theme}`, `size--${props.size}`]]) }, [createVNode(RuleTreeNode_default, {
+					node: __props.modelValue,
+					authentication: __props.authentication,
+					principal: __props.principal,
+					locals: __props.locals,
+					disabled: __props.disabled,
+					level: 0,
+					theme: props.theme,
+					size: props.size,
+					onAddCondition: unref(addCondition),
+					onAddGroup: unref(addGroup),
+					onRemoveNode: unref(removeNode),
+					onUpdateNode: unref(updateNode)
+				}, null, 8, [
+					"node",
+					"authentication",
+					"principal",
+					"locals",
+					"disabled",
+					"theme",
+					"size",
+					"onAddCondition",
+					"onAddGroup",
+					"onRemoveNode",
+					"onUpdateNode"
+				])], 2)]),
+				_: 1
+			}, 8, ["theme"]);
+		};
+	}
+}), [["__scopeId", "data-v-6f5f2d8f"]]);
+//#endregion
+//#region src/constants/index.ts
+var DEFAULT_COMPARATORS = [
+	{
+		value: "==",
+		label: "等于",
+		types: [
+			"string",
+			"number",
+			"boolean",
+			"date"
+		]
+	},
+	{
+		value: "!=",
+		label: "不等于",
+		types: [
+			"string",
+			"number",
+			"boolean",
+			"date"
+		]
+	},
+	{
+		value: ">",
+		label: "大于",
+		types: ["number", "date"]
+	},
+	{
+		value: ">=",
+		label: "大于等于",
+		types: ["number", "date"]
+	},
+	{
+		value: "<",
+		label: "小于",
+		types: ["number", "date"]
+	},
+	{
+		value: "<=",
+		label: "小于等于",
+		types: ["number", "date"]
+	},
+	{
+		value: "contains",
+		label: "包含",
+		types: ["string"]
+	},
+	{
+		value: "startsWith",
+		label: "开头",
+		types: ["string"]
+	},
+	{
+		value: "endsWith",
+		label: "结尾",
+		types: ["string"]
+	},
+	{
+		value: "matches",
+		label: "正则匹配",
+		types: ["string"]
+	},
+	{
+		value: "in",
+		label: "在列表中",
+		types: ["string", "number"]
+	},
+	{
+		value: "not in",
+		label: "不在列表中",
+		types: ["string", "number"]
+	},
+	{
+		value: "isEmpty",
+		label: "为空",
+		types: [
+			"string",
+			"array",
+			"object"
+		]
+	},
+	{
+		value: "isNotEmpty",
+		label: "不为空",
+		types: [
+			"string",
+			"array",
+			"object"
+		]
+	}
+];
+var GROUP_OPERATORS = [{
+	value: "and",
+	label: "且"
+}, {
+	value: "or",
+	label: "或"
+}];
+var EDITOR_THEME = "one-dark";
+var EDITOR_DEFAULT_HEIGHT = "400px";
+var RULE_TREE_DEFAULT_HEIGHT = "500px";
+//#endregion
+export { DEFAULT_COMPARATORS, EDITOR_DEFAULT_HEIGHT, EDITOR_THEME, GROUP_OPERATORS, RULE_TREE_DEFAULT_HEIGHT, RuleTree_default as RuleTree, SpelEditor_default as SpelEditor, createEmptyCondition, createEmptyGroup, evalSpelExpression, generateId, ruleNodeToSpel, spelService, useRuleTree, useSpelEditor, validateSpelExpression };
+
+//# sourceMappingURL=index.esm.map