@react-querybuilder/core 8.22.5 → 8.23.0

package/dist/derivations.js

@@ -0,0 +1,2845 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils = require("./utils-e-7KHkjV.js");
+const require_objectUtils = require("./objectUtils-DfnEmDSV.js");
+const require_convertQuery = require("./convertQuery-BLT0GIhM.js");
+const require_prepareQueryObjects = require("./prepareQueryObjects-Dj9cTl9D.js");
+const require_isRuleOrGroupValid = require("./isRuleOrGroupValid-CtUf4_4x.js");
+const require_transformQuery = require("./transformQuery.js");
+let immer = require("immer");
+//#region src/controlPropKeys.ts
+/**
+* Runtime data describing the set of query builder controls and the props each one receives.
+*
+* These live in `@react-querybuilder/core` (not `react-querybuilder`) so that non-React ports
+* can consume them without a React dependency.
+*
+* Nothing here can drift from the React implementation unnoticed:
+* `react-querybuilder`'s `types/controlPropKeys.test.ts` gates {@link controlKeys} against
+* `defaultControlElements` and `ControlElementsProp`, and every entry of
+* {@link controlPropKeys} against the corresponding props interface—both at runtime and at
+* compile time, in both directions.
+*/
+/**
+* The name of every query builder control, alphabetized.
+*
+* @group Props
+*/
+const controlKeys = [
+	"actionElement",
+	"addGroupAction",
+	"addRuleAction",
+	"cloneGroupAction",
+	"cloneRuleAction",
+	"combinatorSelector",
+	"dragHandle",
+	"fieldSelector",
+	"inlineCombinator",
+	"lockGroupAction",
+	"lockRuleAction",
+	"matchModeEditor",
+	"muteGroupAction",
+	"muteRuleAction",
+	"notToggle",
+	"operatorSelector",
+	"removeGroupAction",
+	"removeRuleAction",
+	"rule",
+	"ruleGroup",
+	"ruleGroupBodyElements",
+	"ruleGroupHeaderElements",
+	"shiftActions",
+	"undoRedoActions",
+	"valueEditor",
+	"valueSelector",
+	"valueSourceSelector"
+];
+/**
+* The full set of prop names each default control receives. Ports can use this to declare
+* every prop explicitly instead of relying on fall-through/attribute inheritance.
+*
+* Each array is the complete, alphabetized key set of the control's props interface in
+* `react-querybuilder`. The lists are written out in full rather than composed from shared
+* bases because `--isolatedDeclarations` cannot infer array types built with spreads. A
+* compile-time gate in `react-querybuilder` (`types/controlPropKeys.test.ts`) fails the build
+* if any list drifts from its interface in either direction.
+*
+* @group Props
+*/
+const controlPropKeys = {
+	actionElement: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	addGroupAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	addRuleAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	cloneGroupAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	cloneRuleAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	combinatorSelector: [
+		"className",
+		"context",
+		"disabled",
+		"handleOnChange",
+		"level",
+		"options",
+		"path",
+		"ruleGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	],
+	dragHandle: [
+		"className",
+		"context",
+		"disabled",
+		"dragHandleAttributes",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	fieldSelector: [
+		"className",
+		"context",
+		"disabled",
+		"handleOnChange",
+		"level",
+		"operator",
+		"options",
+		"path",
+		"rule",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	],
+	inlineCombinator: [
+		"className",
+		"component",
+		"context",
+		"disabled",
+		"handleOnChange",
+		"level",
+		"options",
+		"path",
+		"ruleGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	],
+	lockGroupAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	lockRuleAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	matchModeEditor: [
+		"className",
+		"classNames",
+		"context",
+		"disabled",
+		"field",
+		"fieldData",
+		"handleOnChange",
+		"level",
+		"match",
+		"numericEditorComponent",
+		"options",
+		"path",
+		"rule",
+		"schema",
+		"selectorComponent",
+		"testID",
+		"thresholdPlaceholder",
+		"title",
+		"validation",
+		"value"
+	],
+	muteGroupAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	muteRuleAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	notToggle: [
+		"checked",
+		"className",
+		"context",
+		"disabled",
+		"handleOnChange",
+		"label",
+		"level",
+		"path",
+		"ruleGroup",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	operatorSelector: [
+		"className",
+		"context",
+		"disabled",
+		"field",
+		"fieldData",
+		"handleOnChange",
+		"level",
+		"options",
+		"path",
+		"rule",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	],
+	removeGroupAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	removeRuleAction: [
+		"className",
+		"context",
+		"disabled",
+		"disabledTranslation",
+		"handleOnClick",
+		"label",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"rules",
+		"schema",
+		"testID",
+		"title",
+		"validation"
+	],
+	rule: [
+		"actions",
+		"context",
+		"disabled",
+		"dndRef",
+		"dragHandleAttributes",
+		"dragMonitorId",
+		"dragRef",
+		"dropEffect",
+		"dropMonitorId",
+		"dropNotAllowed",
+		"field",
+		"groupItems",
+		"id",
+		"isDragging",
+		"isOver",
+		"operator",
+		"parentDisabled",
+		"parentMuted",
+		"path",
+		"rule",
+		"schema",
+		"shiftDownDisabled",
+		"shiftUpDisabled",
+		"translations",
+		"value",
+		"valueSource"
+	],
+	ruleGroup: [
+		"actions",
+		"combinator",
+		"context",
+		"disabled",
+		"dragHandleAttributes",
+		"dragMonitorId",
+		"dragRef",
+		"dropEffect",
+		"dropMonitorId",
+		"dropNotAllowed",
+		"dropRef",
+		"groupItems",
+		"id",
+		"isDragging",
+		"isOver",
+		"not",
+		"parentDisabled",
+		"parentMuted",
+		"path",
+		"previewRef",
+		"ruleGroup",
+		"rules",
+		"schema",
+		"shiftDownDisabled",
+		"shiftUpDisabled",
+		"translations"
+	],
+	ruleGroupBodyElements: [
+		"accessibleDescription",
+		"actions",
+		"addGroup",
+		"addRule",
+		"classNames",
+		"cloneGroup",
+		"combinator",
+		"context",
+		"disabled",
+		"dragHandleAttributes",
+		"dragMonitorId",
+		"dragRef",
+		"dropEffect",
+		"dropMonitorId",
+		"dropNotAllowed",
+		"dropRef",
+		"groupItems",
+		"id",
+		"isDragging",
+		"isOver",
+		"muted",
+		"not",
+		"onCombinatorChange",
+		"onGroupAdd",
+		"onIndependentCombinatorChange",
+		"onNotToggleChange",
+		"outerClassName",
+		"parentDisabled",
+		"parentMuted",
+		"path",
+		"pathsMemo",
+		"previewRef",
+		"removeGroup",
+		"ruleGroup",
+		"rules",
+		"schema",
+		"shiftDownDisabled",
+		"shiftGroupDown",
+		"shiftGroupUp",
+		"shiftUpDisabled",
+		"toggleLockGroup",
+		"toggleMuteGroup",
+		"translations",
+		"validationClassName",
+		"validationResult"
+	],
+	ruleGroupHeaderElements: [
+		"accessibleDescription",
+		"actions",
+		"addGroup",
+		"addRule",
+		"classNames",
+		"cloneGroup",
+		"combinator",
+		"context",
+		"disabled",
+		"dragHandleAttributes",
+		"dragMonitorId",
+		"dragRef",
+		"dropEffect",
+		"dropMonitorId",
+		"dropNotAllowed",
+		"dropRef",
+		"groupItems",
+		"id",
+		"isDragging",
+		"isOver",
+		"muted",
+		"not",
+		"onCombinatorChange",
+		"onGroupAdd",
+		"onIndependentCombinatorChange",
+		"onNotToggleChange",
+		"outerClassName",
+		"parentDisabled",
+		"parentMuted",
+		"path",
+		"pathsMemo",
+		"previewRef",
+		"removeGroup",
+		"ruleGroup",
+		"rules",
+		"schema",
+		"shiftDownDisabled",
+		"shiftGroupDown",
+		"shiftGroupUp",
+		"shiftUpDisabled",
+		"toggleLockGroup",
+		"toggleMuteGroup",
+		"translations",
+		"validationClassName",
+		"validationResult"
+	],
+	shiftActions: [
+		"className",
+		"context",
+		"disabled",
+		"labels",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"schema",
+		"shiftDown",
+		"shiftDownDisabled",
+		"shiftUp",
+		"shiftUpDisabled",
+		"testID",
+		"title",
+		"titles",
+		"validation"
+	],
+	undoRedoActions: [
+		"className",
+		"classNames",
+		"context",
+		"disabled",
+		"labels",
+		"level",
+		"path",
+		"ruleOrGroup",
+		"schema",
+		"testID",
+		"title",
+		"titles",
+		"validation"
+	],
+	valueEditor: [
+		"className",
+		"context",
+		"disabled",
+		"field",
+		"fieldData",
+		"handleOnChange",
+		"inputType",
+		"level",
+		"listsAsArrays",
+		"operator",
+		"parseNumbers",
+		"path",
+		"rule",
+		"schema",
+		"selectorComponent",
+		"separator",
+		"skipHook",
+		"testID",
+		"title",
+		"type",
+		"validation",
+		"value",
+		"valueSource",
+		"values"
+	],
+	valueSelector: [
+		"className",
+		"context",
+		"disabled",
+		"handleOnChange",
+		"level",
+		"listsAsArrays",
+		"multiple",
+		"options",
+		"path",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	],
+	valueSourceSelector: [
+		"className",
+		"context",
+		"disabled",
+		"field",
+		"fieldData",
+		"handleOnChange",
+		"level",
+		"options",
+		"path",
+		"rule",
+		"schema",
+		"testID",
+		"title",
+		"validation",
+		"value"
+	]
+};
+/**
+* Which bulk override, if any, applies to each control: `"action"` for controls that a supplied
+* `actionElement` replaces, `"selector"` for controls that a supplied `valueSelector` replaces,
+* and `null` for controls that neither replaces.
+*
+* `actionElement` and `valueSelector` are themselves `null`—they are the _source_ of a bulk
+* override, not a target of one.
+*
+* Replaces name-suffix sniffing (`key.endsWith('Action')`), which would silently misclassify a
+* future control named e.g. `pathSelector`, and which disagrees between implementations about
+* whether `shiftActions`/`undoRedoActions` (plural) match. They do not: neither receives the
+* `actionElement` bulk override.
+*
+* @group Props
+*/
+const controlKind = {
+	actionElement: null,
+	addGroupAction: "action",
+	addRuleAction: "action",
+	cloneGroupAction: "action",
+	cloneRuleAction: "action",
+	combinatorSelector: "selector",
+	dragHandle: null,
+	fieldSelector: "selector",
+	inlineCombinator: null,
+	lockGroupAction: "action",
+	lockRuleAction: "action",
+	matchModeEditor: null,
+	muteGroupAction: "action",
+	muteRuleAction: "action",
+	notToggle: null,
+	operatorSelector: "selector",
+	removeGroupAction: "action",
+	removeRuleAction: "action",
+	rule: null,
+	ruleGroup: null,
+	ruleGroupBodyElements: null,
+	ruleGroupHeaderElements: null,
+	shiftActions: null,
+	undoRedoActions: null,
+	valueEditor: null,
+	valueSelector: null,
+	valueSourceSelector: "selector"
+};
+//#endregion
+//#region src/utils/abortReasons.ts
+/**
+* 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.
+*
+* Declared apart from `QueryManager` so the `@react-querybuilder/core/derivations` entry point can
+* export it without putting the manager in its module graph.
+*
+* @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"
+];
+new Set(strictAbortReasons);
+//#endregion
+//#region ../../node_modules/clsx/dist/clsx.mjs
+function r(e) {
+	var t, f, n = "";
+	if ("string" == typeof e || "number" == typeof e) n += e;
+	else if ("object" == typeof e) if (Array.isArray(e)) {
+		var o = e.length;
+		for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+	} else for (f in e) e[f] && (n && (n += " "), n += f);
+	return n;
+}
+function clsx() {
+	for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+	return n;
+}
+//#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) => {
+	if (prev === next) return "";
+	if (typeof prev === "string" || typeof next === "string") return typeof prev === typeof next ? `${parentId}:combinator[${index}]` : structuralSignature;
+	const prevIsGroup = require_objectUtils.isRuleGroup(prev);
+	const nextIsGroup = require_objectUtils.isRuleGroup(next);
+	if (prevIsGroup !== nextIsGroup) return structuralSignature;
+	if (!prevIsGroup || !nextIsGroup) {
+		const props = changedProps(prev, next);
+		return props.length === 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) return ownProps.length === 0 ? "" : `${next.id ?? ""}:${ownProps.join(",")}`;
+	if (ownProps.length > 0) return structuralSignature;
+	return signatureOfNode(prev.rules[changedIndex], next.rules[changedIndex], next.id ?? "", 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 src/utils/coalesce.ts
+/**
+* Determines whether a change should be absorbed into the current history entry instead of
+* pushing a new one. This is the exact rule {@link QueryManager} applies when recording history,
+* exposed so non-React implementations can manage their own history stacks without
+* reimplementing (and drifting from) the semantics.
+*
+* A change coalesces only when all three hold:
+* - the change is not structural (rules/groups added, removed, moved, or reordered)
+* - its signature matches the previously recorded signature
+* - it occurred within `coalesceMs` of the previous recording
+*
+* Note that {@link unchangedSignature} is not handled here. A change with no observable
+* difference is never recorded at all, which is a separate decision made before this check.
+*
+* @param prevSig Signature of the previously recorded change, or `undefined` if there is none.
+* @param nextSig Signature of the change being recorded, from {@link signatureOf}.
+* @param prevAt Timestamp of the previous recording.
+* @param now Timestamp of the change being recorded.
+* @param coalesceMs Coalescing window in milliseconds.
+*/
+const shouldCoalesce = (prevSig, nextSig, prevAt, now, coalesceMs = 500) => nextSig !== "~structural" && nextSig === prevSig && now >= prevAt && now - prevAt < coalesceMs;
+//#endregion
+//#region src/utils/defaultValidator.ts
+/**
+* This is an example validation function you can pass to {@link react-querybuilder!QueryBuilder QueryBuilder} in the
+* `validator` prop. It assumes that you want to validate groups, and has a no-op
+* for validating rules which you can replace with your own implementation.
+*/
+const defaultValidator = (query) => {
+	const result = {};
+	/**
+	* Replace this with your custom rule validator.
+	*/
+	const validateRule = (rule) => {
+		/* v8 ignore start -- @preserve */
+		if (rule.id) result[rule.id];
+		/* v8 ignore stop -- @preserve */
+	};
+	const validateGroup = (rg) => {
+		const reasons = [];
+		if (rg.rules.length === 0) reasons.push(require_utils.groupInvalidReasons.empty);
+		else if (!require_objectUtils.isRuleGroupType(rg)) {
+			let invalidICs = false;
+			for (let i = 0; i < rg.rules.length && !invalidICs; i++) if (i % 2 === 0 && typeof rg.rules[i] === "string" || i % 2 === 1 && typeof rg.rules[i] !== "string" || i % 2 === 1 && typeof rg.rules[i] === "string" && !require_utils.defaultCombinators.map((c) => c.name).includes(rg.rules[i])) invalidICs = true;
+			if (invalidICs) reasons.push(require_utils.groupInvalidReasons.invalidIndependentCombinators);
+		}
+		if (require_objectUtils.isRuleGroupType(rg) && !require_utils.defaultCombinators.map((c) => c.name).includes(rg.combinator) && rg.rules.length > 1) reasons.push(require_utils.groupInvalidReasons.invalidCombinator);
+		/* v8 ignore else -- @preserve */
+		if (rg.id) result[rg.id] = reasons.length > 0 ? {
+			valid: false,
+			reasons
+		} : true;
+		for (const r of rg.rules) if (typeof r === "string") {} else if (require_objectUtils.isRuleGroup(r)) validateGroup(r);
+		else validateRule(r);
+	};
+	validateGroup(query);
+	return result;
+};
+//#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
+	}
+];
+/**
+* Conditional classes applied to the query builder's wrapper element.
+*
+* Only a `boolean` validation result contributes a class; a {@link ValidationMap} describes
+* individual rules and groups, not the query as a whole.
+*/
+const queryBuilderOuterConditions = [
+	{
+		key: "disabled",
+		when: (s) => s.disabled
+	},
+	{
+		key: "valid",
+		when: (s) => typeof s.validationResult === "boolean" && s.validationResult
+	},
+	{
+		key: "invalid",
+		when: (s) => typeof s.validationResult === "boolean" && !s.validationResult
+	}
+];
+/**
+* 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?.[condition.key]), suppressStandardClassnames || Object.fromEntries(evaluated.map(([condition, active]) => [require_utils.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 || require_utils.standardClassnames[key], ...sources.map((source) => 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 || require_utils.standardClassnames[standardKey], 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);
+/**
+* The outer (wrapper) classname for the query builder itself, including the conditional
+* `disabled`, `valid`, and `invalid` state classes.
+*
+* @group Query Tools
+*/
+const deriveQueryBuilderClassNames = (options) => deriveOuterClassName("queryBuilder", queryBuilderOuterConditions, options);
+//#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) => 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) => 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?.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 && !require_utils.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 ? require_objectUtils.lc(rule.operator) === "in" || require_objectUtils.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" ? require_prepareQueryObjects.filterFieldsByComparator(fieldData, fields, rule.operator) : rule.valueSource === "parameter" ? parametersAsList ?? [] : getValues(rule.field, rule.operator, { fieldData });
+	return require_utils.isFlexibleOptionArray(v) || require_utils.isFlexibleOptionGroupArray(v) ? require_utils.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 ?? "") => 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 = {}) => {
+	const { fields, fieldMap, getInputType, getMatchModes, getOperators, getParameters, getValueEditorType, getValues, getValueSources, getSubQueryBuilderProps } = resolvers;
+	const fieldData = getFieldData(rule.field, fieldMap);
+	const inputType = fieldData.inputType ?? getInputType(rule.field, rule.operator, { fieldData });
+	const matchModes = getMatchModes(rule.field, { fieldData });
+	const operators = getOperators(rule.field, { fieldData });
+	const operatorObject = require_utils.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: getSubQueryBuilderProps?.(rule.field, { fieldData }) ?? {}
+	};
+};
+/**
+* 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) => require_objectUtils.isRuleGroupType(ruleGroup) ? ruleGroup.combinator : require_utils.getFirstOption(combinators) ?? "";
+/**
+* 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 = {}) => {
+	const independentCombinators = require_objectUtils.isRuleGroupTypeIC(ruleGroup);
+	const combinator = getRuleGroupCombinator(ruleGroup, combinators);
+	const combinatorObject = require_utils.getOption(combinators, combinator);
+	return {
+		combinator,
+		combinatorObject,
+		combinators,
+		combinatorBasedClassName: independentCombinators ? null : combinatorObject?.className ?? "",
+		independentCombinators,
+		validationResult: (options.validationMap ?? {})[options.id ?? ruleGroup.id ?? ""] ?? null
+	};
+};
+//#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 }) => {
+	return !skipHook && type !== "multiselect" && !multiValueOperators.has(operator) && (Array.isArray(value) || inputType === "number" && typeof value === "string" && value.includes(",")) ? {
+		reset: true,
+		value: require_utils.toArray(value, { retainEmptyStrings: true })[0] ?? ""
+	} : {
+		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 = require_utils.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 : require_utils.joinWith(valueAsArray, ",");
+	const v = [...valueAsArray];
+	v[index] = parsedVal;
+	if (needsBetweenFix) v[1] = require_utils.getFirstOption(values) ?? "";
+	return listsAsArrays ? v : require_utils.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 = require_utils.parseNumber(value, {
+		parseNumbers: parseNumberMethod,
+		bigIntOnOverflow: true
+	});
+	try {
+		return BigInt(valAsMaybeNumber);
+	} catch {
+		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 = require_utils.toArray(value);
+	return listsAsArrays ? valueAsArray : require_utils.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 ? require_utils.toArray(value).map(String) : value;
+//#endregion
+//#region src/utils/pathUtils.ts
+/**
+* Returns the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
+* at the given path within a query.
+*/
+const findPath = (path, query) => {
+	let target = query;
+	let level = 0;
+	while (level < path.length && target && require_objectUtils.isRuleGroup(target)) {
+		const t = target.rules[path[level]];
+		target = typeof t === "string" ? null : t;
+		level++;
+	}
+	return level < path.length ? null : target;
+};
+/**
+* Returns the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
+* with the given `id` within a query.
+*/
+const findID = (id, query) => {
+	if (query.id === id) return query;
+	for (const rule of query.rules) {
+		if (typeof rule === "string") continue;
+		if (rule.id === id) return rule;
+		else if (require_objectUtils.isRuleGroup(rule)) {
+			const subRule = findID(id, rule);
+			if (subRule) return subRule;
+		}
+	}
+	return null;
+};
+/**
+* Returns the {@link Path} of the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
+* with the given `id` within a query.
+*/
+const getPathOfID = (id, query) => {
+	if (query.id === id) return [];
+	const idx = query.rules.findIndex((r) => !(typeof r === "string") && r.id === id);
+	if (idx >= 0) return [idx];
+	for (const [i, r] of Object.entries(query.rules)) if (require_objectUtils.isRuleGroup(r)) {
+		const subPath = getPathOfID(id, r);
+		if (Array.isArray(subPath)) return [Number.parseInt(i), ...subPath];
+	}
+	return null;
+};
+/**
+* Truncates the last element of an array and returns the result as a new array.
+*/
+const getParentPath = (path) => path.slice(0, -1);
+/**
+* Determines if two paths (each `Path`) are equivalent.
+*/
+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) => {
+	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.
+*/
+const getCommonAncestorPath = (path1, path2) => {
+	const commonAncestorPath = [];
+	const parentPath1 = getParentPath(path1);
+	const parentPath2 = getParentPath(path2);
+	let i = 0;
+	while (i < parentPath1.length && i < parentPath2.length && parentPath1[i] === parentPath2[i]) {
+		commonAncestorPath.push(parentPath2[i]);
+		i++;
+	}
+	return commonAncestorPath;
+};
+/**
+* Determines if the rule or group at the specified path is either disabled itself
+* or disabled by an ancestor group.
+*/
+const pathIsDisabled = (path, query) => {
+	let disabled = !!query.disabled;
+	let target = query;
+	let level = 0;
+	while (level < path.length && !disabled && require_objectUtils.isRuleGroup(target)) {
+		const t = target.rules[path[level]];
+		if (require_objectUtils.isPojo(t) && (require_objectUtils.isRuleGroup(t) || "field" in t && !!t.field)) {
+			disabled = !!t.disabled;
+			target = t;
+		}
+		level++;
+	}
+	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
+/**
+* The default `accessibleDescriptionGenerator`. Produces the `aria-label` for a rule group:
+* `"Query builder"` for the root group, `"Rule group at path 0-1"` for any other.
+*
+* @group Accessibility
+*/
+const generateAccessibleDescription = (params) => pathsAreEqual([], params.path) ? `Query builder` : `Rule group at path ${params.path.join("-")}`;
+//#endregion
+//#region src/utils/getMatchModesUtil.ts
+const dummyFD = {
+	name: "name",
+	value: "name",
+	matchModes: null,
+	label: "label"
+};
+/**
+* Utility function to get the match modes array for the given
+* field. If the field definition does not define a `matchModes`
+* property, the `getMatchModes` prop is used. Returns
+* `FullOption<MatchMode>[]` of all match modes by default.
+*/
+const getMatchModesUtil = (fieldData, getMatchModes) => {
+	const fd = fieldData ? require_utils.toFullOption(fieldData) : /* v8 ignore next -- @preserve */ dummyFD;
+	let matchModes = fd.matchModes ?? false;
+	if (!matchModes && getMatchModes) matchModes = getMatchModes(fd.value, { fieldData: fd });
+	if (matchModes === true) return require_utils.defaultMatchModes;
+	else if (matchModes === false) return [];
+	if (require_utils.isFlexibleOptionArray(matchModes)) return require_utils.toFullOptionList(matchModes);
+	return matchModes?.map((mm) => require_utils.defaultMatchModes.find((dmm) => dmm.value === require_objectUtils.lc(mm)) ?? {
+		name: mm,
+		value: mm,
+		label: mm
+	}) ?? [];
+};
+//#endregion
+//#region src/utils/getRuleDefaultValue.ts
+const getFirstOptionsFrom = (opts, r, listsAsArrays) => {
+	const firstOption = require_utils.getFirstOption(opts);
+	if (r.operator === "between" || r.operator === "notBetween") {
+		const valueAsArray = [firstOption, firstOption];
+		return listsAsArrays ? valueAsArray : require_utils.joinWith(valueAsArray.map((v) => v ?? /* v8 ignore start -- @preserve */ ""), ",");
+	}
+	return firstOption;
+};
+/**
+* Computes the default `value` for a rule given its `field`/`operator`/`valueSource`, mirroring
+* the precedence the {@link react-querybuilder!QueryBuilder QueryBuilder} applies: a field's
+* `defaultValue`, then a `getDefaultValue` override, then a value derived from the field/operator's
+* value list and editor type (first option for `select`/`radio`, `false` for `checkbox`, paired for
+* `between`/`notBetween`), or a comparator-valid field when `valueSource` is `'field'`. Falls back
+* to `''`.
+*
+* @group Option Lists
+*/
+const getRuleDefaultValue = (rule, options) => {
+	const { fieldData, fields, getValueEditorType, getValues, getDefaultValue, getParameters, listsAsArrays } = options;
+	if (fieldData?.defaultValue !== void 0 && fieldData.defaultValue !== null) return fieldData.defaultValue;
+	else if (getDefaultValue) return getDefaultValue(rule, { fieldData });
+	let value = "";
+	const values = getValues(rule.field, rule.operator, { fieldData });
+	if (rule.valueSource === "field") {
+		const filteredFields = require_prepareQueryObjects.filterFieldsByComparator(fieldData, fields, rule.operator);
+		value = filteredFields.length > 0 ? getFirstOptionsFrom(filteredFields, rule, listsAsArrays) : "";
+	} else if (rule.valueSource === "parameter") {
+		const parameters = getParameters ? getParameters(rule.field, rule.operator, { fieldData }) : null;
+		value = parameters && parameters.length > 0 ? require_utils.getFirstOption(parameters) : "";
+	} else if (values.length > 0) {
+		const editorType = getValueEditorType(rule.field, rule.operator, { fieldData });
+		if (editorType === "multiselect") value = listsAsArrays ? [] : "";
+		else if (editorType === "select" || editorType === "radio") value = getFirstOptionsFrom(values, rule, listsAsArrays);
+	} else if (getValueEditorType(rule.field, rule.operator, { fieldData }) === "checkbox") value = false;
+	return value;
+};
+//#endregion
+//#region src/utils/getValidationClassNames.ts
+/**
+* Gets the standard classname for valid or invalid components
+* based on the given validation result.
+*/
+const getValidationClassNames = (validationResult) => {
+	const valid = typeof validationResult === "boolean" ? validationResult : typeof validationResult === "object" && validationResult !== null ? validationResult.valid : null;
+	return typeof valid === "boolean" ? valid ? require_utils.standardClassnames.valid : require_utils.standardClassnames.invalid : "";
+};
+//#endregion
+//#region src/utils/immerInstances.ts
+/**
+* Globally enables or disables immer's auto-freeze, i.e. the deep freeze applied to every query
+* returned by {@link add}, {@link update}, {@link remove}, {@link move}, {@link insert}, and
+* {@link group}.
+*
+* Re-exported from immer so that consumers mixing these tools with their own `produce` calls can
+* switch both at once. Prefer the per-call `freeze` option, or the {@link QueryManager} option of
+* the same name, when the change should not be process-wide. A per-call `freeze: false` wins
+* regardless of this setting; a per-call `freeze: true` does not re-enable freezing once this has
+* turned it off, since it selects immer's default instance.
+*
+* @group Query Tools
+*/
+const setAutoFreeze = immer.setAutoFreeze;
+const unfrozenImmer = new immer.Immer({ autoFreeze: false });
+/**
+* The `produce` implementation matching the requested freeze behavior.
+*
+* @internal
+*/
+const producerFor = (freeze = true) => freeze ? immer.produce : unfrozenImmer.produce;
+//#endregion
+//#region src/utils/mergeAnyTranslations.ts
+/**
+* Merges any number of partial translations into a single definition.
+*/
+const mergeAnyTranslations = (base, ...otherTranslations) => {
+	const result = { ...base };
+	for (const translations of otherTranslations)
+ // v8 ignore else
+	if (translations) for (const key of require_objectUtils.objectKeys(translations)) {
+		if (require_objectUtils.isUnsafeKey(key)) continue;
+		if (result[key]) result[key] = {
+			...result[key],
+			...translations[key]
+		};
+		else result[key] = { ...translations[key] };
+	}
+	return result;
+};
+const mergeAnyTranslation = (el, keyPropContextMap, defaults) => {
+	if (require_objectUtils.isUnsafeKey(el)) return void 0;
+	const finalKeys = require_objectUtils.objectEntries(keyPropContextMap).map(([key, [pT, cT]]) => [key, pT ?? cT ?? defaults?.[el]?.[key]]).filter((k) => !require_objectUtils.isUnsafeKey(k[0]) && !!k[1]);
+	if (finalKeys.length > 0 || defaults) {
+		const defaultProperties = defaults?.[el] ?? {};
+		const finalObject = Object.assign({}, defaultProperties, Object.fromEntries(finalKeys));
+		return { [el]: finalObject };
+	}
+};
+//#endregion
+//#region src/utils/mergeClassnames.ts
+const joinClassnamesByName = (name, args) => {
+	let result = "";
+	for (let i = 0; i < args.length; i++) {
+		const v = args[i]?.[name];
+		if (!v) continue;
+		const s = typeof v === "string" ? v : clsx(v);
+		if (s) result = result ? `${result} ${s}` : s;
+	}
+	return result;
+};
+/**
+* Merges a list of partial {@link Classnames} definitions into a single definition.
+*/
+const mergeClassnames = (...args) => ({
+	queryBuilder: joinClassnamesByName("queryBuilder", args),
+	ruleGroup: joinClassnamesByName("ruleGroup", args),
+	header: joinClassnamesByName("header", args),
+	body: joinClassnamesByName("body", args),
+	combinators: joinClassnamesByName("combinators", args),
+	addRule: joinClassnamesByName("addRule", args),
+	addGroup: joinClassnamesByName("addGroup", args),
+	cloneRule: joinClassnamesByName("cloneRule", args),
+	cloneGroup: joinClassnamesByName("cloneGroup", args),
+	removeGroup: joinClassnamesByName("removeGroup", args),
+	rule: joinClassnamesByName("rule", args),
+	fields: joinClassnamesByName("fields", args),
+	operators: joinClassnamesByName("operators", args),
+	value: joinClassnamesByName("value", 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),
+	muteRule: joinClassnamesByName("muteRule", args),
+	muteGroup: joinClassnamesByName("muteGroup", args),
+	muted: joinClassnamesByName("muted", args),
+	valueSource: joinClassnamesByName("valueSource", args),
+	actionElement: joinClassnamesByName("actionElement", args),
+	valueSelector: joinClassnamesByName("valueSelector", args),
+	betweenRules: joinClassnamesByName("betweenRules", args),
+	valid: joinClassnamesByName("valid", args),
+	invalid: joinClassnamesByName("invalid", args),
+	dndDragging: joinClassnamesByName("dndDragging", args),
+	dndOver: joinClassnamesByName("dndOver", args),
+	dndCopy: joinClassnamesByName("dndCopy", args),
+	dndGroup: joinClassnamesByName("dndGroup", args),
+	dndDropNotAllowed: joinClassnamesByName("dndDropNotAllowed", args),
+	dndPreviewPosition: joinClassnamesByName("dndPreviewPosition", args),
+	dndHidden: joinClassnamesByName("dndHidden", args),
+	disabled: joinClassnamesByName("disabled", args),
+	valueListItem: joinClassnamesByName("valueListItem", args),
+	matchMode: joinClassnamesByName("matchMode", args),
+	matchThreshold: joinClassnamesByName("matchThreshold", args),
+	branches: joinClassnamesByName("branches", args),
+	hasSubQuery: joinClassnamesByName("hasSubQuery", args),
+	loading: joinClassnamesByName("loading", 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 }) => require_utils.prepareOptionList({
+	optionList: fieldData?.operators ?? getOperators?.(field, { fieldData }) ?? operators,
+	placeholder,
+	baseOption,
+	labelMap: require_utils.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 }) => {
+	if (fieldData?.defaultOperator) return fieldData.defaultOperator;
+	if (getDefaultOperator) return typeof getDefaultOperator === "function" ? getDefaultOperator(field, { fieldData }) : getDefaultOperator;
+	return require_utils.getFirstOption(getOperators(field, { fieldData })) ?? "";
+};
+/**
+* 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 }) => {
+	if (fieldData?.valueEditorType) return typeof fieldData.valueEditorType === "function" ? fieldData.valueEditorType(operator) : fieldData.valueEditorType;
+	return getValueEditorType?.(field, operator, { fieldData }) ?? "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 }) => require_utils.prepareOptionList({
+	optionList: fieldData?.values ?? getValues?.(field, operator, { fieldData }) ?? [],
+	placeholder,
+	baseOption,
+	autoSelectOption
+}).optionList;
+//#endregion
+//#region src/utils/optionsEqual.ts
+const isPlainObject = (x) => {
+	const proto = Object.getPrototypeOf(x);
+	return proto === null || proto === Object.prototype;
+};
+/**
+* Structural equality for {@link QueryManagerOptions} values. Arrays and plain objects are
+* compared by value; everything else — functions, class instances, `Map`s, `Date`s — by
+* identity.
+*
+* That split is what makes an options object rebuilt on every render compare equal as long as
+* its _data_ did not change, which is the entire point: a caller that passes object literals
+* (`fields={[...]}`, `translations={{...}}`) hands a fresh identity to every reconfigure, so an
+* identity-only comparison would report a change every time.
+*
+* Comparing functions by identity is deliberate rather than a limitation. Two functions cannot
+* be proven equivalent, so a caller that rebuilds `getDefaultValue` per render must either
+* memoize it or accept the reconfigure.
+*/
+const valuesEqual = (a, b) => {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => valuesEqual(v, b[i]));
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b) || !isPlainObject(a)) return false;
+	const aKeys = Object.keys(a);
+	return aKeys.length === Object.keys(b).length && aKeys.every((k) => valuesEqual(a[k], b[k]));
+};
+/**
+* Whether two {@link QueryManagerOptions} objects describe the same configuration, per
+* {@link valuesEqual}: data by value, functions by identity.
+*
+* {@link QueryManager.reconfigure} uses this to gate itself, so most callers never need it
+* directly. It is exported for framework adapters that decide whether to _call_ `reconfigure`
+* at all — skipping the call avoids building the merged options object in the first place.
+*
+* Nested option objects (`history`, `translations`, …) are descended into rather than compared
+* by identity, so `{ history: { maxHistory: 10 } }` rebuilt per render compares equal.
+*/
+const optionsEqual = (a, b) => valuesEqual(a, b);
+//#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;
+/**
+* For given default, prop, and context values, return the first provided of prop,
+* context, and default, in that order.
+*/
+const preferProp = (def, prop, context, doNotFinalize) => !doNotFinalize ? def ? preferPropDefaultTrue(prop, context) : preferPropDefaultFalse(prop, context) : prop ?? context;
+/**
+* For given default, prop, and context values, return the first provided of prop,
+* context, and default, in that order.
+*/
+const preferAnyProp = (def, prop, context) => prop !== void 0 && prop != null ? prop : context !== void 0 && context != null ? context : def;
+/**
+* For a given set of defaults, props, and context values, return the first provided of prop,
+* context, and default—in that order—for each property in the defaults object.
+*/
+const preferFlagProps = (props = {}, contextVals = {}, finalize) => require_objectUtils.objectEntries(require_utils.queryBuilderFlagDefaults).reduce((acc, [key, def]) => {
+	acc[key] = preferProp(def, props[key], contextVals[key], !finalize);
+	return acc;
+}, {});
+//#endregion
+//#region src/utils/regenerateIDs.ts
+/**
+* Generates a new `id` property for a rule.
+*/
+const regenerateID = (rule, { idGenerator = require_prepareQueryObjects.generateID } = {}) => structuredClone({
+	...rule,
+	id: idGenerator()
+});
+/**
+* Recursively generates new `id` properties for a rule group and all its rules and subgroups.
+*/
+const regenerateIDs = (subject, { idGenerator = require_prepareQueryObjects.generateID } = {}) => {
+	if (!require_objectUtils.isPojo(subject)) return subject;
+	if (!require_objectUtils.isRuleGroup(subject)) return structuredClone({
+		...subject,
+		id: idGenerator()
+	});
+	const newGroup = {
+		...subject,
+		id: idGenerator()
+	};
+	// v8 ignore else
+	if (Array.isArray(newGroup.rules)) newGroup.rules = subject.rules.map((r) => typeof r === "string" ? r : require_objectUtils.isRuleGroup(r) ? regenerateIDs(r, { idGenerator }) : regenerateID(r, { idGenerator }));
+	return newGroup;
+};
+//#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.
+*
+* @group Query Tools
+*/
+const add = (query, ruleOrGroup, parentPathOrID, options = {}) => producerFor(options.freeze)(query, (q) => addInPlace(q, ruleOrGroup, parentPathOrID, options));
+/**
+* Adds a rule or group to a query in place.
+*
+* @returns The query (mutated in place) with the rule or group added.
+*
+* @group Query Tools
+*/
+const addInPlace = (query, ruleOrGroup, parentPathOrID, options = {}) => {
+	const { combinators = require_utils.defaultCombinators, combinatorPreceding, idGenerator = require_prepareQueryObjects.generateID, onAbort } = options;
+	const parent = Array.isArray(parentPathOrID) ? findPath(parentPathOrID, query) : findID(parentPathOrID, query);
+	if (!parent) {
+		onAbort?.({
+			reason: "parent-not-found",
+			operation: "add",
+			pathOrID: parentPathOrID
+		});
+		return query;
+	}
+	if (!require_objectUtils.isRuleGroup(parent)) {
+		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?.({
+			reason: addGuardReason,
+			operation: "add",
+			pathOrID: parentPathOrID
+		});
+		return query;
+	}
+	if (require_objectUtils.isRuleGroup(ruleOrGroup) && exceedsMaxLevels(parentPath, options)) {
+		onAbort?.({
+			reason: "max-levels-exceeded",
+			operation: "add",
+			pathOrID: parentPathOrID
+		});
+		return query;
+	}
+	if (require_objectUtils.isRuleGroupTypeIC(parent) && parent.rules.length > 0) {
+		const prevCombinator = parent.rules.at(-2);
+		parent.rules.push(combinatorPreceding ?? (typeof prevCombinator === "string" ? prevCombinator : require_utils.getFirstOption(combinators)));
+	}
+	parent.rules.push(require_prepareQueryObjects.prepareRuleOrGroup(ruleOrGroup, { idGenerator }));
+	return query;
+};
+/**
+* Relative order in which properties are applied during a multi-property update.
+* Lower ranks apply first; `value` applies last so an explicitly-provided value
+* is never clobbered by a reset triggered by a `field`/`operator`/`valueSource`
+* change. Unranked properties default to `3` (between `valueSource` and `value`).
+*/
+const updatePropRank = {
+	field: 0,
+	operator: 1,
+	valueSource: 2,
+	value: 4
+};
+/** Stable-sorts `[prop, value]` entries by {@link updatePropRank}. */
+const orderUpdateEntries = (entries) => entries.toSorted((x, y) => (updatePropRank[x[0]] ?? 3) - (updatePropRank[y[0]] ?? 3));
+/**
+* Normalizes the variadic {@link update}/{@link updateInPlace} arguments (single
+* prop+value, parallel arrays, or property map) into a canonically-ordered list
+* of `[prop, value]` entries plus the target path/ID and options.
+*/
+const normalizeUpdateArgs = (a, b, c, d) => {
+	if (typeof a === "string") return {
+		entries: [[a, b]],
+		pathOrID: c,
+		options: d ?? {}
+	};
+	if (Array.isArray(a)) {
+		const values = b;
+		return {
+			entries: orderUpdateEntries(a.map((prop, i) => [prop, values[i]])),
+			pathOrID: c,
+			options: d ?? {}
+		};
+	}
+	return {
+		entries: orderUpdateEntries(Object.entries(a)),
+		pathOrID: b,
+		options: c ?? {}
+	};
+};
+/**
+* The options argument of an {@link update} call, whose position depends on the argument form.
+* Cheaper than {@link normalizeUpdateArgs} when only the options are needed.
+*/
+const updateOptionsOf = (a, b, c, d) => (typeof a === "string" || Array.isArray(a) ? d : c) ?? {};
+/**
+* Applies one or more property updates to a query in place. Shared by
+* {@link update} and {@link updateInPlace}.
+*/
+const applyUpdatesInPlace = (query, a, b, c, d) => {
+	const { entries, pathOrID, options } = normalizeUpdateArgs(a, b, c, d);
+	for (const [prop, value] of entries) updateInPlaceSingle(query, prop, value, pathOrID, options);
+	return query;
+};
+/**
+* Updates one or more properties of a rule or group within a query without
+* mutating the original query. Properties may be supplied individually
+* (`prop`, `value`), as parallel arrays (`props`, `values`), or as a
+* property-to-value map. For multi-property updates, `field`, `operator`, and
+* `valueSource` are applied before `value`, so an explicit `value` is never
+* reset by a change to one of those properties.
+*
+* @returns A new query with the rule or group properties updated.
+*
+* @group Query Tools
+*/
+const update = ((query, a, b, c, d) => producerFor(updateOptionsOf(a, b, c, d).freeze)(query, (q) => {
+	applyUpdatesInPlace(q, a, b, c, d);
+}));
+/**
+* Updates one or more properties of a rule or group within a query in place.
+* See {@link update} for the supported argument forms and ordering semantics.
+*
+* @returns The query (mutated in place) with the rule or group properties updated.
+*
+* @group Query Tools
+*/
+const updateInPlace = ((query, a, b, c, d) => applyUpdatesInPlace(query, a, b, c, d));
+/**
+* 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 = () => [], onAbort } = options;
+	let resetOnFieldChange = _resetOnFieldChange;
+	const path = Array.isArray(pathOrID) ? pathOrID : getPathOfID(pathOrID, query);
+	if (!path) {
+		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?.({
+			reason: updateGuardReason,
+			operation: "update",
+			pathOrID
+		});
+		return query;
+	}
+	if (prop === "combinator" && !require_objectUtils.isRuleGroupType(query)) {
+		const parent = findPath(getParentPath(path), query);
+		if (!parent || !require_objectUtils.isRuleGroup(parent)) {
+			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?.({
+				reason: "no-change",
+				operation: "update",
+				pathOrID
+			});
+			else parentRules[path.at(-1)] = value;
+		} else onAbort?.({
+			reason: "not-a-combinator-slot",
+			operation: "update",
+			pathOrID
+		});
+		return query;
+	}
+	const ruleOrGroup = findPath(path, query);
+	if (!ruleOrGroup) {
+		onAbort?.({
+			reason: "target-not-found",
+			operation: "update",
+			pathOrID
+		});
+		return query;
+	}
+	const isGroup = require_objectUtils.isRuleGroup(ruleOrGroup);
+	if (ruleOrGroup[prop] === value) {
+		onAbort?.({
+			reason: "no-change",
+			operation: "update",
+			pathOrID
+		});
+		return query;
+	}
+	if (prop !== "valueSource") ruleOrGroup[prop] = value;
+	if (isGroup) return query;
+	let resetValueSource = false;
+	let resetValue = false;
+	if (prop === "field") {
+		const fromFieldMatchModes = getMatchModes(ruleOrGroup.field);
+		const toFieldMatchModes = getMatchModes(value);
+		if (toFieldMatchModes.length === 0) delete ruleOrGroup.match;
+		else {
+			const nextMatchMode = ruleOrGroup.match?.mode && require_utils.getOption(toFieldMatchModes, ruleOrGroup.match.mode) ? null : require_utils.getFirstOption(toFieldMatchModes);
+			if (nextMatchMode) ruleOrGroup.match = {
+				mode: nextMatchMode,
+				threshold: 1
+			};
+		}
+		if (fromFieldMatchModes.length > 0 || toFieldMatchModes.length > 0) resetOnFieldChange = true;
+	}
+	if (resetOnFieldChange && prop === "field") {
+		ruleOrGroup.operator = getRuleDefaultOperator(value);
+		resetValueSource = true;
+		resetValue = true;
+	}
+	if (resetOnOperatorChange && prop === "operator") {
+		resetValueSource = true;
+		resetValue = true;
+	}
+	const valueSources = require_prepareQueryObjects.getValueSourcesUtil({
+		name: ruleOrGroup.field,
+		value: ruleOrGroup.field,
+		label: ""
+	}, ruleOrGroup.operator, getValueSources);
+	const defaultValueSource = require_utils.getFirstOption(valueSources);
+	if (resetValueSource && ruleOrGroup.valueSource && defaultValueSource !== ruleOrGroup.valueSource || prop === "valueSource" && value !== ruleOrGroup.valueSource) {
+		resetValue = !!ruleOrGroup.valueSource || !ruleOrGroup.valueSource && value !== defaultValueSource;
+		ruleOrGroup.valueSource = resetValueSource ? defaultValueSource : value;
+	}
+	if (resetValue) ruleOrGroup.value = getRuleDefaultValue(ruleOrGroup);
+	return query;
+};
+/**
+* Removes a rule or group from a query without mutating the original query.
+*
+* @returns A new query with the rule or group removed.
+*
+* @group Query Tools
+*/
+const remove = (query, pathOrID, options = {}) => producerFor(options.freeze)(query, (q) => removeInPlace(q, pathOrID, options));
+/**
+* Removes a rule or group from a query in place.
+*
+* @returns The query (mutated in place) with the rule or group removed.
+*
+* @group Query Tools
+*/
+const removeInPlace = (query, pathOrID, options = {}) => {
+	const { onAbort } = options;
+	const path = Array.isArray(pathOrID) ? pathOrID : getPathOfID(pathOrID, query);
+	if (!path) {
+		onAbort?.({
+			reason: "target-not-found",
+			operation: "remove",
+			pathOrID
+		});
+		return query;
+	}
+	if (path.length === 0) {
+		onAbort?.({
+			reason: "root-not-allowed",
+			operation: "remove",
+			pathOrID
+		});
+		return query;
+	}
+	const removeGuardReason = getGuardAbortReason(query, path, options);
+	if (removeGuardReason) {
+		onAbort?.({
+			reason: removeGuardReason,
+			operation: "remove",
+			pathOrID
+		});
+		return query;
+	}
+	if (!findPath(path, query)) {
+		onAbort?.({
+			reason: "target-not-found",
+			operation: "remove",
+			pathOrID
+		});
+		return query;
+	}
+	const index = path.at(-1);
+	const parent = findPath(getParentPath(path), query);
+	if (!require_objectUtils.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 = require_objectUtils.isRuleGroupTypeIC(query);
+	if (newPathOrShiftDirection === "up") {
+		if (pathsAreEqual(currentPath, [0])) return currentPath;
+		else if (currentPath.at(-1) === 0) {
+			const parentPath = getParentPath(currentPath);
+			return [...getParentPath(parentPath), Math.max(0, parentPath.at(-1) - (ic ? 1 : 0))];
+		} else {
+			const evaluationPath = [...getParentPath(currentPath), Math.max(0, currentPath.at(-1) - (ic ? 2 : 1))];
+			const entityAtTarget = findPath(evaluationPath, query);
+			if (require_objectUtils.isRuleGroup(entityAtTarget)) return [...evaluationPath, entityAtTarget.rules.length];
+			else return [...getParentPath(currentPath), Math.max(0, currentPath.at(-1) - (ic ? 3 : 1))];
+		}
+	} else if (newPathOrShiftDirection === "down") {
+		if (pathsAreEqual([query.rules.length - 1], currentPath)) return currentPath;
+		else if (currentPath.at(-1) === findPath(getParentPath(currentPath), query).rules.length - 1) {
+			const parentPath = getParentPath(currentPath);
+			return [...getParentPath(parentPath), parentPath.at(-1) + 1];
+		} else {
+			const evaluationPath = [...getParentPath(currentPath), currentPath.at(-1) + (ic ? 2 : 1)];
+			const entityToEvaluate = findPath(evaluationPath, query);
+			if (require_objectUtils.isRuleGroup(entityToEvaluate)) return [...evaluationPath, 0];
+			else return [...getParentPath(currentPath), currentPath.at(-1) + (ic ? 3 : 2)];
+		}
+	}
+	return currentPath;
+};
+/**
+* Moves a rule or group from one path to another without mutating the original query.
+* In the options parameter, pass `{ clone: true }` to copy instead of move.
+*
+* @returns A new query with the rule or group moved or cloned.
+*
+* @group Query Tools
+*/
+const move = (query, oldPathOrID, newPath, options = {}) => producerFor(options.freeze)(query, (q) => moveInPlace(q, oldPathOrID, newPath, options));
+/**
+* Moves a rule or group from one path to another in place.
+* In the options parameter, pass `{ clone: true }` to copy instead of move.
+*
+* @returns The query (mutated in place) with the rule or group moved or cloned.
+*
+* @group Query Tools
+*/
+const moveInPlace = (query, oldPathOrID, newPath, options = {}) => {
+	const { clone = false, combinators = require_utils.defaultCombinators, idGenerator = require_prepareQueryObjects.generateID, onAbort } = options;
+	const oldPath = Array.isArray(oldPathOrID) ? oldPathOrID : getPathOfID(oldPathOrID, query);
+	if (!oldPath) {
+		onAbort?.({
+			reason: "target-not-found",
+			operation: "move",
+			pathOrID: oldPathOrID
+		});
+		return query;
+	}
+	const ruleOrGroupOriginal = findPath(oldPath, query);
+	if (!ruleOrGroupOriginal) {
+		onAbort?.({
+			reason: "target-not-found",
+			operation: "move",
+			pathOrID: oldPathOrID
+		});
+		return query;
+	}
+	const nextPath = getNextPath(query, oldPath, newPath);
+	if (oldPath.length === 0) {
+		onAbort?.({
+			reason: "root-not-allowed",
+			operation: "move",
+			pathOrID: oldPathOrID
+		});
+		return query;
+	}
+	const moveGuardReason = getGuardAbortReason(query, oldPath, options);
+	if (moveGuardReason) {
+		onAbort?.({
+			reason: moveGuardReason,
+			operation: "move",
+			pathOrID: oldPathOrID
+		});
+		return query;
+	}
+	if (pathsAreEqual(oldPath, nextPath)) {
+		onAbort?.({
+			reason: "same-location",
+			operation: "move",
+			pathOrID: oldPathOrID
+		});
+		return query;
+	}
+	if (!findPath(getParentPath(nextPath), query)) {
+		onAbort?.({
+			reason: "destination-not-found",
+			operation: "move",
+			pathOrID: newPath
+		});
+		return query;
+	}
+	if (!clone && isAncestor(oldPath, nextPath)) {
+		onAbort?.({
+			reason: "destination-not-found",
+			operation: "move",
+			pathOrID: newPath
+		});
+		return query;
+	}
+	const ruleOrGroup = clone ? regenerateIDs((0, immer.isDraft)(ruleOrGroupOriginal) ? (0, immer.current)(ruleOrGroupOriginal) : ruleOrGroupOriginal, { idGenerator }) : ruleOrGroupOriginal;
+	const independentCombinators = require_objectUtils.isRuleGroupTypeIC(query);
+	const parentOfRuleToRemove = findPath(getParentPath(oldPath), query);
+	const ruleToRemoveIndex = oldPath.at(-1);
+	const oldPrevCombinator = independentCombinators && ruleToRemoveIndex > 0 ? parentOfRuleToRemove.rules[ruleToRemoveIndex - 1] : null;
+	const oldNextCombinator = independentCombinators && ruleToRemoveIndex < parentOfRuleToRemove.rules.length - 1 ? parentOfRuleToRemove.rules[ruleToRemoveIndex + 1] : null;
+	if (!clone) {
+		const idxStartDelete = independentCombinators ? Math.max(0, ruleToRemoveIndex - 1) : ruleToRemoveIndex;
+		const deleteLength = independentCombinators ? 2 : 1;
+		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 && 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(spliceIndex, 0, ...args);
+	if (parentToInsertInto.rules.length === 0 || !independentCombinators) insertRuleOrGroup(ruleOrGroup);
+	else if (newIndex === 0) {
+		if (ruleToRemoveIndex === 0 && oldNextCombinator) insertRuleOrGroup(ruleOrGroup, oldNextCombinator);
+		else insertRuleOrGroup(ruleOrGroup, parentToInsertInto.rules[1] ?? oldPrevCombinator ?? require_utils.getFirstOption(combinators));
+	} else if (oldPrevCombinator) insertRuleOrGroup(oldPrevCombinator, ruleOrGroup);
+	else insertRuleOrGroup(parentToInsertInto.rules[spliceIndex - 2] ?? oldNextCombinator ?? require_utils.getFirstOption(combinators), ruleOrGroup);
+	return query;
+};
+/**
+* Inserts a rule or group into a query without mutating the original query.
+*
+* @returns A new query with the rule or group inserted.
+*
+* @group Query Tools
+*/
+const insert = (query, ruleOrGroup, path, options = {}) => producerFor(options.freeze)(query, (q) => insertInPlace(q, ruleOrGroup, path, options));
+/**
+* Inserts a rule or group into a query in place.
+*
+* @returns The query (mutated in place) with the rule or group inserted.
+*
+* @group Query Tools
+*/
+const insertInPlace = (query, ruleOrGroup, path, options = {}) => {
+	const { combinators = require_utils.defaultCombinators, combinatorPreceding, combinatorSucceeding, idGenerator = require_prepareQueryObjects.generateID, replace = false, onAbort } = options;
+	const parentToInsertInto = findPath(getParentPath(path), query);
+	if (!parentToInsertInto) {
+		onAbort?.({
+			reason: "parent-not-found",
+			operation: "insert",
+			pathOrID: path
+		});
+		return query;
+	}
+	if (!require_objectUtils.isRuleGroup(parentToInsertInto)) {
+		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?.({
+			reason: insertGuardReason,
+			operation: "insert",
+			pathOrID: path
+		});
+		return query;
+	}
+	if (require_objectUtils.isRuleGroup(ruleOrGroup) && exceedsMaxLevels(parentPath, options)) {
+		onAbort?.({
+			reason: "max-levels-exceeded",
+			operation: "insert",
+			pathOrID: path
+		});
+		return query;
+	}
+	const rorg = regenerateIDs(ruleOrGroup, { idGenerator });
+	const independentCombinators = require_objectUtils.isRuleGroupTypeIC(query);
+	const newIndex = path.at(-1);
+	/**
+	* 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 = (idx, ...args) => parentToInsertInto.rules.splice(idx, replace ? args.length : 0, ...args);
+	if (parentToInsertInto.rules.length === 0 || !independentCombinators) insertRuleOrGroup(newIndex, rorg);
+	else if (replace && independentCombinators) insertRuleOrGroup(newIndex + newIndex % 2, rorg);
+	else if (newIndex === 0) {
+		if (rorg.path?.at(-1) === 0 && combinatorSucceeding) insertRuleOrGroup(newIndex, rorg, combinatorSucceeding);
+		else insertRuleOrGroup(newIndex, rorg, parentToInsertInto.rules[1] ?? combinatorPreceding ?? require_utils.getFirstOption(combinators));
+	} else {
+		const normalizedNewIndex = newIndex % 2 === 0 ? newIndex - 1 : newIndex;
+		if (combinatorPreceding) insertRuleOrGroup(normalizedNewIndex, combinatorPreceding, rorg);
+		else insertRuleOrGroup(normalizedNewIndex, parentToInsertInto.rules[normalizedNewIndex - 2] ?? combinatorSucceeding ?? require_utils.getFirstOption(combinators), rorg);
+	}
+	return query;
+};
+/**
+* Creates a new group at a target path with its `rules` array containing the current
+* objects at the target path and the source path without mutating the original query.
+* In the options parameter, pass `{ clone: true }` to copy the source rule/group instead of move.
+*
+* @returns A new query with the rules or groups grouped.
+*
+* @group Query Tools
+*/
+const group = (query, sourcePathOrID, targetPathOrID, options = {}) => producerFor(options.freeze)(query, (q) => groupInPlace(q, sourcePathOrID, targetPathOrID, options));
+/**
+* Creates a new group at a target path with its `rules` array containing the current
+* objects at the target path and the source path in place.
+* In the options parameter, pass `{ clone: true }` to copy the source rule/group instead of move.
+*
+* @returns The query (mutated in place) with the rules or groups grouped.
+*
+* @group Query Tools
+*/
+const groupInPlace = (query, sourcePathOrID, targetPathOrID, options = {}) => {
+	const { clone = false, combinators = require_utils.defaultCombinators, idGenerator = require_prepareQueryObjects.generateID, onAbort } = options;
+	const sourcePath = Array.isArray(sourcePathOrID) ? sourcePathOrID : getPathOfID(sourcePathOrID, query);
+	const targetPath = Array.isArray(targetPathOrID) ? targetPathOrID : getPathOfID(targetPathOrID, query);
+	if (!sourcePath) {
+		onAbort?.({
+			reason: "target-not-found",
+			operation: "group",
+			pathOrID: sourcePathOrID
+		});
+		return query;
+	}
+	if (!targetPath) {
+		onAbort?.({
+			reason: "target-not-found",
+			operation: "group",
+			pathOrID: targetPathOrID
+		});
+		return query;
+	}
+	const nextPath = getNextPath(query, sourcePath, targetPath);
+	if (sourcePath.length === 0) {
+		onAbort?.({
+			reason: "root-not-allowed",
+			operation: "group",
+			pathOrID: sourcePathOrID
+		});
+		return query;
+	}
+	const groupGuardReason = getGuardAbortReason(query, sourcePath, options);
+	if (groupGuardReason) {
+		onAbort?.({
+			reason: groupGuardReason,
+			operation: "group",
+			pathOrID: sourcePathOrID
+		});
+		return query;
+	}
+	if (pathsAreEqual(sourcePath, nextPath)) {
+		onAbort?.({
+			reason: "same-location",
+			operation: "group",
+			pathOrID: sourcePathOrID
+		});
+		return query;
+	}
+	if (!findPath(getParentPath(nextPath), query)) {
+		onAbort?.({
+			reason: "destination-not-found",
+			operation: "group",
+			pathOrID: targetPathOrID
+		});
+		return query;
+	}
+	if (!clone && isAncestor(sourcePath, nextPath)) {
+		onAbort?.({
+			reason: "destination-not-found",
+			operation: "group",
+			pathOrID: targetPathOrID
+		});
+		return query;
+	}
+	const sourceRuleOrGroupOriginal = findPath(sourcePath, query);
+	const targetRuleOrGroup = findPath(targetPath, query);
+	if (!sourceRuleOrGroupOriginal) {
+		onAbort?.({
+			reason: "target-not-found",
+			operation: "group",
+			pathOrID: sourcePathOrID
+		});
+		return query;
+	}
+	if (!targetRuleOrGroup) {
+		onAbort?.({
+			reason: "target-not-found",
+			operation: "group",
+			pathOrID: targetPathOrID
+		});
+		return query;
+	}
+	const sourceRuleOrGroup = clone ? regenerateIDs((0, immer.isDraft)(sourceRuleOrGroupOriginal) ? (0, immer.current)(sourceRuleOrGroupOriginal) : sourceRuleOrGroupOriginal, { idGenerator }) : sourceRuleOrGroupOriginal;
+	const independentCombinators = require_objectUtils.isRuleGroupTypeIC(query);
+	const parentOfRuleToRemove = findPath(getParentPath(sourcePath), query);
+	const ruleToRemoveIndex = sourcePath.at(-1);
+	if (!clone) {
+		const idxStartDelete = independentCombinators ? Math.max(0, ruleToRemoveIndex - 1) : ruleToRemoveIndex;
+		const deleteLength = independentCombinators ? 2 : 1;
+		parentOfRuleToRemove.rules.splice(idxStartDelete, deleteLength);
+	}
+	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 newNewParentPath = getParentPath(newNewPath);
+	const parentOfTargetPath = findPath(newNewParentPath, query);
+	const targetPathIndex = newNewPath.at(-1);
+	parentOfTargetPath.rules.splice(targetPathIndex, 1, require_prepareQueryObjects.prepareRuleOrGroup(independentCombinators ? { rules: [
+		targetRuleOrGroup,
+		require_utils.getFirstOption(combinators),
+		sourceRuleOrGroup
+	] } : {
+		combinator: require_utils.getFirstOption(combinators),
+		rules: [targetRuleOrGroup, sourceRuleOrGroup]
+	}, { idGenerator }));
+	return query;
+};
+//#endregion
+//#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, freeze, onAddRule, onAddGroup, onRemove, onMoveRule, onMoveGroup, onGroupRule, onGroupGroup, onLog } = config;
+	const log = (payload) => onLog?.({
+		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: require_utils.LogType.parentPathDisabled,
+					rule,
+					parentPath,
+					query
+				});
+				return;
+			}
+			const nextRule = onAddRule ? onAddRule(rule, parentPath, query, context) : true;
+			if (!nextRule) {
+				log({
+					type: require_utils.LogType.onAddRuleFalse,
+					rule,
+					parentPath,
+					query
+				});
+				return;
+			}
+			const newRule = nextRule === true ? rule : nextRule;
+			const newQuery = add(query, newRule, parentPath, {
+				combinators,
+				combinatorPreceding: newRule.combinatorPreceding,
+				idGenerator,
+				freeze
+			});
+			log({
+				type: require_utils.LogType.add,
+				query,
+				newQuery,
+				newRule,
+				parentPath
+			});
+			return newQuery;
+		},
+		addGroup: (query, ruleGroup, parentPath, context) => {
+			if (parentPath.length >= maxLevels) return void 0;
+			if (blocked(query, parentPath, true)) {
+				log({
+					type: require_utils.LogType.parentPathDisabled,
+					ruleGroup,
+					parentPath,
+					query
+				});
+				return;
+			}
+			const nextGroup = onAddGroup ? onAddGroup(ruleGroup, parentPath, query, context) : true;
+			if (!nextGroup) {
+				log({
+					type: require_utils.LogType.onAddGroupFalse,
+					ruleGroup,
+					parentPath,
+					query
+				});
+				return;
+			}
+			const newGroup = nextGroup === true ? ruleGroup : nextGroup;
+			const newQuery = add(query, newGroup, parentPath, {
+				combinators,
+				combinatorPreceding: newGroup.combinatorPreceding ?? void 0,
+				idGenerator,
+				freeze
+			});
+			log({
+				type: require_utils.LogType.add,
+				query,
+				newQuery,
+				newGroup,
+				parentPath
+			});
+			return newQuery;
+		},
+		propChange: (query, prop, value, path) => {
+			if (getGuardAbortReason(query, path, prop === "disabled" ? { queryDisabled } : guards)) {
+				log({
+					type: require_utils.LogType.pathDisabled,
+					path,
+					prop,
+					value,
+					query
+				});
+				return;
+			}
+			const newQuery = update(query, prop, value, path, {
+				resetOnFieldChange,
+				resetOnOperatorChange,
+				getRuleDefaultOperator,
+				getValueSources,
+				getRuleDefaultValue,
+				getMatchModes,
+				freeze
+			});
+			log({
+				type: require_utils.LogType.update,
+				query,
+				newQuery,
+				prop,
+				value,
+				path
+			});
+			return newQuery;
+		},
+		removeRuleOrGroup: (query, path, context) => {
+			if (blocked(query, path)) {
+				log({
+					type: require_utils.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: require_utils.LogType.onRemoveFalse,
+					ruleOrGroup,
+					path,
+					query
+				});
+				return;
+			}
+			const newQuery = remove(query, path, { freeze });
+			log({
+				type: require_utils.LogType.remove,
+				query,
+				newQuery,
+				path,
+				ruleOrGroup
+			});
+			return newQuery;
+		},
+		moveRule: (query, oldPath, newPath, clone, context) => {
+			if (blocked(query, oldPath)) {
+				log({
+					type: require_utils.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,
+				freeze
+			});
+			const isGroup = require_objectUtils.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 ? require_utils.LogType.onMoveGroupFalse : require_utils.LogType.onMoveRuleFalse,
+					ruleOrGroup,
+					oldPath,
+					newPath,
+					clone,
+					query,
+					nextQuery
+				});
+				return;
+			}
+			const newQuery = require_objectUtils.isRuleGroup(callbackResult) ? callbackResult : nextQuery;
+			log({
+				type: require_utils.LogType.move,
+				query,
+				newQuery,
+				oldPath,
+				newPath,
+				clone
+			});
+			return newQuery;
+		},
+		groupRule: (query, sourcePath, targetPath, clone, context) => {
+			if (blocked(query, sourcePath)) {
+				log({
+					type: require_utils.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,
+				freeze
+			});
+			const isGroup = require_objectUtils.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 ? require_utils.LogType.onGroupGroupFalse : require_utils.LogType.onGroupRuleFalse,
+					ruleOrGroup,
+					sourcePath,
+					targetPath,
+					clone,
+					query,
+					nextQuery
+				});
+				return;
+			}
+			const newQuery = require_objectUtils.isRuleGroup(callbackResult) ? callbackResult : nextQuery;
+			log({
+				type: require_utils.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 = require_prepareQueryObjects.generateID }) => {
+	let field = require_utils.getFirstOption(fields) ?? "";
+	if (getDefaultField) {
+		if (typeof getDefaultField === "function") {
+			const defaultField = getDefaultField(fields);
+			if (defaultField) field = defaultField;
+		} else field = getDefaultField;
+	}
+	const fieldData = require_utils.getOption(fields, field);
+	const operator = getRuleDefaultOperator(field);
+	const valueSource = require_utils.getFirstOption(getValueSources(field, operator, { fieldData })) ?? "value";
+	const matchMode = require_utils.getFirstOption(getMatchModes(field, { fieldData }));
+	const newRule = {
+		id: idGenerator(),
+		field,
+		operator,
+		valueSource,
+		value: "",
+		...matchMode ? { match: {
+			mode: matchMode,
+			threshold: 1
+		} } : null
+	};
+	return {
+		...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 = require_prepareQueryObjects.generateID }, independentCombinators) => {
+	const id = idGenerator();
+	const rules = addRuleToNewGroups ? [createRuleMain()] : [];
+	if (independentCombinators) return {
+		id,
+		rules,
+		not: false
+	};
+	return {
+		id,
+		rules,
+		combinator: require_utils.getFirstOption(combinators) ?? "",
+		not: false
+	};
+};
+//#endregion
+exports.LogType = require_utils.LogType;
+exports.TestID = require_utils.TestID;
+exports.add = add;
+exports.addInPlace = addInPlace;
+exports.betweenOperators = require_utils.betweenOperators;
+exports.clsx = clsx;
+exports.coerceBigIntValue = coerceBigIntValue;
+exports.coerceInputType = coerceInputType;
+exports.controlKeys = controlKeys;
+exports.controlKind = controlKind;
+exports.controlPropKeys = controlPropKeys;
+exports.convertFromIC = require_convertQuery.convertFromIC;
+exports.convertQuery = require_convertQuery.convertQuery;
+exports.convertToIC = require_convertQuery.convertToIC;
+exports.createQueryActions = createQueryActions;
+exports.createRule = createRule;
+exports.createRuleGroup = createRuleGroup;
+exports.defaultCoalesceMs = require_utils.defaultCoalesceMs;
+exports.defaultCombinatorLabelMap = require_utils.defaultCombinatorLabelMap;
+exports.defaultCombinators = require_utils.defaultCombinators;
+exports.defaultCombinatorsExtended = require_utils.defaultCombinatorsExtended;
+exports.defaultControlClassnames = require_utils.defaultControlClassnames;
+exports.defaultJoinChar = require_utils.defaultJoinChar;
+exports.defaultMatchModes = require_utils.defaultMatchModes;
+exports.defaultMaxHistory = require_utils.defaultMaxHistory;
+exports.defaultOperatorLabelMap = require_utils.defaultOperatorLabelMap;
+exports.defaultOperatorNegationMap = require_utils.defaultOperatorNegationMap;
+exports.defaultOperators = require_utils.defaultOperators;
+exports.defaultPlaceholderFieldGroupLabel = require_utils.defaultPlaceholderFieldGroupLabel;
+exports.defaultPlaceholderFieldLabel = require_utils.defaultPlaceholderFieldLabel;
+exports.defaultPlaceholderFieldName = require_utils.defaultPlaceholderFieldName;
+exports.defaultPlaceholderLabel = require_utils.defaultPlaceholderLabel;
+exports.defaultPlaceholderName = require_utils.defaultPlaceholderName;
+exports.defaultPlaceholderOperatorGroupLabel = require_utils.defaultPlaceholderOperatorGroupLabel;
+exports.defaultPlaceholderOperatorLabel = require_utils.defaultPlaceholderOperatorLabel;
+exports.defaultPlaceholderOperatorName = require_utils.defaultPlaceholderOperatorName;
+exports.defaultPlaceholderValueGroupLabel = require_utils.defaultPlaceholderValueGroupLabel;
+exports.defaultPlaceholderValueLabel = require_utils.defaultPlaceholderValueLabel;
+exports.defaultPlaceholderValueName = require_utils.defaultPlaceholderValueName;
+exports.defaultTranslations = require_utils.defaultTranslations;
+exports.defaultValidator = defaultValidator;
+exports.derivePathInfo = derivePathInfo;
+exports.deriveQueryBuilderClassNames = deriveQueryBuilderClassNames;
+exports.deriveRuleClassName = deriveRuleClassName;
+exports.deriveRuleClassNames = deriveRuleClassNames;
+exports.deriveRuleContext = deriveRuleContext;
+exports.deriveRuleGroupClassNames = deriveRuleGroupClassNames;
+exports.deriveRuleGroupContext = deriveRuleGroupContext;
+exports.deriveRuleGroupOuterClassName = deriveRuleGroupOuterClassName;
+exports.deriveRuleOuterClassName = deriveRuleOuterClassName;
+exports.exceedsMaxLevels = exceedsMaxLevels;
+exports.filterFieldsByComparator = require_prepareQueryObjects.filterFieldsByComparator;
+exports.findID = findID;
+exports.findPath = findPath;
+exports.generateAccessibleDescription = generateAccessibleDescription;
+Object.defineProperty(exports, "generateID", {
+	enumerable: true,
+	get: function() {
+		return require_prepareQueryObjects.generateID;
+	}
+});
+exports.getCommonAncestorPath = getCommonAncestorPath;
+exports.getFieldData = getFieldData;
+exports.getFirstOption = require_utils.getFirstOption;
+exports.getGuardAbortReason = getGuardAbortReason;
+exports.getMatchModesUtil = getMatchModesUtil;
+exports.getMultiValueUpdate = getMultiValueUpdate;
+exports.getOption = require_utils.getOption;
+exports.getParametersAsList = getParametersAsList;
+exports.getParentPath = getParentPath;
+exports.getParseNumberMethod = require_utils.getParseNumberMethod;
+exports.getPathOfID = getPathOfID;
+exports.getRuleDefaultValue = getRuleDefaultValue;
+exports.getRuleGroupCombinator = getRuleGroupCombinator;
+exports.getRuleInputType = getRuleInputType;
+exports.getRuleValidationResult = getRuleValidationResult;
+exports.getRuleValueEditorType = getRuleValueEditorType;
+exports.getRuleValueSourceOptions = getRuleValueSourceOptions;
+exports.getRuleValues = getRuleValues;
+exports.getValidationClassNames = getValidationClassNames;
+exports.getValueEditorReset = getValueEditorReset;
+exports.getValueSelectorUpdate = getValueSelectorUpdate;
+exports.getValueSourcesUtil = require_prepareQueryObjects.getValueSourcesUtil;
+exports.group = group;
+exports.groupInPlace = groupInPlace;
+exports.groupInvalidReasons = require_utils.groupInvalidReasons;
+exports.hideValueControlsForOperator = hideValueControlsForOperator;
+exports.inOperators = require_utils.inOperators;
+exports.insert = insert;
+exports.insertInPlace = insertInPlace;
+exports.isAncestor = isAncestor;
+exports.isBetweenOperator = isBetweenOperator;
+exports.isFlexibleOptionArray = require_utils.isFlexibleOptionArray;
+exports.isFlexibleOptionGroupArray = require_utils.isFlexibleOptionGroupArray;
+exports.isFullOptionArray = require_utils.isFullOptionArray;
+exports.isFullOptionGroupArray = require_utils.isFullOptionGroupArray;
+exports.isOptionGroupArray = require_utils.isOptionGroupArray;
+exports.isPojo = require_objectUtils.isPojo;
+exports.isRuleGroup = require_objectUtils.isRuleGroup;
+exports.isRuleGroupType = require_objectUtils.isRuleGroupType;
+exports.isRuleGroupTypeIC = require_objectUtils.isRuleGroupTypeIC;
+exports.isRuleOrGroupValid = require_isRuleOrGroupValid.isRuleOrGroupValid;
+exports.isRuleType = require_objectUtils.isRuleType;
+exports.isUnsafeKey = require_objectUtils.isUnsafeKey;
+exports.isValidationResult = require_isRuleOrGroupValid.isValidationResult;
+exports.joinWith = require_utils.joinWith;
+exports.lc = require_objectUtils.lc;
+exports.mergeAnyTranslation = mergeAnyTranslation;
+exports.mergeAnyTranslations = mergeAnyTranslations;
+exports.mergeClassnames = mergeClassnames;
+exports.move = move;
+exports.moveInPlace = moveInPlace;
+exports.normalizeValueSelectorValue = normalizeValueSelectorValue;
+exports.nullFreeArray = require_utils.nullFreeArray;
+exports.nullOperators = require_utils.nullOperators;
+exports.nullOrUndefinedOrEmpty = require_objectUtils.nullOrUndefinedOrEmpty;
+exports.numericRegex = require_objectUtils.numericRegex;
+exports.objectEntries = require_objectUtils.objectEntries;
+exports.objectKeys = require_objectUtils.objectKeys;
+exports.optionsEqual = optionsEqual;
+exports.parseNumber = require_utils.parseNumber;
+exports.pathIsDisabled = pathIsDisabled;
+exports.pathIsDisabledByPaths = pathIsDisabledByPaths;
+exports.pathsAreEqual = pathsAreEqual;
+exports.preferAnyProp = preferAnyProp;
+exports.preferFlagProps = preferFlagProps;
+exports.preferProp = preferProp;
+exports.prepareOptionList = require_utils.prepareOptionList;
+exports.prepareRule = require_prepareQueryObjects.prepareRule;
+exports.prepareRuleGroup = require_prepareQueryObjects.prepareRuleGroup;
+exports.prepareRuleOrGroup = require_prepareQueryObjects.prepareRuleOrGroup;
+exports.queryBuilderFlagDefaults = require_utils.queryBuilderFlagDefaults;
+exports.regenerateID = regenerateID;
+exports.regenerateIDs = regenerateIDs;
+exports.relationalOperators = require_utils.relationalOperators;
+exports.remove = remove;
+exports.removeInPlace = removeInPlace;
+exports.resolveCandidateQuery = require_prepareQueryObjects.resolveCandidateQuery;
+exports.resolveDefaultOperator = resolveDefaultOperator;
+exports.resolveOperatorList = resolveOperatorList;
+exports.resolveValueEditorType = resolveValueEditorType;
+exports.resolveValueList = resolveValueList;
+exports.rootPath = require_utils.rootPath;
+exports.setAutoFreeze = setAutoFreeze;
+exports.shouldCoalesce = shouldCoalesce;
+exports.signatureOf = signatureOf;
+exports.splitBy = require_utils.splitBy;
+exports.standardClassnames = require_utils.standardClassnames;
+exports.strictAbortReasons = strictAbortReasons;
+exports.structuralSignature = structuralSignature;
+exports.substringOperators = require_utils.substringOperators;
+exports.toArray = require_utils.toArray;
+exports.toFlatOptionArray = require_utils.toFlatOptionArray;
+exports.toFullOption = require_utils.toFullOption;
+exports.toFullOptionList = require_utils.toFullOptionList;
+exports.toFullOptionMap = require_utils.toFullOptionMap;
+exports.transformQuery = require_transformQuery.transformQuery;
+exports.trimIfString = require_utils.trimIfString;
+exports.unchangedSignature = unchangedSignature;
+exports.uniqByIdentifier = require_utils.uniqByIdentifier;
+exports.uniqByName = require_utils.uniqByName;
+exports.uniqOptGroups = require_utils.uniqOptGroups;
+exports.uniqOptList = require_utils.uniqOptList;
+exports.update = update;
+exports.updateInPlace = updateInPlace;
+exports.uuidV4regex = require_prepareQueryObjects.uuidV4regex;
+exports.valuesEqual = valuesEqual;
+
+//# sourceMappingURL=derivations.js.map