@react-querybuilder/core 8.21.1 → 8.22.0

package/dist/react-querybuilder_core.legacy-esm.js

@@ -1,5 +1,5 @@
 import { numericQuantity, numericRegex as numericRegex$1 } from "numeric-quantity";
-import { current, isDraft, produce } from "immer";
+import { current, freeze, isDraft, produce } from "immer";
 //#region src/defaults.ts
 /**
 * @group Defaults
@@ -130,6 +130,14 @@ const defaultTranslations = {
 		label: "˅",
 		title: "Shift down"
 	},
+	undo: {
+		label: "↶",
+		title: "Undo"
+	},
+	redo: {
+		label: "↷",
+		title: "Redo"
+	},
 	dragHandle: {
 		label: "⁞⁞",
 		title: "Drag handle"
@@ -454,6 +462,9 @@ const standardClassnames = {
 	valid: "queryBuilder-valid",
 	invalid: "queryBuilder-invalid",
 	shiftActions: "shiftActions",
+	undoRedoActions: "undoRedoActions",
+	undoAction: "undoRedoActions-undo",
+	redoAction: "undoRedoActions-redo",
 	dndDragging: "dndDragging",
 	dndOver: "dndOver",
 	dndCopy: "dndCopy",
@@ -502,6 +513,9 @@ const defaultControlClassnames = {
 	value: "",
 	removeRule: "",
 	shiftActions: "",
+	undoRedoActions: "",
+	undoAction: "",
+	redoAction: "",
 	dragHandle: "",
 	lockRule: "",
 	lockGroup: "",
@@ -559,6 +573,9 @@ const TestID = {
 	valueEditor: "value-editor",
 	notToggle: "not-toggle",
 	shiftActions: "shift-actions",
+	undoRedoActions: "undo-redo-actions",
+	undoAction: "undo-action",
+	redoAction: "redo-action",
 	dragHandle: "drag-handle",
 	lockRule: "lock-rule",
 	lockGroup: "lock-group",
@@ -605,6 +622,7 @@ const queryBuilderFlagDefaults = {
 	enableDragAndDrop: false,
 	enableMountQueryChange: true,
 	listsAsArrays: false,
+	preserveQueryStateOnUnmount: false,
 	resetOnFieldChange: true,
 	resetOnOperatorChange: false,
 	showCloneButtons: false,
@@ -613,8 +631,22 @@ const queryBuilderFlagDefaults = {
 	showMuteButtons: false,
 	showNotToggle: false,
 	showShiftActions: false,
+	showUndoRedo: false,
 	suppressStandardClassnames: false
 };
+/**
+* Default maximum number of undo steps retained by query history.
+*
+* @group Defaults
+*/
+const defaultMaxHistory = 50;
+/**
+* Default time window (in milliseconds) within which consecutive changes to the same
+* property of the same rule are coalesced into a single undo step.
+*
+* @group Defaults
+*/
+const defaultCoalesceMs = 500;
 //#endregion
 //#region src/utils/arrayUtils.ts
 /**
@@ -718,7 +750,7 @@ const isRuleGroupType = (rg) => isRuleGroup(rg) && typeof rg.combinator === "str
 */
 const isRuleGroupTypeIC = (rg) => isRuleGroup(rg) && rg.combinator === void 0;
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/typeof.js
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -728,7 +760,7 @@ function _typeof(o) {
 	}, _typeof(o);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPrimitive.js
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/toPrimitive.js
 function toPrimitive(t, r) {
 	if ("object" != _typeof(t) || !t) return t;
 	var e = t[Symbol.toPrimitive];
@@ -740,13 +772,13 @@ function toPrimitive(t, r) {
 	return ("string" === r ? String : Number)(t);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPropertyKey.js
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/toPropertyKey.js
 function toPropertyKey(t) {
 	var i = toPrimitive(t, "string");
 	return "symbol" == _typeof(i) ? i : i + "";
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/defineProperty.js
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/defineProperty.js
 function _defineProperty(e, r, t) {
 	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 		value: t,
@@ -756,7 +788,7 @@ function _defineProperty(e, r, t) {
 	}) : e[r] = t, e;
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/objectSpread2.js
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/objectSpread2.js
 function ownKeys(e, r) {
 	var t = Object.keys(e);
 	if (Object.getOwnPropertySymbols) {
@@ -779,7 +811,7 @@ function _objectSpread2(e) {
 	return e;
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/objectWithoutPropertiesLoose.js
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/objectWithoutPropertiesLoose.js
 function _objectWithoutPropertiesLoose(r, e) {
 	if (null == r) return {};
 	var t = {};
@@ -790,7 +822,7 @@ function _objectWithoutPropertiesLoose(r, e) {
 	return t;
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/objectWithoutProperties.js
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/objectWithoutProperties.js
 function _objectWithoutProperties(e, t) {
 	if (null == e) return {};
 	var o, r, i = _objectWithoutPropertiesLoose(e, t);
@@ -802,7 +834,7 @@ function _objectWithoutProperties(e, t) {
 }
 //#endregion
 //#region src/utils/convertQuery.ts
-const _excluded = ["combinator"];
+const _excluded$1 = ["combinator"];
 const combinatorLevels = [
 	"or",
 	"xor",
@@ -862,7 +894,7 @@ const convertFromIC = (rg) => {
 */
 const convertToIC = (rg) => {
 	if (isRuleGroupTypeIC(rg)) return rg;
-	const { combinator } = rg, queryWithoutCombinator = _objectWithoutProperties(rg, _excluded);
+	const { combinator } = rg, queryWithoutCombinator = _objectWithoutProperties(rg, _excluded$1);
 	const rules = [];
 	const { length } = rg.rules;
 	for (let idx = 0; idx < length; idx++) {
@@ -877,6 +909,181 @@ function convertQuery(query) {
 	return isRuleGroupTypeIC(query) ? convertFromIC(query) : convertToIC(query);
 }
 //#endregion
+//#region src/utils/deriveClassNames.ts
+const ruleClassnameSources = {
+	shiftActions: ["shiftActions"],
+	dragHandle: ["dragHandle"],
+	fields: ["valueSelector", "fields"],
+	matchMode: ["valueSelector", "matchMode"],
+	matchThreshold: ["valueSelector", "matchThreshold"],
+	operators: ["valueSelector", "operators"],
+	valueSource: ["valueSelector", "valueSource"],
+	value: ["value"],
+	cloneRule: ["actionElement", "cloneRule"],
+	lockRule: ["actionElement", "lockRule"],
+	muteRule: ["actionElement", "muteRule"],
+	removeRule: ["actionElement", "removeRule"],
+	valueListItem: ["valueListItem"]
+};
+const ruleGroupClassnameSources = {
+	header: {
+		sources: ["header"],
+		conditions: [
+			{
+				key: "dndOver",
+				when: (s) => s.isOver,
+				standardOnly: true
+			},
+			{
+				key: "dndCopy",
+				when: (s) => s.isOver && s.dropEffect === "copy"
+			},
+			{
+				key: "dndDropNotAllowed",
+				when: (s) => s.dropNotAllowed
+			}
+		]
+	},
+	shiftActions: ["shiftActions"],
+	undoRedoActions: ["undoRedoActions"],
+	undoAction: ["actionElement", "undoAction"],
+	redoAction: ["actionElement", "redoAction"],
+	dragHandle: ["dragHandle"],
+	combinators: ["valueSelector", "combinators"],
+	notToggle: ["notToggle"],
+	addRule: ["actionElement", "addRule"],
+	addGroup: ["actionElement", "addGroup"],
+	cloneGroup: ["actionElement", "cloneGroup"],
+	lockGroup: ["actionElement", "lockGroup"],
+	muteGroup: ["actionElement", "muteGroup"],
+	removeGroup: ["actionElement", "removeGroup"],
+	body: ["body"]
+};
+/**
+* Conditional classes applied to a rule's wrapper element.
+*
+* Note that this is deliberately _not_ the same set as {@link ruleGroupOuterConditions}: a rule
+* reflects more drag-and-drop states than a group does. Declaring each set separately is what
+* keeps an implementation from assuming they're symmetric.
+*/
+const ruleOuterConditions = [
+	{
+		key: "disabled",
+		when: (s) => s.disabled
+	},
+	{
+		key: "muted",
+		when: (s) => s.muted
+	},
+	{
+		key: "dndDragging",
+		when: (s) => s.isDragging
+	},
+	{
+		key: "dndOver",
+		when: (s) => s.isOver
+	},
+	{
+		key: "dndCopy",
+		when: (s) => s.isOver && s.dropEffect === "copy"
+	},
+	{
+		key: "dndGroup",
+		when: (s) => s.isOver && s.groupItems
+	},
+	{
+		key: "dndDropNotAllowed",
+		when: (s) => s.dropNotAllowed
+	},
+	{
+		key: "hasSubQuery",
+		when: (s) => s.hasSubQuery
+	}
+];
+/** Conditional classes applied to a rule group's wrapper element. */
+const ruleGroupOuterConditions = [
+	{
+		key: "disabled",
+		when: (s) => s.disabled
+	},
+	{
+		key: "muted",
+		when: (s) => s.muted
+	},
+	{
+		key: "dndDragging",
+		when: (s) => s.isDragging
+	},
+	{
+		key: "dndGroup",
+		when: (s) => s.isOver && s.groupItems
+	}
+];
+/**
+* Expands conditions into `clsx` arguments: every custom class first (in declaration order),
+* then a single object of standard classes.
+*/
+const conditionArgs = (conditions, state, { classNames, suppressStandardClassnames }) => {
+	const evaluated = conditions.map((condition) => [condition, !!condition.when(state)]);
+	return [...evaluated.filter(([condition]) => !condition.standardOnly).map(([condition, active]) => active && (classNames === null || classNames === void 0 ? void 0 : classNames[condition.key])), suppressStandardClassnames || Object.fromEntries(evaluated.map(([condition, active]) => [standardClassnames[condition.key], active]))];
+};
+/** Composes the classname for a single entry of a spec map. */
+const deriveFromSpec = (key, spec, state, options) => {
+	const { sources, conditions } = Array.isArray(spec) ? { sources: spec } : spec;
+	return clsx(options.suppressStandardClassnames || standardClassnames[key], ...sources.map((source) => {
+		var _options$classNames;
+		return (_options$classNames = options.classNames) === null || _options$classNames === void 0 ? void 0 : _options$classNames[source];
+	}), ...conditions ? conditionArgs(conditions, state, options) : []);
+};
+const deriveFromSpecs = (specs, state, options) => {
+	const result = {};
+	for (const [key, spec] of Object.entries(specs)) result[key] = deriveFromSpec(key, spec, state, options);
+	return result;
+};
+/**
+* Classnames for each element rendered by a rule. This is the framework-agnostic core of the
+* `classNames` object returned by the `useRule` hook.
+*
+* @group Query Tools
+*/
+const deriveRuleClassNames = (options) => deriveFromSpecs(ruleClassnameSources, {}, options);
+/**
+* The classname for a single element of a rule, composed from the same table as
+* {@link deriveRuleClassNames}. Useful where only one is needed, such as the items of a
+* multi-value editor.
+*
+* @group Query Tools
+*/
+const deriveRuleClassName = (key, options) => deriveFromSpec(key, ruleClassnameSources[key], {}, options);
+/**
+* Classnames for each element rendered by a rule group, including its conditionally-classed
+* `header`. This is the framework-agnostic core of the `classNames` object returned by the
+* `useRuleGroup` hook.
+*
+* @group Query Tools
+*/
+const deriveRuleGroupClassNames = (options) => deriveFromSpecs(ruleGroupClassnameSources, options, options);
+const deriveOuterClassName = (standardKey, conditions, options) => {
+	const { classNames, suppressStandardClassnames, leadingClassNames = [], validationClassName } = options;
+	return clsx(...leadingClassNames, suppressStandardClassnames || standardClassnames[standardKey], classNames === null || classNames === void 0 ? void 0 : classNames[standardKey], ...conditionArgs(conditions, options, options), validationClassName);
+};
+/**
+* The outer (wrapper) classname for a rule, including every conditional state class.
+*
+* @group Query Tools
+*/
+const deriveRuleOuterClassName = (options) => deriveOuterClassName("rule", ruleOuterConditions, options);
+/**
+* The outer (wrapper) classname for a rule group, including every conditional state class.
+*
+* A group reflects fewer drag-and-drop states than a rule—`dndOver`, `dndCopy`,
+* `dndDropNotAllowed`, and `hasSubQuery` do not apply—so this is not interchangeable with
+* {@link deriveRuleOuterClassName}.
+*
+* @group Query Tools
+*/
+const deriveRuleGroupOuterClassName = (options) => deriveOuterClassName("ruleGroup", ruleGroupOuterConditions, options);
+//#endregion
 //#region src/utils/defaultValidator.ts
 /**
 * This is an example validation function you can pass to {@link react-querybuilder!QueryBuilder QueryBuilder} in the
@@ -1183,7 +1390,7 @@ const filterFieldsByComparator = (field, fields, operator) => {
 	if (!field.comparator) {
 		const filterOutSameField = (f) => {
 			var _f$value, _field$value;
-			return ((_f$value = f.value) !== null && _f$value !== void 0 ? _f$value : 			/* v8 ignore start -- @preserve */ f.name) !== ((_field$value = field.value) !== null && _field$value !== void 0 ? _field$value : 
+			return ((_f$value = f.value) !== null && _f$value !== void 0 ? _f$value : /* v8 ignore start -- @preserve */ f.name) !== ((_field$value = field.value) !== null && _field$value !== void 0 ? _field$value : 
 			/* v8 ignore start -- @preserve */ field.name);
 		};
 		if (isFlexibleOptionGroupArray(fields)) return fields.map((og) => _objectSpread2(_objectSpread2({}, og), {}, { options: og.options.filter((v) => filterOutSameField(v)) }));
@@ -1193,6 +1400,142 @@ const filterFieldsByComparator = (field, fields, operator) => {
 	return fields.filter((f) => filterByComparator(field, operator, f));
 };
 //#endregion
+//#region src/utils/deriveRuleContext.ts
+/**
+* Resolves the field configuration for a rule's `field`, falling back to a minimal option object
+* when the field isn't present in the field map.
+*/
+const getFieldData = (field, fieldMap) => {
+	var _fieldMap$field;
+	return (_fieldMap$field = fieldMap === null || fieldMap === void 0 ? void 0 : fieldMap[field]) !== null && _fieldMap$field !== void 0 ? _fieldMap$field : {
+		name: field,
+		value: field,
+		label: field
+	};
+};
+/**
+* The input type for a rule. A field's own `inputType` takes precedence over `getInputType`.
+*/
+const getRuleInputType = (field, operator, fieldData, getInputType) => {
+	var _fieldData$inputType;
+	return (_fieldData$inputType = fieldData.inputType) !== null && _fieldData$inputType !== void 0 ? _fieldData$inputType : getInputType(field, operator, { fieldData });
+};
+/**
+* Whether the value editor(s) should be hidden for an operator, based on its `arity`.
+*/
+const hideValueControlsForOperator = (operatorObject) => {
+	const arity = operatorObject === null || operatorObject === void 0 ? void 0 : operatorObject.arity;
+	return typeof arity === "string" && arity === "unary" || typeof arity === "number" && arity < 2;
+};
+/**
+* Value source options for a rule. A `valueSource` present on the rule but absent from the
+* configured list is appended, so the current selection is always representable.
+*/
+const getRuleValueSourceOptions = (rule, fieldData, getValueSources) => {
+	const configuredVSs = getValueSources(rule.field, rule.operator, { fieldData });
+	if (rule.valueSource && !getOption(configuredVSs, rule.valueSource)) return [...configuredVSs, {
+		name: rule.valueSource,
+		value: rule.valueSource,
+		label: rule.valueSource
+	}];
+	return configuredVSs;
+};
+/**
+* Normalizes the result of `getParameters` to a non-empty list or `null`.
+*/
+const getParametersAsList = (parameters) => parameters && parameters.length > 0 ? parameters : null;
+/**
+* The value editor type for a rule. `valueSource: "field"` always uses a select list, and
+* `valueSource: "parameter"` uses a (multi)select when parameters are available.
+*/
+const getRuleValueEditorType = (rule, fieldData, parametersAsList, getValueEditorType) => rule.valueSource === "field" ? "select" : rule.valueSource === "parameter" ? parametersAsList ? lc(rule.operator) === "in" || lc(rule.operator) === "notin" ? "multiselect" : "select" : "text" : getValueEditorType(rule.field, rule.operator, { fieldData });
+/**
+* The option list presented by a rule's value editor, resolved from its `valueSource`.
+*/
+const getRuleValues = (rule, fieldData, fields, parametersAsList, getValues) => {
+	const v = rule.valueSource === "field" ? filterFieldsByComparator(fieldData, fields, rule.operator) : rule.valueSource === "parameter" ? parametersAsList !== null && parametersAsList !== void 0 ? parametersAsList : [] : getValues(rule.field, rule.operator, { fieldData });
+	return isFlexibleOptionArray(v) || isFlexibleOptionGroupArray(v) ? toFullOptionList(v) : v;
+};
+/**
+* The validation result for a rule: the entry from a query-level {@link ValidationMap} if present,
+* otherwise the field's own `validator` result, otherwise `null`.
+*/
+const getRuleValidationResult = (rule, fieldData, validationMap = {}, id = ((_rule$id) => (_rule$id = rule.id) !== null && _rule$id !== void 0 ? _rule$id : "")()) => {
+	var _validationMap$id;
+	return (_validationMap$id = validationMap[id]) !== null && _validationMap$id !== void 0 ? _validationMap$id : typeof fieldData.validator === "function" ? fieldData.validator(rule) : null;
+};
+/**
+* Resolves everything about a single rule that depends on the field/operator configuration:
+* its field data, operators, value editor type, value list, value sources, match modes, and
+* validation result.
+*
+* This is the framework-agnostic core of the `useRule` hook, shared with
+* {@link QueryManager.getRuleContext} so that non-React implementations derive identical results.
+* It performs no memoization; callers are responsible for caching as appropriate.
+*
+* @group Query Tools
+*/
+const deriveRuleContext = (rule, resolvers, options = {}) => {
+	var _fieldData$inputType2, _getSubQueryBuilderPr;
+	const { fields, fieldMap, getInputType, getMatchModes, getOperators, getParameters, getValueEditorType, getValues, getValueSources, getSubQueryBuilderProps } = resolvers;
+	const fieldData = getFieldData(rule.field, fieldMap);
+	const inputType = (_fieldData$inputType2 = fieldData.inputType) !== null && _fieldData$inputType2 !== void 0 ? _fieldData$inputType2 : getInputType(rule.field, rule.operator, { fieldData });
+	const matchModes = getMatchModes(rule.field, { fieldData });
+	const operators = getOperators(rule.field, { fieldData });
+	const operatorObject = getOption(operators, rule.operator);
+	const valueSourceOptions = getRuleValueSourceOptions(rule, fieldData, getValueSources);
+	const parameters = getParametersAsList(getParameters(rule.field, rule.operator, { fieldData }));
+	return {
+		fieldData,
+		hideValueControls: hideValueControlsForOperator(operatorObject),
+		inputType,
+		matchModes,
+		operatorObject,
+		operators,
+		parameters,
+		validationResult: getRuleValidationResult(rule, fieldData, options.validationMap, options.id),
+		valueEditorType: getRuleValueEditorType(rule, fieldData, parameters, getValueEditorType),
+		values: getRuleValues(rule, fieldData, fields, parameters, getValues),
+		valueSourceOptions,
+		valueSources: valueSourceOptions.map(({ value }) => value),
+		subQueryBuilderProps: (_getSubQueryBuilderPr = getSubQueryBuilderProps === null || getSubQueryBuilderProps === void 0 ? void 0 : getSubQueryBuilderProps(rule.field, { fieldData })) !== null && _getSubQueryBuilderPr !== void 0 ? _getSubQueryBuilderPr : {}
+	};
+};
+/**
+* The effective combinator for a group: its own `combinator` when it has one, otherwise the
+* first configured combinator (which is the case for groups with independent combinators).
+*
+* This intentionally covers only the current property-based API. The `RuleGroup` component
+* additionally falls back to its deprecated `combinator` prop; that fallback stays in the hook.
+*/
+const getRuleGroupCombinator = (ruleGroup, combinators) => {
+	var _getFirstOption;
+	return isRuleGroupType(ruleGroup) ? ruleGroup.combinator : (_getFirstOption = getFirstOption(combinators)) !== null && _getFirstOption !== void 0 ? _getFirstOption : "";
+};
+/**
+* Resolves everything about a rule group that depends on the combinator configuration, plus its
+* validation result.
+*
+* Note that unlike {@link deriveRuleContext}, there is no field-level validator fallback—a
+* group's validation result comes only from the query-level {@link ValidationMap}.
+*
+* @group Query Tools
+*/
+const deriveRuleGroupContext = (ruleGroup, combinators, options = {}) => {
+	var _combinatorObject$cla, _ref, _options$validationMa, _ref2, _options$id;
+	const independentCombinators = isRuleGroupTypeIC(ruleGroup);
+	const combinator = getRuleGroupCombinator(ruleGroup, combinators);
+	const combinatorObject = getOption(combinators, combinator);
+	return {
+		combinator,
+		combinatorObject,
+		combinators,
+		combinatorBasedClassName: independentCombinators ? null : (_combinatorObject$cla = combinatorObject === null || combinatorObject === void 0 ? void 0 : combinatorObject.className) !== null && _combinatorObject$cla !== void 0 ? _combinatorObject$cla : "",
+		independentCombinators,
+		validationResult: (_ref = ((_options$validationMa = options.validationMap) !== null && _options$validationMa !== void 0 ? _options$validationMa : {})[(_ref2 = (_options$id = options.id) !== null && _options$id !== void 0 ? _options$id : ruleGroup.id) !== null && _ref2 !== void 0 ? _ref2 : ""]) !== null && _ref !== void 0 ? _ref : null
+	};
+};
+//#endregion
 //#region src/utils/parseNumber.ts
 /**
 * Converts a string to a number. Uses native `parseFloat` if `parseNumbers` is "native",
@@ -1212,6 +1555,108 @@ const parseNumber = (val, { parseNumbers, bigIntOnOverflow } = {}) => {
 	return typeof valAsNum === "bigint" || !Number.isNaN(valAsNum) ? valAsNum : val;
 };
 //#endregion
+//#region src/utils/deriveValueEditor.ts
+/** Operators whose value is a list rather than a single scalar. */
+const multiValueOperators = /* @__PURE__ */ new Set([
+	"between",
+	"notBetween",
+	"in",
+	"notIn"
+]);
+/**
+* Whether an operator's value is a list of two bounds.
+*
+* @group Value Editors
+*/
+const isBetweenOperator = (operator) => operator === "between" || operator === "notBetween";
+/**
+* Determines whether a rule's `value` needs to be collapsed to a single element because it no
+* longer represents a list, and what it should become.
+*
+* This happens when the value is an array (or a comma-containing string in a `number` input,
+* which `<input type="number">` can't display) while the operator is not one of the multi-value
+* operators and the editor is not a multiselect—typically right after the operator changes from
+* `"in"` or `"between"` to something else.
+*
+* The React `useValueEditor` hook applies the result in an effect; other implementations may
+* apply it wherever is idiomatic.
+*
+* @group Value Editors
+*/
+const getValueEditorReset = ({ skipHook, type, operator, value, inputType }) => {
+	var _toArray$;
+	return !skipHook && type !== "multiselect" && !multiValueOperators.has(operator) && (Array.isArray(value) || inputType === "number" && typeof value === "string" && value.includes(",")) ? {
+		reset: true,
+		value: (_toArray$ = toArray(value, { retainEmptyStrings: true })[0]) !== null && _toArray$ !== void 0 ? _toArray$ : ""
+	} : {
+		reset: false,
+		value
+	};
+};
+/**
+* Produces the next value for a series of value editors when the editor at `index` changes.
+*
+* For `between`/`notBetween`, editing the first bound guarantees an array of at least two
+* elements, seeding the second from the first available option. The result is a comma-joined
+* string unless `listsAsArrays` is `true`.
+*
+* @group Value Editors
+*/
+const getMultiValueUpdate = ({ value, index, valueAsArray, operator, values, listsAsArrays, parseNumberMethod }) => {
+	const parsedVal = parseNumber(value, { parseNumbers: parseNumberMethod });
+	const needsBetweenFix = index === 0 && isBetweenOperator(operator) && (valueAsArray.length < 2 || valueAsArray[1] === void 0);
+	if (valueAsArray[index] === parsedVal && !needsBetweenFix) return listsAsArrays ? valueAsArray : joinWith(valueAsArray, ",");
+	const v = [...valueAsArray];
+	v[index] = parsedVal;
+	if (needsBetweenFix) {
+		var _getFirstOption;
+		v[1] = (_getFirstOption = getFirstOption(values)) !== null && _getFirstOption !== void 0 ? _getFirstOption : "";
+	}
+	return listsAsArrays ? v : joinWith(v, ",");
+};
+/**
+* Coerces a value to a `bigint`, falling back to the parsed number when it can't be represented
+* as one (an empty string or a decimal, for example).
+*
+* @group Value Editors
+*/
+const coerceBigIntValue = (value, parseNumberMethod) => {
+	const valAsMaybeNumber = parseNumber(value, {
+		parseNumbers: parseNumberMethod,
+		bigIntOnOverflow: true
+	});
+	try {
+		return BigInt(valAsMaybeNumber);
+	} catch (_unused) {
+		return valAsMaybeNumber;
+	}
+};
+/**
+* The `type` attribute an `<input>` should use for a rule. `bigint` values and the `in`/`notIn`
+* operators (whose value is a comma-separated list) both require a text input.
+*
+* @group Value Editors
+*/
+const coerceInputType = (inputType, operator) => inputType === "bigint" || operator === "in" || operator === "notIn" ? "text" : inputType || "text";
+/**
+* Produces the next value for a value selector. Multiselect values are normalized to an array
+* first, then comma-joined unless `listsAsArrays` is `true`. Single-select values pass through.
+*
+* @group Value Editors
+*/
+const getValueSelectorUpdate = (value, { multiple, listsAsArrays } = {}) => {
+	if (!multiple) return value;
+	const valueAsArray = toArray(value);
+	return listsAsArrays ? valueAsArray : joinWith(valueAsArray, ",");
+};
+/**
+* Normalizes a value selector's current value for display. Multiselect values become an array of
+* strings so they match option names, which are always strings (e.g. `[42]` becomes `["42"]`).
+*
+* @group Value Editors
+*/
+const normalizeValueSelectorValue = (value, multiple) => multiple ? toArray(value).map(String) : value;
+//#endregion
 //#region src/utils/transformQuery.ts
 const remapProperties = (obj, propertyMap, deleteRemappedProperties) => {
 	const result = {};
@@ -1571,6 +2016,21 @@ const processMatchMode = (rule) => {
 	};
 };
 /**
+* Base alias assigned to the element binding of a subquery generated for a rule's
+* {@link MatchMode `match` mode} (e.g. `unnest(field) as elem_alias`).
+*/
+const subqueryElementAliasBase = "elem_alias";
+/**
+* Returns the element alias for a subquery at the given nesting depth. Depth 0 (the common,
+* non-nested case) uses {@link subqueryElementAliasBase} unchanged; deeper levels are suffixed
+* with the depth, so a subquery nested within a subquery cannot shadow its parent's binding.
+*
+* Deterministic by depth rather than randomized, so output remains stable and snapshot-friendly.
+*
+* @group Export
+*/
+const getSubqueryElementAlias = (subqueryDepth = 0) => subqueryDepth > 0 ? `${subqueryElementAliasBase}_${subqueryDepth}` : subqueryElementAliasBase;
+/**
 * "Replacer" method for JSON.stringify's second argument. Converts `bigint` values to
 * objects with a `$bigint` property having a value of a string representation of
 * the actual `bigint`-type value.
@@ -1600,7 +2060,7 @@ const defaultRuleGroupProcessorCEL = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
 		const processedRules = [];
 		let precedingCombinator = "";
 		let firstRule = true;
@@ -1663,9 +2123,12 @@ const defaultRuleProcessorCEL = (rule, opts = {}) => {
 	const matchEval = processMatchMode(rule);
 	if (matchEval === false) return "";
 	else if (matchEval) {
+		var _opts$subqueryDepth;
 		const { mode, threshold } = matchEval;
-		const arrayElementAlias = "elem_alias";
-		const nestedArrayFilter = defaultRuleGroupProcessorCEL(transformQuery(rule.value, { ruleProcessor: (r) => _objectSpread2(_objectSpread2({}, r), {}, { field: `${arrayElementAlias}${r.field ? `.${r.field}` : ""}` }) }), opts);
+		const subqueryDepth = (_opts$subqueryDepth = opts.subqueryDepth) !== null && _opts$subqueryDepth !== void 0 ? _opts$subqueryDepth : 0;
+		const arrayElementAlias = getSubqueryElementAlias(subqueryDepth);
+		const celQuery = transformQuery(rule.value, { ruleProcessor: (r) => _objectSpread2(_objectSpread2({}, r), {}, { field: `${arrayElementAlias}${r.field ? `.${r.field}` : ""}` }) });
+		const nestedArrayFilter = defaultRuleGroupProcessorCEL(celQuery, _objectSpread2(_objectSpread2({}, opts), {}, { subqueryDepth: subqueryDepth + 1 }));
 		switch (mode) {
 			case "all": return `${field}.all(${arrayElementAlias}, ${nestedArrayFilter})`;
 			case "none":
@@ -1740,7 +2203,7 @@ const defaultRuleGroupProcessorMongoDBQuery = (ruleGroup, options, meta) => {
 	const { inExpressionContext } = context !== null && context !== void 0 ? context : {};
 	const processRuleGroup = (rg, outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermost ? mongoDbFallback : false;
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermost ? mongoDbFallback : false;
 		const combinator = `$${lc(rg.combinator)}`;
 		let hasChildRules = false;
 		const expressions = rg.rules.map((rule) => {
@@ -1906,7 +2369,7 @@ const defaultRuleGroupProcessorSpEL = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
 		const processedRules = [];
 		let precedingCombinator = "";
 		let firstRule = true;
@@ -2147,7 +2610,7 @@ const defaultRuleGroupProcessorCypher = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
 		const processedRules = [];
 		let precedingCombinator = "";
 		let firstRule = true;
@@ -2212,7 +2675,7 @@ const defaultRuleGroupProcessorDrizzle = (ruleGroup, options, _meta) => (columns
 	const { and, not, or } = drizzleOperators;
 	const processRuleGroup = (rg, _outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return;
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return;
 		const processedRules = rg.rules.map((rule) => {
 			if (isRuleGroup(rule)) return processRuleGroup(rule);
 			const [validationResult, fieldValidator] = validateRule(rule);
@@ -2244,7 +2707,7 @@ const defaultRuleGroupProcessorElasticSearch = (ruleGroup, options) => {
 	const { fields, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return false;
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return false;
 		const processedRules = rg.rules.map((rule) => {
 			if (isRuleGroup(rule)) return processRuleGroup(rule);
 			const [validationResult, fieldValidator] = validateRule(rule);
@@ -2280,7 +2743,9 @@ const defaultRuleGroupProcessorGremlin = (ruleGroup, options) => {
 		// v8 ignore next -- @preserve
 		if (typeof rule === "string" || isRuleGroup(rule)) return void 0;
 		const [validationResult, fieldValidator] = validateRule(rule);
-		if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return;
+		if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || 
+		/* v8 ignore next 2 -- @preserve */
+		rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return;
 		const fieldData = getOption(fields, rule.field);
 		return ruleProcessor(rule, _objectSpread2(_objectSpread2({}, options), {}, {
 			parseNumbers: getParseNumberBoolean(fieldData === null || fieldData === void 0 ? void 0 : fieldData.inputType),
@@ -2291,7 +2756,7 @@ const defaultRuleGroupProcessorGremlin = (ruleGroup, options) => {
 	/** Recursively processes a nested group into `.and()`/`.or()`/`.not()` form. */
 	const processNested = (rg) => {
 		var _rg$id, _combinator;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return "";
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return "";
 		const predicates = [];
 		for (const rule of rg.rules) {
 			if (typeof rule === "string") continue;
@@ -2309,7 +2774,7 @@ const defaultRuleGroupProcessorGremlin = (ruleGroup, options) => {
 		if (predicates.length === 1 && !rg.not) return predicates[0];
 		return `.${prefix}(${predicates.map((p) => p.startsWith(".") ? `__${p}` : p).join(", ")})`;
 	};
-	if (!isRuleOrGroupValid(ruleGroup, validationMap[(_ruleGroup$id = ruleGroup.id) !== null && _ruleGroup$id !== void 0 ? _ruleGroup$id : 	/* v8 ignore start -- @preserve */ ""])) return fallbackExpression;
+	if (!isRuleOrGroupValid(ruleGroup, validationMap[(_ruleGroup$id = ruleGroup.id) !== null && _ruleGroup$id !== void 0 ? _ruleGroup$id : /* v8 ignore start -- @preserve */ ""])) return fallbackExpression;
 	const steps = [];
 	for (const rule of ruleGroup.rules) {
 		if (typeof rule === "string") continue;
@@ -2335,7 +2800,7 @@ const defaultRuleGroupProcessorJSONata = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
 		const processedRules = [];
 		let precedingCombinator = "";
 		let firstRule = true;
@@ -2392,7 +2857,7 @@ const defaultRuleGroupProcessorJsonLogic = (ruleGroup, options) => {
 	const query = convertFromIC(ruleGroup);
 	const processRuleGroup = (rg, _outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return false;
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return false;
 		const processedRules = rg.rules.map((rule) => {
 			if (isRuleGroup(rule)) return processRuleGroup(rule);
 			const [validationResult, fieldValidator] = validateRule(rule);
@@ -2420,7 +2885,7 @@ const defaultRuleGroupProcessorLDAP = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
 		const rules = rg.rules.map((rule) => {
 			var _rule$valueSource;
 			if (isRuleGroup(rule)) return processRuleGroup(rule);
@@ -2454,7 +2919,7 @@ const defaultRuleGroupProcessorMongoDB = (ruleGroup, options, meta) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
 		const combinator = `"$${lc(rg.combinator)}"`;
 		let hasChildRules = false;
 		const expressions = rg.rules.map((rule) => {
@@ -2491,7 +2956,7 @@ const defaultRuleGroupProcessorNL = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, translations, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermostOrLonelyInGroup) => {
 		var _rg$id, _rg2$combinator2, _translations$ruleSep2, _translations2;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
 		const rg2 = isRuleGroupTypeIC(rg) && rg.rules.some((r) => typeof r === "string" && lc(r) === "xor") ? convertFromIC(rg) : rg;
 		const processedRules = [];
 		let precedingCombinator = "";
@@ -2593,7 +3058,7 @@ const defaultRuleGroupProcessorParameterized = (ruleGroup, options) => {
 	};
 	const processRuleGroup = (rg, outermostOrLonelyInGroup) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
 		const processedRules = [];
 		let precedingCombinator = "";
 		let firstRule = true;
@@ -2654,7 +3119,7 @@ const defaultRuleGroupProcessorPrisma = (ruleGroup, options) => {
 	const { fields, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermost ? prismaFallback : void 0;
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermost ? prismaFallback : void 0;
 		const combinator = rg.combinator.toUpperCase();
 		let hasChildRules = false;
 		const expressions = rg.rules.map((rule) => {
@@ -2693,7 +3158,7 @@ const defaultRuleGroupProcessorSequelize = (ruleGroup, options) => {
 	if (!Op) return void 0;
 	const processRuleGroup = (rg, _outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return;
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return;
 		const combinator = rg.combinator.toUpperCase();
 		let hasChildRules = false;
 		const expressions = rg.rules.map((rule) => {
@@ -2732,7 +3197,7 @@ const defaultRuleGroupProcessorSPARQL = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermost) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermost ? fallbackExpression : "";
 		const processedRules = [];
 		let precedingCombinator = "";
 		let firstRule = true;
@@ -2788,7 +3253,7 @@ const defaultRuleGroupProcessorSQL = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermostOrLonelyInGroup) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
 		const processedRules = [];
 		let precedingCombinator = "";
 		let firstRule = true;
@@ -2858,7 +3323,7 @@ const defaultRuleGroupProcessorTanStackDB = (ruleGroup, options) => (refs) => {
 	if (refKeys.length === 0) return fallback;
 	const processRuleGroup = (rg) => {
 		var _rg$id;
-		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : 		/* v8 ignore start -- @preserve */ ""])) return;
+		if (!isRuleOrGroupValid(rg, validationMap[(_rg$id = rg.id) !== null && _rg$id !== void 0 ? _rg$id : /* v8 ignore start -- @preserve */ ""])) return;
 		const processedRules = rg.rules.map((rule) => {
 			if (isRuleGroup(rule)) return processRuleGroup(rule);
 			const [validationResult, fieldValidator] = validateRule(rule);
@@ -3258,7 +3723,7 @@ const defaultRuleProcessorCypher = (rule, opts = {}) => {
 * @group Export
 */
 const defaultRuleProcessorDrizzle = (rule, _options) => {
-	const opts = _options !== null && _options !== void 0 ? _options : 	/* v8 ignore start -- @preserve */ {};
+	const opts = _options !== null && _options !== void 0 ? _options : /* v8 ignore start -- @preserve */ {};
 	// v8 ignore next
 	const { parseNumbers, preserveValueOrder, context = {} } = opts;
 	const { columns, drizzleOperators, useRawFields } = context;
@@ -3277,10 +3742,16 @@ const defaultRuleProcessorDrizzle = (rule, _options) => {
 	const matchEval = processMatchMode(rule);
 	if (matchEval === false) return;
 	else if (matchEval) {
+		var _opts$subqueryDepth;
 		if (opts.preset !== "postgresql") return void 0;
 		const { mode, threshold } = matchEval;
-		const arrayElementAlias = "elem_alias";
-		const nestedArrayFilter = defaultRuleGroupProcessorDrizzle(transformQuery(rule.value, { ruleProcessor: (r) => _objectSpread2(_objectSpread2({}, r), {}, { field: arrayElementAlias }) }), _objectSpread2(_objectSpread2({}, opts), {}, { context: _objectSpread2(_objectSpread2({}, opts.context), {}, { useRawFields: true }) }));
+		const subqueryDepth = (_opts$subqueryDepth = opts.subqueryDepth) !== null && _opts$subqueryDepth !== void 0 ? _opts$subqueryDepth : 0;
+		const arrayElementAlias = getSubqueryElementAlias(subqueryDepth);
+		const sqlQuery = transformQuery(rule.value, { ruleProcessor: (r) => _objectSpread2(_objectSpread2({}, r), {}, { field: arrayElementAlias }) });
+		const nestedArrayFilter = defaultRuleGroupProcessorDrizzle(sqlQuery, _objectSpread2(_objectSpread2({}, opts), {}, {
+			context: _objectSpread2(_objectSpread2({}, opts.context), {}, { useRawFields: true }),
+			subqueryDepth: subqueryDepth + 1
+		}));
 		switch (mode) {
 			case "all": return sql`(select count(*) from unnest(${column}) as ${sql.raw(arrayElementAlias)} where ${nestedArrayFilter({}, drizzleOperators)}) = array_length(${column}, 1)`;
 			case "none": return sql`not exists (select 1 from unnest(${column}) as ${sql.raw(arrayElementAlias)} where ${nestedArrayFilter({}, drizzleOperators)})`;
@@ -3808,7 +4279,7 @@ const defaultValueProcessorNL = (rule, opts = {}) => {
 	const { escapeQuotes, fields, parseNumbers, quoteFieldNamesWith, quoteValuesWith, fieldIdentifierSeparator, translations } = opts;
 	const valueIsField = rule.valueSource === "field";
 	const operatorLowerCase = lc(rule.operator);
-	const quoteChar = quoteValuesWith || "'";
+	const quoteChar = quoteValuesWith || /* v8 ignore start -- @preserve */ "'";
 	const quoteValue = (v) => `${quoteChar}${v}${quoteChar}`;
 	const escapeValue = (v) => escapeStringValueQuotes(v, quoteChar, escapeQuotes);
 	const wrapAndEscape = (v) => quoteValue(escapeValue(v));
@@ -3816,7 +4287,7 @@ const defaultValueProcessorNL = (rule, opts = {}) => {
 		quoteFieldNamesWith,
 		fieldIdentifierSeparator
 	});
-	const t = translations !== null && translations !== void 0 ? translations : 	/* v8 ignore start -- @preserve */ {};
+	const t = translations !== null && translations !== void 0 ? translations : /* v8 ignore start -- @preserve */ {};
 	const orTL = (_t$or = t.or) !== null && _t$or !== void 0 ? _t$or : "or";
 	const trueTL = (_t$true = t.true) !== null && _t$true !== void 0 ? _t$true : "true";
 	const falseTL = (_t$false = t.false) !== null && _t$false !== void 0 ? _t$false : "false";
@@ -3905,7 +4376,7 @@ const defaultOperatorProcessorNL = (rule, opts = {}) => {
 		name: field,
 		value: field,
 		label: field
-	} })) !== null && _getOperators !== void 0 ? _getOperators : 	/* v8 ignore start -- @preserve */ []), normalizedOperator)) !== null && _getOption !== void 0 ? _getOption : {
+	} })) !== null && _getOperators !== void 0 ? _getOperators : /* v8 ignore start -- @preserve */ []), normalizedOperator)) !== null && _getOption !== void 0 ? _getOption : {
 		name: normalizedOperator,
 		value: normalizedOperator,
 		label: normalizedOperator
@@ -3922,7 +4393,7 @@ const defaultRuleProcessorNL = (rule, opts) => {
 	var _fieldData$label, _opts$translations, _translations$afterSu, _translations$afterVe, _translations$afterOb;
 	const { field, operator } = rule;
 	// v8 ignore next
-	const { fieldData, quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator = "", quoteValuesWith = `'`, operatorProcessor = defaultOperatorProcessorNL, valueProcessor = defaultValueProcessorNL, concatOperator = "||", wordOrder = "SVO" } = opts !== null && opts !== void 0 ? opts : 	/* v8 ignore start -- @preserve */ {};
+	const { fieldData, quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator = "", quoteValuesWith = `'`, operatorProcessor = defaultOperatorProcessorNL, valueProcessor = defaultValueProcessorNL, concatOperator = "||", wordOrder = "SVO" } = opts !== null && opts !== void 0 ? opts : /* v8 ignore start -- @preserve */ {};
 	const processedField = getQuotedFieldName((_fieldData$label = fieldData === null || fieldData === void 0 ? void 0 : fieldData.label) !== null && _fieldData$label !== void 0 ? _fieldData$label : field, {
 		quoteFieldNamesWith,
 		fieldIdentifierSeparator
@@ -3992,10 +4463,12 @@ const defaultRuleProcessorSQL = (rule, opts = {}) => {
 	const matchEval = processMatchMode(rule);
 	if (matchEval === false) return;
 	else if (matchEval) {
+		var _opts$subqueryDepth;
 		if ((opts === null || opts === void 0 ? void 0 : opts.preset) !== "postgresql") return "";
 		const { mode, threshold } = matchEval;
-		const arrayElementAlias = "elem_alias";
-		const nestedArrayFilter = defaultRuleGroupProcessorSQL(transformQuery(rule.value, { ruleProcessor: (r) => _objectSpread2(_objectSpread2({}, r), {}, { field: arrayElementAlias }) }), opts);
+		const subqueryDepth = (_opts$subqueryDepth = opts.subqueryDepth) !== null && _opts$subqueryDepth !== void 0 ? _opts$subqueryDepth : 0;
+		const arrayElementAlias = getSubqueryElementAlias(subqueryDepth);
+		const nestedArrayFilter = defaultRuleGroupProcessorSQL(transformQuery(rule.value, { ruleProcessor: (r) => _objectSpread2(_objectSpread2({}, r), {}, { field: arrayElementAlias }) }), _objectSpread2(_objectSpread2({}, opts), {}, { subqueryDepth: subqueryDepth + 1 }));
 		switch (mode) {
 			case "all": return `(select count(*) from unnest(${ruleField}) as ${wrapFieldName(arrayElementAlias)} where ${nestedArrayFilter}) = array_length(${ruleField}, 1)`;
 			case "none": return `not exists (select 1 from unnest(${ruleField}) as ${wrapFieldName(arrayElementAlias)} where ${nestedArrayFilter})`;
@@ -4050,10 +4523,15 @@ const defaultRuleProcessorParameterized = (rule, opts, meta) => {
 	/* v8 ignore start -- @preserve */
 	if (matchEval === false) return;
 	else if (matchEval) {
+		var _opts$subqueryDepth;
 		if ((opts === null || opts === void 0 ? void 0 : opts.preset) !== "postgresql") return finalize("");
 		const { mode, threshold } = matchEval;
-		const arrayElementAlias = "elem_alias";
-		const { sql: nestedSQL, params: nestedParams } = defaultRuleGroupProcessorParameterized(transformQuery(rule.value, { ruleProcessor: (r) => _objectSpread2(_objectSpread2({}, r), {}, { field: arrayElementAlias }) }), _objectSpread2(_objectSpread2({}, opts), {}, { fields: [] }));
+		const subqueryDepth = (_opts$subqueryDepth = opts.subqueryDepth) !== null && _opts$subqueryDepth !== void 0 ? _opts$subqueryDepth : 0;
+		const arrayElementAlias = getSubqueryElementAlias(subqueryDepth);
+		const { sql: nestedSQL, params: nestedParams } = defaultRuleGroupProcessorParameterized(transformQuery(rule.value, { ruleProcessor: (r) => _objectSpread2(_objectSpread2({}, r), {}, { field: arrayElementAlias }) }), _objectSpread2(_objectSpread2({}, opts), {}, {
+			fields: [],
+			subqueryDepth: subqueryDepth + 1
+		}));
 		if (Array.isArray(nestedParams)) params.push(...nestedParams);
 		else Object.assign(paramsNamed, nestedParams);
 		switch (mode) {
@@ -4124,7 +4602,7 @@ const defaultRuleProcessorParameterized = (rule, opts, meta) => {
 	}
 	let paramValue = rule.value;
 	if (typeof rule.value === "string") if (shouldRenderAsNumber(rule.value, parseNumbers)) paramValue = parseNumber(rule.value, { parseNumbers });
-	else paramValue = /^'.*'$/g.test(value) ? value.replaceAll(/(^'|'$)/g, "") : 	/* v8 ignore next -- @preserve */ value;
+	else paramValue = /^'.*'$/g.test(value) ? value.replaceAll(/(^'|'$)/g, "") : /* v8 ignore next -- @preserve */ value;
 	let paramName = "";
 	if (parameterized) params.push(paramValue);
 	else {
@@ -4342,7 +4820,7 @@ const defaultRuleProcessorSPARQL = (rule, opts = {}) => {
 * @group Export
 */
 const defaultRuleProcessorTanStackDB = (rule, _options) => {
-	const { parseNumbers, preserveValueOrder, context = {} } = _options !== null && _options !== void 0 ? _options : 	/* v8 ignore start -- @preserve */ {};
+	const { parseNumbers, preserveValueOrder, context = {} } = _options !== null && _options !== void 0 ? _options : /* v8 ignore start -- @preserve */ {};
 	const ops = context.tanStackDbOperators;
 	const refs = context._tanstackDbRefs;
 	const primaryRef = context._tanstackDbPrimaryRef;
@@ -4603,7 +5081,7 @@ function formatQuery(ruleGroup, optionParam = {}) {
  // v8 ignore else
 	if (typeof f.validator === "function") {
 		var _f$value;
-		validatorMap[(_f$value = f.value) !== null && _f$value !== void 0 ? _f$value : 		/* v8 ignore start -- @preserve */ f.name] = f.validator;
+		validatorMap[(_f$value = f.value) !== null && _f$value !== void 0 ? _f$value : /* v8 ignore start -- @preserve */ f.name] = f.validator;
 	}
 	const validateRule = (rule) => {
 		let validationResult;
@@ -4774,12 +5252,20 @@ const getParentPath = (path) => path.slice(0, -1);
 /**
 * Determines if two paths (each `Path`) are equivalent.
 */
-const pathsAreEqual = (path1, path2) => path1.length === path2.length && path1.every((val, idx) => val === path2[idx]);
+const pathsAreEqual = (path1, path2) => {
+	if (path1.length !== path2.length) return false;
+	for (let i = 0; i < path1.length; i++) if (path1[i] !== path2[i]) return false;
+	return true;
+};
 /**
 * Determines if the first path is an ancestor of the second path. The first path must
 * be shorter and exactly match the second path up through the length of the first path.
 */
-const isAncestor = (maybeAncestor, path) => maybeAncestor.length < path.length && new RegExp(`^${maybeAncestor.join("-")}`).test(path.join("-"));
+const isAncestor = (maybeAncestor, path) => {
+	if (maybeAncestor.length >= path.length) return false;
+	for (let i = 0; i < maybeAncestor.length; i++) if (maybeAncestor[i] !== path[i]) return false;
+	return true;
+};
 /**
 * Finds the deepest/longest path that two paths have in common.
 */
@@ -4812,11 +5298,38 @@ const pathIsDisabled = (path, query) => {
 	}
 	return disabled;
 };
+/**
+* Determines if the rule or group at the specified path is disabled by `disabledPaths`—the array
+* form of the `QueryBuilder` `disabled` prop, which disables nodes by position rather than by a
+* `disabled` property on the node itself. A path is disabled if it appears in `disabledPaths` or
+* descends from a path that does.
+*
+* @group Paths
+*/
+const pathIsDisabledByPaths = (path, disabledPaths = []) => disabledPaths.some((p) => pathsAreEqual(p, path) || isAncestor(p, path));
+/**
+* Builds the {@link PathInfo} for each child of a group at `path`. A child is disabled if its
+* parent is disabled or if its own path appears in `disabledPaths`.
+*
+* @group Paths
+*/
+const derivePathInfo = (path, childCount, { disabled = false, disabledPaths = [] } = {}) => {
+	const paths = [];
+	for (let i = 0; i < childCount; i++) {
+		const thisPath = [...path, i];
+		paths[i] = {
+			path: thisPath,
+			disabled: disabled || disabledPaths.some((p) => pathsAreEqual(thisPath, p))
+		};
+	}
+	return paths;
+};
 //#endregion
 //#region src/utils/generateAccessibleDescription.ts
 const generateAccessibleDescription = (params) => pathsAreEqual([], params.path) ? `Query builder` : `Rule group at path ${params.path.join("-")}`;
 //#endregion
 //#region src/utils/generateID.ts
+/* v8 ignore file -- this is fine */
 const cryptoModule = globalThis.crypto;
 const uuidV4regex = /^[\da-f]{8}-[\da-f]{4}-4[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/i;
 /**
@@ -4866,7 +5379,7 @@ const dummyFD$1 = {
 */
 const getMatchModesUtil = (fieldData, getMatchModes) => {
 	var _fd$matchModes, _matchModes$map;
-	const fd = fieldData ? toFullOption(fieldData) : 	/* v8 ignore next -- @preserve */ dummyFD$1;
+	const fd = fieldData ? toFullOption(fieldData) : /* v8 ignore next -- @preserve */ dummyFD$1;
 	let matchModes = (_fd$matchModes = fd.matchModes) !== null && _fd$matchModes !== void 0 ? _fd$matchModes : false;
 	if (!matchModes && getMatchModes) matchModes = getMatchModes(fd.value, { fieldData: fd });
 	if (matchModes === true) return defaultMatchModes;
@@ -4887,7 +5400,7 @@ const getFirstOptionsFrom = (opts, r, listsAsArrays) => {
 	const firstOption = getFirstOption(opts);
 	if (r.operator === "between" || r.operator === "notBetween") {
 		const valueAsArray = [firstOption, firstOption];
-		return listsAsArrays ? valueAsArray : joinWith(valueAsArray.map((v) => v !== null && v !== void 0 ? v : 		/* v8 ignore start -- @preserve */ ""), ",");
+		return listsAsArrays ? valueAsArray : joinWith(valueAsArray.map((v) => v !== null && v !== void 0 ? v : /* v8 ignore start -- @preserve */ ""), ",");
 	}
 	return firstOption;
 };
@@ -5029,6 +5542,9 @@ const mergeClassnames = (...args) => ({
 	removeRule: joinClassnamesByName("removeRule", args),
 	notToggle: joinClassnamesByName("notToggle", args),
 	shiftActions: joinClassnamesByName("shiftActions", args),
+	undoRedoActions: joinClassnamesByName("undoRedoActions", args),
+	undoAction: joinClassnamesByName("undoAction", args),
+	redoAction: joinClassnamesByName("redoAction", args),
 	dragHandle: joinClassnamesByName("dragHandle", args),
 	lockRule: joinClassnamesByName("lockRule", args),
 	lockGroup: joinClassnamesByName("lockGroup", args),
@@ -5058,6 +5574,66 @@ const mergeClassnames = (...args) => ({
 	valueDateTimeRelative: joinClassnamesByName("valueDateTimeRelative", args)
 });
 //#endregion
+//#region src/utils/optionResolvers.ts
+/**
+* Resolves the operator list for a field, applying the same precedence as the `QueryBuilder`
+* component: the field's own `operators`, then the `getOperators` callback, then the
+* query-level operator list.
+*
+* @group Option Lists
+*/
+const resolveOperatorList = ({ field, fieldData, getOperators, operators, placeholder, baseOption, autoSelectOption }) => {
+	var _ref, _fieldData$operators;
+	return prepareOptionList({
+		optionList: (_ref = (_fieldData$operators = fieldData === null || fieldData === void 0 ? void 0 : fieldData.operators) !== null && _fieldData$operators !== void 0 ? _fieldData$operators : getOperators === null || getOperators === void 0 ? void 0 : getOperators(field, { fieldData })) !== null && _ref !== void 0 ? _ref : operators,
+		placeholder,
+		baseOption,
+		labelMap: defaultOperatorLabelMap,
+		autoSelectOption
+	}).optionList;
+};
+/**
+* Resolves the default operator for a field, applying the same precedence as the `QueryBuilder`
+* component: the field's own `defaultOperator`, then the `getDefaultOperator` option (a string or
+* a function), then the first available operator.
+*
+* @group Option Lists
+*/
+const resolveDefaultOperator = ({ field, fieldData, getDefaultOperator, getOperators }) => {
+	var _getFirstOption;
+	if (fieldData === null || fieldData === void 0 ? void 0 : fieldData.defaultOperator) return fieldData.defaultOperator;
+	if (getDefaultOperator) return typeof getDefaultOperator === "function" ? getDefaultOperator(field, { fieldData }) : getDefaultOperator;
+	return (_getFirstOption = getFirstOption(getOperators(field, { fieldData }))) !== null && _getFirstOption !== void 0 ? _getFirstOption : "";
+};
+/**
+* Resolves the value editor type for a field/operator pair, applying the same precedence as the
+* `QueryBuilder` component: the field's own `valueEditorType` (a string or a function of the
+* operator), then the `getValueEditorType` callback, then `"text"`.
+*
+* @group Option Lists
+*/
+const resolveValueEditorType = ({ field, operator, fieldData, getValueEditorType }) => {
+	var _getValueEditorType;
+	if (fieldData === null || fieldData === void 0 ? void 0 : fieldData.valueEditorType) return typeof fieldData.valueEditorType === "function" ? fieldData.valueEditorType(operator) : fieldData.valueEditorType;
+	return (_getValueEditorType = getValueEditorType === null || getValueEditorType === void 0 ? void 0 : getValueEditorType(field, operator, { fieldData })) !== null && _getValueEditorType !== void 0 ? _getValueEditorType : "text";
+};
+/**
+* Resolves the value option list for a field/operator pair, applying the same precedence as the
+* `QueryBuilder` component: the field's own `values`, then the `getValues` callback, then an
+* empty list.
+*
+* @group Option Lists
+*/
+const resolveValueList = ({ field, operator, fieldData, getValues, placeholder, baseOption, autoSelectOption }) => {
+	var _ref2, _fieldData$values;
+	return prepareOptionList({
+		optionList: (_ref2 = (_fieldData$values = fieldData === null || fieldData === void 0 ? void 0 : fieldData.values) !== null && _fieldData$values !== void 0 ? _fieldData$values : getValues === null || getValues === void 0 ? void 0 : getValues(field, operator, { fieldData })) !== null && _ref2 !== void 0 ? _ref2 : [],
+		placeholder,
+		baseOption,
+		autoSelectOption
+	}).optionList;
+};
+//#endregion
 //#region src/utils/preferProp.ts
 const preferPropDefaultTrue = (prop, context) => prop === false ? false : prop ? true : !(context === false);
 const preferPropDefaultFalse = (prop, context) => prop ? true : prop === false ? false : !!context;
@@ -5114,6 +5690,22 @@ const prepareRuleGroup = (queryObject, { idGenerator = generateID } = {}) => {
 * Ensures that a rule or group is valid. See {@link prepareRule} and {@link prepareRuleGroup}.
 */
 const prepareRuleOrGroup = (rg, { idGenerator = generateID } = {}) => isRuleGroup(rg) ? prepareRuleGroup(rg, { idGenerator }) : prepareRule(rg, { idGenerator });
+/**
+* Resolves the query a query builder should render from the available sources, in precedence
+* order: the controlled `query`, then whatever is already in the store, then the uncontrolled
+* `defaultQuery`, then a freshly created empty group.
+*
+* The result is prepared with {@link prepareRuleGroup} unless it already has an `id`, which is
+* taken to mean it has been prepared before—most often because the caller is passing back the
+* object it received from `onQueryChange`.
+*
+* @group Query Tools
+*/
+const resolveCandidateQuery = (sources, options) => {
+	var _ref, _ref2, _sources$query;
+	const candidateQuery = (_ref = (_ref2 = (_sources$query = sources.query) !== null && _sources$query !== void 0 ? _sources$query : sources.storeQuery) !== null && _ref2 !== void 0 ? _ref2 : sources.defaultQuery) !== null && _ref !== void 0 ? _ref : sources.fallbackQuery;
+	return candidateQuery.id ? candidateQuery : prepareRuleGroup(candidateQuery, options);
+};
 //#endregion
 //#region src/utils/regenerateIDs.ts
 /**
@@ -5134,6 +5726,28 @@ const regenerateIDs = (subject, { idGenerator = generateID } = {}) => {
 //#endregion
 //#region src/utils/queryTools.ts
 /**
+* Whether a mutation targeting `pathOrID` is blocked by the given guards, and why.
+* Returns `null` when the mutation may proceed.
+*
+* Exported so that callers which run their own logic before mutating—such as a UI layer that
+* invokes a confirmation callback—can apply the same rules without duplicating them.
+*
+* @group Query Tools
+*/
+const getGuardAbortReason = (query, pathOrID, guards = {}, { asParent = false } = {}) => {
+	if (guards.queryDisabled) return asParent ? "parent-disabled" : "target-disabled";
+	if (!guards.respectDisabled || pathOrID === void 0) return null;
+	const path = Array.isArray(pathOrID) ? pathOrID : getPathOfID(pathOrID, query);
+	if (path && (pathIsDisabled(path, query) || pathIsDisabledByPaths(path, guards.disabledPaths))) return asParent ? "parent-disabled" : "target-disabled";
+	return null;
+};
+/**
+* Whether adding a group beneath `parentPath` would exceed `maxLevels`.
+*
+* @group Query Tools
+*/
+const exceedsMaxLevels = (parentPath, { maxLevels = Infinity } = {}) => !!parentPath && parentPath.length >= maxLevels;
+/**
 * Adds a rule or group to a query without mutating the original query.
 *
 * @returns A new query with the rule or group added.
@@ -5149,9 +5763,42 @@ const add = (query, ruleOrGroup, parentPathOrID, options = {}) => produce(query,
 * @group Query Tools
 */
 const addInPlace = (query, ruleOrGroup, parentPathOrID, options = {}) => {
-	const { combinators = defaultCombinators, combinatorPreceding, idGenerator = generateID } = options;
+	const { combinators = defaultCombinators, combinatorPreceding, idGenerator = generateID, onAbort } = options;
 	const parent = Array.isArray(parentPathOrID) ? findPath(parentPathOrID, query) : findID(parentPathOrID, query);
-	if (!parent || !isRuleGroup(parent)) return query;
+	if (!parent) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "parent-not-found",
+			operation: "add",
+			pathOrID: parentPathOrID
+		});
+		return query;
+	}
+	if (!isRuleGroup(parent)) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "parent-not-a-group",
+			operation: "add",
+			pathOrID: parentPathOrID
+		});
+		return query;
+	}
+	const parentPath = Array.isArray(parentPathOrID) ? parentPathOrID : getPathOfID(parentPathOrID, query);
+	const addGuardReason = getGuardAbortReason(query, parentPath, options, { asParent: true });
+	if (addGuardReason) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: addGuardReason,
+			operation: "add",
+			pathOrID: parentPathOrID
+		});
+		return query;
+	}
+	if (isRuleGroup(ruleOrGroup) && exceedsMaxLevels(parentPath, options)) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "max-levels-exceeded",
+			operation: "add",
+			pathOrID: parentPathOrID
+		});
+		return query;
+	}
 	if (isRuleGroupTypeIC(parent) && parent.rules.length > 0) {
 		const prevCombinator = parent.rules.at(-2);
 		parent.rules.push(combinatorPreceding !== null && combinatorPreceding !== void 0 ? combinatorPreceding : typeof prevCombinator === "string" ? prevCombinator : getFirstOption(combinators));
@@ -5172,7 +5819,7 @@ const updatePropRank = {
 	value: 4
 };
 /** Stable-sorts `[prop, value]` entries by {@link updatePropRank}. */
-const orderUpdateEntries = (entries) => entries.sort((x, y) => {
+const orderUpdateEntries = (entries) => entries.toSorted((x, y) => {
 	var _updatePropRank$x$, _updatePropRank$y$;
 	return ((_updatePropRank$x$ = updatePropRank[x[0]]) !== null && _updatePropRank$x$ !== void 0 ? _updatePropRank$x$ : 3) - ((_updatePropRank$y$ = updatePropRank[y[0]]) !== null && _updatePropRank$y$ !== void 0 ? _updatePropRank$y$ : 3);
 });
@@ -5243,19 +5890,69 @@ const updateInPlace = ((query, a, b, c, d) => applyUpdatesInPlace(query, a, b, c
 * Updates a single property of a rule or group within a query in place.
 */
 const updateInPlaceSingle = (query, prop, value, pathOrID, options = {}) => {
-	const { resetOnFieldChange: _resetOnFieldChange = true, resetOnOperatorChange = false, getRuleDefaultOperator = () => "=", getValueSources = () => ["value"], getRuleDefaultValue = () => "", getMatchModes = () => [] } = options;
+	const { resetOnFieldChange: _resetOnFieldChange = true, resetOnOperatorChange = false, getRuleDefaultOperator = () => "=", getValueSources = () => ["value"], getRuleDefaultValue = () => "", getMatchModes = () => [], onAbort } = options;
 	let resetOnFieldChange = _resetOnFieldChange;
 	const path = Array.isArray(pathOrID) ? pathOrID : getPathOfID(pathOrID, query);
-	if (!path) return query;
+	if (!path) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "target-not-found",
+			operation: "update",
+			pathOrID
+		});
+		return query;
+	}
+	const updateGuards = prop === "disabled" ? { queryDisabled: options.queryDisabled } : options;
+	const updateGuardReason = getGuardAbortReason(query, path, updateGuards);
+	if (updateGuardReason) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: updateGuardReason,
+			operation: "update",
+			pathOrID
+		});
+		return query;
+	}
 	if (prop === "combinator" && !isRuleGroupType(query)) {
-		const parentRules = findPath(getParentPath(path), query).rules;
-		if (path.at(-1) % 2 === 1) parentRules[path.at(-1)] = value;
+		const parent = findPath(getParentPath(path), query);
+		if (!parent || !isRuleGroup(parent)) {
+			onAbort === null || onAbort === void 0 || onAbort({
+				reason: "target-not-found",
+				operation: "update",
+				pathOrID
+			});
+			return query;
+		}
+		const parentRules = parent.rules;
+		if (path.at(-1) % 2 === 1) if (parentRules[path.at(-1)] === value) onAbort === null || onAbort === void 0 || onAbort({
+			reason: "no-change",
+			operation: "update",
+			pathOrID
+		});
+		else parentRules[path.at(-1)] = value;
+		else onAbort === null || onAbort === void 0 || onAbort({
+			reason: "not-a-combinator-slot",
+			operation: "update",
+			pathOrID
+		});
 		return query;
 	}
 	const ruleOrGroup = findPath(path, query);
-	if (!ruleOrGroup) return query;
+	if (!ruleOrGroup) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "target-not-found",
+			operation: "update",
+			pathOrID
+		});
+		return query;
+	}
 	const isGroup = isRuleGroup(ruleOrGroup);
-	if (ruleOrGroup[prop] === value) return query;
+	if (ruleOrGroup[prop] === value) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "no-change",
+			operation: "update",
+			pathOrID
+		});
+		return query;
+	}
 	if (prop !== "valueSource") ruleOrGroup[prop] = value;
 	if (isGroup) return query;
 	let resetValueSource = false;
@@ -5302,7 +5999,7 @@ const updateInPlaceSingle = (query, prop, value, pathOrID, options = {}) => {
 *
 * @group Query Tools
 */
-const remove = (query, pathOrID) => produce(query, (q) => removeInPlace(q, pathOrID));
+const remove = (query, pathOrID, options = {}) => produce(query, (q) => removeInPlace(q, pathOrID, options));
 /**
 * Removes a rule or group from a query in place.
 *
@@ -5310,20 +6007,53 @@ const remove = (query, pathOrID) => produce(query, (q) => removeInPlace(q, pathO
 *
 * @group Query Tools
 */
-const removeInPlace = (query, pathOrID) => {
+const removeInPlace = (query, pathOrID, options = {}) => {
+	const { onAbort } = options;
 	const path = Array.isArray(pathOrID) ? pathOrID : getPathOfID(pathOrID, query);
-	if (!path || path.length === 0 || !isRuleGroupType(query) && !findPath(path, query)) return query;
-	const index = path.at(-1);
-	const parent = findPath(getParentPath(path), query);
-	if (parent && isRuleGroup(parent)) if (!isRuleGroupType(parent) && parent.rules.length > 1) {
-		const idxStartDelete = index === 0 ? 0 : index - 1;
-		parent.rules.splice(idxStartDelete, 2);
-	} else parent.rules.splice(index, 1);
-	return query;
-};
-const getNextPath = (query, currentPath, newPathOrShiftDirection) => {
-	if (Array.isArray(newPathOrShiftDirection)) return newPathOrShiftDirection;
-	const ic = isRuleGroupTypeIC(query);
+	if (!path) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "target-not-found",
+			operation: "remove",
+			pathOrID
+		});
+		return query;
+	}
+	if (path.length === 0) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "root-not-allowed",
+			operation: "remove",
+			pathOrID
+		});
+		return query;
+	}
+	const removeGuardReason = getGuardAbortReason(query, path, options);
+	if (removeGuardReason) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: removeGuardReason,
+			operation: "remove",
+			pathOrID
+		});
+		return query;
+	}
+	if (!findPath(path, query)) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "target-not-found",
+			operation: "remove",
+			pathOrID
+		});
+		return query;
+	}
+	const index = path.at(-1);
+	const parent = findPath(getParentPath(path), query);
+	if (!isRuleGroupType(parent) && parent.rules.length > 1) {
+		const idxStartDelete = index === 0 ? 0 : index - 1;
+		parent.rules.splice(idxStartDelete, 2);
+	} else parent.rules.splice(index, 1);
+	return query;
+};
+const getNextPath = (query, currentPath, newPathOrShiftDirection) => {
+	if (Array.isArray(newPathOrShiftDirection)) return newPathOrShiftDirection;
+	const ic = isRuleGroupTypeIC(query);
 	if (newPathOrShiftDirection === "up") if (pathsAreEqual(currentPath, [0])) return currentPath;
 	else if (currentPath.at(-1) === 0) {
 		const parentPath = getParentPath(currentPath);
@@ -5340,7 +6070,8 @@ const getNextPath = (query, currentPath, newPathOrShiftDirection) => {
 		return [...getParentPath(parentPath), parentPath.at(-1) + 1];
 	} else {
 		const evaluationPath = [...getParentPath(currentPath), currentPath.at(-1) + (ic ? 2 : 1)];
-		if (isRuleGroup(findPath(evaluationPath, query))) return [...evaluationPath, 0];
+		const entityToEvaluate = findPath(evaluationPath, query);
+		if (isRuleGroup(entityToEvaluate)) return [...evaluationPath, 0];
 		else return [...getParentPath(currentPath), currentPath.at(-1) + (ic ? 3 : 2)];
 	}
 	return currentPath;
@@ -5363,13 +6094,67 @@ const move = (query, oldPathOrID, newPath, options = {}) => produce(query, (q) =
 * @group Query Tools
 */
 const moveInPlace = (query, oldPathOrID, newPath, options = {}) => {
-	const { clone = false, combinators = defaultCombinators, idGenerator = generateID } = options;
+	const { clone = false, combinators = defaultCombinators, idGenerator = generateID, onAbort } = options;
 	const oldPath = Array.isArray(oldPathOrID) ? oldPathOrID : getPathOfID(oldPathOrID, query);
-	if (!oldPath) return query;
-	const nextPath = getNextPath(query, oldPath, newPath);
-	if (oldPath.length === 0 || pathsAreEqual(oldPath, nextPath) || !findPath(getParentPath(nextPath), query)) return query;
+	if (!oldPath) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "target-not-found",
+			operation: "move",
+			pathOrID: oldPathOrID
+		});
+		return query;
+	}
 	const ruleOrGroupOriginal = findPath(oldPath, query);
-	if (!ruleOrGroupOriginal) return query;
+	if (!ruleOrGroupOriginal) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "target-not-found",
+			operation: "move",
+			pathOrID: oldPathOrID
+		});
+		return query;
+	}
+	const nextPath = getNextPath(query, oldPath, newPath);
+	if (oldPath.length === 0) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "root-not-allowed",
+			operation: "move",
+			pathOrID: oldPathOrID
+		});
+		return query;
+	}
+	const moveGuardReason = getGuardAbortReason(query, oldPath, options);
+	if (moveGuardReason) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: moveGuardReason,
+			operation: "move",
+			pathOrID: oldPathOrID
+		});
+		return query;
+	}
+	if (pathsAreEqual(oldPath, nextPath)) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "same-location",
+			operation: "move",
+			pathOrID: oldPathOrID
+		});
+		return query;
+	}
+	if (!findPath(getParentPath(nextPath), query)) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "destination-not-found",
+			operation: "move",
+			pathOrID: newPath
+		});
+		return query;
+	}
+	if (!clone && isAncestor(oldPath, nextPath)) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "destination-not-found",
+			operation: "move",
+			pathOrID: newPath
+		});
+		return query;
+	}
 	const ruleOrGroup = clone ? regenerateIDs(isDraft(ruleOrGroupOriginal) ? current(ruleOrGroupOriginal) : ruleOrGroupOriginal, { idGenerator }) : ruleOrGroupOriginal;
 	const independentCombinators = isRuleGroupTypeIC(query);
 	const parentOfRuleToRemove = findPath(getParentPath(oldPath), query);
@@ -5382,15 +6167,18 @@ const moveInPlace = (query, oldPathOrID, newPath, options = {}) => {
 		parentOfRuleToRemove.rules.splice(idxStartDelete, deleteLength);
 	}
 	const newNewPath = [...nextPath];
+	if (independentCombinators && newNewPath.at(-1) % 2 === 1) newNewPath[newNewPath.length - 1] += 1;
 	const commonAncestorPath = getCommonAncestorPath(oldPath, nextPath);
-	if (!clone && oldPath.length === commonAncestorPath.length + 1 && nextPath[commonAncestorPath.length] > oldPath[commonAncestorPath.length]) newNewPath[commonAncestorPath.length] -= independentCombinators ? 2 : 1;
-	const parentToInsertInto = findPath(getParentPath(newNewPath), query);
+	if (!clone && oldPath.length === commonAncestorPath.length + 1 && newNewPath[commonAncestorPath.length] > oldPath[commonAncestorPath.length]) newNewPath[commonAncestorPath.length] -= independentCombinators ? 2 : 1;
+	const newNewParentPath = getParentPath(newNewPath);
+	const parentToInsertInto = findPath(newNewParentPath, query);
 	const newIndex = newNewPath.at(-1);
+	const spliceIndex = independentCombinators && newIndex > 0 ? newIndex - 1 : newIndex;
 	/**
 	* This function 1) glosses over the need for type assertions to splice directly
 	* into `parentToInsertInto.rules`, and 2) shortens the actual insertion code.
 	*/
-	const insertRuleOrGroup = (...args) => parentToInsertInto.rules.splice(newIndex, 0, ...args);
+	const insertRuleOrGroup = (...args) => parentToInsertInto.rules.splice(spliceIndex, 0, ...args);
 	if (parentToInsertInto.rules.length === 0 || !independentCombinators) insertRuleOrGroup(ruleOrGroup);
 	else if (newIndex === 0) if (ruleToRemoveIndex === 0 && oldNextCombinator) insertRuleOrGroup(ruleOrGroup, oldNextCombinator);
 	else {
@@ -5400,7 +6188,7 @@ const moveInPlace = (query, oldPathOrID, newPath, options = {}) => {
 	else if (oldPrevCombinator) insertRuleOrGroup(oldPrevCombinator, ruleOrGroup);
 	else {
 		var _ref5, _parentToInsertInto$r2;
-		insertRuleOrGroup((_ref5 = (_parentToInsertInto$r2 = parentToInsertInto.rules[newIndex - 2]) !== null && _parentToInsertInto$r2 !== void 0 ? _parentToInsertInto$r2 : oldNextCombinator) !== null && _ref5 !== void 0 ? _ref5 : getFirstOption(combinators), ruleOrGroup);
+		insertRuleOrGroup((_ref5 = (_parentToInsertInto$r2 = parentToInsertInto.rules[spliceIndex - 2]) !== null && _parentToInsertInto$r2 !== void 0 ? _parentToInsertInto$r2 : oldNextCombinator) !== null && _ref5 !== void 0 ? _ref5 : getFirstOption(combinators), ruleOrGroup);
 	}
 	return query;
 };
@@ -5420,9 +6208,42 @@ const insert = (query, ruleOrGroup, path, options = {}) => produce(query, (q) =>
 * @group Query Tools
 */
 const insertInPlace = (query, ruleOrGroup, path, options = {}) => {
-	const { combinators = defaultCombinators, combinatorPreceding, combinatorSucceeding, idGenerator = generateID, replace = false } = options;
+	const { combinators = defaultCombinators, combinatorPreceding, combinatorSucceeding, idGenerator = generateID, replace = false, onAbort } = options;
 	const parentToInsertInto = findPath(getParentPath(path), query);
-	if (!parentToInsertInto || !isRuleGroup(parentToInsertInto)) return query;
+	if (!parentToInsertInto) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "parent-not-found",
+			operation: "insert",
+			pathOrID: path
+		});
+		return query;
+	}
+	if (!isRuleGroup(parentToInsertInto)) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "parent-not-a-group",
+			operation: "insert",
+			pathOrID: path
+		});
+		return query;
+	}
+	const parentPath = getParentPath(path);
+	const insertGuardReason = getGuardAbortReason(query, parentPath, options, { asParent: true });
+	if (insertGuardReason) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: insertGuardReason,
+			operation: "insert",
+			pathOrID: path
+		});
+		return query;
+	}
+	if (isRuleGroup(ruleOrGroup) && exceedsMaxLevels(parentPath, options)) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "max-levels-exceeded",
+			operation: "insert",
+			pathOrID: path
+		});
+		return query;
+	}
 	const rorg = regenerateIDs(ruleOrGroup, { idGenerator });
 	const independentCombinators = isRuleGroupTypeIC(query);
 	const newIndex = path.at(-1);
@@ -5470,15 +6291,85 @@ const group = (query, sourcePathOrID, targetPathOrID, options = {}) => produce(q
 * @group Query Tools
 */
 const groupInPlace = (query, sourcePathOrID, targetPathOrID, options = {}) => {
-	const { clone = false, combinators = defaultCombinators, idGenerator = generateID } = options;
+	const { clone = false, combinators = defaultCombinators, idGenerator = generateID, onAbort } = options;
 	const sourcePath = Array.isArray(sourcePathOrID) ? sourcePathOrID : getPathOfID(sourcePathOrID, query);
 	const targetPath = Array.isArray(targetPathOrID) ? targetPathOrID : getPathOfID(targetPathOrID, query);
-	if (!sourcePath || !targetPath) return query;
+	if (!sourcePath) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "target-not-found",
+			operation: "group",
+			pathOrID: sourcePathOrID
+		});
+		return query;
+	}
+	if (!targetPath) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "target-not-found",
+			operation: "group",
+			pathOrID: targetPathOrID
+		});
+		return query;
+	}
 	const nextPath = getNextPath(query, sourcePath, targetPath);
-	if (sourcePath.length === 0 || pathsAreEqual(sourcePath, nextPath) || !findPath(getParentPath(nextPath), query)) return query;
+	if (sourcePath.length === 0) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "root-not-allowed",
+			operation: "group",
+			pathOrID: sourcePathOrID
+		});
+		return query;
+	}
+	const groupGuardReason = getGuardAbortReason(query, sourcePath, options);
+	if (groupGuardReason) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: groupGuardReason,
+			operation: "group",
+			pathOrID: sourcePathOrID
+		});
+		return query;
+	}
+	if (pathsAreEqual(sourcePath, nextPath)) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "same-location",
+			operation: "group",
+			pathOrID: sourcePathOrID
+		});
+		return query;
+	}
+	if (!findPath(getParentPath(nextPath), query)) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "destination-not-found",
+			operation: "group",
+			pathOrID: targetPathOrID
+		});
+		return query;
+	}
+	if (!clone && isAncestor(sourcePath, nextPath)) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "destination-not-found",
+			operation: "group",
+			pathOrID: targetPathOrID
+		});
+		return query;
+	}
 	const sourceRuleOrGroupOriginal = findPath(sourcePath, query);
 	const targetRuleOrGroup = findPath(targetPath, query);
-	if (!sourceRuleOrGroupOriginal || !targetRuleOrGroup) return query;
+	if (!sourceRuleOrGroupOriginal) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "target-not-found",
+			operation: "group",
+			pathOrID: sourcePathOrID
+		});
+		return query;
+	}
+	if (!targetRuleOrGroup) {
+		onAbort === null || onAbort === void 0 || onAbort({
+			reason: "target-not-found",
+			operation: "group",
+			pathOrID: targetPathOrID
+		});
+		return query;
+	}
 	const sourceRuleOrGroup = clone ? regenerateIDs(isDraft(sourceRuleOrGroupOriginal) ? current(sourceRuleOrGroupOriginal) : sourceRuleOrGroupOriginal, { idGenerator }) : sourceRuleOrGroupOriginal;
 	const independentCombinators = isRuleGroupTypeIC(query);
 	const parentOfRuleToRemove = findPath(getParentPath(sourcePath), query);
@@ -5491,7 +6382,8 @@ const groupInPlace = (query, sourcePathOrID, targetPathOrID, options = {}) => {
 	const newNewPath = [...nextPath];
 	const commonAncestorPath = getCommonAncestorPath(sourcePath, nextPath);
 	if (!clone && sourcePath.length === commonAncestorPath.length + 1 && nextPath[commonAncestorPath.length] > sourcePath[commonAncestorPath.length]) newNewPath[commonAncestorPath.length] -= independentCombinators ? 2 : 1;
-	const parentOfTargetPath = findPath(getParentPath(newNewPath), query);
+	const newNewParentPath = getParentPath(newNewPath);
+	const parentOfTargetPath = findPath(newNewParentPath, query);
 	const targetPathIndex = newNewPath.at(-1);
 	parentOfTargetPath.rules.splice(targetPathIndex, 1, prepareRuleOrGroup(independentCombinators ? { rules: [
 		targetRuleOrGroup,
@@ -5504,6 +6396,1301 @@ const groupInPlace = (query, sourcePathOrID, targetPathOrID, options = {}) => {
 	return query;
 };
 //#endregion
-export { LogType, TestID, add, addInPlace, betweenOperators, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, convertFromIC, convertQuery, convertToIC, cypherCombinatorMap, defaultCELValueProcessor, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleGroupProcessorTanStackDB, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultSpELValueProcessor, defaultTranslations, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFirstOption, getLikeWildcards, getMatchModesUtil, getNLTranslataion, getOption, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getRuleDefaultValue, getSQLConcat, getValidationClassNames, getValueSourcesUtil, group, groupInPlace, groupInvalidReasons, inOperators, insert, insertInPlace, isAncestor, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isUnsafeKey, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeAnyTranslation, mergeAnyTranslations, mergeClassnames, mongoDbFallback, mongoOperators, move, moveInPlace, normalizeConstituentWordOrder, nullFreeArray, nullOperators, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathsAreEqual, preferAnyProp, preferFlagProps, preferProp, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, queryBuilderFlagDefaults, regenerateID, regenerateIDs, relationalOperators, remove, removeInPlace, rootPath, shouldRenderAsNumber, sparqlVar, splitBy, sqlDialectPresets, standardClassnames, stripParamPrefix, substringOperators, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update, updateInPlace, uuidV4regex, withParamPrefix, wrapLikeFragment };
+//#region src/utils/queryActions.ts
+/**
+* Builds the query builder's six mutation handlers as pure functions of the current query.
+*
+* This is the framework-agnostic core of the action handlers in `useQueryBuilderSchema`. It owns
+* the policy that surrounds the query tools—disabled gating, the confirmation callback protocol,
+* `maxLevels`, and debug logging—so an implementation only has to supply its own storage: read
+* the current query, call the action, and apply a non-`undefined` result.
+*
+* @group Query Tools
+*/
+const createQueryActions = (config = {}) => {
+	const { qbId, combinators, idGenerator, maxLevels = Infinity, queryDisabled, respectDisabled = true, disabledPaths, resetOnFieldChange, resetOnOperatorChange, getRuleDefaultOperator, getValueSources, getRuleDefaultValue, getMatchModes, onAddRule, onAddGroup, onRemove, onMoveRule, onMoveGroup, onGroupRule, onGroupGroup, onLog } = config;
+	const log = (payload) => onLog === null || onLog === void 0 ? void 0 : onLog(_objectSpread2({ qbId }, payload));
+	const guards = {
+		respectDisabled,
+		queryDisabled,
+		disabledPaths
+	};
+	/** Whether the mutation is blocked, using the same rules the query tools apply internally. */
+	const blocked = (query, path, asParent = false) => !!getGuardAbortReason(query, path, guards, { asParent });
+	return {
+		addRule: (query, rule, parentPath, context) => {
+			if (blocked(query, parentPath, true)) {
+				log({
+					type: LogType.parentPathDisabled,
+					rule,
+					parentPath,
+					query
+				});
+				return;
+			}
+			const nextRule = onAddRule ? onAddRule(rule, parentPath, query, context) : true;
+			if (!nextRule) {
+				log({
+					type: LogType.onAddRuleFalse,
+					rule,
+					parentPath,
+					query
+				});
+				return;
+			}
+			const newRule = nextRule === true ? rule : nextRule;
+			const newQuery = add(query, newRule, parentPath, {
+				combinators,
+				combinatorPreceding: newRule.combinatorPreceding,
+				idGenerator
+			});
+			log({
+				type: LogType.add,
+				query,
+				newQuery,
+				newRule,
+				parentPath
+			});
+			return newQuery;
+		},
+		addGroup: (query, ruleGroup, parentPath, context) => {
+			var _combinatorPreceding;
+			if (parentPath.length >= maxLevels) return void 0;
+			if (blocked(query, parentPath, true)) {
+				log({
+					type: LogType.parentPathDisabled,
+					ruleGroup,
+					parentPath,
+					query
+				});
+				return;
+			}
+			const nextGroup = onAddGroup ? onAddGroup(ruleGroup, parentPath, query, context) : true;
+			if (!nextGroup) {
+				log({
+					type: LogType.onAddGroupFalse,
+					ruleGroup,
+					parentPath,
+					query
+				});
+				return;
+			}
+			const newGroup = nextGroup === true ? ruleGroup : nextGroup;
+			const newQuery = add(query, newGroup, parentPath, {
+				combinators,
+				combinatorPreceding: (_combinatorPreceding = newGroup.combinatorPreceding) !== null && _combinatorPreceding !== void 0 ? _combinatorPreceding : void 0,
+				idGenerator
+			});
+			log({
+				type: LogType.add,
+				query,
+				newQuery,
+				newGroup,
+				parentPath
+			});
+			return newQuery;
+		},
+		propChange: (query, prop, value, path) => {
+			if (getGuardAbortReason(query, path, prop === "disabled" ? { queryDisabled } : guards)) {
+				log({
+					type: LogType.pathDisabled,
+					path,
+					prop,
+					value,
+					query
+				});
+				return;
+			}
+			const newQuery = update(query, prop, value, path, {
+				resetOnFieldChange,
+				resetOnOperatorChange,
+				getRuleDefaultOperator,
+				getValueSources,
+				getRuleDefaultValue,
+				getMatchModes
+			});
+			log({
+				type: LogType.update,
+				query,
+				newQuery,
+				prop,
+				value,
+				path
+			});
+			return newQuery;
+		},
+		removeRuleOrGroup: (query, path, context) => {
+			if (blocked(query, path)) {
+				log({
+					type: LogType.pathDisabled,
+					path,
+					query
+				});
+				return;
+			}
+			const ruleOrGroup = findPath(path, query);
+			/* v8 ignore next -- @preserve */
+			if (!ruleOrGroup) return void 0;
+			if (onRemove && !onRemove(ruleOrGroup, path, query, context)) {
+				log({
+					type: LogType.onRemoveFalse,
+					ruleOrGroup,
+					path,
+					query
+				});
+				return;
+			}
+			const newQuery = remove(query, path);
+			log({
+				type: LogType.remove,
+				query,
+				newQuery,
+				path,
+				ruleOrGroup
+			});
+			return newQuery;
+		},
+		moveRule: (query, oldPath, newPath, clone, context) => {
+			if (blocked(query, oldPath)) {
+				log({
+					type: LogType.pathDisabled,
+					oldPath,
+					newPath,
+					query
+				});
+				return;
+			}
+			const ruleOrGroup = findPath(oldPath, query);
+			if (!ruleOrGroup) return void 0;
+			const nextQuery = move(query, oldPath, newPath, {
+				clone,
+				combinators,
+				idGenerator
+			});
+			const isGroup = isRuleGroup(ruleOrGroup);
+			const callback = isGroup ? onMoveGroup : onMoveRule;
+			const callbackResult = callback ? callback(ruleOrGroup, oldPath, newPath, query, nextQuery, {
+				clone,
+				combinators
+			}, context) : true;
+			if (!callbackResult) {
+				log({
+					type: isGroup ? LogType.onMoveGroupFalse : LogType.onMoveRuleFalse,
+					ruleOrGroup,
+					oldPath,
+					newPath,
+					clone,
+					query,
+					nextQuery
+				});
+				return;
+			}
+			const newQuery = isRuleGroup(callbackResult) ? callbackResult : nextQuery;
+			log({
+				type: LogType.move,
+				query,
+				newQuery,
+				oldPath,
+				newPath,
+				clone
+			});
+			return newQuery;
+		},
+		groupRule: (query, sourcePath, targetPath, clone, context) => {
+			if (blocked(query, sourcePath)) {
+				log({
+					type: LogType.pathDisabled,
+					sourcePath,
+					targetPath,
+					query
+				});
+				return;
+			}
+			const ruleOrGroup = findPath(sourcePath, query);
+			if (!ruleOrGroup) return void 0;
+			const nextQuery = group(query, sourcePath, targetPath, {
+				clone,
+				combinators,
+				idGenerator
+			});
+			const isGroup = isRuleGroup(ruleOrGroup);
+			const callback = isGroup ? onGroupGroup : onGroupRule;
+			const callbackResult = callback ? callback(ruleOrGroup, sourcePath, targetPath, query, nextQuery, {
+				clone,
+				combinators
+			}, context) : true;
+			if (!callbackResult) {
+				log({
+					type: isGroup ? LogType.onGroupGroupFalse : LogType.onGroupRuleFalse,
+					ruleOrGroup,
+					sourcePath,
+					targetPath,
+					clone,
+					query,
+					nextQuery
+				});
+				return;
+			}
+			const newQuery = isRuleGroup(callbackResult) ? callbackResult : nextQuery;
+			log({
+				type: LogType.group,
+				query,
+				newQuery,
+				sourcePath,
+				targetPath,
+				clone
+			});
+			return newQuery;
+		}
+	};
+};
+//#endregion
+//#region src/utils/ruleFactory.ts
+/**
+* Creates a rule from the given configuration, applying the same precedence as the
+* `QueryBuilder` component. The `value` is computed in a second pass, once `field`, `operator`,
+* and `valueSource` are known, since the default value depends on all three.
+*
+* @group Query Tools
+*/
+const createRule = ({ fields, getDefaultField, getRuleDefaultOperator, getValueSources, getMatchModes, getRuleDefaultValue, idGenerator = generateID }) => {
+	var _getFirstOption, _getFirstOption2;
+	let field = (_getFirstOption = getFirstOption(fields)) !== null && _getFirstOption !== void 0 ? _getFirstOption : "";
+	if (getDefaultField) if (typeof getDefaultField === "function") {
+		const defaultField = getDefaultField(fields);
+		if (defaultField) field = defaultField;
+	} else field = getDefaultField;
+	const fieldData = getOption(fields, field);
+	const operator = getRuleDefaultOperator(field);
+	const valueSource = (_getFirstOption2 = getFirstOption(getValueSources(field, operator, { fieldData }))) !== null && _getFirstOption2 !== void 0 ? _getFirstOption2 : "value";
+	const matchMode = getFirstOption(getMatchModes(field, { fieldData }));
+	const newRule = _objectSpread2({
+		id: idGenerator(),
+		field,
+		operator,
+		valueSource,
+		value: ""
+	}, matchMode ? { match: {
+		mode: matchMode,
+		threshold: 1
+	} } : null);
+	return _objectSpread2(_objectSpread2({}, newRule), {}, { value: getRuleDefaultValue(newRule) });
+};
+/**
+* Creates a group from the given configuration. Pass `true` for `independentCombinators` to omit
+* the `combinator` property.
+*
+* The group's own `id` is generated _before_ any contained rule's, matching the order the
+* `QueryBuilder` component has always used. This is observable when `idGenerator` is
+* deterministic, as it often is in tests.
+*
+* @group Query Tools
+*/
+const createRuleGroup = ({ combinators, addRuleToNewGroups, createRule: createRuleMain, idGenerator = generateID }, independentCombinators) => {
+	var _getFirstOption3;
+	const id = idGenerator();
+	const rules = addRuleToNewGroups ? [createRuleMain()] : [];
+	if (independentCombinators) return {
+		id,
+		rules,
+		not: false
+	};
+	return {
+		id,
+		rules,
+		combinator: (_getFirstOption3 = getFirstOption(combinators)) !== null && _getFirstOption3 !== void 0 ? _getFirstOption3 : "",
+		not: false
+	};
+};
+//#endregion
+//#region src/utils/signature.ts
+/**
+* Signature returned when a change alters the _shape_ of the query—rules or groups added,
+* removed, moved, or reordered—rather than the properties of a single node. Structural changes
+* never coalesce with each other, so each one produces its own history entry.
+*/
+const structuralSignature = "~structural";
+/**
+* Signature returned when two queries differ by reference only, with no observable difference
+* in their properties.
+*/
+const unchangedSignature = "";
+/**
+* Returns the list of property names that differ between two nodes, ignoring `rules` (which is
+* compared structurally by the caller).
+*/
+const changedProps = (prev, next) => {
+	const keys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)]);
+	keys.delete("rules");
+	const changed = [];
+	for (const key of keys) if (!Object.is(prev[key], next[key])) changed.push(key);
+	return changed.toSorted();
+};
+const signatureOfNode = (prev, next, parentId, index) => {
+	var _next$id3;
+	if (prev === next) return "";
+	if (typeof prev === "string" || typeof next === "string") return typeof prev === typeof next ? `${parentId}:combinator[${index}]` : structuralSignature;
+	const prevIsGroup = isRuleGroup(prev);
+	const nextIsGroup = isRuleGroup(next);
+	if (prevIsGroup !== nextIsGroup) return structuralSignature;
+	if (!prevIsGroup || !nextIsGroup) {
+		var _next$id;
+		const props = changedProps(prev, next);
+		return props.length === 0 ? "" : `${(_next$id = next.id) !== null && _next$id !== void 0 ? _next$id : ""}:${props.join(",")}`;
+	}
+	if (prev.rules.length !== next.rules.length) return structuralSignature;
+	const ownProps = changedProps(prev, next);
+	let changedIndex = -1;
+	for (const [i, prevRule] of prev.rules.entries()) if (prevRule !== next.rules[i]) {
+		if (changedIndex !== -1) return structuralSignature;
+		changedIndex = i;
+	}
+	if (changedIndex === -1) {
+		var _next$id2;
+		return ownProps.length === 0 ? "" : `${(_next$id2 = next.id) !== null && _next$id2 !== void 0 ? _next$id2 : ""}:${ownProps.join(",")}`;
+	}
+	if (ownProps.length > 0) return structuralSignature;
+	return signatureOfNode(prev.rules[changedIndex], next.rules[changedIndex], (_next$id3 = next.id) !== null && _next$id3 !== void 0 ? _next$id3 : "", changedIndex);
+};
+/**
+* Describes _what changed_ between two versions of a query as a short string, so that
+* consecutive edits to the same property of the same rule (e.g. typing in a value editor) can
+* be recognized and coalesced into a single history entry.
+*
+* Returns {@link structuralSignature} for changes to the shape of the query, {@link unchangedSignature} when the
+* two queries differ by reference only, and `"<id>:<props>"` otherwise.
+*
+* The walk prunes on reference equality, so it costs O(depth) rather than O(size) for the
+* single-node edits that make up the overwhelming majority of changes.
+*
+* Note that this relies on the structural sharing that Immer—and therefore every query
+* produced by RQB's own update functions—guarantees: nodes that did not change keep their
+* identity. A query that has been wholly rebuilt (deep-cloned, round-tripped through JSON,
+* re-parsed from a string) shares no identity with its predecessor, so it is reported as
+* {@link structuralSignature} and will not coalesce. That is a graceful degradation—every change simply
+* gets its own history entry—but controlled components that clone the query on every change
+* will not benefit from coalescing.
+*/
+const signatureOf = (prev, next) => signatureOfNode(prev, next, "", -1);
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/classPrivateMethodInitSpec.js
+function _classPrivateMethodInitSpec(e, a) {
+	_checkPrivateRedeclaration(e, a), a.add(e);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/classPrivateFieldSet2.js
+function _classPrivateFieldSet2(s, a, r) {
+	return s.set(_assertClassBrand(s, a), r), r;
+}
+//#endregion
+//#region src/utils/QueryManager.ts
+const _excluded = ["strict", "onInvalidTarget"];
+const _excluded2 = ["strict", "onInvalidTarget"];
+const _excluded3 = ["strict", "onInvalidTarget"];
+const _excluded4 = ["strict", "onInvalidTarget"];
+const _excluded5 = ["strict", "onInvalidTarget"];
+const _excluded6 = ["strict", "onInvalidTarget"];
+let _Symbol$iterator;
+/**
+* Abort reasons that {@link QueryManager}'s `strict` mode treats as errors. The remaining
+* reasons—`"same-location"` and `"no-change"`—describe valid operations that had nothing to do,
+* so they are reported to `onInvalidTarget` but never throw.
+*
+* @group Query Tools
+*/
+const strictAbortReasons = [
+	"target-not-found",
+	"parent-not-found",
+	"parent-not-a-group",
+	"destination-not-found",
+	"root-not-allowed",
+	"not-a-combinator-slot",
+	"target-disabled",
+	"parent-disabled",
+	"max-levels-exceeded"
+];
+const strictAbortReasonSet = new Set(strictAbortReasons);
+/**
+* Thrown by {@link QueryManager} methods in `strict` mode when an operation cannot be carried
+* out because its target could not be used.
+*
+* @group Query Tools
+*/
+var QueryManagerError = class QueryManagerError extends Error {
+	constructor(info) {
+		super(`QueryManager: "${info.operation}" aborted (${info.reason})${info.pathOrID === void 0 ? "" : ` for target ${JSON.stringify(info.pathOrID)}`}.`);
+		_defineProperty(this, "code", void 0);
+		_defineProperty(this, "info", void 0);
+		this.name = "QueryManagerError";
+		this.code = info.reason;
+		this.info = info;
+		Object.setPrototypeOf(this, QueryManagerError.prototype);
+	}
+};
+var _query = /* @__PURE__ */ new WeakMap();
+var _options = /* @__PURE__ */ new WeakMap();
+var _fields = /* @__PURE__ */ new WeakMap();
+var _fieldMap = /* @__PURE__ */ new WeakMap();
+var _operators = /* @__PURE__ */ new WeakMap();
+var _combinators = /* @__PURE__ */ new WeakMap();
+var _idGenerator = /* @__PURE__ */ new WeakMap();
+var _validator = /* @__PURE__ */ new WeakMap();
+var _strict = /* @__PURE__ */ new WeakMap();
+var _respectDisabled = /* @__PURE__ */ new WeakMap();
+var _onInvalidTarget = /* @__PURE__ */ new WeakMap();
+var _listeners = /* @__PURE__ */ new WeakMap();
+var _historyEnabled = /* @__PURE__ */ new WeakMap();
+var _maxHistory = /* @__PURE__ */ new WeakMap();
+var _coalesceMs = /* @__PURE__ */ new WeakMap();
+var _now = /* @__PURE__ */ new WeakMap();
+var _past = /* @__PURE__ */ new WeakMap();
+var _future = /* @__PURE__ */ new WeakMap();
+var _lastSig = /* @__PURE__ */ new WeakMap();
+var _lastAt = /* @__PURE__ */ new WeakMap();
+var _batchDepth = /* @__PURE__ */ new WeakMap();
+var _batchSnapshot = /* @__PURE__ */ new WeakMap();
+var _historyBypassed = /* @__PURE__ */ new WeakMap();
+var _cacheFor = /* @__PURE__ */ new WeakMap();
+var _idPathIndex = /* @__PURE__ */ new WeakMap();
+var _validation = /* @__PURE__ */ new WeakMap();
+var _QueryManager_brand = /* @__PURE__ */ new WeakSet();
+_Symbol$iterator = Symbol.iterator;
+/**
+* Stateful wrapper around the {@link add}/{@link remove}/{@link update}/{@link move}/
+* {@link insert}/{@link group} query tools, plus rule/group factories, {@link defaultValidator
+* validation}, and {@link formatQuery formatting}.
+*
+* The query is held internally, so each method takes the same arguments as its `queryTools`
+* counterpart minus the leading `query` parameter, and returns the manager itself for chaining.
+* Mutations use the non-`InPlace` tools, so a query previously handed out by
+* {@link QueryManager.getQuery} is never modified.
+*
+* ```ts
+* const q = new QueryManager(undefined, { fields });
+* q.add(q.createRule()).add({ field: 'firstName', operator: '=', value: 'Steve' });
+* q.format('sql');
+* ```
+*
+* Like the underlying query tools, methods are a no-op when the target path or `id` can't be
+* resolved (including attempts to remove the root group). By default nothing is thrown; pass
+* `strict: true` to raise a {@link QueryManagerError} instead, or `onInvalidTarget` to observe
+* aborted operations without changing control flow.
+*
+* @group Query Tools
+*/
+var QueryManager = class QueryManager {
+	constructor(query, options = {}) {
+		var _options$idGenerator, _options$validator, _options$strict, _options$respectDisab, _options$history, _historyOptions$maxHi, _historyOptions$coale, _options$now, _options$operators, _options$combinators;
+		_classPrivateMethodInitSpec(this, _QueryManager_brand);
+		_classPrivateFieldInitSpec(this, _query, void 0);
+		_classPrivateFieldInitSpec(this, _options, void 0);
+		_classPrivateFieldInitSpec(this, _fields, void 0);
+		_classPrivateFieldInitSpec(this, _fieldMap, void 0);
+		_classPrivateFieldInitSpec(this, _operators, void 0);
+		_classPrivateFieldInitSpec(this, _combinators, void 0);
+		_classPrivateFieldInitSpec(this, _idGenerator, void 0);
+		_classPrivateFieldInitSpec(this, _validator, void 0);
+		_classPrivateFieldInitSpec(this, _strict, void 0);
+		_classPrivateFieldInitSpec(this, _respectDisabled, void 0);
+		_classPrivateFieldInitSpec(this, _onInvalidTarget, void 0);
+		_classPrivateFieldInitSpec(this, _listeners, /* @__PURE__ */ new Set());
+		_classPrivateFieldInitSpec(this, _historyEnabled, void 0);
+		_classPrivateFieldInitSpec(this, _maxHistory, void 0);
+		_classPrivateFieldInitSpec(this, _coalesceMs, void 0);
+		_classPrivateFieldInitSpec(this, _now, void 0);
+		_classPrivateFieldInitSpec(this, _past, []);
+		_classPrivateFieldInitSpec(this, _future, []);
+		_classPrivateFieldInitSpec(this, _lastSig, void 0);
+		_classPrivateFieldInitSpec(this, _lastAt, 0);
+		_classPrivateFieldInitSpec(this, _batchDepth, 0);
+		_classPrivateFieldInitSpec(this, _batchSnapshot, void 0);
+		_classPrivateFieldInitSpec(this, _historyBypassed, false);
+		_classPrivateFieldInitSpec(this, _cacheFor, void 0);
+		_classPrivateFieldInitSpec(this, _idPathIndex, void 0);
+		_classPrivateFieldInitSpec(this, _validation, void 0);
+		_defineProperty(
+			this,
+			/**
+			* The current query. The returned object is frozen and structurally shared, so it is safe to
+			* retain and compare by reference to detect changes.
+			*
+			* Like {@link QueryManager.subscribe}, this method is bound to the instance, so it can be
+			* passed as a bare reference (e.g. as the `getSnapshot` argument to `useSyncExternalStore`).
+			*/
+			"getQuery",
+			() => _classPrivateFieldGet2(_query, this)
+		);
+		_defineProperty(
+			this,
+			/**
+			* Registers a listener called after every change to the query, and returns a function that
+			* unregisters it. Mutations that resolve to a no-op do not notify, and a
+			* {@link QueryManager.batch batch} notifies once no matter how many changes it contains.
+			*
+			* Together with {@link QueryManager.getQuery}, this satisfies React's `useSyncExternalStore`
+			* contract. Both methods are bound to the instance, so they are stable references across
+			* renders and can be passed directly:
+			*
+			* ```ts
+			* const query = useSyncExternalStore(q.subscribe, q.getQuery);
+			* ```
+			*
+			* In React, prefer the `useQueryManager` hook from `react-querybuilder`, which wraps this.
+			*/
+			"subscribe",
+			(listener) => {
+				_classPrivateFieldGet2(_listeners, this).add(listener);
+				return () => {
+					_classPrivateFieldGet2(_listeners, this).delete(listener);
+				};
+			}
+		);
+		_classPrivateFieldSet2(_options, this, options);
+		_classPrivateFieldSet2(_idGenerator, this, (_options$idGenerator = options.idGenerator) !== null && _options$idGenerator !== void 0 ? _options$idGenerator : generateID);
+		_classPrivateFieldSet2(_validator, this, (_options$validator = options.validator) !== null && _options$validator !== void 0 ? _options$validator : defaultValidator);
+		_classPrivateFieldSet2(_strict, this, (_options$strict = options.strict) !== null && _options$strict !== void 0 ? _options$strict : false);
+		_classPrivateFieldSet2(_respectDisabled, this, (_options$respectDisab = options.respectDisabled) !== null && _options$respectDisab !== void 0 ? _options$respectDisab : true);
+		_classPrivateFieldSet2(_onInvalidTarget, this, options.onInvalidTarget);
+		const history = (_options$history = options.history) !== null && _options$history !== void 0 ? _options$history : false;
+		const historyOptions = typeof history === "object" ? history : {};
+		_classPrivateFieldSet2(_historyEnabled, this, history !== false);
+		_classPrivateFieldSet2(_maxHistory, this, (_historyOptions$maxHi = historyOptions.maxHistory) !== null && _historyOptions$maxHi !== void 0 ? _historyOptions$maxHi : 50);
+		_classPrivateFieldSet2(_coalesceMs, this, (_historyOptions$coale = historyOptions.coalesceMs) !== null && _historyOptions$coale !== void 0 ? _historyOptions$coale : 500);
+		_classPrivateFieldSet2(_now, this, (_options$now = options.now) !== null && _options$now !== void 0 ? _options$now : Date.now);
+		const { optionList: fields, optionsMap: fieldMap } = prepareOptionList({
+			optionList: options.fields,
+			baseOption: options.baseField,
+			autoSelectOption: options.autoSelectField
+		});
+		_classPrivateFieldSet2(_fields, this, freeze(fields, true));
+		_classPrivateFieldSet2(_fieldMap, this, freeze(fieldMap, true));
+		_classPrivateFieldSet2(_operators, this, prepareOptionList({
+			optionList: (_options$operators = options.operators) !== null && _options$operators !== void 0 ? _options$operators : defaultOperators,
+			baseOption: options.baseOperator,
+			labelMap: defaultOperatorLabelMap,
+			autoSelectOption: options.autoSelectOperator
+		}).optionList);
+		_classPrivateFieldSet2(_combinators, this, freeze(prepareOptionList({
+			optionList: (_options$combinators = options.combinators) !== null && _options$combinators !== void 0 ? _options$combinators : defaultCombinators,
+			baseOption: options.baseCombinator
+		}).optionList, true));
+		_classPrivateFieldSet2(_query, this, freeze(query ? prepareRuleGroup(query, { idGenerator: _classPrivateFieldGet2(_idGenerator, this) }) : this.createRuleGroup(), true));
+	}
+	/** Replaces the current query, ensuring every rule and group has an `id`. */
+	setQuery(query) {
+		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, freeze(prepareRuleGroup(query, { idGenerator: _classPrivateFieldGet2(_idGenerator, this) }), true));
+		return this;
+	}
+	/**
+	* Creates a rule using the configured fields, operators, and defaults. The rule is not added
+	* to the query—pass it to {@link QueryManager.add} or {@link QueryManager.insert}.
+	*/
+	createRule() {
+		return createRule({
+			fields: _classPrivateFieldGet2(_fields, this),
+			getDefaultField: _classPrivateFieldGet2(_options, this).getDefaultField,
+			getRuleDefaultOperator: (f) => _assertClassBrand(_QueryManager_brand, this, _defaultOperator).call(this, f),
+			getValueSources: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valueSourcesFor).call(this, f, o),
+			getMatchModes: (f) => _assertClassBrand(_QueryManager_brand, this, _matchModesFor).call(this, f),
+			getRuleDefaultValue: (r) => _assertClassBrand(_QueryManager_brand, this, _defaultValue).call(this, r),
+			idGenerator: _classPrivateFieldGet2(_idGenerator, this)
+		});
+	}
+	/**
+	* Creates a group. Pass `true` for a group with independent combinators. The group is not
+	* added to the query—pass it to {@link QueryManager.add} or {@link QueryManager.insert}.
+	*/
+	createRuleGroup(independentCombinators) {
+		return createRuleGroup({
+			combinators: _classPrivateFieldGet2(_combinators, this),
+			addRuleToNewGroups: _classPrivateFieldGet2(_options, this).addRuleToNewGroups,
+			createRule: () => this.createRule(),
+			idGenerator: _classPrivateFieldGet2(_idGenerator, this)
+		}, independentCombinators);
+	}
+	/**
+	* Adds a rule or group to the end of the group at `parentPathOrID`, which defaults to the
+	* root group.
+	*/
+	add(ruleOrGroup, parentPathOrID = [], options = {}) {
+		const { strict, onInvalidTarget } = options, toolOptions = _objectWithoutProperties(options, _excluded);
+		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, add(_classPrivateFieldGet2(_query, this), ruleOrGroup, parentPathOrID, _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _toolOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+			strict,
+			onInvalidTarget
+		}) })));
+		return this;
+	}
+	/** Removes the rule or group at the given path or `id`. The root group cannot be removed. */
+	remove(pathOrID, options = {}) {
+		const { strict, onInvalidTarget } = options, toolOptions = _objectWithoutProperties(options, _excluded2);
+		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, remove(_classPrivateFieldGet2(_query, this), pathOrID, _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _guardOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+			strict,
+			onInvalidTarget
+		}) })));
+		return this;
+	}
+	update(a, b, c, d) {
+		var _args$optionsIndex;
+		const optionsIndex = typeof a === "string" || Array.isArray(a) ? 3 : 2;
+		const args = [
+			a,
+			b,
+			c,
+			d
+		];
+		const _ref = (_args$optionsIndex = args[optionsIndex]) !== null && _args$optionsIndex !== void 0 ? _args$optionsIndex : {}, { strict, onInvalidTarget } = _ref, toolOptions = _objectWithoutProperties(_ref, _excluded3);
+		args[optionsIndex] = _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _updateOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+			strict,
+			onInvalidTarget
+		}) });
+		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, update(_classPrivateFieldGet2(_query, this), ...args.slice(0, optionsIndex + 1)));
+		return this;
+	}
+	/** Moves the rule or group at `oldPathOrID` to `newPath`, or shifts it `'up'`/`'down'`. */
+	move(oldPathOrID, newPath, options = {}) {
+		const { strict, onInvalidTarget } = options, toolOptions = _objectWithoutProperties(options, _excluded4);
+		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, move(_classPrivateFieldGet2(_query, this), oldPathOrID, newPath, _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _toolOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+			strict,
+			onInvalidTarget
+		}) })));
+		return this;
+	}
+	/**
+	* Inserts a rule or group at the given path. Unlike the other methods, this accepts a path
+	* only—inserting _at_ an `id` would be ambiguous.
+	*/
+	insert(ruleOrGroup, path, options = {}) {
+		const { strict, onInvalidTarget } = options, toolOptions = _objectWithoutProperties(options, _excluded5);
+		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, insert(_classPrivateFieldGet2(_query, this), ruleOrGroup, path, _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _toolOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+			strict,
+			onInvalidTarget
+		}) })));
+		return this;
+	}
+	/**
+	* Creates a new group at `targetPathOrID` containing the rules/groups currently at
+	* `targetPathOrID` and `sourcePathOrID`.
+	*/
+	group(sourcePathOrID, targetPathOrID, options = {}) {
+		const { strict, onInvalidTarget } = options, toolOptions = _objectWithoutProperties(options, _excluded6);
+		_assertClassBrand(_QueryManager_brand, this, _commit).call(this, group(_classPrivateFieldGet2(_query, this), sourcePathOrID, targetPathOrID, _objectSpread2(_objectSpread2(_objectSpread2({}, _assertClassBrand(_QueryManager_brand, this, _toolOptions).call(this)), toolOptions), {}, { onAbort: _assertClassBrand(_QueryManager_brand, this, _onAbort).call(this, {
+			strict,
+			onInvalidTarget
+		}) })));
+		return this;
+	}
+	/**
+	* Creates an independent manager with the same configuration and the current query.
+	*
+	* Subscribers and history are _not_ carried over: the clone starts with no listeners and an
+	* empty undo stack. Because every mutation produces a new query object, the two managers
+	* share the initial query safely and diverge from the first change.
+	*
+	* Pass `{ regenerateIDs: true }` to give every rule and group in the clone a new `id`, which
+	* is useful when both queries will be used together (e.g. inserted into the same tree).
+	*/
+	clone(options) {
+		const query = (options === null || options === void 0 ? void 0 : options.regenerateIDs) ? regenerateIDs(_classPrivateFieldGet2(_query, this), { idGenerator: _classPrivateFieldGet2(_idGenerator, this) }) : _classPrivateFieldGet2(_query, this);
+		return new QueryManager(query, _classPrivateFieldGet2(_options, this));
+	}
+	/**
+	* Runs `fn`, deferring history recording and subscriber notification until it returns. The
+	* whole batch becomes a single undo step and triggers a single notification, or neither if
+	* the query ends up unchanged.
+	*
+	* Batches may be nested; only the outermost one commits. If `fn` throws, the query and its
+	* history are restored to their pre-batch state and the error propagates, so a batch either
+	* applies completely or not at all.
+	*
+	* {@link QueryManager.undo}, {@link QueryManager.redo}, and {@link QueryManager.clearHistory}
+	* may be called inside a batch; their notifications are deferred like everything else. Because
+	* they manage the history stacks themselves, a batch containing one of them records no entry of
+	* its own, leaving the stacks exactly as those methods left them.
+	*/
+	batch(fn) {
+		var _this$batchDepth;
+		_classPrivateFieldSet2(_batchDepth, this, (_this$batchDepth = _classPrivateFieldGet2(_batchDepth, this), _this$batchDepth++, _this$batchDepth));
+		if (_classPrivateFieldGet2(_batchDepth, this) === 1) _classPrivateFieldSet2(_batchSnapshot, this, {
+			query: _classPrivateFieldGet2(_query, this),
+			past: [..._classPrivateFieldGet2(_past, this)],
+			future: [..._classPrivateFieldGet2(_future, this)],
+			lastSig: _classPrivateFieldGet2(_lastSig, this),
+			lastAt: _classPrivateFieldGet2(_lastAt, this)
+		});
+		try {
+			fn();
+		} catch (error) {
+			if (_classPrivateFieldGet2(_batchDepth, this) === 1) {
+				const snapshot = _classPrivateFieldGet2(_batchSnapshot, this);
+				_classPrivateFieldSet2(_query, this, snapshot.query);
+				_classPrivateFieldSet2(_past, this, snapshot.past);
+				_classPrivateFieldSet2(_future, this, snapshot.future);
+				_classPrivateFieldSet2(_lastSig, this, snapshot.lastSig);
+				_classPrivateFieldSet2(_lastAt, this, snapshot.lastAt);
+			}
+			throw error;
+		} finally {
+			var _this$batchDepth3;
+			_classPrivateFieldSet2(_batchDepth, this, (_this$batchDepth3 = _classPrivateFieldGet2(_batchDepth, this), _this$batchDepth3--, _this$batchDepth3));
+			if (_classPrivateFieldGet2(_batchDepth, this) === 0) {
+				const { query: base } = _classPrivateFieldGet2(_batchSnapshot, this);
+				_classPrivateFieldSet2(_batchSnapshot, this, void 0);
+				if (base !== _classPrivateFieldGet2(_query, this)) {
+					if (!_classPrivateFieldGet2(_historyBypassed, this)) _assertClassBrand(_QueryManager_brand, this, _record).call(this, base, _classPrivateFieldGet2(_query, this));
+					_assertClassBrand(_QueryManager_brand, this, _notify).call(this);
+				}
+				_classPrivateFieldSet2(_historyBypassed, this, false);
+			}
+		}
+		return this;
+	}
+	/** Whether there is a previous query to restore. Always `false` unless `history` is enabled. */
+	canUndo() {
+		return _classPrivateFieldGet2(_past, this).length > 0;
+	}
+	/** Whether there is an undone query to restore. Always `false` unless `history` is enabled. */
+	canRedo() {
+		return _classPrivateFieldGet2(_future, this).length > 0;
+	}
+	/** Restores the previous query. No-op when {@link QueryManager.canUndo} is `false`. */
+	undo() {
+		if (_classPrivateFieldGet2(_past, this).length === 0) return this;
+		_classPrivateFieldGet2(_future, this).unshift(_classPrivateFieldGet2(_query, this));
+		_classPrivateFieldSet2(_query, this, _classPrivateFieldGet2(_past, this).pop());
+		_classPrivateFieldSet2(_lastSig, this, void 0);
+		_assertClassBrand(_QueryManager_brand, this, _markHistoryBypassed).call(this);
+		if (_classPrivateFieldGet2(_batchDepth, this) === 0) _assertClassBrand(_QueryManager_brand, this, _notify).call(this);
+		return this;
+	}
+	/** Restores the most recently undone query. No-op when {@link QueryManager.canRedo} is `false`. */
+	redo() {
+		if (_classPrivateFieldGet2(_future, this).length === 0) return this;
+		_classPrivateFieldGet2(_past, this).push(_classPrivateFieldGet2(_query, this));
+		_classPrivateFieldSet2(_query, this, _classPrivateFieldGet2(_future, this).shift());
+		_classPrivateFieldSet2(_lastSig, this, void 0);
+		_assertClassBrand(_QueryManager_brand, this, _markHistoryBypassed).call(this);
+		if (_classPrivateFieldGet2(_batchDepth, this) === 0) _assertClassBrand(_QueryManager_brand, this, _notify).call(this);
+		return this;
+	}
+	/** Discards all undo/redo history without changing the current query. */
+	clearHistory() {
+		_assertClassBrand(_QueryManager_brand, this, _markHistoryBypassed).call(this);
+		_classPrivateFieldSet2(_past, this, []);
+		_classPrivateFieldSet2(_future, this, []);
+		_classPrivateFieldSet2(_lastSig, this, void 0);
+		return this;
+	}
+	/**
+	* The recorded history: `past` oldest first, `future` newest first. Both are copies, so
+	* mutating them does not affect the manager.
+	*/
+	getHistory() {
+		return {
+			past: [..._classPrivateFieldGet2(_past, this)],
+			future: [..._classPrivateFieldGet2(_future, this)]
+		};
+	}
+	/**
+	* Validates the current query with the configured validator.
+	*
+	* The result is cached until the query changes, so a custom `validator` with side effects (or
+	* one that depends on anything other than the query) may run fewer times than expected.
+	*/
+	validate() {
+		var _classPrivateFieldGet4;
+		_assertClassBrand(_QueryManager_brand, this, _ensureCache).call(this);
+		(_classPrivateFieldGet4 = _classPrivateFieldGet2(_validation, this)) !== null && _classPrivateFieldGet4 !== void 0 || _classPrivateFieldSet2(_validation, this, _classPrivateFieldGet2(_validator, this).call(this, _classPrivateFieldGet2(_query, this)));
+		return _classPrivateFieldGet2(_validation, this);
+	}
+	format(options) {
+		return formatQuery(_classPrivateFieldGet2(_query, this), options);
+	}
+	/**
+	* Yields every rule and group in the query, depth-first in pre-order, starting with the root
+	* group itself. Combinator strings in independent-combinator groups are skipped.
+	*
+	* ```ts
+	* for (const { node, path, parent } of qm.walk({ rulesOnly: true })) {
+	*   console.log(path, node.field);
+	* }
+	* ```
+	*
+	* Traversal operates on the query as it was when iteration began, so mutating the manager
+	* mid-iteration does not affect a walk already in progress. Because generators are lazy, that
+	* happens on the first iteration step rather than when `walk` is called.
+	*
+	* @yields Every rule and group in the query, subject to `options`.
+	*/
+	*walk(options = {}) {
+		const { from, rulesOnly, groupsOnly } = options;
+		let start = _classPrivateFieldGet2(_query, this);
+		let startPath = [];
+		let startParent = null;
+		if (from !== void 0) {
+			const path = _assertClassBrand(_QueryManager_brand, this, _toPath).call(this, from);
+			const node = path && findPath(path, _classPrivateFieldGet2(_query, this));
+			if (!path || !node) return;
+			start = node;
+			startPath = path;
+			startParent = path.length === 0 ? null : findPath(getParentPath(path), _classPrivateFieldGet2(_query, this));
+		}
+		for (const entry of _assertClassBrand(_QueryManager_brand, this, _walkFrom).call(this, start, startPath, startParent)) {
+			if (rulesOnly && isRuleGroup(entry.node)) continue;
+			if (groupsOnly && !isRuleGroup(entry.node)) continue;
+			yield entry;
+		}
+	}
+	/** Yields every rule in the query. Shorthand for `walk({ ...options, rulesOnly: true })`. */
+	rules(options = {}) {
+		return this.walk(_objectSpread2(_objectSpread2({}, options), {}, { rulesOnly: true }));
+	}
+	/**
+	* Yields every group in the query, including the root group. Shorthand for
+	* `walk({ ...options, groupsOnly: true })`.
+	*/
+	groups(options = {}) {
+		return this.walk(_objectSpread2(_objectSpread2({}, options), {}, { groupsOnly: true }));
+	}
+	/** Returns the first node matching `predicate`, or `null` if there is none. */
+	find(predicate, options = {}) {
+		for (const entry of this.walk(options)) if (predicate(entry)) return entry;
+		return null;
+	}
+	/** Returns every node matching `predicate`. */
+	filter(predicate, options = {}) {
+		const results = [];
+		for (const entry of this.walk(options)) if (predicate(entry)) results.push(entry);
+		return results;
+	}
+	/** Equivalent to {@link QueryManager.walk} with no options, enabling `for...of` and spread. */
+	[_Symbol$iterator]() {
+		return this.walk();
+	}
+	/**
+	* Returns the rule or group at the given path, or `null` if the path can't be resolved.
+	*
+	* Unlike the standalone {@link findPath}, which can return `undefined` for an out-of-range
+	* index, unresolvable paths are always normalized to `null` here.
+	*/
+	findPath(path) {
+		var _findPath;
+		return (_findPath = findPath(path, _classPrivateFieldGet2(_query, this))) !== null && _findPath !== void 0 ? _findPath : null;
+	}
+	/**
+	* Returns the rule or group with the given `id`, or `null` if there is none. Backed by an
+	* index built once per query, so repeated lookups are constant time.
+	*/
+	findID(id) {
+		const path = _assertClassBrand(_QueryManager_brand, this, _index).call(this).get(id);
+		return path === void 0 ? null : findPath(path, _classPrivateFieldGet2(_query, this));
+	}
+	/**
+	* Returns the {@link Path} of the rule or group with the given `id`, or `null` if there is
+	* none. Backed by an index built once per query, so repeated lookups are constant time.
+	*/
+	getPathOfID(id) {
+		var _this$index$get2;
+		return (_this$index$get2 = _assertClassBrand(_QueryManager_brand, this, _index).call(this).get(id)) !== null && _this$index$get2 !== void 0 ? _this$index$get2 : null;
+	}
+	/**
+	* Determines whether the rule or group at the given path is disabled, either itself or by an
+	* ancestor group.
+	*/
+	pathIsDisabled(path) {
+		return pathIsDisabled(path, _classPrivateFieldGet2(_query, this));
+	}
+	/** Returns the rule or group at the given path or `id`, or `null` if it can't be resolved. */
+	getNode(pathOrID) {
+		var _findPath2;
+		const path = _assertClassBrand(_QueryManager_brand, this, _toPath).call(this, pathOrID);
+		return path === null ? null : (_findPath2 = findPath(path, _classPrivateFieldGet2(_query, this))) !== null && _findPath2 !== void 0 ? _findPath2 : null;
+	}
+	/**
+	* Returns the rule at the given path or `id`, or `null` if it can't be resolved _or_ resolves
+	* to a group.
+	*/
+	getRule(pathOrID) {
+		const node = this.getNode(pathOrID);
+		return node && !isRuleGroup(node) ? node : null;
+	}
+	/**
+	* Returns the group at the given path or `id`, or `null` if it can't be resolved _or_
+	* resolves to a rule.
+	*/
+	getGroup(pathOrID) {
+		const node = this.getNode(pathOrID);
+		return node && isRuleGroup(node) ? node : null;
+	}
+	/**
+	* Returns the group containing the rule or group at the given path or `id`. Returns `null`
+	* for the root group, which has no parent, and when the target can't be resolved.
+	*/
+	getParent(pathOrID) {
+		const path = _assertClassBrand(_QueryManager_brand, this, _toPath).call(this, pathOrID);
+		if (path === null || path.length === 0) return null;
+		if (!findPath(path, _classPrivateFieldGet2(_query, this))) return null;
+		return findPath(getParentPath(path), _classPrivateFieldGet2(_query, this));
+	}
+	/**
+	* The normalized field list, as the `QueryBuilder` component would render it. Needed to
+	* populate a field selector.
+	*/
+	getFields() {
+		return _classPrivateFieldGet2(_fields, this);
+	}
+	/**
+	* The normalized combinator list, as the `QueryBuilder` component would render it. Needed to
+	* populate a combinator selector.
+	*/
+	getCombinators() {
+		return _classPrivateFieldGet2(_combinators, this);
+	}
+	/**
+	* The field configuration for a field name. When the field isn't configured, returns the same
+	* minimal fallback (`{ name, value, label }`, all set to the field name) that
+	* {@link QueryManager.getRuleContext} reports as `fieldData`, so both access paths agree.
+	*/
+	getFieldData(field) {
+		return getFieldData(field, _classPrivateFieldGet2(_fieldMap, this));
+	}
+	/** The operator list for a field, mirroring `QueryBuilder`'s precedence. */
+	getOperators(field) {
+		return _assertClassBrand(_QueryManager_brand, this, _operatorsFor).call(this, field);
+	}
+	/** The value sources available for a field/operator pair. */
+	getValueSources(field, operator) {
+		return _assertClassBrand(_QueryManager_brand, this, _valueSourcesFor).call(this, field, operator);
+	}
+	/** The match modes available for a field. */
+	getMatchModes(field) {
+		return _assertClassBrand(_QueryManager_brand, this, _matchModesFor).call(this, field);
+	}
+	/** The value option list for a field/operator pair. */
+	getValues(field, operator) {
+		return _assertClassBrand(_QueryManager_brand, this, _valuesFor).call(this, field, operator);
+	}
+	/** The value editor type for a field/operator pair. */
+	getValueEditorType(field, operator) {
+		return _assertClassBrand(_QueryManager_brand, this, _valueEditorTypeFor).call(this, field, operator);
+	}
+	/**
+	* Resolves everything about a rule that depends on the field/operator configuration—field data,
+	* operators, value editor type, value list, value sources, match modes, and validation result.
+	* Returns `null` when the target can't be resolved or isn't a rule.
+	*
+	* This is the same derivation the `useRule` hook performs, so a non-React implementation can
+	* render a rule without reimplementing the configuration precedence rules.
+	*/
+	getRuleContext(pathOrID) {
+		const rule = this.getRule(pathOrID);
+		if (!rule) return null;
+		const validation = this.validate();
+		return deriveRuleContext(rule, {
+			fields: _classPrivateFieldGet2(_fields, this),
+			fieldMap: _classPrivateFieldGet2(_fieldMap, this),
+			getInputType: (f, o, misc) => {
+				var _this$options$getInpu, _classPrivateFieldGet5, _classPrivateFieldGet6;
+				return (_this$options$getInpu = (_classPrivateFieldGet5 = (_classPrivateFieldGet6 = _classPrivateFieldGet2(_options, this)).getInputType) === null || _classPrivateFieldGet5 === void 0 ? void 0 : _classPrivateFieldGet5.call(_classPrivateFieldGet6, f, o, misc)) !== null && _this$options$getInpu !== void 0 ? _this$options$getInpu : null;
+			},
+			getMatchModes: (f) => _assertClassBrand(_QueryManager_brand, this, _matchModesFor).call(this, f),
+			getOperators: (f) => _assertClassBrand(_QueryManager_brand, this, _operatorsFor).call(this, f),
+			getParameters: (f, o, misc) => _assertClassBrand(_QueryManager_brand, this, _parametersFor).call(this, f, o, misc),
+			getValueEditorType: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valueEditorTypeFor).call(this, f, o),
+			getValues: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valuesFor).call(this, f, o),
+			getValueSources: (f, o) => this.getValueSources(f, o),
+			getSubQueryBuilderProps: (f, misc) => {
+				var _this$options$getSubQ, _classPrivateFieldGet7, _classPrivateFieldGet8;
+				return (_this$options$getSubQ = (_classPrivateFieldGet7 = (_classPrivateFieldGet8 = _classPrivateFieldGet2(_options, this)).getSubQueryBuilderProps) === null || _classPrivateFieldGet7 === void 0 ? void 0 : _classPrivateFieldGet7.call(_classPrivateFieldGet8, f, misc)) !== null && _this$options$getSubQ !== void 0 ? _this$options$getSubQ : {};
+			}
+		}, {
+			validationMap: typeof validation === "boolean" ? {} : validation,
+			id: rule.id
+		});
+	}
+	/**
+	* Resolves everything about a rule group that depends on the combinator configuration, plus its
+	* validation result. Returns `null` when the target can't be resolved or isn't a group.
+	*
+	* This is the same derivation the `useRuleGroup` hook performs.
+	*/
+	getRuleGroupContext(pathOrID = []) {
+		const ruleGroup = this.getGroup(pathOrID);
+		if (!ruleGroup) return null;
+		const validation = this.validate();
+		return deriveRuleGroupContext(ruleGroup, _classPrivateFieldGet2(_combinators, this), {
+			validationMap: typeof validation === "boolean" ? {} : validation,
+			id: ruleGroup.id
+		});
+	}
+	/** Whether the current query uses independent combinators. */
+	isIC() {
+		return isRuleGroupTypeIC(_classPrivateFieldGet2(_query, this));
+	}
+	/**
+	* Returns the signature describing how the current query differs from `other`, as used by
+	* this manager's history coalescing.
+	*/
+	signatureOf(other) {
+		return signatureOf(_classPrivateFieldGet2(_query, this), other);
+	}
+	/** Generates a {@link DiagnosticsResult}. Shorthand for `format('diagnostics')`. */
+	diagnostics() {
+		return formatQuery(_classPrivateFieldGet2(_query, this), "diagnostics");
+	}
+	/**
+	* Returns the current query, so `JSON.stringify(queryManager)` produces the same output as
+	* `JSON.stringify(queryManager.getQuery())`.
+	*/
+	toJSON() {
+		return _classPrivateFieldGet2(_query, this);
+	}
+	/**
+	* Returns a new manager with the same configuration and the current query converted to use
+	* independent combinators. Idempotent, and never modifies this manager. As with
+	* {@link QueryManager.clone}, subscribers and history are not carried over.
+	*/
+	toIC() {
+		return new QueryManager(convertToIC(_classPrivateFieldGet2(_query, this)), _classPrivateFieldGet2(_options, this));
+	}
+	/**
+	* Returns a new manager with the same configuration and the current query converted to use a
+	* single combinator per group. Idempotent, and never modifies this manager. As with
+	* {@link QueryManager.clone}, subscribers and history are not carried over.
+	*/
+	fromIC() {
+		return new QueryManager(convertFromIC(_classPrivateFieldGet2(_query, this)), _classPrivateFieldGet2(_options, this));
+	}
+	/**
+	* Runs {@link transformQuery} against the current query and returns its result.
+	*
+	* Unlike {@link QueryManager.toIC}/{@link QueryManager.fromIC}, this returns the raw
+	* transformed value rather than a new manager, since `transformQuery` can produce arbitrary
+	* shapes that are no longer valid queries. This manager is never modified.
+	*/
+	transform(options) {
+		return transformQuery(_classPrivateFieldGet2(_query, this), options);
+	}
+};
+/** Resolves the field configuration for a field name. */
+function _fieldData(field) {
+	var _this$fieldMap$field;
+	return (_this$fieldMap$field = _classPrivateFieldGet2(_fieldMap, this)[field]) !== null && _this$fieldMap$field !== void 0 ? _this$fieldMap$field : {};
+}
+/** Resolves the operator list for a field, mirroring `QueryBuilder`'s precedence. */
+function _operatorsFor(field) {
+	return resolveOperatorList({
+		field,
+		fieldData: _assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field),
+		getOperators: _classPrivateFieldGet2(_options, this).getOperators,
+		operators: _classPrivateFieldGet2(_operators, this),
+		baseOption: _classPrivateFieldGet2(_options, this).baseOperator,
+		autoSelectOption: _classPrivateFieldGet2(_options, this).autoSelectOperator
+	});
+}
+/** Resolves the default operator for a field, mirroring `QueryBuilder`'s precedence. */
+function _defaultOperator(field) {
+	return resolveDefaultOperator({
+		field,
+		fieldData: _assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field),
+		getDefaultOperator: _classPrivateFieldGet2(_options, this).getDefaultOperator,
+		getOperators: (f) => _assertClassBrand(_QueryManager_brand, this, _operatorsFor).call(this, f)
+	});
+}
+function _valueSourcesFor(field, operator) {
+	return getValueSourcesUtil(_assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field), operator, _classPrivateFieldGet2(_options, this).getValueSources);
+}
+function _matchModesFor(field) {
+	return getMatchModesUtil(_assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field), _classPrivateFieldGet2(_options, this).getMatchModes);
+}
+function _valuesFor(field, operator) {
+	return resolveValueList({
+		field,
+		operator,
+		fieldData: _assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field),
+		getValues: _classPrivateFieldGet2(_options, this).getValues,
+		autoSelectOption: _classPrivateFieldGet2(_options, this).autoSelectValue
+	});
+}
+function _valueEditorTypeFor(field, operator) {
+	return resolveValueEditorType({
+		field,
+		operator,
+		fieldData: _assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, field),
+		getValueEditorType: _classPrivateFieldGet2(_options, this).getValueEditorType
+	});
+}
+/** Computes the default `value` for a rule, mirroring `QueryBuilder`'s precedence. */
+function _defaultValue(rule) {
+	const { getDefaultValue, getParameters, listsAsArrays } = _classPrivateFieldGet2(_options, this);
+	return getRuleDefaultValue(rule, {
+		fieldData: _assertClassBrand(_QueryManager_brand, this, _fieldData).call(this, rule.field),
+		fields: _classPrivateFieldGet2(_fields, this),
+		listsAsArrays,
+		getValueEditorType: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valueEditorTypeFor).call(this, f, o),
+		getValues: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valuesFor).call(this, f, o),
+		getDefaultValue: getDefaultValue && ((r, misc) => getDefaultValue(r, misc)),
+		getParameters: getParameters && ((f, o, misc) => _assertClassBrand(_QueryManager_brand, this, _parametersFor).call(this, f, o, misc))
+	});
+}
+/**
+* Resolves the parameter list for a field/operator pair, normalized the same way as every
+* other option list. Shared by {@link QueryManager.#defaultValue} and
+* {@link QueryManager.getRuleContext} so both see the same shape.
+*/
+function _parametersFor(field, operator, misc) {
+	var _this$options$getPara, _classPrivateFieldGet2$1, _classPrivateFieldGet3;
+	return prepareOptionList({
+		optionList: (_this$options$getPara = (_classPrivateFieldGet2$1 = (_classPrivateFieldGet3 = _classPrivateFieldGet2(_options, this)).getParameters) === null || _classPrivateFieldGet2$1 === void 0 ? void 0 : _classPrivateFieldGet2$1.call(_classPrivateFieldGet3, field, operator, misc)) !== null && _this$options$getPara !== void 0 ? _this$options$getPara : [],
+		autoSelectOption: _classPrivateFieldGet2(_options, this).autoSelectValue
+	}).optionList;
+}
+/** Defaults shared by every mutating method, overridable per call. */
+function _guardOptions() {
+	const { maxLevels } = _classPrivateFieldGet2(_options, this);
+	return {
+		maxLevels: (maxLevels !== null && maxLevels !== void 0 ? maxLevels : 0) > 0 ? Number(maxLevels) : Infinity,
+		respectDisabled: _classPrivateFieldGet2(_respectDisabled, this),
+		disabledPaths: _classPrivateFieldGet2(_options, this).disabledPaths,
+		queryDisabled: _classPrivateFieldGet2(_options, this).queryDisabled
+	};
+}
+function _toolOptions() {
+	return _objectSpread2({
+		combinators: _classPrivateFieldGet2(_combinators, this),
+		idGenerator: _classPrivateFieldGet2(_idGenerator, this)
+	}, _assertClassBrand(_QueryManager_brand, this, _guardOptions).call(this));
+}
+/**
+* Builds the `onAbort` handler passed to the query tools, applying the per-call overrides on
+* top of the manager's own options.
+*/
+function _onAbort({ strict, onInvalidTarget }) {
+	const strictMain = strict !== null && strict !== void 0 ? strict : _classPrivateFieldGet2(_strict, this);
+	const handler = onInvalidTarget !== null && onInvalidTarget !== void 0 ? onInvalidTarget : _classPrivateFieldGet2(_onInvalidTarget, this);
+	return (info) => {
+		handler === null || handler === void 0 || handler(info);
+		if (strictMain && strictAbortReasonSet.has(info.reason)) throw new QueryManagerError(info);
+	};
+}
+/** Defaults for {@link update}, so resets mirror `QueryBuilder`'s behavior. */
+function _updateOptions() {
+	return _objectSpread2({
+		getRuleDefaultOperator: (f) => _assertClassBrand(_QueryManager_brand, this, _defaultOperator).call(this, f),
+		getRuleDefaultValue: (r) => _assertClassBrand(_QueryManager_brand, this, _defaultValue).call(this, r),
+		getValueSources: (f, o) => _assertClassBrand(_QueryManager_brand, this, _valueSourcesFor).call(this, f, o),
+		getMatchModes: (f) => _assertClassBrand(_QueryManager_brand, this, _matchModesFor).call(this, f),
+		resetOnFieldChange: _classPrivateFieldGet2(_options, this).resetOnFieldChange,
+		resetOnOperatorChange: _classPrivateFieldGet2(_options, this).resetOnOperatorChange
+	}, _assertClassBrand(_QueryManager_brand, this, _guardOptions).call(this));
+}
+/**
+* Applies a new query, recording history and notifying subscribers as appropriate. Every
+* mutation funnels through here. A tool that could not resolve its target returns the same
+* query object, which is treated as a no-op.
+*/
+function _commit(next) {
+	const prev = _classPrivateFieldGet2(_query, this);
+	if (prev === next) return;
+	_classPrivateFieldSet2(_query, this, next);
+	if (_classPrivateFieldGet2(_batchDepth, this) > 0) return;
+	_assertClassBrand(_QueryManager_brand, this, _record).call(this, prev, next);
+	_assertClassBrand(_QueryManager_brand, this, _notify).call(this);
+}
+/**
+* Records a change, either as a new history entry or by absorbing it into the current one.
+* Mirrors the recording semantics of the `react-querybuilder/history` entry point.
+*/
+function _record(prev, next) {
+	if (!_classPrivateFieldGet2(_historyEnabled, this)) return;
+	const sig = signatureOf(prev, next);
+	if (sig === "") return;
+	const now = _classPrivateFieldGet2(_now, this).call(this);
+	if (!(sig !== "~structural" && sig === _classPrivateFieldGet2(_lastSig, this) && now - _classPrivateFieldGet2(_lastAt, this) < _classPrivateFieldGet2(_coalesceMs, this))) {
+		_classPrivateFieldGet2(_past, this).push(prev);
+		if (_classPrivateFieldGet2(_past, this).length > _classPrivateFieldGet2(_maxHistory, this)) _classPrivateFieldGet2(_past, this).shift();
+		_classPrivateFieldSet2(_future, this, []);
+	}
+	_classPrivateFieldSet2(_lastSig, this, sig);
+	_classPrivateFieldSet2(_lastAt, this, now);
+}
+function _notify() {
+	for (const listener of _classPrivateFieldGet2(_listeners, this)) listener();
+}
+/**
+* Records that a history-stack method ran inside the current batch. Those methods manage
+* `#past`/`#future` themselves, so the batch must not also record an entry on completion —
+* doing so would push a duplicate onto `#past` and clear the redo stack that `undo` just
+* populated.
+*/
+function _markHistoryBypassed() {
+	if (_classPrivateFieldGet2(_batchDepth, this) > 0) _classPrivateFieldSet2(_historyBypassed, this, true);
+}
+/**
+* Discards every cached derivation when the query has been replaced since they were computed.
+* Called at the top of each cached reader.
+*/
+function _ensureCache() {
+	if (_classPrivateFieldGet2(_cacheFor, this) === _classPrivateFieldGet2(_query, this)) return;
+	_classPrivateFieldSet2(_cacheFor, this, _classPrivateFieldGet2(_query, this));
+	_classPrivateFieldSet2(_idPathIndex, this, void 0);
+	_classPrivateFieldSet2(_validation, this, void 0);
+}
+/**
+* The single traversal implementation. Combinator strings in independent-combinator groups
+* are skipped.
+*
+* @yields The subtree rooted at `node`, depth-first in pre-order, starting with `node` itself.
+*/
+function* _walkFrom(node, path, parent) {
+	yield {
+		node,
+		path,
+		parent
+	};
+	if (!isRuleGroup(node)) return;
+	const startGroup = node;
+	for (const [index, child] of startGroup.rules.entries()) {
+		if (typeof child === "string") continue;
+		yield* _assertClassBrand(_QueryManager_brand, this, _walkFrom).call(this, child, [...path, index], startGroup);
+	}
+}
+/** Builds (once per query) the `id` to {@link Path} index backing `findID`/`getPathOfID`. */
+function _index() {
+	_assertClassBrand(_QueryManager_brand, this, _ensureCache).call(this);
+	if (!_classPrivateFieldGet2(_idPathIndex, this)) {
+		const index = /* @__PURE__ */ new Map();
+		for (const { node, path } of _assertClassBrand(_QueryManager_brand, this, _walkFrom).call(this, _classPrivateFieldGet2(_query, this), [], null)) if (node.id !== void 0 && !index.has(node.id)) index.set(node.id, path);
+		_classPrivateFieldSet2(_idPathIndex, this, index);
+	}
+	return _classPrivateFieldGet2(_idPathIndex, this);
+}
+/** Resolves a path or `id` to a path, or `null` when the `id` isn't present. */
+function _toPath(pathOrID) {
+	var _this$index$get;
+	return typeof pathOrID === "string" ? (_this$index$get = _assertClassBrand(_QueryManager_brand, this, _index).call(this).get(pathOrID)) !== null && _this$index$get !== void 0 ? _this$index$get : null : pathOrID;
+}
+//#endregion
+export { LogType, QueryManager, QueryManagerError, TestID, add, addInPlace, betweenOperators, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, coerceBigIntValue, coerceInputType, convertFromIC, convertQuery, convertToIC, createQueryActions, createRule, createRuleGroup, cypherCombinatorMap, defaultCELValueProcessor, defaultCoalesceMs, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, defaultMaxHistory, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleGroupProcessorTanStackDB, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultSpELValueProcessor, defaultTranslations, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, derivePathInfo, deriveRuleClassName, deriveRuleClassNames, deriveRuleContext, deriveRuleGroupClassNames, deriveRuleGroupContext, deriveRuleGroupOuterClassName, deriveRuleOuterClassName, exceedsMaxLevels, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFieldData, getFirstOption, getGuardAbortReason, getLikeWildcards, getMatchModesUtil, getMultiValueUpdate, getNLTranslataion, getOption, getParametersAsList, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getRuleDefaultValue, getRuleGroupCombinator, getRuleInputType, getRuleValidationResult, getRuleValueEditorType, getRuleValueSourceOptions, getRuleValues, getSQLConcat, getSubqueryElementAlias, getValidationClassNames, getValueEditorReset, getValueSelectorUpdate, getValueSourcesUtil, group, groupInPlace, groupInvalidReasons, hideValueControlsForOperator, inOperators, insert, insertInPlace, isAncestor, isBetweenOperator, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isUnsafeKey, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeAnyTranslation, mergeAnyTranslations, mergeClassnames, mongoDbFallback, mongoOperators, move, moveInPlace, normalizeConstituentWordOrder, normalizeValueSelectorValue, nullFreeArray, nullOperators, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathIsDisabledByPaths, pathsAreEqual, preferAnyProp, preferFlagProps, preferProp, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, queryBuilderFlagDefaults, regenerateID, regenerateIDs, relationalOperators, remove, removeInPlace, resolveCandidateQuery, resolveDefaultOperator, resolveOperatorList, resolveValueEditorType, resolveValueList, rootPath, shouldRenderAsNumber, signatureOf, sparqlVar, splitBy, sqlDialectPresets, standardClassnames, strictAbortReasons, stripParamPrefix, structuralSignature, subqueryElementAliasBase, substringOperators, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, unchangedSignature, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update, updateInPlace, uuidV4regex, withParamPrefix, wrapLikeFragment };
 
 //# sourceMappingURL=react-querybuilder_core.legacy-esm.js.map