@react-querybuilder/core 8.9.0

package/dist/cjs/react-querybuilder_core.cjs.development.js

@@ -0,0 +1,4033 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let immer = require("immer");
+immer = __toESM(immer);
+let numeric_quantity = require("numeric-quantity");
+numeric_quantity = __toESM(numeric_quantity);
+
+//#region src/defaults.ts
+/**
+* @group Defaults
+*/
+const defaultPlaceholderName = "~";
+/**
+* @group Defaults
+*/
+const defaultPlaceholderLabel = "------";
+/**
+* Default `name` for placeholder option in the `fields` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderFieldName = defaultPlaceholderName;
+/**
+* Default `label` for placeholder option in the `fields` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderFieldLabel = defaultPlaceholderLabel;
+/**
+* Default `label` for placeholder option group in the `fields` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderFieldGroupLabel = defaultPlaceholderLabel;
+/**
+* Default `name` for placeholder option in the `operators` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderOperatorName = defaultPlaceholderName;
+/**
+* Default `label` for placeholder option in the `operators` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderOperatorLabel = defaultPlaceholderLabel;
+/**
+* Default `label` for placeholder option group in the `operators` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderOperatorGroupLabel = defaultPlaceholderLabel;
+/**
+* Default `name` for placeholder option in the `values` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderValueName = defaultPlaceholderName;
+/**
+* Default `label` for placeholder option in the `values` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderValueLabel = defaultPlaceholderLabel;
+/**
+* Default `label` for placeholder option group in the `values` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderValueGroupLabel = defaultPlaceholderLabel;
+/**
+* Default character used to `.join` and `.split` arrays.
+*
+* @group Defaults
+*/
+const defaultJoinChar = ",";
+const defaultOperatorLabelMap = {
+	"=": "=",
+	"!=": "!=",
+	"<": "<",
+	">": ">",
+	"<=": "<=",
+	">=": ">=",
+	contains: "contains",
+	beginsWith: "begins with",
+	endsWith: "ends with",
+	doesNotContain: "does not contain",
+	doesNotBeginWith: "does not begin with",
+	doesNotEndWith: "does not end with",
+	null: "is null",
+	notNull: "is not null",
+	in: "in",
+	notIn: "not in",
+	between: "between",
+	notBetween: "not between"
+};
+const defaultCombinatorLabelMap = {
+	and: "AND",
+	or: "OR",
+	xor: "XOR"
+};
+/**
+* Default operator list.
+*
+* @group Defaults
+*/
+const defaultOperators = [
+	{
+		name: "=",
+		value: "=",
+		label: "="
+	},
+	{
+		name: "!=",
+		value: "!=",
+		label: "!="
+	},
+	{
+		name: "<",
+		value: "<",
+		label: "<"
+	},
+	{
+		name: ">",
+		value: ">",
+		label: ">"
+	},
+	{
+		name: "<=",
+		value: "<=",
+		label: "<="
+	},
+	{
+		name: ">=",
+		value: ">=",
+		label: ">="
+	},
+	{
+		name: "contains",
+		value: "contains",
+		label: "contains"
+	},
+	{
+		name: "beginsWith",
+		value: "beginsWith",
+		label: "begins with"
+	},
+	{
+		name: "endsWith",
+		value: "endsWith",
+		label: "ends with"
+	},
+	{
+		name: "doesNotContain",
+		value: "doesNotContain",
+		label: "does not contain"
+	},
+	{
+		name: "doesNotBeginWith",
+		value: "doesNotBeginWith",
+		label: "does not begin with"
+	},
+	{
+		name: "doesNotEndWith",
+		value: "doesNotEndWith",
+		label: "does not end with"
+	},
+	{
+		name: "null",
+		value: "null",
+		label: "is null"
+	},
+	{
+		name: "notNull",
+		value: "notNull",
+		label: "is not null"
+	},
+	{
+		name: "in",
+		value: "in",
+		label: "in"
+	},
+	{
+		name: "notIn",
+		value: "notIn",
+		label: "not in"
+	},
+	{
+		name: "between",
+		value: "between",
+		label: "between"
+	},
+	{
+		name: "notBetween",
+		value: "notBetween",
+		label: "not between"
+	}
+];
+/**
+* Map of default operators to their respective opposite/negating operators.
+*
+* @group Defaults
+*/
+const defaultOperatorNegationMap = {
+	"=": "!=",
+	"!=": "=",
+	"<": ">=",
+	"<=": ">",
+	">": "<=",
+	">=": "<",
+	beginsWith: "doesNotBeginWith",
+	doesNotBeginWith: "beginsWith",
+	endsWith: "doesNotEndWith",
+	doesNotEndWith: "endsWith",
+	contains: "doesNotContain",
+	doesNotContain: "contains",
+	between: "notBetween",
+	notBetween: "between",
+	in: "notIn",
+	notIn: "in",
+	notNull: "null",
+	null: "notNull"
+};
+/**
+* Default combinator list.
+*
+* @group Defaults
+*/
+const defaultCombinators = [{
+	name: "and",
+	value: "and",
+	label: "AND"
+}, {
+	name: "or",
+	value: "or",
+	label: "OR"
+}];
+/**
+* Default combinator list, with `XOR` added.
+*
+* @group Defaults
+*/
+const defaultCombinatorsExtended = [...defaultCombinators, {
+	name: "xor",
+	value: "xor",
+	label: "XOR"
+}];
+/**
+* Default match modes.
+*
+* @group Defaults
+*/
+const defaultMatchModes = [
+	{
+		name: "all",
+		value: "all",
+		label: "all"
+	},
+	{
+		name: "some",
+		value: "some",
+		label: "some"
+	},
+	{
+		name: "none",
+		value: "none",
+		label: "none"
+	},
+	{
+		name: "atLeast",
+		value: "atLeast",
+		label: "at least"
+	},
+	{
+		name: "atMost",
+		value: "atMost",
+		label: "at most"
+	},
+	{
+		name: "exactly",
+		value: "exactly",
+		label: "exactly"
+	}
+];
+/**
+* Standard classnames applied to each component.
+*
+* @group Defaults
+*/
+const standardClassnames = {
+	queryBuilder: "queryBuilder",
+	ruleGroup: "ruleGroup",
+	header: "ruleGroup-header",
+	body: "ruleGroup-body",
+	combinators: "ruleGroup-combinators",
+	addRule: "ruleGroup-addRule",
+	addGroup: "ruleGroup-addGroup",
+	cloneRule: "rule-cloneRule",
+	cloneGroup: "ruleGroup-cloneGroup",
+	removeGroup: "ruleGroup-remove",
+	notToggle: "ruleGroup-notToggle",
+	rule: "rule",
+	fields: "rule-fields",
+	matchMode: "rule-matchMode",
+	matchThreshold: "rule-matchThreshold",
+	operators: "rule-operators",
+	value: "rule-value",
+	removeRule: "rule-remove",
+	betweenRules: "betweenRules",
+	valid: "queryBuilder-valid",
+	invalid: "queryBuilder-invalid",
+	shiftActions: "shiftActions",
+	dndDragging: "dndDragging",
+	dndOver: "dndOver",
+	dndCopy: "dndCopy",
+	dndGroup: "dndGroup",
+	dndDropNotAllowed: "dndDropNotAllowed",
+	dragHandle: "queryBuilder-dragHandle",
+	disabled: "queryBuilder-disabled",
+	lockRule: "rule-lock",
+	lockGroup: "ruleGroup-lock",
+	valueSource: "rule-valueSource",
+	valueListItem: "rule-value-list-item",
+	branches: "queryBuilder-branches",
+	justified: "queryBuilder-justified",
+	hasSubQuery: "rule-hasSubQuery"
+};
+/**
+* Default classnames for each component.
+*
+* @group Defaults
+*/
+const defaultControlClassnames = {
+	queryBuilder: "",
+	ruleGroup: "",
+	header: "",
+	body: "",
+	combinators: "",
+	addRule: "",
+	addGroup: "",
+	cloneRule: "",
+	cloneGroup: "",
+	removeGroup: "",
+	notToggle: "",
+	rule: "",
+	fields: "",
+	matchMode: "",
+	matchThreshold: "",
+	operators: "",
+	value: "",
+	removeRule: "",
+	shiftActions: "",
+	dragHandle: "",
+	lockRule: "",
+	lockGroup: "",
+	valueSource: "",
+	actionElement: "",
+	valueSelector: "",
+	betweenRules: "",
+	valid: "",
+	invalid: "",
+	dndDragging: "",
+	dndOver: "",
+	dndGroup: "",
+	dndCopy: "",
+	dndDropNotAllowed: "",
+	disabled: "",
+	valueListItem: "",
+	branches: "",
+	hasSubQuery: ""
+};
+/**
+* Default reason codes for a group being invalid.
+*
+* @group Defaults
+*/
+const groupInvalidReasons = {
+	empty: "empty",
+	invalidCombinator: "invalid combinator",
+	invalidIndependentCombinators: "invalid independent combinators"
+};
+/**
+* Component identifiers for testing.
+*
+* @group Defaults
+*/
+const TestID = {
+	rule: "rule",
+	ruleGroup: "rule-group",
+	inlineCombinator: "inline-combinator",
+	addGroup: "add-group",
+	removeGroup: "remove-group",
+	cloneGroup: "clone-group",
+	cloneRule: "clone-rule",
+	addRule: "add-rule",
+	removeRule: "remove-rule",
+	combinators: "combinators",
+	fields: "fields",
+	operators: "operators",
+	valueEditor: "value-editor",
+	notToggle: "not-toggle",
+	shiftActions: "shift-actions",
+	dragHandle: "drag-handle",
+	lockRule: "lock-rule",
+	lockGroup: "lock-group",
+	valueSourceSelector: "value-source-selector",
+	matchModeEditor: "match-mode-editor"
+};
+const LogType = {
+	parentPathDisabled: "action aborted: parent path disabled",
+	pathDisabled: "action aborted: path is disabled",
+	queryUpdate: "query updated",
+	onAddRuleFalse: "onAddRule callback returned false",
+	onAddGroupFalse: "onAddGroup callback returned false",
+	onGroupRuleFalse: "onGroupRule callback returned false",
+	onGroupGroupFalse: "onGroupGroup callback returned false",
+	onMoveRuleFalse: "onMoveRule callback returned false",
+	onMoveGroupFalse: "onMoveGroup callback returned false",
+	onRemoveFalse: "onRemove callback returned false",
+	add: "rule or group added",
+	remove: "rule or group removed",
+	update: "rule or group updated",
+	move: "rule or group moved",
+	group: "rule or group grouped with another"
+};
+/**
+* The {@link Path} of the root group.
+*
+* @group Defaults
+*/
+const rootPath = [];
+
+//#endregion
+//#region src/utils/arrayUtils.ts
+/**
+* Splits a string by a given character (see {@link defaultJoinChar}). Escaped characters
+* (characters preceded by a backslash) will not apply to the split, and the backslash will
+* be removed in the array element. Inverse of {@link joinWith}.
+*
+* @example
+* splitBy('this\\,\\,that,,the other,,,\\,')
+* // or
+* splitBy('this\\,\\,that,,the other,,,\\,', ',')
+* // would return
+* ['this,,that', '', 'the other', '', '', ',']
+*/
+const splitBy = (str, splitChar = defaultJoinChar) => typeof str === "string" ? str.split(`\\${splitChar}`).map((c) => c.split(splitChar)).reduce((prev, curr, idx) => {
+	if (idx === 0) return curr;
+	return [
+		...prev.slice(0, -1),
+		`${prev.at(-1)}${splitChar}${curr[0]}`,
+		...curr.slice(1)
+	];
+}, []) : [];
+/**
+* Joins an array of strings using the given character (see {@link defaultJoinChar}). When
+* the given character appears in an array element, a backslash will be added just before it
+* to distinguish it from the join character. Effectively the inverse of {@link splitBy}.
+*
+* TIP: The join character can actually be a string of any length. Only the first character
+* will be searched for in the array elements and preceded by a backslash.
+*
+* @example
+* joinWith(['this,,that', '', 'the other', '', '', ','], ', ')
+* // would return
+* 'this\\,\\,that, , the other, , , \\,'
+*/
+const joinWith = (strArr, joinChar = defaultJoinChar) => strArr.map((str) => `${str ?? ""}`.replaceAll(joinChar[0], `\\${joinChar[0]}`)).join(joinChar);
+/**
+* Trims the value if it is a string. Otherwise returns the value as is.
+*/
+const trimIfString = (val) => typeof val === "string" ? val.trim() : val;
+/**
+* Splits a string by comma then trims each element. Arrays are returned as is except
+* any string elements are trimmed.
+*/
+const toArray = (v, { retainEmptyStrings } = {}) => Array.isArray(v) ? v.map((v$1) => trimIfString(v$1)) : typeof v === "string" ? splitBy(v, defaultJoinChar).filter(retainEmptyStrings ? () => true : (s) => !/^\s*$/.test(s)).map((s) => s.trim()) : typeof v === "number" ? [v] : [];
+/**
+* Determines if an array is free of `null`/`undefined`.
+*/
+const nullFreeArray = (arr) => arr.every((el) => el === false || (el ?? false) !== false);
+
+//#endregion
+//#region src/utils/clsx.ts
+// istanbul ignore next
+function toVal(mix) {
+	let k;
+	let y;
+	let str = "";
+	if (typeof mix === "string" || typeof mix === "number") str += mix;
+	else if (typeof mix === "object") {
+		if (Array.isArray(mix)) {
+			const len = mix.length;
+			for (k = 0; k < len; k++) if (mix[k] && (y = toVal(mix[k]))) {
+				str && (str += " ");
+				str += y;
+			}
+		} else for (y in mix) if (mix[y]) {
+			str && (str += " ");
+			str += y;
+		}
+	}
+	return str;
+}
+// istanbul ignore next
+function clsx(...args) {
+	let i = 0;
+	let tmp;
+	let x;
+	let str = "";
+	const len = args.length;
+	for (; i < len; i++) if ((tmp = args[i]) && (x = toVal(tmp))) {
+		str && (str += " ");
+		str += x;
+	}
+	return str;
+}
+
+//#endregion
+//#region src/utils/misc.ts
+/**
+* Converts a value to lowercase if it's a string, otherwise returns the value as is.
+*/
+// istanbul ignore next
+const lc = (v) => typeof v === "string" ? v.toLowerCase() : v;
+/**
+* Regex matching numeric strings. Passes for positive/negative integers, decimals,
+* and E notation, with optional surrounding whitespace.
+*/
+const numericRegex = new RegExp(numeric_quantity.numericRegex.source.replace(/^\^/, String.raw`^\s*`).replace(/\$$/, String.raw`\s*$`));
+/**
+* Determines if a variable is a plain old JavaScript object, aka POJO.
+*/
+const isPojo = (obj) => obj === null || typeof obj !== "object" ? false : Object.getPrototypeOf(obj) === Object.prototype;
+/**
+* Simple helper to determine whether a value is null, undefined, or an empty string.
+*/
+const nullOrUndefinedOrEmpty = (value) => value === null || value === void 0 || value === "";
+
+//#endregion
+//#region src/utils/isRuleGroup.ts
+/**
+* Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.
+*/
+const isRuleGroup = (rg) => isPojo(rg) && Array.isArray(rg.rules);
+/**
+* Determines if an object is a {@link RuleGroupType}.
+*/
+const isRuleGroupType = (rg) => isRuleGroup(rg) && typeof rg.combinator === "string";
+/**
+* Determines if an object is a {@link RuleGroupTypeIC}.
+*/
+const isRuleGroupTypeIC = (rg) => isRuleGroup(rg) && rg.combinator === void 0;
+
+//#endregion
+//#region src/utils/convertQuery.ts
+const combinatorLevels = [
+	"or",
+	"xor",
+	"and"
+];
+const isSameString = (a, b) => lc(a) === b;
+const generateRuleGroupICWithConsistentCombinators = (rg, baseCombinatorLevel = 0) => {
+	const baseCombinator = combinatorLevels[baseCombinatorLevel];
+	if (!rg.rules.includes(baseCombinator)) return baseCombinatorLevel < combinatorLevels.length - 2 ? generateRuleGroupICWithConsistentCombinators(rg, baseCombinatorLevel + 1) : rg;
+	return (0, immer.produce)(rg, (draft) => {
+		let cursor = 0;
+		while (cursor < draft.rules.length - 2) {
+			if (isSameString(draft.rules[cursor + 1], baseCombinator)) {
+				cursor += 2;
+				continue;
+			}
+			const nextBaseCombinatorIndex = draft.rules.findIndex((r, i) => i > cursor && typeof r === "string" && lc(r) === baseCombinator);
+			if (nextBaseCombinatorIndex === -1) {
+				draft.rules.splice(cursor, draft.rules.length, generateRuleGroupICWithConsistentCombinators({ rules: draft.rules.slice(cursor) }, baseCombinatorLevel + 1));
+				break;
+			} else draft.rules.splice(cursor, nextBaseCombinatorIndex - cursor, generateRuleGroupICWithConsistentCombinators({ rules: draft.rules.slice(cursor, nextBaseCombinatorIndex) }, baseCombinatorLevel + 1));
+		}
+	});
+};
+/**
+* Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.
+*
+* This function is idempotent: {@link RuleGroupType} queries will be
+* returned as-is.
+*
+* @group Query Tools
+*/
+const convertFromIC = (rg) => {
+	if (isRuleGroupType(rg)) return rg;
+	const processedRG = generateRuleGroupICWithConsistentCombinators(rg);
+	const rulesAsMixedList = processedRG.rules.map((r) => typeof r === "string" || !isRuleGroup(r) ? r : convertFromIC(r));
+	const combinator = rulesAsMixedList.length < 2 ? "and" : rulesAsMixedList[1];
+	const rules = rulesAsMixedList.filter((r) => typeof r !== "string");
+	return {
+		...processedRG,
+		combinator,
+		rules
+	};
+};
+/**
+* Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.
+*
+* This function is idempotent: {@link RuleGroupTypeIC} queries will be
+* returned as-is.
+*
+* @group Query Tools
+*/
+const convertToIC = (rg) => {
+	if (isRuleGroupTypeIC(rg)) return rg;
+	const { combinator,...queryWithoutCombinator } = rg;
+	const rules = [];
+	const { length } = rg.rules;
+	for (const [idx, r] of rg.rules.entries()) {
+		if (isRuleGroup(r)) rules.push(convertToIC(r));
+		else rules.push(r);
+		if (combinator && idx < length - 1) rules.push(combinator);
+	}
+	return {
+		...queryWithoutCombinator,
+		rules
+	};
+};
+function convertQuery(query) {
+	return isRuleGroupTypeIC(query) ? convertFromIC(query) : convertToIC(query);
+}
+
+//#endregion
+//#region src/utils/defaultValidator.ts
+/**
+* This is an example validation function you can pass to {@link 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) => {
+		// istanbul ignore else
+		if (rule.id) result[rule.id];
+	};
+	const validateGroup = (rg) => {
+		const reasons = [];
+		if (rg.rules.length === 0) reasons.push(groupInvalidReasons.empty);
+		else if (!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" && !defaultCombinators.map((c) => c.name).includes(rg.rules[i])) invalidICs = true;
+			if (invalidICs) reasons.push(groupInvalidReasons.invalidIndependentCombinators);
+		}
+		if (isRuleGroupType(rg) && !defaultCombinators.map((c) => c.name).includes(rg.combinator) && rg.rules.length > 1) reasons.push(groupInvalidReasons.invalidCombinator);
+		/* istanbul ignore else */
+		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 (isRuleGroup(r)) validateGroup(r);
+		else validateRule(r);
+	};
+	validateGroup(query);
+	return result;
+};
+
+//#endregion
+//#region src/utils/optGroupUtils.ts
+const isOptionWithName = (opt) => isPojo(opt) && "name" in opt && typeof opt.name === "string";
+const isOptionWithValue = (opt) => isPojo(opt) && "value" in opt && typeof opt.value === "string";
+/**
+* Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})
+* into a {@link FullOption}. Full options are left unchanged.
+*
+* @group Option Lists
+*/
+function toFullOption(opt, baseProperties, labelMap) {
+	return (0, immer.produce)((draft) => {
+		const idObj = {};
+		let needsUpdating = !!baseProperties;
+		if (typeof draft === "string") return {
+			...baseProperties,
+			name: draft,
+			value: draft,
+			label: labelMap?.[draft] ?? draft
+		};
+		if (isOptionWithName(draft) && !isOptionWithValue(draft)) {
+			idObj.value = draft.name;
+			needsUpdating = true;
+		} else if (!isOptionWithName(draft) && isOptionWithValue(draft)) {
+			idObj.name = draft.value;
+			needsUpdating = true;
+		}
+		if (needsUpdating) return Object.assign({}, baseProperties, draft, idObj);
+	})(opt);
+}
+/**
+* Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.
+* Lists of full options are left unchanged.
+*
+* @group Option Lists
+*/
+function toFullOptionList(optList, baseProperties, labelMap) {
+	if (!Array.isArray(optList)) return [];
+	return (0, immer.produce)((draft) => {
+		if (isFlexibleOptionGroupArray(draft)) for (const optGroup of draft) for (const [idx, opt] of optGroup.options.entries()) optGroup.options[idx] = toFullOption(opt, baseProperties, labelMap);
+		else for (const [idx, opt] of draft.entries()) draft[idx] = toFullOption(opt, baseProperties, labelMap);
+	})(optList);
+}
+/**
+* Converts a {@link FlexibleOptionList} into a {@link FullOptionList}.
+* Lists of full options are left unchanged.
+*
+* @group Option Lists
+*/
+function toFullOptionMap(optMap, baseProperties) {
+	return Object.fromEntries(Object.entries(optMap).map(([k, v]) => [k, toFullOption(v, baseProperties)]));
+}
+/**
+* @deprecated Renamed to {@link uniqByIdentifier}.
+*
+* @group Option Lists
+*/
+const uniqByName = (originalArray) => uniqByIdentifier(originalArray);
+/**
+* Generates a new array of objects with duplicates removed based
+* on the identifying property (`value` or `name`)
+*
+* @group Option Lists
+*/
+const uniqByIdentifier = (originalArray) => {
+	const names = /* @__PURE__ */ new Set();
+	const newArray = [];
+	for (const el of originalArray) if (!names.has(el.value ?? el.name)) {
+		names.add(el.value ?? el.name);
+		newArray.push(el);
+	}
+	return originalArray.length === newArray.length ? originalArray : newArray;
+};
+/**
+* Determines if an {@link OptionList} is an {@link OptionGroup} array.
+*
+* @group Option Lists
+*/
+const isOptionGroupArray = (arr) => Array.isArray(arr) && arr.length > 0 && isPojo(arr[0]) && "options" in arr[0] && Array.isArray(arr[0].options);
+/**
+* Determines if an array is a flat array of {@link FlexibleOption}.
+*
+* @group Option Lists
+*/
+const isFlexibleOptionArray = (arr) => {
+	let isFOA = false;
+	if (Array.isArray(arr)) for (const o of arr) if (isOptionWithName(o) || isOptionWithValue(o)) isFOA = true;
+	else return false;
+	return isFOA;
+};
+/**
+* Determines if an array is a flat array of {@link FullOption}.
+*
+* @group Option Lists
+*/
+const isFullOptionArray = (arr) => {
+	let isFOA = false;
+	if (Array.isArray(arr)) for (const o of arr) if (isOptionWithName(o) && isOptionWithValue(o)) isFOA = true;
+	else return false;
+	return isFOA;
+};
+/**
+* Determines if a {@link FlexibleOptionList} is a {@link FlexibleOptionGroup} array.
+*
+* @group Option Lists
+*/
+const isFlexibleOptionGroupArray = (arr, { allowEmpty = false } = {}) => {
+	let isFOGA = false;
+	if (Array.isArray(arr)) for (const og of arr) if (isPojo(og) && "options" in og && (isFlexibleOptionArray(og.options) || allowEmpty && Array.isArray(og.options) && og.options.length === 0)) isFOGA = true;
+	else return false;
+	return isFOGA;
+};
+/**
+* Determines if a {@link FlexibleOptionList} is a {@link OptionGroup} array of {@link FullOption}.
+*
+* @group Option Lists
+*/
+const isFullOptionGroupArray = (arr, { allowEmpty = false } = {}) => {
+	let isFOGA = false;
+	if (Array.isArray(arr)) for (const og of arr) if (isPojo(og) && "options" in og && (isFullOptionArray(og.options) || allowEmpty && Array.isArray(og.options) && og.options.length === 0)) isFOGA = true;
+	else return false;
+	return isFOGA;
+};
+function getOption(arr, name) {
+	return (isFlexibleOptionGroupArray(arr, { allowEmpty: true }) ? arr.flatMap((og) => og.options) : arr).find((op) => op.value === name || op.name === name);
+}
+function getFirstOption(arr) {
+	if (!Array.isArray(arr) || arr.length === 0) return null;
+	else if (isFlexibleOptionGroupArray(arr, { allowEmpty: true })) {
+		for (const og of arr) if (og.options.length > 0) return og.options[0].value ?? og.options[0].name;
+		// istanbul ignore next
+		return null;
+	}
+	return arr[0].value ?? arr[0].name;
+}
+/**
+* Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.
+* If the array is already flat, it is returned as is.
+*
+* @group Option Lists
+*/
+const toFlatOptionArray = (arr) => uniqByIdentifier(isOptionGroupArray(arr) ? arr.flatMap((og) => og.options) : arr);
+/**
+* Generates a new {@link OptionGroup} array with duplicates
+* removed based on the identifying property (`value` or `name`).
+*
+* @group Option Lists
+*/
+const uniqOptGroups = (originalArray) => {
+	const labels = /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	const newArray = [];
+	for (const el of originalArray) if (!labels.has(el.label)) {
+		labels.add(el.label);
+		const optionsForThisGroup = [];
+		for (const opt of el.options) if (!names.has(opt.value ?? opt.name)) {
+			names.add(opt.value ?? opt.name);
+			optionsForThisGroup.push(toFullOption(opt));
+		}
+		newArray.push({
+			...el,
+			options: optionsForThisGroup
+		});
+	}
+	return newArray;
+};
+/**
+* Generates a new {@link Option} or {@link OptionGroup} array with duplicates
+* removed based on the identifier property (`value` or `name`).
+*
+* @group Option Lists
+*/
+const uniqOptList = (originalArray) => {
+	if (isFlexibleOptionGroupArray(originalArray)) return uniqOptGroups(originalArray);
+	return uniqByIdentifier(originalArray.map((o) => toFullOption(o)));
+};
+
+//#endregion
+//#region src/utils/filterFieldsByComparator.ts
+const filterByComparator = (field, operator, fieldToCompare) => {
+	const fullField = toFullOption(field);
+	const fullFieldToCompare = toFullOption(fieldToCompare);
+	if (fullField.value === fullFieldToCompare.value) return false;
+	if (typeof fullField.comparator === "string") return fullField[fullField.comparator] === fullFieldToCompare[fullField.comparator];
+	return fullField.comparator?.(fullFieldToCompare, operator) ?? false;
+};
+/**
+* For a given {@link FullField}, returns the `fields` list filtered for
+* other fields that match by `comparator`. Only fields *other than the
+* one in question* will ever be included, even if `comparator` is `null`
+* or `undefined`. If `comparator` is a string, fields with the same value
+* for that property will be included. If `comparator` is a function, each
+* field will be passed to the function along with the `operator` and fields
+* for which the function returns `true` will be included.
+*
+* @group Option Lists
+*/
+const filterFieldsByComparator = (field, fields, operator) => {
+	if (!field.comparator) {
+		const filterOutSameField = (f) => (f.value ?? f.name) !== (field.value ?? field.name);
+		if (isFlexibleOptionGroupArray(fields)) return fields.map((og) => ({
+			...og,
+			options: og.options.filter((v) => filterOutSameField(v))
+		}));
+		return fields.filter((v) => filterOutSameField(v));
+	}
+	if (isFlexibleOptionGroupArray(fields)) return fields.map((og) => ({
+		...og,
+		options: og.options.filter((f) => filterByComparator(field, operator, f))
+	})).filter((og) => og.options.length > 0);
+	return fields.filter((f) => filterByComparator(field, operator, f));
+};
+
+//#endregion
+//#region src/utils/parseNumber.ts
+/**
+* Converts a string to a number. Uses native `parseFloat` if `parseNumbers` is "native",
+* otherwise uses [`numeric-quantity`](https://jakeboone02.github.io/numeric-quantity/).
+* If that returns `NaN`, the string is returned unchanged. Numeric values are returned
+* as-is regardless of the `parseNumbers` option.
+*/
+const parseNumber = (val, { parseNumbers, bigIntOnOverflow } = {}) => {
+	if (!parseNumbers || typeof val === "bigint" || typeof val === "number") return val;
+	if (parseNumbers === "native") return Number.parseFloat(val);
+	const valAsNum = (0, numeric_quantity.numericQuantity)(val, {
+		allowTrailingInvalid: parseNumbers === "enhanced",
+		bigIntOnOverflow,
+		romanNumerals: false,
+		round: false
+	});
+	return typeof valAsNum === "bigint" || !Number.isNaN(valAsNum) ? valAsNum : val;
+};
+
+//#endregion
+//#region src/utils/transformQuery.ts
+const remapProperties = (obj, propertyMap, deleteRemappedProperties) => (0, immer.produce)(obj, (draft) => {
+	for (const [k, v] of Object.entries(propertyMap)) if (v === false) delete draft[k];
+	else if (!!v && k !== v && k in draft) {
+		draft[v] = draft[k];
+		if (deleteRemappedProperties) delete draft[k];
+	}
+});
+function transformQuery(query, options = {}) {
+	const { ruleProcessor = (r) => r, ruleGroupProcessor = (rg) => rg, propertyMap = {}, combinatorMap = {}, operatorMap = {}, omitPath = false, deleteRemappedProperties = true } = options;
+	const processGroup = (rg) => ({
+		...ruleGroupProcessor(remapProperties({
+			...rg,
+			...isRuleGroupType(rg) ? { combinator: combinatorMap[rg.combinator] ?? rg.combinator } : {}
+		}, propertyMap, deleteRemappedProperties)),
+		...propertyMap["rules"] === false ? null : { [propertyMap["rules"] ?? "rules"]: rg.rules.map((r, idx) => {
+			const pathObject = omitPath ? null : { path: [...rg.path, idx] };
+			if (typeof r === "string") return combinatorMap[r] ?? r;
+			else if (isRuleGroup(r)) return processGroup({
+				...r,
+				...pathObject
+			});
+			return ruleProcessor(remapProperties({
+				...r,
+				...pathObject,
+				..."operator" in r ? { operator: operatorMap[r.operator] ?? r.operator } : {}
+			}, propertyMap, deleteRemappedProperties));
+		}) }
+	});
+	return processGroup({
+		...query,
+		...omitPath ? null : { path: [] }
+	});
+}
+
+//#endregion
+//#region src/utils/isRuleOrGroupValid.ts
+/**
+* Determines if an object is useful as a validation result.
+*/
+const isValidationResult = (vr) => isPojo(vr) && typeof vr.valid === "boolean";
+/**
+* Determines if a rule or group is valid based on a validation result (if defined)
+* or a validator function. Returns `true` if neither are defined.
+*/
+const isRuleOrGroupValid = (rg, validationResult, validator) => {
+	if (typeof validationResult === "boolean") return validationResult;
+	if (isValidationResult(validationResult)) return validationResult.valid;
+	if (typeof validator === "function" && !isRuleGroup(rg)) {
+		const vr = validator(rg);
+		if (typeof vr === "boolean") return vr;
+		// istanbul ignore else
+		if (isValidationResult(vr)) return vr.valid;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/utils/getParseNumberMethod.ts
+const getParseNumberMethod = ({ parseNumbers, inputType }) => {
+	if (typeof parseNumbers === "string") {
+		const [method, level] = parseNumbers.split("-");
+		if (level === "limited") return inputType === "number" ? method : false;
+		return method;
+	}
+	return parseNumbers ? "strict" : false;
+};
+
+//#endregion
+//#region src/utils/formatQuery/utils.ts
+/**
+* Maps a {@link DefaultOperatorName} to a SQL operator.
+*
+* @group Export
+*/
+const mapSQLOperator = (rqbOperator) => {
+	switch (lc(rqbOperator)) {
+		case "null": return "is null";
+		case "notnull": return "is not null";
+		case "notin": return "not in";
+		case "notbetween": return "not between";
+		case "contains":
+		case "beginswith":
+		case "endswith": return "like";
+		case "doesnotcontain":
+		case "doesnotbeginwith":
+		case "doesnotendwith": return "not like";
+		default: return rqbOperator;
+	}
+};
+/**
+* Maps a (lowercase) {@link DefaultOperatorName} to a MongoDB operator.
+*
+* @group Export
+*/
+const mongoOperators = {
+	"=": "$eq",
+	"!=": "$ne",
+	"<": "$lt",
+	"<=": "$lte",
+	">": "$gt",
+	">=": "$gte",
+	in: "$in",
+	notin: "$nin",
+	notIn: "$nin"
+};
+/**
+* Maps a (lowercase) {@link DefaultOperatorName} to a Prisma ORM operator.
+*
+* @group Export
+*/
+const prismaOperators = {
+	"=": "equals",
+	"!=": "not",
+	"<": "lt",
+	"<=": "lte",
+	">": "gt",
+	">=": "gte",
+	in: "in",
+	notin: "notIn"
+};
+/**
+* Maps a {@link DefaultCombinatorName} to a CEL combinator.
+*
+* @group Export
+*/
+const celCombinatorMap = {
+	and: "&&",
+	or: "||"
+};
+/**
+* Register these operators with `jsonLogic` before applying the result
+* of `formatQuery(query, 'jsonlogic')`.
+*
+* @example
+* ```
+* for (const [op, func] of Object.entries(jsonLogicAdditionalOperators)) {
+*   jsonLogic.add_operation(op, func);
+* }
+* jsonLogic.apply({ "startsWith": [{ "var": "firstName" }, "Stev"] }, data);
+* ```
+*
+* @group Export
+*/
+const jsonLogicAdditionalOperators = {
+	startsWith: (a, b) => typeof a === "string" && a.startsWith(b),
+	endsWith: (a, b) => typeof a === "string" && a.endsWith(b)
+};
+/**
+* Converts all `string`-type `value` properties of a query object into `number` where appropriate.
+*
+* Used by {@link formatQuery} for the `json*` formats when `parseNumbers` is `true`.
+*
+* @group Export
+*/
+const numerifyValues = (rg, options) => ({
+	...rg,
+	rules: rg.rules.map((r) => {
+		if (typeof r === "string") return r;
+		if (isRuleGroup(r)) return numerifyValues(r, options);
+		const fieldData = getOption(options.fields, r.field);
+		const parseNumbers = getParseNumberMethod({
+			parseNumbers: options.parseNumbers,
+			inputType: fieldData?.inputType
+		});
+		if (Array.isArray(r.value)) return {
+			...r,
+			value: r.value.map((v) => parseNumber(v, { parseNumbers }))
+		};
+		const valAsArray = toArray(r.value, { retainEmptyStrings: true }).map((v) => parseNumber(v, { parseNumbers }));
+		if (valAsArray.every((v) => typeof v === "number")) {
+			// istanbul ignore else
+			if (valAsArray.length > 1) return {
+				...r,
+				value: valAsArray
+			};
+			else if (valAsArray.length === 1) return {
+				...r,
+				value: valAsArray[0]
+			};
+		}
+		return r;
+	})
+});
+/**
+* Determines whether a value is _anything_ except an empty `string` or `NaN`.
+*
+* @group Export
+*/
+const isValidValue = (value) => typeof value === "string" && value.length > 0 || typeof value === "number" && !Number.isNaN(value) || typeof value !== "string" && typeof value !== "number";
+/**
+* Determines whether {@link formatQuery} should render the given value as a number.
+* As long as `parseNumbers` is `true`, `number` and `bigint` values will return `true` and
+* `string` values will return `true` if they test positive against {@link numericRegex}.
+*
+* @group Export
+*/
+const shouldRenderAsNumber = (value, parseNumbers) => !!parseNumbers && (typeof value === "number" || typeof value === "bigint" || typeof value === "string" && numericRegex.test(value));
+/**
+* Used by {@link formatQuery} to determine whether the given value processor is a
+* "legacy" value processor by counting the number of arguments. Legacy value
+* processors take 3 arguments (not counting any arguments with default values), while
+* rule-based value processors take no more than 2 arguments.
+*
+* @group Export
+*/
+const isValueProcessorLegacy = (valueProcessor) => valueProcessor.length >= 3;
+/**
+* Converts the `quoteFieldNamesWith` option into an array of two strings.
+* If the option is a string, the array elements are both that string.
+*
+* @default
+* ['', '']
+*
+* @group Export
+*/
+const getQuoteFieldNamesWithArray = (quoteFieldNamesWith = ["", ""]) => Array.isArray(quoteFieldNamesWith) ? quoteFieldNamesWith : typeof quoteFieldNamesWith === "string" ? [quoteFieldNamesWith, quoteFieldNamesWith] : quoteFieldNamesWith ?? ["", ""];
+/**
+* Given a field name and relevant {@link ValueProcessorOptions}, returns the field name
+* wrapped in the configured quote character(s).
+*
+* @group Export
+*/
+const getQuotedFieldName = (fieldName, { quoteFieldNamesWith, fieldIdentifierSeparator }) => {
+	const [qPre, qPost] = getQuoteFieldNamesWithArray(quoteFieldNamesWith);
+	return typeof fieldIdentifierSeparator === "string" && fieldIdentifierSeparator.length > 0 ? joinWith(splitBy(fieldName, fieldIdentifierSeparator).map((part) => `${qPre}${part}${qPost}`), fieldIdentifierSeparator) : `${qPre}${fieldName}${qPost}`;
+};
+const defaultWordOrder = [
+	"S",
+	"V",
+	"O"
+];
+/**
+* Given a [Constituent word order](https://en.wikipedia.org/wiki/Word_order#Constituent_word_orders)
+* like "svo" or "sov", returns a permutation of `["S", "V", "O"]` based on the first occurrence of
+* each letter in the input string (case insensitive). This widens the valid input from abbreviations
+* like "svo" to more expressive strings like "subject-verb-object" or "sub ver obj". Any missing
+* letters are appended in the default order "SVO" (e.g., "object" would yield `["O", "S", "V"]`).
+*
+* @group Export
+*/
+const normalizeConstituentWordOrder = (input) => {
+	const result = [];
+	const letterSet = new Set(defaultWordOrder);
+	for (const char of input.toUpperCase()) if (letterSet.has(char)) {
+		result.push(char);
+		letterSet.delete(char);
+		if (letterSet.size === 0) break;
+	}
+	for (const letter of defaultWordOrder) if (letterSet.has(letter)) result.push(letter);
+	return result;
+};
+/**
+* Default translations used by {@link formatQuery} for "natural_language" format.
+*
+* @group Export
+*/
+const defaultNLTranslations = {
+	groupPrefix: "",
+	groupPrefix_not_xor: "either zero or more than one of",
+	groupPrefix_xor: "exactly one of",
+	groupSuffix: "is true",
+	groupSuffix_not: "is not true"
+};
+/**
+* Note: This function assumes `conditions.length > 0`
+*/
+const translationMatchFilter = (key, keyToTest, conditions) => keyToTest.startsWith(key) && conditions.every((c) => keyToTest.includes(`_${c}`) && keyToTest.match(/_/g)?.length === conditions.length);
+/**
+* Used by {@link formatQuery} to get a translation based on certain conditions
+* for the "natural_language" format.
+*
+* @group Export
+*/
+const getNLTranslataion = (key, translations, conditions = []) => conditions.length === 0 ? translations[key] ?? defaultNLTranslations[key] ?? "" : Object.entries(translations).find(([keyToTest]) => translationMatchFilter(key, keyToTest, conditions))?.[1] ?? Object.entries(defaultNLTranslations).find(([keyToTest]) => translationMatchFilter(key, keyToTest, conditions))?.[1] ?? defaultNLTranslations[key] ?? "";
+const processMatchMode = (rule) => {
+	const { mode, threshold } = rule.match ?? {};
+	if (mode) {
+		if (!isRuleGroup(rule.value)) return false;
+		const matchModeLC = lc(mode);
+		const matchModeCoerced = matchModeLC === "atleast" && threshold === 1 ? "some" : matchModeLC === "atmost" && threshold === 0 ? "none" : matchModeLC;
+		if ((matchModeCoerced === "atleast" || matchModeCoerced === "atmost" || matchModeCoerced === "exactly") && (typeof threshold !== "number" || threshold < 0)) return false;
+		return {
+			mode: matchModeCoerced,
+			threshold
+		};
+	}
+};
+/**
+* "Replacer" method for JSON.stringify's second argument. Converts `bigint` values to
+* objects with a `$bigint` property having a value of a string representation of
+* the actual `bigint`-type value.
+*
+* Inverse of {@link bigIntJsonParseReviver}.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
+*/
+const bigIntJsonStringifyReplacer = (_key, value) => typeof value === "bigint" ? { $bigint: value.toString() } : value;
+/**
+* "Reviver" method for JSON.parse's second argument. Converts objects having a single
+* `$bigint: string` property to an actual `bigint` value.
+*
+* Inverse of {@link bigIntJsonStringifyReplacer}.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
+*/
+const bigIntJsonParseReviver = (_key, value) => isPojo(value) && Object.keys(value).length === 1 && typeof value.$bigint === "string" ? BigInt(value.$bigint) : value;
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorCEL.ts
+/**
+* Rule group processor used by {@link formatQuery} for "cel" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorCEL = (ruleGroup, options) => {
+	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const processRuleGroup = (rg, outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? fallbackExpression : "";
+		const expression = rg.rules.map((rule) => {
+			if (typeof rule === "string") return celCombinatorMap[rule];
+			if (isRuleGroup(rule)) return processRuleGroup(rule);
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return "";
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes: (rule.valueSource ?? "value") === "value",
+				fieldData
+			});
+		}).filter(Boolean).join(isRuleGroupType(rg) ? ` ${celCombinatorMap[rg.combinator]} ` : " ");
+		const [prefix, suffix] = rg.not || !outermost ? [`${rg.not ? "!" : ""}(`, ")"] : ["", ""];
+		return expression ? `${prefix}${expression}${suffix}` : fallbackExpression;
+	};
+	return processRuleGroup(ruleGroup, true);
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorCEL.ts
+const shouldNegate$2 = (op) => op.startsWith("not") || op.startsWith("doesnot");
+const escapeDoubleQuotes = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`"`, `\\"`);
+/**
+* Default rule processor used by {@link formatQuery} for "cel" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorCEL = (rule, opts = {}) => {
+	const { escapeQuotes, parseNumbers, preserveValueOrder } = opts;
+	const { field, operator, value, valueSource } = rule;
+	const valueIsField = valueSource === "field";
+	const operatorTL = lc(operator === "=" ? "==" : operator);
+	const useBareValue = typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || shouldRenderAsNumber(value, parseNumbers);
+	const matchEval = processMatchMode(rule);
+	if (matchEval === false) return "";
+	else if (matchEval) {
+		const { mode, threshold } = matchEval;
+		const arrayElementAlias = "elem_alias";
+		const celQuery = transformQuery(rule.value, { ruleProcessor: (r) => ({
+			...r,
+			field: `${arrayElementAlias}${r.field ? `.${r.field}` : ""}`
+		}) });
+		const nestedArrayFilter = defaultRuleGroupProcessorCEL(celQuery, opts);
+		switch (mode) {
+			case "all": return `${field}.all(${arrayElementAlias}, ${nestedArrayFilter})`;
+			case "none":
+			case "some": return `${mode === "none" ? "!" : ""}${field}.exists(${arrayElementAlias}, ${nestedArrayFilter})`;
+			case "atleast":
+			case "atmost":
+			case "exactly": {
+				const totalCount = `double(${field}.size())`;
+				const filteredCount = `${field}.filter(${arrayElementAlias}, ${nestedArrayFilter}).size()`;
+				const op = mode === "atleast" ? ">=" : mode === "atmost" ? "<=" : "==";
+				if (threshold > 0 && threshold < 1) return `${filteredCount} ${op} (${totalCount} * ${threshold})`;
+				return `${filteredCount} ${op} ${threshold}`;
+			}
+		}
+	}
+	switch (operatorTL) {
+		case "<":
+		case "<=":
+		case "==":
+		case "!=":
+		case ">":
+		case ">=": return `${field} ${operatorTL} ${valueIsField || useBareValue ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`}`;
+		case "contains":
+		case "doesnotcontain": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.contains(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`})`;
+		case "beginswith":
+		case "doesnotbeginwith": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.startsWith(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`})`;
+		case "endswith":
+		case "doesnotendwith": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.endsWith(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`})`;
+		case "null": return `${field} == null`;
+		case "notnull": return `${field} != null`;
+		case "in":
+		case "notin": {
+			const [prefix, suffix] = shouldNegate$2(operatorTL) ? ["!(", ")"] : ["", ""];
+			const valueAsArray = toArray(value);
+			return `${prefix}${field} in [${valueAsArray.map((val) => valueIsField || shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : `"${escapeDoubleQuotes(val, escapeQuotes)}"`).join(", ")}]${suffix}`;
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = toArray(value);
+			if (valueAsArray.length >= 2 && !nullOrUndefinedOrEmpty(valueAsArray[0]) && !nullOrUndefinedOrEmpty(valueAsArray[1])) {
+				const [first, second] = valueAsArray;
+				const shouldParseNumbers = !(parseNumbers === false);
+				const firstNum = shouldRenderAsNumber(first, shouldParseNumbers) ? parseNumber(first, { parseNumbers: shouldParseNumbers }) : NaN;
+				const secondNum = shouldRenderAsNumber(second, shouldParseNumbers) ? parseNumber(second, { parseNumbers: shouldParseNumbers }) : NaN;
+				let firstValue = Number.isNaN(firstNum) ? valueIsField ? `${first}` : `"${escapeDoubleQuotes(first, escapeQuotes)}"` : firstNum;
+				let secondValue = Number.isNaN(secondNum) ? valueIsField ? `${second}` : `"${escapeDoubleQuotes(second, escapeQuotes)}"` : secondNum;
+				if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
+					const tempNum = secondNum;
+					secondValue = firstNum;
+					firstValue = tempNum;
+				}
+				return operatorTL === "between" ? `(${field} >= ${firstValue} && ${field} <= ${secondValue})` : `(${field} < ${firstValue} || ${field} > ${secondValue})`;
+			} else return "";
+		}
+	}
+	return "";
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDBQuery.ts
+/**
+* Default fallback object used by {@link formatQuery} for "mongodb_query" format.
+*
+* @group Export
+*/
+const mongoDbFallback = { $and: [{ $expr: true }] };
+/**
+* Rule group processor used by {@link formatQuery} for "mongodb_query" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorMongoDBQuery = (ruleGroup, options, meta) => {
+	const { fields, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const processRuleGroup = (rg, outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? mongoDbFallback : false;
+		const combinator = `$${lc(rg.combinator)}`;
+		let hasChildRules = false;
+		const expressions = rg.rules.map((rule) => {
+			if (isRuleGroup(rule)) {
+				const processedRuleGroup = processRuleGroup(rule);
+				if (processedRuleGroup) {
+					hasChildRules = true;
+					return processedRuleGroup;
+				}
+				return false;
+			}
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return false;
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				fieldData
+			}, meta);
+		}).filter(Boolean);
+		return expressions.length > 0 ? expressions.length === 1 && !hasChildRules ? expressions[0] : { [combinator]: expressions } : mongoDbFallback;
+	};
+	return processRuleGroup(convertFromIC(ruleGroup), true);
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorMongoDBQuery.ts
+const processNumber$1 = (value, fallback, parseNumbers = false) => shouldRenderAsNumber(value, parseNumbers || typeof value === "bigint") ? Number(parseNumber(value, { parseNumbers: "strict" })) : fallback;
+/**
+* Default rule processor used by {@link formatQuery} for "mongodb_query" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorMongoDBQuery = (rule, options = {}) => {
+	const { field, operator, value, valueSource } = rule;
+	const { parseNumbers, preserveValueOrder, context } = options;
+	const valueIsField = valueSource === "field";
+	const { avoidFieldsAsKeys } = context ?? {};
+	const matchEval = processMatchMode(rule);
+	if (matchEval === false) return;
+	else if (matchEval) {
+		const { mode, threshold } = matchEval;
+		const totalCount = { $size: { $ifNull: [`$${field}`, []] } };
+		const subQueryNoAggCtx = defaultRuleGroupProcessorMongoDBQuery(transformQuery(value, { ruleProcessor: (r) => ({
+			...r,
+			field: r.field ? `${field}.${r.field}` : field
+		}) }), {
+			...options,
+			ruleProcessor: defaultRuleProcessorMongoDBQuery,
+			context: {
+				...options.context,
+				avoidFieldsAsKeys: false
+			}
+		});
+		const subQueryWithAggCtx = defaultRuleGroupProcessorMongoDBQuery(transformQuery(value, { ruleProcessor: (r) => ({
+			...r,
+			field: r.field ? `$item.${r.field}` : "$item"
+		}) }), {
+			...options,
+			ruleProcessor: defaultRuleProcessorMongoDBQuery,
+			context: {
+				...options.context,
+				avoidFieldsAsKeys: true
+			}
+		});
+		const filteredCount = { $size: { $ifNull: [{ $filter: {
+			input: `$${field}`,
+			as: "item",
+			cond: { $and: [subQueryWithAggCtx] }
+		} }, []] } };
+		switch (mode) {
+			case "all": return { $expr: { $eq: [filteredCount, totalCount] } };
+			case "none": return { $nor: [subQueryNoAggCtx] };
+			case "some": return subQueryNoAggCtx;
+			case "atleast":
+			case "atmost":
+			case "exactly": {
+				const op = mode === "atleast" ? mongoOperators[">="] : mode === "atmost" ? mongoOperators["<="] : mongoOperators["="];
+				if (threshold > 0 && threshold < 1) return { $expr: { [op]: [filteredCount, { $multiply: [totalCount, threshold] }] } };
+				return { $expr: { [op]: [filteredCount, threshold] } };
+			}
+		}
+	}
+	if (operator === "=" && !valueIsField) return avoidFieldsAsKeys ? { $eq: [`$${field}`, processNumber$1(value, value, parseNumbers)] } : { [field]: processNumber$1(value, value, parseNumbers) };
+	const operatorLC = lc(operator);
+	switch (operatorLC) {
+		case "<":
+		case "<=":
+		case "=":
+		case "!=":
+		case ">":
+		case ">=": {
+			const mongoOperator = mongoOperators[operatorLC];
+			return valueIsField ? { [mongoOperator]: [`$${field}`, `$${value}`] } : avoidFieldsAsKeys ? { $and: [{ $ne: [`$${field}`, null] }, { [mongoOperator]: [`$${field}`, processNumber$1(value, value, parseNumbers)] }] } : { [field]: { [mongoOperator]: processNumber$1(value, value, parseNumbers) } };
+		}
+		case "contains": return valueIsField ? { $where: `this.${field}.includes(this.${value})` } : avoidFieldsAsKeys ? { $regexMatch: {
+			input: `$${field}`,
+			regex: value
+		} } : { [field]: { $regex: value } };
+		case "beginswith": return valueIsField ? { $where: `this.${field}.startsWith(this.${value})` } : avoidFieldsAsKeys ? { $regexMatch: {
+			input: `$${field}`,
+			regex: `^${value}`
+		} } : { [field]: { $regex: `^${value}` } };
+		case "endswith": return valueIsField ? { $where: `this.${field}.endsWith(this.${value})` } : avoidFieldsAsKeys ? { $regexMatch: {
+			input: `$${field}`,
+			regex: `${value}$`
+		} } : { [field]: { $regex: `${value}$` } };
+		case "doesnotcontain": return valueIsField ? { $where: `!this.${field}.includes(this.${value})` } : avoidFieldsAsKeys ? { $not: { $regexMatch: {
+			input: `$${field}`,
+			regex: value
+		} } } : { [field]: { $not: { $regex: value } } };
+		case "doesnotbeginwith": return valueIsField ? { $where: `!this.${field}.startsWith(this.${value})` } : avoidFieldsAsKeys ? { $not: { $regexMatch: {
+			input: `$${field}`,
+			regex: `^${value}`
+		} } } : { [field]: { $not: { $regex: `^${value}` } } };
+		case "doesnotendwith": return valueIsField ? { $where: `!this.${field}.endsWith(this.${value})` } : avoidFieldsAsKeys ? { $not: { $regexMatch: {
+			input: `$${field}`,
+			regex: `${value}$`
+		} } } : { [field]: { $not: { $regex: `${value}$` } } };
+		case "null": return avoidFieldsAsKeys ? { $eq: [`$${field}`, null] } : { [field]: null };
+		case "notnull": return avoidFieldsAsKeys ? { $ne: [`$${field}`, null] } : { [field]: { $ne: null } };
+		case "in":
+		case "notin": {
+			const valueAsArray = toArray(value);
+			return valueIsField ? { $where: `${operatorLC === "notin" ? "!" : ""}[${valueAsArray.map((val) => `this.${val}`).join(",")}].includes(this.${field})` } : avoidFieldsAsKeys ? operatorLC === "notin" ? { $not: { [mongoOperators.in]: [`$${field}`, valueAsArray.map((val) => processNumber$1(val, val, parseNumbers))] } } : { [mongoOperators[operatorLC]]: [`$${field}`, valueAsArray.map((val) => processNumber$1(val, val, parseNumbers))] } : { [field]: { [mongoOperators[operatorLC]]: valueAsArray.map((val) => processNumber$1(val, val, parseNumbers)) } };
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = toArray(value);
+			if (valueAsArray.length >= 2 && isValidValue(valueAsArray[0]) && isValidValue(valueAsArray[1])) {
+				const [first, second] = valueAsArray;
+				const firstNum = processNumber$1(first, NaN, true);
+				const secondNum = processNumber$1(second, NaN, true);
+				let firstValue = valueIsField ? first : Number.isNaN(firstNum) ? first : firstNum;
+				let secondValue = valueIsField ? second : Number.isNaN(secondNum) ? second : secondNum;
+				if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
+					const tempNum = secondNum;
+					secondValue = firstNum;
+					firstValue = tempNum;
+				}
+				if (operatorLC === "between") return valueIsField ? {
+					$gte: [`$${field}`, `$${firstValue}`],
+					$lte: [`$${field}`, `$${secondValue}`]
+				} : avoidFieldsAsKeys ? { $and: [{ $gte: [`$${field}`, firstValue] }, { $lte: [`$${field}`, secondValue] }] } : { [field]: {
+					$gte: firstValue,
+					$lte: secondValue
+				} };
+				else return valueIsField ? { $or: [{ $lt: [`$${field}`, `$${firstValue}`] }, { $gt: [`$${field}`, `$${secondValue}`] }] } : avoidFieldsAsKeys ? { $or: [{ $lt: [`$${field}`, firstValue] }, { $gt: [`$${field}`, secondValue] }] } : { $or: [{ [field]: { $lt: firstValue } }, { [field]: { $gt: secondValue } }] };
+			} else return "";
+		}
+	}
+	return "";
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorMongoDB.ts
+/**
+* Default rule processor used by {@link formatQuery} for "mongodb" format.
+*
+* Note that the "mongodb" format is deprecated in favor of the "mongodb_query" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorMongoDB = (rule, options) => {
+	const queryObj = defaultRuleProcessorMongoDBQuery(rule, options);
+	return queryObj ? JSON.stringify(queryObj) : "";
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSpEL.ts
+/**
+* Default rule processor used by {@link formatQuery} for "spel" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorSpEL = (ruleGroup, options) => {
+	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const processRuleGroup = (rg, outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? fallbackExpression : "";
+		const expression = rg.rules.map((rule) => {
+			if (typeof rule === "string") return rule;
+			if (isRuleGroup(rule)) return processRuleGroup(rule);
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return "";
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes: (rule.valueSource ?? "value") === "value",
+				fieldData
+			});
+		}).filter(Boolean).join(isRuleGroupType(rg) ? ` ${rg.combinator} ` : " ");
+		const [prefix, suffix] = rg.not || !outermost ? [`${rg.not ? "!" : ""}(`, ")"] : ["", ""];
+		return expression ? `${prefix}${expression}${suffix}` : fallbackExpression;
+	};
+	return processRuleGroup(ruleGroup, true);
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorSpEL.ts
+const shouldNegate$1 = (op) => op.startsWith("not") || op.startsWith("doesnot");
+const wrapInNegation = (clause, negate$1) => negate$1 ? `!(${clause})` : clause;
+const escapeSingleQuotes = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`'`, `\\'`);
+/**
+* Default rule processor used by {@link formatQuery} for "spel" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorSpEL = (rule, opts = {}) => {
+	const { field, operator, value, valueSource } = rule;
+	const { escapeQuotes, parseNumbers, preserveValueOrder } = opts;
+	const valueIsField = valueSource === "field";
+	const operatorTL = lc(operator === "=" ? "==" : operator);
+	const useBareValue = typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || shouldRenderAsNumber(value, parseNumbers);
+	const matchEval = processMatchMode(rule);
+	if (matchEval === false) return "";
+	else if (matchEval) {
+		const { mode, threshold } = matchEval;
+		const nestedArrayFilter = defaultRuleGroupProcessorSpEL(transformQuery(rule.value, { ruleProcessor: (r) => ({
+			...r,
+			field: r.field || "#this"
+		}) }), opts);
+		const totalCount = `${field}.size()`;
+		const filteredCount = `${field}.?[${nestedArrayFilter}].size()`;
+		switch (mode) {
+			case "all": return `${filteredCount} == ${totalCount}`;
+			case "none": return `${filteredCount} == 0`;
+			case "some": return `${filteredCount} >= 1`;
+			case "atleast":
+			case "atmost":
+			case "exactly": {
+				const op = mode === "atleast" ? ">=" : mode === "atmost" ? "<=" : "==";
+				if (threshold > 0 && threshold < 1) return `${filteredCount} ${op} (${totalCount} * ${threshold})`;
+				return `${filteredCount} ${op} ${threshold}`;
+			}
+		}
+	}
+	switch (operatorTL) {
+		case "<":
+		case "<=":
+		case "==":
+		case "!=":
+		case ">":
+		case ">=": return `${field} ${operatorTL} ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes(value, escapeQuotes)}'`}`;
+		case "contains":
+		case "doesnotcontain": return wrapInNegation(`${field} matches ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes(value, escapeQuotes)}'`}`, shouldNegate$1(operatorTL));
+		case "beginswith":
+		case "doesnotbeginwith": {
+			const valueTL = valueIsField ? `'^'.concat(${trimIfString(value)})` : `'${typeof value === "string" && !value.startsWith("^") || useBareValue ? "^" : ""}${escapeSingleQuotes(value, escapeQuotes)}'`;
+			return wrapInNegation(`${field} matches ${valueTL}`, shouldNegate$1(operatorTL));
+		}
+		case "endswith":
+		case "doesnotendwith": {
+			const valueTL = valueIsField ? `${trimIfString(value)}.concat('$')` : `'${escapeSingleQuotes(value, escapeQuotes)}${typeof value === "string" && !value.endsWith("$") || useBareValue ? "$" : ""}'`;
+			return wrapInNegation(`${field} matches ${valueTL}`, shouldNegate$1(operatorTL));
+		}
+		case "null": return `${field} == null`;
+		case "notnull": return `${field} != null`;
+		case "in":
+		case "notin": {
+			const negate$1 = shouldNegate$1(operatorTL) ? "!" : "";
+			const valueAsArray = toArray(value);
+			return valueAsArray.length > 0 ? `${negate$1}(${valueAsArray.map((val) => `${field} == ${valueIsField || shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : `'${escapeSingleQuotes(val, escapeQuotes)}'`}`).join(" or ")})` : "";
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = toArray(value);
+			if (valueAsArray.length >= 2 && !nullOrUndefinedOrEmpty(valueAsArray[0]) && !nullOrUndefinedOrEmpty(valueAsArray[1])) {
+				const [first, second] = valueAsArray;
+				const shouldParseNumbers = !(parseNumbers === false);
+				const firstNum = shouldRenderAsNumber(first, shouldParseNumbers) ? parseNumber(first, { parseNumbers: shouldParseNumbers }) : NaN;
+				const secondNum = shouldRenderAsNumber(second, shouldParseNumbers) ? parseNumber(second, { parseNumbers: shouldParseNumbers }) : NaN;
+				let firstValue = Number.isNaN(firstNum) ? valueIsField ? `${first}` : `'${escapeSingleQuotes(first, escapeQuotes)}'` : firstNum;
+				let secondValue = Number.isNaN(secondNum) ? valueIsField ? `${second}` : `'${escapeSingleQuotes(second, escapeQuotes)}'` : secondNum;
+				if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
+					const tempNum = secondNum;
+					secondValue = firstNum;
+					firstValue = tempNum;
+				}
+				return operatorTL === "between" ? `(${field} >= ${firstValue} and ${field} <= ${secondValue})` : `(${field} < ${firstValue} or ${field} > ${secondValue})`;
+			} else return "";
+		}
+	}
+	return "";
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultValueProcessorByRule.ts
+const escapeStringValueQuotes$1 = (v, quoteChar, escapeQuotes) => escapeQuotes && typeof v === "string" ? v.replaceAll(`${quoteChar}`, `${quoteChar}${quoteChar}`) : v;
+/**
+* Default value processor used by {@link formatQuery} for "sql" format.
+*
+* @group Export
+*/
+const defaultValueProcessorByRule = ({ operator, value, valueSource }, { escapeQuotes, parseNumbers, preserveValueOrder, quoteFieldNamesWith, quoteValuesWith, concatOperator = "||", fieldIdentifierSeparator, wrapValueWith = ["", ""], translations } = {}) => {
+	const valueIsField = valueSource === "field";
+	const operatorLowerCase = lc(operator);
+	const quoteChar = quoteValuesWith || "'";
+	const quoteValue = (v) => `${wrapValueWith[0]}${quoteChar}${v}${quoteChar}${wrapValueWith[1]}`;
+	const escapeValue = (v) => escapeStringValueQuotes$1(v, quoteChar, escapeQuotes);
+	const wrapAndEscape = (v) => quoteValue(escapeValue(v));
+	const wrapFieldName = (v) => getQuotedFieldName(v, {
+		quoteFieldNamesWith,
+		fieldIdentifierSeparator
+	});
+	const concat = (...values) => concatOperator.toUpperCase() === "CONCAT" ? `CONCAT(${values.join(", ")})` : values.join(` ${concatOperator} `);
+	switch (operatorLowerCase) {
+		case "null":
+		case "notnull": return "";
+		case "in":
+		case "notin": {
+			const valueAsArray = toArray(value);
+			if (valueAsArray.length > 0) return `(${valueAsArray.map((v) => valueIsField ? wrapFieldName(v) : shouldRenderAsNumber(v, parseNumbers) ? `${trimIfString(v)}` : `${wrapAndEscape(v)}`).join(", ")})`;
+			return "";
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = toArray(value, { retainEmptyStrings: true });
+			if (valueAsArray.length < 2 || !isValidValue(valueAsArray[0]) || !isValidValue(valueAsArray[1])) return "";
+			const [first, second] = valueAsArray;
+			const firstNum = shouldRenderAsNumber(first, parseNumbers) ? parseNumber(first, { parseNumbers: "strict" }) : NaN;
+			const secondNum = shouldRenderAsNumber(second, parseNumbers) ? parseNumber(second, { parseNumbers: "strict" }) : NaN;
+			const firstValue = Number.isNaN(firstNum) ? valueIsField ? `${first}` : first : firstNum;
+			const secondValue = Number.isNaN(secondNum) ? valueIsField ? `${second}` : second : secondNum;
+			const valsOneAndTwoOnly = [firstValue, secondValue];
+			if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
+				valsOneAndTwoOnly[0] = secondNum;
+				valsOneAndTwoOnly[1] = firstNum;
+			}
+			return (valueIsField ? valsOneAndTwoOnly.map((v) => wrapFieldName(v)) : valsOneAndTwoOnly.every((v) => shouldRenderAsNumber(v, parseNumbers)) ? valsOneAndTwoOnly.map((v) => parseNumber(v, { parseNumbers: "strict" })) : valsOneAndTwoOnly.map((v) => wrapAndEscape(v))).join(` ${translations?.and ?? "and"} `);
+		}
+		case "contains":
+		case "doesnotcontain": return valueIsField ? concat(quoteValue("%"), wrapFieldName(value), quoteValue("%")) : quoteValue(`%${escapeValue(value)}%`);
+		case "beginswith":
+		case "doesnotbeginwith": return valueIsField ? concat(wrapFieldName(value), quoteValue("%")) : quoteValue(`${escapeValue(value)}%`);
+		case "endswith":
+		case "doesnotendwith": return valueIsField ? concat(quoteValue("%"), wrapFieldName(value)) : quoteValue(`%${escapeValue(value)}`);
+	}
+	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+	return valueIsField ? wrapFieldName(value) : shouldRenderAsNumber(value, parseNumbers) ? `${trimIfString(value)}` : `${wrapAndEscape(value)}`;
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorDrizzle.ts
+/**
+* Default rule processor used by {@link formatQuery} for the "drizzle" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorDrizzle = (rule, _options) => {
+	const opts = _options ?? (	/* istanbul ignore next */ {});
+	// istanbul ignore next
+	const { parseNumbers, preserveValueOrder, context = {} } = opts;
+	const { columns, drizzleOperators, useRawFields } = context;
+	if (!columns || !drizzleOperators) return;
+	const { between, eq, gt, gte, inArray, isNotNull, isNull, like, lt, lte, ne, notBetween, notInArray, notLike, sql } = drizzleOperators;
+	const { field, operator, value, valueSource } = rule;
+	const column = useRawFields && /[a-z][a-z0-9]*/i.test(field) ? sql.raw(field) : columns[field];
+	const operatorLC = lc(operator);
+	const valueIsField = valueSource === "field";
+	const asFieldOrValue = (v) => valueIsField ? columns[v] : v;
+	if (!column) return;
+	const matchEval = processMatchMode(rule);
+	if (matchEval === false) return;
+	else if (matchEval) {
+		if (opts.preset !== "postgresql") return;
+		const { mode, threshold } = matchEval;
+		const arrayElementAlias = "elem_alias";
+		const sqlQuery = transformQuery(rule.value, { ruleProcessor: (r) => ({
+			...r,
+			field: arrayElementAlias
+		}) });
+		const nestedArrayFilter = defaultRuleGroupProcessorDrizzle(sqlQuery, {
+			...opts,
+			context: {
+				...opts.context,
+				useRawFields: true
+			}
+		});
+		switch (mode) {
+			case "all": return sql`(select count(*) from unnest(${column}) as ${sql.raw(arrayElementAlias)} where ${nestedArrayFilter({}, drizzleOperators)}) = array_length(${column}, 1)`;
+			case "none": return sql`not exists (select 1 from unnest(${column}) as ${sql.raw(arrayElementAlias)} where ${nestedArrayFilter({}, drizzleOperators)})`;
+			case "some": return sql`exists (select 1 from unnest(${column}) as ${sql.raw(arrayElementAlias)} where ${nestedArrayFilter({}, drizzleOperators)})`;
+			case "atleast":
+			case "atmost":
+			case "exactly": {
+				const op = mode === "atleast" ? ">=" : mode === "atmost" ? "<=" : "=";
+				return threshold > 0 && threshold < 1 ? sql`(select count(*) / array_length(${column}, 1) from unnest(${column}) as ${sql.raw(arrayElementAlias)} where ${nestedArrayFilter({}, drizzleOperators)}) ${sql.raw(`${op} ${threshold}`)}` : sql`(select count(*) from unnest(${column}) as ${sql.raw(arrayElementAlias)} where ${nestedArrayFilter({}, drizzleOperators)}) ${sql.raw(`${op} ${threshold}`)}`;
+			}
+		}
+	}
+	switch (operatorLC) {
+		case "=": return eq(column, asFieldOrValue(value));
+		case "!=": return ne(column, asFieldOrValue(value));
+		case ">": return gt(column, asFieldOrValue(value));
+		case "<": return lt(column, asFieldOrValue(value));
+		case ">=": return gte(column, asFieldOrValue(value));
+		case "<=": return lte(column, asFieldOrValue(value));
+		case "beginswith":
+		case "doesnotbeginwith": return (operatorLC === "doesnotbeginwith" ? notLike : like)(column, valueIsField ? sql`${asFieldOrValue(value)} || '%'` : `${value}%`);
+		case "contains":
+		case "doesnotcontain": return (operatorLC === "doesnotcontain" ? notLike : like)(column, valueIsField ? sql`'%' || ${asFieldOrValue(value)} || '%'` : `%${value}%`);
+		case "endswith":
+		case "doesnotendwith": return (operatorLC === "doesnotendwith" ? notLike : like)(column, valueIsField ? sql`'%' || ${asFieldOrValue(value)}` : `%${value}`);
+		case "null": return isNull(column);
+		case "notnull": return isNotNull(column);
+		case "in":
+		case "notin": {
+			const valueAsArray = toArray(value).map((v) => asFieldOrValue(v));
+			return operatorLC === "notin" ? notInArray(column, valueAsArray) : inArray(column, valueAsArray);
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = toArray(value);
+			if (valueAsArray.length >= 2 && isValidValue(valueAsArray[0]) && isValidValue(valueAsArray[1])) {
+				let [first, second] = valueAsArray;
+				const shouldParseNumbers = !(parseNumbers === false);
+				if (!valueIsField && shouldRenderAsNumber(first, shouldParseNumbers) && shouldRenderAsNumber(second, shouldParseNumbers)) {
+					const firstNum = parseNumber(first, { parseNumbers: shouldParseNumbers });
+					const secondNum = parseNumber(second, { parseNumbers: shouldParseNumbers });
+					if (!preserveValueOrder && secondNum < firstNum) {
+						const tempNum = secondNum;
+						second = firstNum;
+						first = tempNum;
+					} else {
+						first = firstNum;
+						second = secondNum;
+					}
+				} else if (valueIsField) {
+					first = asFieldOrValue(first);
+					second = asFieldOrValue(second);
+				}
+				return operatorLC === "notbetween" ? notBetween(column, first, second) : between(column, first, second);
+			}
+			return;
+		}
+		default: return;
+	}
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorDrizzle.ts
+/**
+* Default rule group processor used by {@link formatQuery} for the "drizzle" format. The returned
+* function can be assigned to the `where` property in the Drizzle relational queries API.
+*
+* @example
+* const where = formatQuery(query, 'drizzle');
+* const results = db.query.users.findMany({ where });
+*
+* @returns Function that takes a Drizzle table config and an object of Drizzle operators.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorDrizzle = (ruleGroup, options, _meta) => (columns, drizzleOperators) => {
+	const { fields, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, validateRule, validationMap } = options;
+	if (!columns || !drizzleOperators) return;
+	const { and, not, or } = drizzleOperators;
+	const query = isRuleGroupType(ruleGroup) ? ruleGroup : convertFromIC(ruleGroup);
+	const ruleProcessor = defaultRuleProcessorDrizzle;
+	const processRuleGroup = (rg, _outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return;
+		const processedRules = rg.rules.map((rule) => {
+			if (isRuleGroup(rule)) return processRuleGroup(rule);
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return;
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				fieldData,
+				context: {
+					...options.context,
+					columns,
+					drizzleOperators
+				}
+			});
+		}).filter(Boolean);
+		if (processedRules.length === 0) return;
+		const ruleGroupSQL = rg.combinator === "or" ? or(...processedRules) : and(...processedRules);
+		return rg.not ? not(ruleGroupSQL) : ruleGroupSQL;
+	};
+	return processRuleGroup(query, true);
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorElasticSearch.ts
+/**
+* Rule group processor used by {@link formatQuery} for "elasticsearch" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorElasticSearch = (ruleGroup, options) => {
+	const { fields, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const query = convertFromIC(ruleGroup);
+	const processRuleGroup = (rg) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return false;
+		const processedRules = rg.rules.map((rule) => {
+			if (isRuleGroup(rule)) return processRuleGroup(rule);
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return false;
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				fieldData
+			});
+		}).filter(Boolean);
+		if (processedRules.length === 0) return false;
+		return { bool: rg.not ? { must_not: /^or$/i.test(rg.combinator) ? { bool: { should: processedRules } } : processedRules } : { [/^or$/i.test(rg.combinator) ? "should" : "must"]: processedRules } };
+	};
+	const processedRuleGroup = processRuleGroup(query);
+	return processedRuleGroup === false ? {} : processedRuleGroup;
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorJSONata.ts
+/**
+* Rule group processor used by {@link formatQuery} for "jsonata" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorJSONata = (ruleGroup, options) => {
+	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const processRuleGroup = (rg, outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? fallbackExpression : "";
+		const expression = rg.rules.map((rule) => {
+			if (typeof rule === "string") return rule;
+			if (isRuleGroup(rule)) return processRuleGroup(rule);
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return "";
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes: (rule.valueSource ?? "value") === "value",
+				fieldData
+			});
+		}).filter(Boolean).join(isRuleGroupType(rg) ? ` ${rg.combinator} ` : " ");
+		const [prefix, suffix] = rg.not || !outermost ? [`${rg.not ? "$not" : ""}(`, ")"] : ["", ""];
+		return expression ? `${prefix}${expression}${suffix}` : fallbackExpression;
+	};
+	return processRuleGroup(ruleGroup, true);
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorJsonLogic.ts
+/**
+* Rule group processor used by {@link formatQuery} for "jsonlogic" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorJsonLogic = (ruleGroup, options) => {
+	const { fields, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const query = convertFromIC(ruleGroup);
+	const processRuleGroup = (rg, _outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return false;
+		const processedRules = rg.rules.map((rule) => {
+			if (isRuleGroup(rule)) return processRuleGroup(rule);
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return false;
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				fieldData
+			});
+		}).filter(Boolean);
+		if (processedRules.length === 0) return false;
+		const jsonRuleGroup = { [rg.combinator]: processedRules };
+		return rg.not ? { "!": jsonRuleGroup } : jsonRuleGroup;
+	};
+	return processRuleGroup(query, true);
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorLDAP.ts
+/**
+* Rule group processor used by {@link formatQuery} for "ldap" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorLDAP = (ruleGroup, options) => {
+	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const query = convertFromIC(ruleGroup);
+	const processRuleGroup = (rg, outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? fallbackExpression : "";
+		const rules = rg.rules.map((rule) => {
+			if (isRuleGroup(rule)) return processRuleGroup(rule);
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return "";
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes: (rule.valueSource ?? "value") === "value",
+				fieldData
+			});
+		}).filter(Boolean);
+		const expression = rules.join("");
+		const [notPrefix, notSuffix] = rg.not ? ["(!", ")"] : ["", ""];
+		const [prefix, suffix] = rules.length > 1 ? [`${notPrefix}(${rg.combinator === "or" ? "|" : "&"}`, `)${notSuffix}`] : [notPrefix, notSuffix];
+		return expression ? `${prefix}${expression}${suffix}` : fallbackExpression;
+	};
+	return processRuleGroup(query, true);
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorMongoDB.ts
+const isBracketed = (str) => str.startsWith("{") && str.endsWith("}");
+/**
+* Rule group processor used by {@link formatQuery} for "mongodb" format.
+*
+* Note that the "mongodb" format is deprecated in favor of the "mongodb_query" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorMongoDB = (ruleGroup, options, meta) => {
+	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const processRuleGroup = (rg, outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? fallbackExpression : "";
+		const combinator = `"$${lc(rg.combinator)}"`;
+		let hasChildRules = false;
+		const expressions = rg.rules.map((rule) => {
+			if (isRuleGroup(rule)) {
+				const processedRuleGroup = processRuleGroup(rule);
+				if (processedRuleGroup) {
+					hasChildRules = true;
+					return isBracketed(processedRuleGroup) ? processedRuleGroup : `{${processedRuleGroup}}`;
+				}
+				return "";
+			}
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return "";
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				fieldData
+			}, meta);
+		}).filter(Boolean);
+		return expressions.length > 0 ? expressions.length === 1 && !hasChildRules ? expressions[0] : `${combinator}:[${expressions.join(",")}]` : fallbackExpression;
+	};
+	const processedQuery = processRuleGroup(convertFromIC(ruleGroup), true);
+	return isBracketed(processedQuery) ? processedQuery : `{${processedQuery}}`;
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorNL.ts
+/**
+* Rule group processor used by {@link formatQuery} for "natural_language" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorNL = (ruleGroup, options) => {
+	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, translations, validateRule, validationMap } = options;
+	const processRuleGroup = (rg, outermostOrLonelyInGroup) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
+		const rg2 = isRuleGroupTypeIC(rg) && rg.rules.some((r) => typeof r === "string" && lc(r) === "xor") ? convertFromIC(rg) : rg;
+		const processedRules = rg2.rules.map((rule) => {
+			if (typeof rule === "string") return `, ${translations[rule] ?? rule} `;
+			if (isRuleGroup(rule)) return processRuleGroup(rule, rg2.rules.length === 1 && !(rg2.not || /^xor$/i.test(rg2.combinator ?? "")));
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return "";
+			const escapeQuotes = (rule.valueSource ?? "value") === "value";
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes,
+				fieldData
+			});
+		});
+		if (processedRules.length === 0) return fallbackExpression;
+		const isXOR = lc(rg2.combinator ?? "") === "xor";
+		const combinator = isXOR ? rg2.combinator.slice(1) : rg2.combinator;
+		const mustWrap = rg2.not || !outermostOrLonelyInGroup || isXOR && processedRules.length > 1;
+		const [prefixTL, suffixTL] = ["groupPrefix", "groupSuffix"].map((key) => rg2.not ? isXOR ? getNLTranslataion(key, translations, ["not", "xor"]) : getNLTranslataion(key, translations, ["not"]) : isXOR ? getNLTranslataion(key, translations, ["xor"]) : getNLTranslataion(key, translations));
+		const prefix = mustWrap ? `${prefixTL} (`.trim() : "";
+		const suffix = mustWrap ? `) ${suffixTL}`.trim() : "";
+		return `${prefix}${processedRules.filter(Boolean).join(isRuleGroupType(rg2) ? `, ${translations[combinator] ?? combinator} ` : "")}${suffix}`;
+	};
+	return processRuleGroup(ruleGroup, true);
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorParameterized.ts
+/**
+* Rule group processor used by {@link formatQuery} for "parameterized" and
+* "parameterized_named" formats.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorParameterized = (ruleGroup, options) => {
+	const { format, fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const parameterized = format === "parameterized";
+	const params = [];
+	const paramsNamed = {};
+	const fieldParams = /* @__PURE__ */ new Map();
+	const getNextNamedParam = (field) => {
+		if (!fieldParams.has(field)) fieldParams.set(field, /* @__PURE__ */ new Set());
+		const nextNamedParam = `${field}_${fieldParams.get(field).size + 1}`;
+		fieldParams.get(field).add(nextNamedParam);
+		return nextNamedParam;
+	};
+	const processRule = (rule) => {
+		const [validationResult, fieldValidator] = validateRule(rule);
+		if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return "";
+		const fieldData = getOption(fields, rule.field);
+		const fieldParamNames = Object.fromEntries([...fieldParams.entries()].map(([f, s]) => [f, [...s]]));
+		const processedRule = ruleProcessor(rule, {
+			...options,
+			parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+			getNextNamedParam,
+			fieldParamNames,
+			fieldData
+		}, { processedParams: params });
+		if (!isPojo(processedRule)) return "";
+		const { sql, params: customParams } = processedRule;
+		if (typeof sql !== "string" || !sql) return "";
+		// istanbul ignore else
+		if (format === "parameterized" && Array.isArray(customParams)) params.push(...customParams);
+		else if (format === "parameterized_named" && isPojo(customParams)) {
+			Object.assign(paramsNamed, customParams);
+			for (const p of Object.keys(customParams)) fieldParams.get(rule.field)?.add(p);
+		}
+		return sql;
+	};
+	const processRuleGroup = (rg, outermostOrLonelyInGroup) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
+		const processedRules = rg.rules.map((rule) => {
+			if (typeof rule === "string") return rule;
+			if (isRuleGroup(rule)) return processRuleGroup(rule, rg.rules.length === 1);
+			return processRule(rule);
+		}).filter(Boolean);
+		if (processedRules.length === 0) return fallbackExpression;
+		return `${rg.not ? "NOT " : ""}(${processedRules.join(isRuleGroupType(rg) ? ` ${rg.combinator} ` : " ")})`;
+	};
+	if (parameterized) return {
+		sql: processRuleGroup(ruleGroup, true),
+		params
+	};
+	return {
+		sql: processRuleGroup(ruleGroup, true),
+		params: paramsNamed
+	};
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorPrisma.ts
+/**
+* Default fallback object used by {@link formatQuery} for "prisma" format.
+*
+* @group Export
+*/
+const prismaFallback = {};
+/**
+* Rule group processor used by {@link formatQuery} for "prisma" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorPrisma = (ruleGroup, options) => {
+	const { fields, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const processRuleGroup = (rg, outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? prismaFallback : void 0;
+		const combinator = rg.combinator.toUpperCase();
+		let hasChildRules = false;
+		const expressions = rg.rules.map((rule) => {
+			if (isRuleGroup(rule)) {
+				const processedRuleGroup = processRuleGroup(rule);
+				if (processedRuleGroup) {
+					hasChildRules = true;
+					return processedRuleGroup;
+				}
+				return;
+			}
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return;
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				fieldData
+			});
+		}).filter(Boolean);
+		return expressions.length > 0 ? expressions.length === 1 && !hasChildRules ? expressions[0] : { [combinator]: expressions } : prismaFallback;
+	};
+	const result = processRuleGroup(convertFromIC(ruleGroup), true);
+	return ruleGroup.not ? { NOT: result } : result;
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSequelize.ts
+/**
+* Rule group processor used by {@link formatQuery} for "sequelize" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorSequelize = (ruleGroup, options) => {
+	// istanbul ignore next
+	const { fields, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap, context = {} } = options;
+	const { sequelizeOperators: Op } = context;
+	if (!Op) return;
+	const processRuleGroup = (rg, _outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return;
+		const combinator = rg.combinator.toUpperCase();
+		let hasChildRules = false;
+		const expressions = rg.rules.map((rule) => {
+			if (isRuleGroup(rule)) {
+				const processedRuleGroup = processRuleGroup(rule);
+				if (processedRuleGroup) {
+					hasChildRules = true;
+					return processedRuleGroup;
+				}
+				return;
+			}
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return;
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				fieldData
+			});
+		}).filter(Boolean);
+		if (expressions.length === 0) return;
+		const result = expressions.length === 1 && !hasChildRules ? expressions[0] : { [lc(combinator) === "or" ? Op.or : Op.and]: expressions };
+		return rg.not ? { [Op.not]: result } : result;
+	};
+	return processRuleGroup(convertFromIC(ruleGroup), true);
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSQL.ts
+/**
+* Default rule processor used by {@link formatQuery} for "sql" format.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorSQL = (ruleGroup, options) => {
+	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const processRuleGroup = (rg, outermostOrLonelyInGroup) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
+		const processedRules = rg.rules.map((rule) => {
+			if (typeof rule === "string") return rule;
+			if (isRuleGroup(rule)) return processRuleGroup(rule, rg.rules.length === 1);
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return "";
+			const escapeQuotes = (rule.valueSource ?? "value") === "value";
+			const fieldData = getOption(fields, rule.field);
+			return ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes,
+				fieldData
+			});
+		}).filter(Boolean);
+		if (processedRules.length === 0) return fallbackExpression;
+		return `${rg.not ? "NOT " : ""}(${processedRules.join(isRuleGroupType(rg) ? ` ${rg.combinator} ` : " ")})`;
+	};
+	return processRuleGroup(ruleGroup, true);
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorElasticSearch.ts
+const rangeOperatorMap = {
+	"<": "lt",
+	"<=": "lte",
+	">": "gt",
+	">=": "gte"
+};
+const negateIfNotOp$1 = (op, elasticSearchRule) => op.startsWith("not") || op.startsWith("doesnot") ? { bool: { must_not: elasticSearchRule } } : elasticSearchRule;
+const escapeSQ = (s) => s?.replace(/('|\\)/g, `\\$1`);
+const textFunctionMap = {
+	beginswith: "startsWith",
+	doesnotbeginwith: "startsWith",
+	doesnotcontain: "contains",
+	doesnotendwith: "endsWith",
+	endswith: "endsWith"
+};
+const getTextScript = (f, o, v) => {
+	const script = `doc['${f}'].value.${textFunctionMap[o] ?? o}(doc['${v}'].value)`;
+	return o.startsWith("d") ? `!${script}` : script;
+};
+const valueRenderer = (v, parseNumbers) => typeof v === "boolean" ? v : shouldRenderAsNumber(v, parseNumbers) ? parseNumber(v, { parseNumbers }) : v;
+/**
+* Default rule processor used by {@link formatQuery} for "elasticsearch" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorElasticSearch = (rule, options = {}) => {
+	const { field, operator, value, valueSource } = rule;
+	const { parseNumbers, preserveValueOrder } = options;
+	const operatorLC = lc(operator);
+	if (processMatchMode(rule)) return false;
+	if (valueSource === "field") {
+		if (toArray(value).some((v) => typeof v !== "string")) return false;
+		const fieldForScript = escapeSQ(field);
+		switch (operatorLC) {
+			case "=":
+			case "!=":
+			case ">":
+			case ">=":
+			case "<":
+			case "<=": {
+				const operatorForScript = operatorLC === "=" ? "==" : operatorLC;
+				const valueForScript = escapeSQ(value);
+				return valueForScript ? { bool: { filter: { script: { script: `doc['${fieldForScript}'].value ${operatorForScript} doc['${valueForScript}'].value` } } } } : false;
+			}
+			case "in":
+			case "notin": {
+				const valueAsArray = toArray(value);
+				if (valueAsArray.length > 0) {
+					const arr = valueAsArray.map((v) => ({ bool: { filter: { script: { script: `doc['${fieldForScript}'].value == doc['${v}'].value` } } } }));
+					return { bool: operatorLC === "in" ? { should: arr } : { must_not: arr } };
+				}
+				return false;
+			}
+			case "between":
+			case "notbetween": {
+				const valueAsArray = toArray(value);
+				if (valueAsArray.length >= 2 && valueAsArray[0] && valueAsArray[1]) {
+					const script = `doc['${fieldForScript}'].value >= doc['${valueAsArray[0]}'].value && doc['${fieldForScript}'].value <= doc['${valueAsArray[1]}'].value`;
+					return { bool: { filter: { script: { script: operatorLC === "notbetween" ? `!(${script})` : script } } } };
+				}
+				return false;
+			}
+			case "contains":
+			case "doesnotcontain":
+			case "beginswith":
+			case "doesnotbeginwith":
+			case "endswith":
+			case "doesnotendwith": {
+				const valueForScript = escapeSQ(value);
+				if (!valueForScript) return false;
+				return { bool: { filter: { script: { script: getTextScript(fieldForScript, operatorLC, valueForScript) } } } };
+			}
+		}
+	}
+	switch (operatorLC) {
+		case "<":
+		case "<=":
+		case ">":
+		case ">=": return { range: { [field]: { [rangeOperatorMap[operatorLC]]: valueRenderer(value, parseNumbers) } } };
+		case "=": return { term: { [field]: valueRenderer(value, parseNumbers) } };
+		case "!=": return { bool: { must_not: { term: { [field]: valueRenderer(value, parseNumbers) } } } };
+		case "null": return { bool: { must_not: { exists: { field } } } };
+		case "notnull": return { exists: { field } };
+		case "in":
+		case "notin": {
+			const valueAsArray = toArray(value).map((v) => valueRenderer(v, parseNumbers));
+			if (valueAsArray.length > 0) {
+				const arr = valueAsArray.map((v) => ({ term: { [field]: valueRenderer(v, parseNumbers) } }));
+				return { bool: operatorLC === "in" ? { should: arr } : { must_not: arr } };
+			}
+			return false;
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = toArray(value);
+			if (valueAsArray.length >= 2 && isValidValue(valueAsArray[0]) && isValidValue(valueAsArray[1])) {
+				let [first, second] = valueAsArray;
+				const shouldParseNumbers = !(parseNumbers === false);
+				if (shouldRenderAsNumber(first, shouldParseNumbers) && shouldRenderAsNumber(second, shouldParseNumbers)) {
+					const firstNum = parseNumber(first, { parseNumbers: shouldParseNumbers });
+					const secondNum = parseNumber(second, { parseNumbers: shouldParseNumbers });
+					if (!preserveValueOrder && secondNum < firstNum) {
+						const tempNum = secondNum;
+						second = firstNum;
+						first = tempNum;
+					} else {
+						first = firstNum;
+						second = secondNum;
+					}
+				}
+				return negateIfNotOp$1(operatorLC, { range: { [field]: {
+					gte: first,
+					lte: second
+				} } });
+			}
+			return false;
+		}
+		case "contains":
+		case "doesnotcontain": return negateIfNotOp$1(operatorLC, { regexp: { [field]: { value: `.*${value}.*` } } });
+		case "beginswith":
+		case "doesnotbeginwith": return negateIfNotOp$1(operatorLC, { regexp: { [field]: { value: `${value}.*` } } });
+		case "endswith":
+		case "doesnotendwith": return negateIfNotOp$1(operatorLC, { regexp: { [field]: { value: `.*${value}` } } });
+	}
+	return false;
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorJSONata.ts
+const shouldNegate = (op) => op.startsWith("not") || op.startsWith("doesnot");
+const quote = (v, escapeQuotes) => `"${typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`"`, `\\"`)}"`;
+const negate = (clause, negate$1) => negate$1 ? `$not(${clause})` : clause;
+const escapeStringRegex = (s) => `${s}`.replaceAll(/[/$()*+.?[\\\]^{|}]/g, String.raw`\$&`).replaceAll("-", String.raw`\x2d`);
+/**
+* Default rule processor used by {@link formatQuery} for "jsonata" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorJSONata = (rule, options = {}) => {
+	const { field, operator, value, valueSource } = rule;
+	const { escapeQuotes, parseNumbers, preserveValueOrder, quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator = "" } = options;
+	const valueIsField = valueSource === "field";
+	const useBareValue = typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || shouldRenderAsNumber(value, parseNumbers);
+	const qfn = (f) => getQuotedFieldName(f, {
+		quoteFieldNamesWith,
+		fieldIdentifierSeparator
+	});
+	const matchEval = processMatchMode(rule);
+	if (matchEval === false) return;
+	else if (matchEval) {
+		const { mode, threshold } = matchEval;
+		const totalCount = `$count(${qfn(field)})`;
+		const filteredCount = `$count($filter(${qfn(field)}, function($v) {${defaultRuleGroupProcessorJSONata(transformQuery(value, { ruleProcessor: (r) => ({
+			...r,
+			field: r.field ? `$v.${r.field}` : "$v"
+		}) }), options)}}))`;
+		switch (mode) {
+			case "all": return `${filteredCount} = ${totalCount}`;
+			case "none": return `${filteredCount} = 0`;
+			case "some": return `${filteredCount} > 0`;
+			case "atleast":
+			case "atmost":
+			case "exactly": {
+				const op = mode === "atleast" ? ">=" : mode === "atmost" ? "<=" : "=";
+				if (threshold > 0 && threshold < 1) return `${filteredCount} ${op} (${totalCount} * ${threshold})`;
+				return `${filteredCount} ${op} ${threshold}`;
+			}
+		}
+	}
+	const operatorLC = lc(operator);
+	switch (operatorLC) {
+		case "<":
+		case "<=":
+		case "=":
+		case "!=":
+		case ">":
+		case ">=": return `${qfn(field)} ${operatorLC} ${valueIsField ? qfn(trimIfString(value)) : useBareValue ? trimIfString(value) : quote(value, escapeQuotes)}`;
+		case "contains":
+		case "doesnotcontain": return negate(`$contains(${qfn(field)}, ${valueIsField ? qfn(trimIfString(value)) : quote(value, escapeQuotes)})`, shouldNegate(operatorLC));
+		case "beginswith":
+		case "doesnotbeginwith": return negate(valueIsField ? `$substring(${qfn(field)}, 0, $length(${qfn(trimIfString(value))})) = ${qfn(trimIfString(value))}` : `$contains(${qfn(field)}, /^${escapeStringRegex(value)}/)`, shouldNegate(operatorLC));
+		case "endswith":
+		case "doesnotendwith": return negate(valueIsField ? `$substring(${qfn(field)}, $length(${qfn(field)}) - $length(${qfn(trimIfString(value))})) = ${qfn(trimIfString(value))}` : `$contains(${qfn(field)}, /${escapeStringRegex(value)}$/)`, shouldNegate(operatorLC));
+		case "null": return `${qfn(field)} = null`;
+		case "notnull": return `${qfn(field)} != null`;
+		case "in":
+		case "notin": {
+			const valueAsArray = toArray(value);
+			return negate(`${qfn(field)} in [${valueAsArray.map((val) => valueIsField ? `${qfn(trimIfString(val))}` : shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : quote(val, escapeQuotes)).join(", ")}]`, shouldNegate(operatorLC));
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = toArray(value);
+			if (valueAsArray.length < 2 || nullOrUndefinedOrEmpty(valueAsArray[0]) || nullOrUndefinedOrEmpty(valueAsArray[1])) return "";
+			const [first, second] = valueAsArray;
+			const shouldParseNumbers = !(parseNumbers === false);
+			const firstNum = shouldRenderAsNumber(first, shouldParseNumbers) ? parseNumber(first, { parseNumbers: shouldParseNumbers }) : NaN;
+			const secondNum = shouldRenderAsNumber(second, shouldParseNumbers) ? parseNumber(second, { parseNumbers: shouldParseNumbers }) : NaN;
+			let firstValue = Number.isNaN(firstNum) ? valueIsField ? `${first}` : first : firstNum;
+			let secondValue = Number.isNaN(secondNum) ? valueIsField ? `${second}` : second : secondNum;
+			if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
+				const tempNum = secondNum;
+				secondValue = firstNum;
+				firstValue = tempNum;
+			}
+			const renderAsNumbers = shouldRenderAsNumber(first, parseNumbers) && shouldRenderAsNumber(second, parseNumbers);
+			const getValueString = (raw, val) => valueIsField ? qfn(raw) : renderAsNumbers ? val : quote(val, escapeQuotes);
+			const expression = `${qfn(field)} >= ${getValueString(first, firstValue)} and ${qfn(field)} <= ${getValueString(second, secondValue)}`;
+			return operatorLC === "between" ? `(${expression})` : negate(expression, true);
+		}
+	}
+	return "";
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorJsonLogic.ts
+const convertOperator = (op) => op.replace(/^(=)$/, "$1=").replace(/^notnull$/i, "!=").replace(/^null$/i, "==");
+const negateIfNotOp = (op, jsonRule) => op.startsWith("not") || op.startsWith("doesnot") ? { "!": jsonRule } : jsonRule;
+/**
+* Default rule processor used by {@link formatQuery} for "jsonlogic" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorJsonLogic = (rule, options = {}) => {
+	const { field, operator, value, valueSource } = rule;
+	const { parseNumbers, preserveValueOrder } = options;
+	const valueIsField = valueSource === "field";
+	const fieldObject = { var: field };
+	const fieldOrNumberRenderer = (v) => valueIsField ? { var: `${v}` } : shouldRenderAsNumber(v, parseNumbers) ? parseNumber(v, { parseNumbers }) : v;
+	const matchEval = processMatchMode(rule);
+	if (matchEval === false) return false;
+	else if (matchEval) {
+		const { mode, threshold } = matchEval;
+		switch (mode) {
+			case "all":
+			case "none":
+			case "some": return { [mode]: [{ var: field }, value.rules.length === 1 && !isRuleGroup(value.rules[0]) ? defaultRuleProcessorJsonLogic(value.rules[0], options) : defaultRuleGroupProcessorJsonLogic(value, options)] };
+			case "atleast":
+			case "atmost":
+			case "exactly": {
+				const op = mode === "atleast" ? ">=" : mode === "atmost" ? "<=" : "==";
+				const filteredCount = { reduce: [
+					{ filter: [{ var: field }, value.rules.length === 1 && !isRuleGroup(value.rules[0]) ? defaultRuleProcessorJsonLogic(value.rules[0], options) : defaultRuleGroupProcessorJsonLogic(value, options)] },
+					{ "+": [1, { var: "accumulator" }] },
+					0
+				] };
+				if (threshold > 0 && threshold < 1) {
+					const totalCount = { reduce: [
+						{ var: field },
+						{ "+": [1, { var: "accumulator" }] },
+						0
+					] };
+					return { [op]: [filteredCount, { "*": [totalCount, threshold] }] };
+				}
+				return { [op]: [filteredCount, threshold] };
+			}
+		}
+	}
+	const operatorLC = lc(operator);
+	switch (operatorLC) {
+		case "<":
+		case "<=":
+		case "=":
+		case "!=":
+		case ">":
+		case ">=": return { [convertOperator(operatorLC)]: [fieldObject, fieldOrNumberRenderer(value)] };
+		case "null":
+		case "notnull": return { [`${operatorLC === "notnull" ? "!" : "="}=`]: [fieldObject, null] };
+		case "in":
+		case "notin": {
+			const valueAsArray = toArray(value).map((v) => fieldOrNumberRenderer(v));
+			return negateIfNotOp(operatorLC, { in: [fieldObject, valueAsArray] });
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = toArray(value);
+			if (valueAsArray.length >= 2 && isValidValue(valueAsArray[0]) && isValidValue(valueAsArray[1])) {
+				let [first, second] = valueAsArray;
+				const shouldParseNumbers = !(parseNumbers === false);
+				if (!valueIsField && shouldRenderAsNumber(first, shouldParseNumbers) && shouldRenderAsNumber(second, shouldParseNumbers)) {
+					const firstNum = parseNumber(first, { parseNumbers: shouldParseNumbers });
+					const secondNum = parseNumber(second, { parseNumbers: shouldParseNumbers });
+					if (!preserveValueOrder && secondNum < firstNum) {
+						const tempNum = secondNum;
+						second = firstNum;
+						first = tempNum;
+					} else {
+						first = firstNum;
+						second = secondNum;
+					}
+				} else if (valueIsField) {
+					first = { var: first };
+					second = { var: second };
+				}
+				return negateIfNotOp(operatorLC, { "<=": [
+					first,
+					fieldObject,
+					second
+				] });
+			}
+			return false;
+		}
+		case "contains":
+		case "doesnotcontain": {
+			const jsonRule = { in: [fieldOrNumberRenderer(value), fieldObject] };
+			return negateIfNotOp(operatorLC, jsonRule);
+		}
+		case "beginswith":
+		case "doesnotbeginwith": {
+			const jsonRule = { startsWith: [fieldObject, fieldOrNumberRenderer(value)] };
+			return negateIfNotOp(operatorLC, jsonRule);
+		}
+		case "endswith":
+		case "doesnotendwith": {
+			const jsonRule = { endsWith: [fieldObject, fieldOrNumberRenderer(value)] };
+			return negateIfNotOp(operatorLC, jsonRule);
+		}
+	}
+	return false;
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorLDAP.ts
+const negateIf = (clause, negate$1) => negate$1 ? `(!${clause})` : `${clause}`;
+const ldapEscape = (s) => `${trimIfString(s)}`.replaceAll(/[()&|=<>~*\\/]/g, (m) => `\\${m.codePointAt(0).toString(16)}`);
+/**
+* Default rule processor used by {@link formatQuery} for "ldap" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorLDAP = (rule, options = {}) => {
+	const { field, operator, value, valueSource } = rule;
+	const { preserveValueOrder } = options;
+	const operatorLC = lc(operator);
+	if (valueSource === "field" || nullOrUndefinedOrEmpty(value) && operatorLC !== "null" && operatorLC !== "notnull" || processMatchMode(rule)) return "";
+	switch (operatorLC) {
+		case "=":
+		case "!=": return negateIf(`(${field}=${ldapEscape(value)})`, operatorLC === "!=");
+		case ">":
+		case ">=": return `(${field}>=${ldapEscape(value)})`;
+		case "<":
+		case "<=": return `(${field}<=${ldapEscape(value)})`;
+		case "contains":
+		case "doesnotcontain": return negateIf(`(${field}=*${ldapEscape(value)}*)`, operatorLC === "doesnotcontain");
+		case "beginswith":
+		case "doesnotbeginwith": return negateIf(`(${field}=${ldapEscape(value)}*)`, operatorLC === "doesnotbeginwith");
+		case "endswith":
+		case "doesnotendwith": return negateIf(`(${field}=*${ldapEscape(value)})`, operatorLC === "doesnotendwith");
+		case "null":
+		case "notnull": return negateIf(`(${field}=*)`, operatorLC === "notnull");
+		case "in":
+		case "notin": {
+			const valueAsArray = toArray(value);
+			return negateIf(`(|${valueAsArray.map((val) => `(${field}=${ldapEscape(val)})`).join("")})`, operatorLC === "notin");
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = toArray(value);
+			if (valueAsArray.length < 2 || nullOrUndefinedOrEmpty(valueAsArray[0]) || nullOrUndefinedOrEmpty(valueAsArray[1])) return "";
+			const [first, second] = valueAsArray;
+			const firstNum = shouldRenderAsNumber(first, true) ? parseNumber(first, { parseNumbers: true }) : NaN;
+			const secondNum = shouldRenderAsNumber(second, true) ? parseNumber(second, { parseNumbers: true }) : NaN;
+			let firstValue = Number.isNaN(firstNum) ? first : firstNum;
+			let secondValue = Number.isNaN(secondNum) ? second : secondNum;
+			if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
+				const tempNum = secondNum;
+				secondValue = firstNum;
+				firstValue = tempNum;
+			}
+			return negateIf(`(&(${field}>=${ldapEscape(firstValue)})(${field}<=${ldapEscape(secondValue)}))`, operatorLC === "notbetween");
+		}
+	}
+	// istanbul ignore next
+	return "";
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultValueProcessorNL.ts
+const escapeStringValueQuotes = (v, quoteChar, escapeQuotes) => escapeQuotes && typeof v === "string" ? v.replaceAll(`${quoteChar}`, `${quoteChar}${quoteChar}`) : v;
+/**
+* Default value processor used by {@link formatQuery} for "natural_language" format.
+*
+* @group Export
+*/
+const defaultValueProcessorNL = (rule, opts = {}) => {
+	const { escapeQuotes, fields, parseNumbers, quoteFieldNamesWith, quoteValuesWith, fieldIdentifierSeparator, translations } = opts;
+	const valueIsField = rule.valueSource === "field";
+	const operatorLowerCase = lc(rule.operator);
+	const quoteChar = quoteValuesWith || "'";
+	const quoteValue = (v) => `${quoteChar}${v}${quoteChar}`;
+	const escapeValue = (v) => escapeStringValueQuotes(v, quoteChar, escapeQuotes);
+	const wrapAndEscape = (v) => quoteValue(escapeValue(v));
+	const wrapFieldName = (v) => getQuotedFieldName(v, {
+		quoteFieldNamesWith,
+		fieldIdentifierSeparator
+	});
+	const t = translations ?? (	/* istanbul ignore next */ {});
+	const orTL = t.or ?? "or";
+	const trueTL = t.true ?? "true";
+	const falseTL = t.false ?? "false";
+	switch (operatorLowerCase) {
+		case "null":
+		case "notnull": return "";
+		case "between":
+		case "notbetween": {
+			if (!valueIsField) return defaultValueProcessorByRule(rule, opts);
+			const valueAsArray = toArray(rule.value, { retainEmptyStrings: true }).slice(0, 2).map((v) => wrapFieldName(getOption(fields ?? [], v)?.label ?? v));
+			if (valueAsArray.length < 2 || !isValidValue(valueAsArray[0]) || !isValidValue(valueAsArray[1])) return "";
+			return defaultValueProcessorByRule({
+				...rule,
+				value: valueAsArray
+			}, opts);
+		}
+		case "in":
+		case "notin": {
+			const valueAsArray = toArray(rule.value);
+			if (valueAsArray.length === 0) return "";
+			const valStringArray = valueAsArray.map((v) => valueIsField ? wrapFieldName(getOption(fields ?? [], v)?.label ?? v) : shouldRenderAsNumber(v, parseNumbers) ? `${trimIfString(v)}` : `${wrapAndEscape(v)}`);
+			return `${valStringArray.slice(0, -1).join(", ")}${valStringArray.length > 2 ? "," : ""} ${orTL} ${valStringArray.at(-1)}`;
+		}
+	}
+	if (typeof rule.value === "boolean") return rule.value ? trueTL : falseTL;
+	return valueIsField ? wrapFieldName(getOption(fields ?? [], rule.value)?.label ?? rule.value) : shouldRenderAsNumber(rule.value, parseNumbers) ? `${trimIfString(rule.value)}` : `${wrapAndEscape(rule.value)}`;
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorNL.ts
+/**
+* Default operator map used by {@link formatQuery} for "natural_language" format.
+*
+* @group Export
+*/
+const defaultExportOperatorMap = {
+	"=": ["is", "is the same as the value in"],
+	"!=": ["is not", "is not the same as the value in"],
+	"<": ["is less than", "is less than the value in"],
+	">": ["is greater than", "is greater than the value in"],
+	"<=": ["is less than or equal to", "is less than or equal to the value in"],
+	">=": ["is greater than or equal to", "is greater than or equal to the value in"],
+	contains: ["contains", "contains the value in"],
+	beginswith: ["starts with", "starts with the value in"],
+	endswith: ["ends with", "ends with the value in"],
+	doesnotcontain: ["does not contain", "does not contain the value in"],
+	doesnotbeginwith: ["does not start with", "does not start with the value in"],
+	doesnotendwith: ["does not end with", "does not end with the value in"],
+	null: "is null",
+	notnull: "is not null",
+	in: ["is one of the values", "is the same as a value in"],
+	notin: ["is not one of the values", "is not the same as any value in"],
+	between: ["is between", "is between the values in"],
+	notbetween: ["is not between", "is not between the values in"]
+};
+/* istanbul ignore next */
+const defaultGetOperators = () => [];
+/**
+* Default operator processor used by {@link formatQuery} for "natural_language" format.
+*
+* @group Export
+*/
+const defaultOperatorProcessorNL = (rule, opts = {}) => {
+	const { field, operator, valueSource = "value" } = rule;
+	// istanbul ignore next
+	const { getOperators = defaultGetOperators, operatorMap: operatorMapParam = defaultExportOperatorMap } = opts;
+	const mapOperatorMap = new Map(Object.entries(defaultExportOperatorMap));
+	for (const [key, value] of Object.entries(operatorMapParam)) mapOperatorMap.set(lc(key), value);
+	const operatorMap = Object.fromEntries(mapOperatorMap);
+	const { value: operatorNL, label } = getOption(toFullOptionList(getOperators(field, { fieldData: opts.fieldData ?? {
+		name: field,
+		value: field,
+		label: field
+	} }) ?? []), operator) ?? {
+		name: operator,
+		value: operator,
+		label: operator
+	};
+	const operatorTL = operatorMap[operatorNL] ?? operatorMap[lc(operatorNL)] ?? [label, label];
+	return typeof operatorTL === "string" ? operatorTL : operatorTL[valueSource === "field" ? 1 : 0];
+};
+/**
+* Default rule processor used by {@link formatQuery} for "natural_language" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorNL = (rule, opts) => {
+	const { field, operator } = rule;
+	// istanbul ignore next
+	const { fieldData, quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator = "", quoteValuesWith = `'`, operatorProcessor = defaultOperatorProcessorNL, valueProcessor = defaultValueProcessorNL, concatOperator = "||", wordOrder = "SVO" } = opts ?? (	/* istanbul ignore next */ {});
+	const processedField = getQuotedFieldName(fieldData?.label ?? field, {
+		quoteFieldNamesWith,
+		fieldIdentifierSeparator
+	});
+	const matchEval = processMatchMode(rule);
+	if (matchEval === false) return "";
+	else if (matchEval) {
+		const { mode, threshold } = matchEval;
+		const nestedArrayFilter = defaultRuleGroupProcessorNL(rule.value, {
+			...opts,
+			fields: toFullOptionList(fieldData?.subproperties ?? [])
+		});
+		const hsp = (fieldData?.subproperties?.length ?? 0) > 0;
+		switch (mode) {
+			case "all": return `(${hsp ? "for " : ""}every item in ${processedField}${hsp ? "," : ""} ${nestedArrayFilter})`;
+			case "none": return `(${hsp ? "for " : ""}no item in ${processedField}${hsp ? "," : ""} ${nestedArrayFilter})`;
+			case "some": return `(${hsp ? "for " : ""}at least one item in ${processedField}${hsp ? "," : ""} ${nestedArrayFilter})`;
+			case "atleast":
+			case "atmost":
+			case "exactly": {
+				const mm = mode.replace("at", "at ");
+				if (threshold > 0 && threshold < 1) return `(${hsp ? "for " : ""}${mm} ${threshold * 100}% of the items in ${processedField}${hsp ? "," : ""} ${nestedArrayFilter})`;
+				return `(${hsp ? "for " : ""}${mm} ${threshold} of the items in ${processedField}${hsp ? "," : ""} ${nestedArrayFilter})`;
+			}
+		}
+	}
+	const value = valueProcessor(rule, {
+		...opts,
+		quoteFieldNamesWith,
+		fieldIdentifierSeparator,
+		quoteValuesWith,
+		concatOperator
+	});
+	const operatorLC = lc(operator);
+	if ((operatorLC === "in" || operatorLC === "notin" || operatorLC === "between" || operatorLC === "notbetween") && !value) return "";
+	const processedOperator = operatorProcessor(rule, opts);
+	const wordOrderMap = {
+		S: processedField,
+		V: processedOperator,
+		O: value
+	};
+	return normalizeConstituentWordOrder(wordOrder).map((term) => `${wordOrderMap[term]}`).join(" ").trim();
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorSQL.ts
+/**
+* Default operator processor used by {@link formatQuery} for "sql" and "parameterized*" formats.
+*
+* @group Export
+*/
+const defaultOperatorProcessorSQL = (rule) => lc(mapSQLOperator(rule.operator));
+/**
+* Default rule processor used by {@link formatQuery} for "sql" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorSQL = (rule, opts = {}) => {
+	const { quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator = "", quoteValuesWith = `'`, operatorProcessor = defaultOperatorProcessorSQL, valueProcessor = defaultValueProcessorByRule, concatOperator = "||" } = opts;
+	const wrapFieldName = (v) => getQuotedFieldName(v, {
+		quoteFieldNamesWith,
+		fieldIdentifierSeparator
+	});
+	const ruleField = wrapFieldName(rule.field);
+	const matchEval = processMatchMode(rule);
+	if (matchEval === false) return;
+	else if (matchEval) {
+		if (opts?.preset !== "postgresql") return "";
+		const { mode, threshold } = matchEval;
+		const arrayElementAlias = "elem_alias";
+		const nestedArrayFilter = defaultRuleGroupProcessorSQL(transformQuery(rule.value, { ruleProcessor: (r) => ({
+			...r,
+			field: arrayElementAlias
+		}) }), opts);
+		switch (mode) {
+			case "all": return `(select count(*) from unnest(${ruleField}) as ${wrapFieldName(arrayElementAlias)} where ${nestedArrayFilter}) = array_length(${ruleField}, 1)`;
+			case "none": return `not exists (select 1 from unnest(${ruleField}) as ${wrapFieldName(arrayElementAlias)} where ${nestedArrayFilter})`;
+			case "some": return `exists (select 1 from unnest(${ruleField}) as ${wrapFieldName(arrayElementAlias)} where ${nestedArrayFilter})`;
+			case "atleast":
+			case "atmost":
+			case "exactly": {
+				const op = mode === "atleast" ? ">=" : mode === "atmost" ? "<=" : "=";
+				return `(select count(*)${threshold > 0 && threshold < 1 ? ` / array_length(${ruleField}, 1)` : ""} from unnest(${ruleField}) as ${wrapFieldName(arrayElementAlias)} where ${nestedArrayFilter}) ${op} ${threshold}`;
+			}
+		}
+	}
+	const value = valueProcessor(rule, {
+		...opts,
+		quoteFieldNamesWith,
+		fieldIdentifierSeparator,
+		quoteValuesWith,
+		concatOperator
+	});
+	const operator = operatorProcessor(rule, opts);
+	const operatorLowerCase = lc(operator);
+	if ((operatorLowerCase === "in" || operatorLowerCase === "not in" || operatorLowerCase === "between" || operatorLowerCase === "not between") && !value) return "";
+	return `${ruleField} ${operator} ${value}`.trim();
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorParameterized.ts
+/**
+* Default rule processor used by {@link formatQuery} for "parameterized" and
+* "parameterized_named" formats.
+*
+* @group Export
+*/
+const defaultRuleProcessorParameterized = (rule, opts, meta) => {
+	// istanbul ignore next
+	const { fieldData, format, getNextNamedParam, parseNumbers, paramPrefix, paramsKeepPrefix, numberedParams, quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator, concatOperator, operatorProcessor = defaultOperatorProcessorSQL, valueProcessor = defaultValueProcessorByRule } = opts ?? {};
+	const { processedParams = [] } = meta ?? {};
+	const parameterized = format === "parameterized";
+	const params = [];
+	const paramsNamed = {};
+	const finalize = (sql) => parameterized ? {
+		sql,
+		params
+	} : {
+		sql,
+		params: paramsNamed
+	};
+	const wrapFieldName = (v) => getQuotedFieldName(v, {
+		quoteFieldNamesWith,
+		fieldIdentifierSeparator
+	});
+	const ruleField = wrapFieldName(rule.field);
+	const matchEval = processMatchMode(rule);
+	if (matchEval === false) return;
+	else if (matchEval) {
+		if (opts?.preset !== "postgresql") return finalize("");
+		const { mode, threshold } = matchEval;
+		const arrayElementAlias = "elem_alias";
+		const { sql: nestedSQL, params: nestedParams } = defaultRuleGroupProcessorParameterized(transformQuery(rule.value, { ruleProcessor: (r) => ({
+			...r,
+			field: arrayElementAlias
+		}) }), {
+			...opts,
+			fields: []
+		});
+		// istanbul ignore else
+		if (Array.isArray(nestedParams)) params.push(...nestedParams);
+		else Object.assign(paramsNamed, nestedParams);
+		switch (mode) {
+			case "all": return finalize(`(select count(*) from unnest(${ruleField}) as ${wrapFieldName(arrayElementAlias)} where ${nestedSQL}) = array_length(${ruleField}, 1)`);
+			case "none": return finalize(`not exists (select 1 from unnest(${ruleField}) as ${wrapFieldName(arrayElementAlias)} where ${nestedSQL})`);
+			case "some": return finalize(`exists (select 1 from unnest(${ruleField}) as ${wrapFieldName(arrayElementAlias)} where ${nestedSQL})`);
+			case "atleast":
+			case "atmost":
+			case "exactly": {
+				const op = mode === "atleast" ? ">=" : mode === "atmost" ? "<=" : "=";
+				return finalize(`(select count(*)${threshold > 0 && threshold < 1 ? ` / array_length(${ruleField}, 1)` : ""} from unnest(${ruleField}) as ${wrapFieldName(arrayElementAlias)} where ${nestedSQL}) ${op} ${threshold}`);
+			}
+		}
+	}
+	const value = valueProcessor(rule, {
+		parseNumbers,
+		quoteFieldNamesWith,
+		concatOperator,
+		fieldData,
+		format
+	});
+	const sqlOperator = operatorProcessor(rule, opts);
+	const sqlOperatorLowerCase = lc(sqlOperator);
+	const [qPre, qPost] = quoteFieldNamesWith;
+	if ((sqlOperatorLowerCase === "in" || sqlOperatorLowerCase === "not in" || sqlOperatorLowerCase === "between" || sqlOperatorLowerCase === "not between") && !value) return finalize("");
+	else if (sqlOperatorLowerCase === "is null" || sqlOperatorLowerCase === "is not null") return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator}`);
+	else if (rule.valueSource === "field") return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} ${value}`.trim());
+	else if (sqlOperatorLowerCase === "in" || sqlOperatorLowerCase === "not in") {
+		const splitValue = toArray(rule.value);
+		if (parameterized) {
+			for (const v of splitValue) params.push(shouldRenderAsNumber(v, parseNumbers) ? parseNumber(v, { parseNumbers }) : v);
+			return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} (${splitValue.map((_v, i) => numberedParams ? `${paramPrefix}${processedParams.length + 1 + splitValue.length - (splitValue.length - i)}` : "?").join(", ")})`);
+		}
+		const inParams = [];
+		for (const v of splitValue) {
+			const thisParamName = getNextNamedParam(rule.field);
+			inParams.push(`${paramPrefix}${thisParamName}`);
+			paramsNamed[`${paramsKeepPrefix ? paramPrefix : ""}${thisParamName}`] = shouldRenderAsNumber(v, parseNumbers) ? parseNumber(v, { parseNumbers }) : v;
+		}
+		return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} (${inParams.join(", ")})`);
+	} else if (sqlOperatorLowerCase === "between" || sqlOperatorLowerCase === "not between") {
+		const [first, second] = toArray(rule.value, { retainEmptyStrings: true }).slice(0, 2).map((v) => shouldRenderAsNumber(v, parseNumbers) ? parseNumber(v, { parseNumbers }) : v);
+		if (parameterized) {
+			params.push(first, second);
+			return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} ${numberedParams ? `${paramPrefix}${processedParams.length + 1}` : "?"} and ${numberedParams ? `${paramPrefix}${processedParams.length + 2}` : "?"}`);
+		}
+		const firstParamName = getNextNamedParam(rule.field);
+		const secondParamName = getNextNamedParam(rule.field);
+		paramsNamed[`${paramsKeepPrefix ? paramPrefix : ""}${firstParamName}`] = first;
+		paramsNamed[`${paramsKeepPrefix ? paramPrefix : ""}${secondParamName}`] = second;
+		return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} ${paramPrefix}${firstParamName} and ${paramPrefix}${secondParamName}`);
+	}
+	let paramValue = rule.value;
+	if (typeof rule.value === "string") if (shouldRenderAsNumber(rule.value, parseNumbers)) paramValue = parseNumber(rule.value, { parseNumbers });
+	else paramValue = /^'.*'$/g.test(value) ? value.replaceAll(/(^'|'$)/g, "") : value;
+	let paramName = "";
+	if (parameterized) params.push(paramValue);
+	else {
+		paramName = getNextNamedParam(rule.field);
+		paramsNamed[`${paramsKeepPrefix ? paramPrefix : ""}${paramName}`] = paramValue;
+	}
+	return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} ${parameterized ? numberedParams ? `${paramPrefix}${processedParams.length + 1}` : "?" : `${paramPrefix}${paramName}`}`.trim());
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorPrisma.ts
+const processNumber = (value, fallback, parseNumbers) => shouldRenderAsNumber(value, !!parseNumbers || typeof value === "bigint") ? Number(parseNumber(value, { parseNumbers: !!parseNumbers })) : fallback;
+/**
+* Default rule processor used by {@link formatQuery} for "prisma" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorPrisma = (rule, options = {}) => {
+	const { field, operator, value, valueSource } = rule;
+	// istanbul ignore next
+	const { parseNumbers, preserveValueOrder } = options;
+	if (valueSource === "field" || processMatchMode(rule)) return;
+	const operatorLC = lc(operator);
+	switch (operatorLC) {
+		case "=": return { [field]: processNumber(value, value, parseNumbers) };
+		case "!=":
+		case "<":
+		case "<=":
+		case ">":
+		case ">=": {
+			const prismaOperator = prismaOperators[operatorLC];
+			return { [field]: { [prismaOperator]: processNumber(value, value, parseNumbers) } };
+		}
+		case "contains": return { [field]: { contains: value } };
+		case "beginswith": return { [field]: { startsWith: value } };
+		case "endswith": return { [field]: { endsWith: value } };
+		case "doesnotcontain": return { NOT: { [field]: { contains: value } } };
+		case "doesnotbeginwith": return { NOT: { [field]: { startsWith: value } } };
+		case "doesnotendwith": return { NOT: { [field]: { endsWith: value } } };
+		case "null": return { [field]: null };
+		case "notnull": return { [field]: { not: null } };
+		case "in":
+		case "notin": {
+			const valueAsArray = toArray(value);
+			return { [field]: { [prismaOperators[operatorLC]]: valueAsArray.map((val) => processNumber(val, val, parseNumbers)) } };
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = toArray(value);
+			if (valueAsArray.length >= 2 && isValidValue(valueAsArray[0]) && isValidValue(valueAsArray[1])) {
+				const [first, second] = valueAsArray;
+				const shouldParseNumbers = !(parseNumbers === false);
+				const firstNum = shouldRenderAsNumber(first, shouldParseNumbers) ? parseNumber(first, { parseNumbers }) : NaN;
+				const secondNum = shouldRenderAsNumber(second, shouldParseNumbers) ? parseNumber(second, { parseNumbers }) : NaN;
+				let firstValue = Number.isNaN(firstNum) ? first : firstNum;
+				let secondValue = Number.isNaN(secondNum) ? second : secondNum;
+				if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
+					const tempNum = secondNum;
+					secondValue = firstNum;
+					firstValue = tempNum;
+				}
+				return operatorLC === "between" ? { [field]: {
+					gte: firstValue,
+					lte: secondValue
+				} } : { OR: [{ [field]: { lt: firstValue } }, { [field]: { gt: secondValue } }] };
+			} else return "";
+		}
+	}
+	return "";
+};
+
+//#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorSequelize.ts
+/**
+* Default rule processor used by {@link formatQuery} for the "sequelize" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorSequelize = (rule, { parseNumbers, preserveValueOrder, context = {} } = {}) => {
+	const { sequelizeOperators: Op, sequelizeCol: col, sequelizeFn: fn } = context;
+	if (processMatchMode(rule)) return;
+	const { field, operator, value, valueSource } = rule;
+	const valueIsField = valueSource === "field";
+	const operatorLC = lc(operator);
+	if (!Op || valueIsField && (!col || !fn && [
+		"doesnotcontain",
+		"doesnotbeginwith",
+		"doesnotendwith"
+	].includes(operatorLC))) return;
+	switch (operatorLC) {
+		case "=":
+		case "!=":
+		case "<":
+		case "<=":
+		case ">":
+		case ">=": {
+			const sequelizeOperator = {
+				"=": Op.eq,
+				"!=": Op.ne,
+				"<": Op.lt,
+				"<=": Op.lte,
+				">": Op.gt,
+				">=": Op.gte
+			}[operatorLC];
+			return { [field]: valueIsField && operatorLC === "=" ? { [Op.col]: value } : { [sequelizeOperator]: valueIsField ? col(value) : shouldRenderAsNumber(value, parseNumbers) ? parseNumber(value, { parseNumbers: "strict" }) : value } };
+		}
+		case "contains": return { [field]: { [Op.substring]: valueIsField ? col(value) : `${value}` } };
+		case "beginswith": return { [field]: { [Op.startsWith]: valueIsField ? col(value) : `${value}` } };
+		case "endswith": return { [field]: { [Op.endsWith]: valueIsField ? col(value) : `${value}` } };
+		case "doesnotcontain": return { [field]: { [Op.notLike]: valueIsField ? fn("CONCAT", "%", col(value), "%") : `%${value}%` } };
+		case "doesnotbeginwith": return { [field]: { [Op.notLike]: valueIsField ? fn("CONCAT", col(value), "%") : `${value}%` } };
+		case "doesnotendwith": return { [field]: { [Op.notLike]: valueIsField ? fn("CONCAT", "%", col(value)) : `%${value}` } };
+		case "null": return { [field]: { [Op.is]: null } };
+		case "notnull": return { [field]: { [Op.not]: null } };
+		case "in":
+		case "notin": {
+			const valueAsArray = toArray(value);
+			return { [field]: { [operatorLC === "in" ? Op.in : Op.notIn]: valueAsArray.map((val) => valueIsField ? col(val) : shouldRenderAsNumber(val, parseNumbers) ? parseNumber(val, { parseNumbers: "strict" }) : val) } };
+		}
+		case "between":
+		case "notbetween": {
+			const valueAsArray = toArray(value, { retainEmptyStrings: true });
+			if (valueAsArray.length < 2 || !isValidValue(valueAsArray[0]) || !isValidValue(valueAsArray[1])) return;
+			const [first, second] = valueAsArray;
+			const firstNum = shouldRenderAsNumber(first, parseNumbers) ? parseNumber(first, { parseNumbers: "strict" }) : NaN;
+			const secondNum = shouldRenderAsNumber(second, parseNumbers) ? parseNumber(second, { parseNumbers: "strict" }) : NaN;
+			const firstValue = Number.isNaN(firstNum) ? first : firstNum;
+			const secondValue = Number.isNaN(secondNum) ? second : secondNum;
+			const valsOneAndTwoOnly = [firstValue, secondValue];
+			if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
+				valsOneAndTwoOnly[0] = secondNum;
+				valsOneAndTwoOnly[1] = firstNum;
+			}
+			return { [field]: { [operatorLC === "between" ? Op.between : Op.notBetween]: valueIsField ? valsOneAndTwoOnly.map((v) => col(v)) : valsOneAndTwoOnly.every((v) => shouldRenderAsNumber(v, parseNumbers)) ? valsOneAndTwoOnly.map((v) => parseNumber(v, { parseNumbers: "strict" })) : valsOneAndTwoOnly } };
+		}
+	}
+};
+
+//#endregion
+//#region src/utils/formatQuery/formatQuery.ts
+/**
+* A collection of option presets for {@link formatQuery}, specifically for SQL-based formats.
+*
+* @group Export
+*/
+const sqlDialectPresets = {
+	ansi: {},
+	sqlite: { paramsKeepPrefix: true },
+	oracle: {},
+	mssql: {
+		concatOperator: "+",
+		quoteFieldNamesWith: ["[", "]"],
+		fieldIdentifierSeparator: ".",
+		paramPrefix: "@"
+	},
+	mysql: { concatOperator: "CONCAT" },
+	postgresql: {
+		quoteFieldNamesWith: "\"",
+		numberedParams: true,
+		paramPrefix: "$"
+	}
+};
+/**
+* A collection of option presets for {@link formatQuery}.
+*
+* @group Export
+*/
+const formatQueryOptionPresets = { ...sqlDialectPresets };
+const defaultRuleProcessors = {
+	cel: defaultRuleProcessorCEL,
+	drizzle: defaultRuleProcessorDrizzle,
+	elasticsearch: defaultRuleProcessorElasticSearch,
+	json_without_ids: defaultRuleProcessorSQL,
+	json: defaultRuleProcessorSQL,
+	jsonata: defaultRuleProcessorJSONata,
+	jsonlogic: defaultRuleProcessorJsonLogic,
+	ldap: defaultRuleProcessorLDAP,
+	mongodb_query: defaultRuleProcessorMongoDBQuery,
+	mongodb: defaultRuleProcessorMongoDB,
+	natural_language: defaultRuleProcessorNL,
+	parameterized_named: defaultRuleProcessorParameterized,
+	parameterized: defaultRuleProcessorParameterized,
+	prisma: defaultRuleProcessorPrisma,
+	sequelize: defaultRuleProcessorSequelize,
+	spel: defaultRuleProcessorSpEL,
+	sql: defaultRuleProcessorSQL
+};
+/* istanbul ignore next */
+const defaultOperatorProcessor = (r) => r.operator;
+const defaultOperatorProcessors = {
+	cel: defaultOperatorProcessor,
+	drizzle: defaultOperatorProcessor,
+	elasticsearch: defaultOperatorProcessor,
+	json_without_ids: defaultOperatorProcessor,
+	json: defaultOperatorProcessor,
+	jsonata: defaultOperatorProcessor,
+	jsonlogic: defaultOperatorProcessor,
+	ldap: defaultOperatorProcessor,
+	mongodb_query: defaultOperatorProcessor,
+	mongodb: defaultOperatorProcessor,
+	natural_language: defaultOperatorProcessorNL,
+	parameterized_named: defaultOperatorProcessorSQL,
+	parameterized: defaultOperatorProcessorSQL,
+	prisma: defaultOperatorProcessor,
+	sequelize: defaultOperatorProcessor,
+	spel: defaultOperatorProcessor,
+	sql: defaultOperatorProcessorSQL
+};
+const defaultFallbackExpressions = {
+	cel: "1 == 1",
+	ldap: "",
+	mongodb: "\"$and\":[{\"$expr\":true}]",
+	natural_language: "1 is 1",
+	spel: "1 == 1",
+	sql: "(1 = 1)"
+};
+const defaultFormatQueryOptions = {
+	format: "json",
+	fields: [],
+	quoteFieldNamesWith: ["", ""],
+	fieldIdentifierSeparator: "",
+	getOperators: () => [],
+	paramPrefix: ":",
+	paramsKeepPrefix: false,
+	numberedParams: false,
+	preserveValueOrder: false,
+	placeholderFieldName: defaultPlaceholderFieldName,
+	placeholderOperatorName: defaultPlaceholderOperatorName,
+	quoteValuesWith: "'",
+	concatOperator: "||",
+	preset: "ansi",
+	wordOrder: "SVO",
+	translations: {},
+	operatorMap: {}
+};
+const valueProcessorCanActAsRuleProcessor = new Set([
+	"cel",
+	"drizzle",
+	"elasticsearch",
+	"jsonata",
+	"jsonlogic",
+	"ldap",
+	"mongodb_query",
+	"mongodb",
+	"prisma",
+	"sequelize",
+	"spel"
+]);
+const sqlFormats = new Set([
+	"sql",
+	"parameterized",
+	"parameterized_named",
+	"drizzle",
+	"prisma",
+	"sequelize"
+]);
+function formatQuery(ruleGroup, optionParam = {}) {
+	const options = typeof optionParam === "string" ? { format: lc(optionParam) } : optionParam;
+	const optObj = {
+		...defaultFormatQueryOptions,
+		...!options.format || sqlFormats.has(options.format) ? sqlDialectPresets[options.preset ?? "ansi"] ?? null : null,
+		...options,
+		...!options.format && (Object.keys(sqlDialectPresets).includes(options.preset ?? "") ? { format: "sql" } : null)
+	};
+	const format = lc(optObj.format);
+	const { fallbackExpression: fallbackExpression_option, getOperators: getOperators_option, operatorProcessor: operatorProcessor_option, parseNumbers, quoteFieldNamesWith: quoteFieldNamesWith_option, ruleGroupProcessor: ruleGroupProcessor_option, ruleProcessor: ruleProcessor_option, validator, valueProcessor: valueProcessor_option, context } = optObj;
+	const getParseNumberBoolean = (inputType) => {
+		return typeof getParseNumberMethod({
+			parseNumbers,
+			inputType
+		}) === "string" ? true : typeof parseNumbers === "boolean" ? parseNumbers : void 0;
+	};
+	const operatorProcessor = typeof operatorProcessor_option === "function" ? operatorProcessor_option : defaultOperatorProcessors[format] ?? defaultOperatorProcessor;
+	const valueProcessor = typeof valueProcessor_option === "function" ? isValueProcessorLegacy(valueProcessor_option) ? (r) => valueProcessor_option(r.field, r.operator, r.value, r.valueSource) : valueProcessor_option : format === "natural_language" ? defaultValueProcessorNL : valueProcessorCanActAsRuleProcessor.has(format) ? ruleProcessor_option ?? defaultRuleProcessors[format] : defaultValueProcessorByRule;
+	const ruleProcessor = (typeof ruleProcessor_option === "function" ? ruleProcessor_option : null) ?? (valueProcessorCanActAsRuleProcessor.has(format) && typeof ruleProcessor_option !== "function" && valueProcessor_option ? valueProcessor : null) ?? defaultRuleProcessors[format] ?? defaultRuleProcessorSQL;
+	const quoteFieldNamesWith = getQuoteFieldNamesWithArray(quoteFieldNamesWith_option);
+	const fields = toFullOptionList(optObj.fields);
+	const getOperators = (f, m) => toFullOptionList(getOperators_option(f, m) ?? []);
+	const fallbackExpression = fallbackExpression_option ?? defaultFallbackExpressions[format] ?? defaultFallbackExpressions.sql;
+	let validationMap = {};
+	// istanbul ignore else
+	if (typeof validator === "function") {
+		const validationResult = validator(ruleGroup);
+		if (typeof validationResult === "boolean") {
+			// istanbul ignore else
+			if (!validationResult) return format === "parameterized" ? {
+				sql: fallbackExpression,
+				params: []
+			} : format === "parameterized_named" ? {
+				sql: fallbackExpression,
+				params: {}
+			} : format === "mongodb" ? `{${fallbackExpression}}` : format === "mongodb_query" ? mongoDbFallback : format === "prisma" ? prismaFallback : format === "jsonlogic" ? false : format === "elasticsearch" ? {} : format === "drizzle" || format === "sequelize" ? void 0 : fallbackExpression;
+		} else validationMap = validationResult;
+	}
+	const validatorMap = {};
+	const uniqueFields = toFlatOptionArray(fields);
+	for (const f of uniqueFields)
+ // istanbul ignore else
+	if (typeof f.validator === "function") validatorMap[f.value ?? f.name] = f.validator;
+	const validateRule = (rule) => {
+		let validationResult;
+		let fieldValidator;
+		if (rule.id) validationResult = validationMap[rule.id];
+		if (uniqueFields.length > 0) {
+			const fieldArr = uniqueFields.filter((f) => f.name === rule.field);
+			if (fieldArr.length > 0) {
+				const field = fieldArr[0];
+				// istanbul ignore else
+				if (typeof field.validator === "function") fieldValidator = field.validator;
+			}
+		}
+		return [validationResult, fieldValidator];
+	};
+	const finalOptions = {
+		...optObj,
+		fallbackExpression,
+		fields,
+		format,
+		getOperators,
+		getParseNumberBoolean,
+		quoteFieldNamesWith,
+		operatorProcessor,
+		ruleProcessor,
+		valueProcessor,
+		validateRule,
+		validationMap,
+		context
+	};
+	if (typeof ruleGroupProcessor_option === "function") return ruleGroupProcessor_option(ruleGroup, finalOptions);
+	switch (format) {
+		case "json":
+		case "json_without_ids": {
+			const rg = parseNumbers ? (0, immer.produce)(ruleGroup, (g) => numerifyValues(g, finalOptions)) : ruleGroup;
+			if (format === "json_without_ids") return JSON.stringify(rg, (key, value) => key === "id" || key === "path" ? void 0 : bigIntJsonStringifyReplacer(key, value));
+			return JSON.stringify(rg, bigIntJsonStringifyReplacer, 2);
+		}
+		case "sql": return defaultRuleGroupProcessorSQL(ruleGroup, finalOptions);
+		case "parameterized":
+		case "parameterized_named": return defaultRuleGroupProcessorParameterized(ruleGroup, finalOptions);
+		case "mongodb": return defaultRuleGroupProcessorMongoDB(ruleGroup, finalOptions);
+		case "mongodb_query": return defaultRuleGroupProcessorMongoDBQuery(ruleGroup, finalOptions);
+		case "cel": return defaultRuleGroupProcessorCEL(ruleGroup, finalOptions);
+		case "spel": return defaultRuleGroupProcessorSpEL(ruleGroup, finalOptions);
+		case "jsonata": return defaultRuleGroupProcessorJSONata(ruleGroup, finalOptions);
+		case "jsonlogic": return defaultRuleGroupProcessorJsonLogic(ruleGroup, finalOptions);
+		case "elasticsearch": return defaultRuleGroupProcessorElasticSearch(ruleGroup, finalOptions);
+		case "natural_language": return defaultRuleGroupProcessorNL(ruleGroup, finalOptions);
+		case "ldap": return defaultRuleGroupProcessorLDAP(ruleGroup, finalOptions);
+		case "prisma": return defaultRuleGroupProcessorPrisma(ruleGroup, finalOptions);
+		case "drizzle": return defaultRuleGroupProcessorDrizzle(ruleGroup, finalOptions);
+		case "sequelize": return defaultRuleGroupProcessorSequelize(ruleGroup, finalOptions);
+		default: return "";
+	}
+}
+
+//#endregion
+//#region src/utils/formatQuery/index.ts
+const generateValueProcessor = (vpbr) => (field, operator, value, valueSource) => vpbr({
+	field,
+	operator,
+	value,
+	valueSource
+}, { parseNumbers: false });
+/**
+* Default value processor used by {@link formatQuery} for "sql" format.
+*
+* @group Export
+*/
+const defaultValueProcessor = generateValueProcessor(defaultValueProcessorByRule);
+/**
+* @deprecated Prefer {@link defaultRuleProcessorMongoDB}.
+*
+* @group Export
+*/
+const defaultMongoDBValueProcessor = generateValueProcessor(defaultRuleProcessorMongoDB);
+/**
+* @deprecated Prefer {@link defaultRuleProcessorCEL}.
+*
+* @group Export
+*/
+const defaultCELValueProcessor = generateValueProcessor(defaultRuleProcessorCEL);
+/**
+* @deprecated Prefer {@link defaultRuleProcessorSpEL}.
+*
+* @group Export
+*/
+const defaultSpELValueProcessor = generateValueProcessor(defaultRuleProcessorSpEL);
+/**
+* @deprecated Renamed to {@link defaultRuleProcessorCEL}.
+*
+* @group Export
+*/
+const defaultValueProcessorCELByRule = defaultRuleProcessorCEL;
+/**
+* @deprecated Renamed to {@link defaultRuleProcessorMongoDB}.
+*
+* @group Export
+*/
+const defaultValueProcessorMongoDBByRule = defaultRuleProcessorMongoDB;
+/**
+* @deprecated Renamed to {@link defaultRuleProcessorSpEL}.
+*
+* @group Export
+*/
+const defaultValueProcessorSpELByRule = defaultRuleProcessorSpEL;
+
+//#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 && isRuleGroup(target)) {
+		const t = target.rules[path[level]];
+		target = typeof t === "string" ? null : t;
+		level++;
+	}
+	return 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 (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 (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) => path1.length === path2.length && path1.every((val, idx) => val === path2[idx]);
+/**
+* Determines if the first path is an ancestor of the second path. The first path must
+* be shorter and exactly match the second path up through the length of the first path.
+*/
+const isAncestor = (maybeAncestor, path) => maybeAncestor.length < path.length && (/* @__PURE__ */ new RegExp(`^${maybeAncestor.join("-")}`)).test(path.join("-"));
+/**
+* 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 && isRuleGroup(target)) {
+		const t = target.rules[path[level]];
+		if (isPojo(t) && (isRuleGroup(t) || "field" in t && !!t.field)) {
+			disabled = !!t.disabled;
+			target = t;
+		}
+		level++;
+	}
+	return disabled;
+};
+
+//#endregion
+//#region src/utils/generateAccessibleDescription.ts
+const generateAccessibleDescription = (params) => pathsAreEqual([], params.path) ? `Query builder` : `Rule group at path ${params.path.join("-")}`;
+
+//#endregion
+//#region src/utils/generateID.ts
+const cryptoModule = globalThis.crypto;
+/**
+* Default `id` generator. Generates a valid v4 UUID. Uses `crypto.randomUUID()`
+* when available, otherwise uses an alternate method based on `getRandomValues`.
+* The returned string is guaranteed to match this regex:
+* ```
+* /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i
+* ```
+* @returns Valid v4 UUID
+*/
+// istanbul ignore next
+let generateID = () => "00-0-4-2-000".replaceAll(/[^-]/g, (s) => ((Math.random() + Math.trunc(s)) * 65536 >> Number.parseInt(s)).toString(16).padStart(4, "0"));
+// istanbul ignore else
+if (cryptoModule) {
+	// istanbul ignore else
+	if (typeof cryptoModule.randomUUID === "function") generateID = () => cryptoModule.randomUUID();
+	else if (typeof cryptoModule.getRandomValues === "function") {
+		const position19vals = "89ab";
+		const container = new Uint32Array(32);
+		generateID = () => {
+			cryptoModule.getRandomValues(container);
+			let id = (container[0] % 16).toString(16);
+			for (let i = 1; i < 32; i++) {
+				if (i === 12) id = `${id}4`;
+				else if (i === 16) id = `${id}${position19vals[container[17] % 4]}`;
+				else id = `${id}${(container[i] % 16).toString(16)}`;
+				if (i === 7 || i === 11 || i === 15 || i === 19) id = `${id}-`;
+			}
+			return id;
+		};
+	}
+}
+
+//#endregion
+//#region src/utils/getMatchModesUtil.ts
+const dummyFD$1 = {
+	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 ? toFullOption(fieldData) : dummyFD$1;
+	let matchModes = fd.matchModes ?? false;
+	if (!matchModes && getMatchModes) matchModes = getMatchModes(fd.value, { fieldData: fd });
+	if (matchModes === true) return defaultMatchModes;
+	else if (matchModes === false) return [];
+	if (isFlexibleOptionArray(matchModes)) return toFullOptionList(matchModes);
+	return matchModes?.map((mm) => defaultMatchModes.find((dmm) => dmm.value === lc(mm)) ?? {
+		name: mm,
+		value: mm,
+		label: mm
+	}) ?? [];
+};
+
+//#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 ? standardClassnames.valid : standardClassnames.invalid : "";
+};
+
+//#endregion
+//#region src/utils/getValueSourcesUtil.ts
+const defaultValueSourcesArray = [{
+	name: "value",
+	value: "value",
+	label: "value"
+}];
+const dummyFD = {
+	name: "name",
+	value: "name",
+	valueSources: null,
+	label: "label"
+};
+/**
+* Utility function to get the value sources array for the given
+* field and operator. If the field definition does not define a
+* `valueSources` property, the `getValueSources` prop is used.
+* Returns `[FullOption<"value">]` by default.
+*/
+const getValueSourcesUtil = (fieldData, operator, getValueSources) => {
+	const fd = fieldData ? toFullOption(fieldData) : dummyFD;
+	let valueSourcesNEW = fd.valueSources ?? false;
+	if (typeof valueSourcesNEW === "function") valueSourcesNEW = valueSourcesNEW(operator);
+	if (!valueSourcesNEW && getValueSources) valueSourcesNEW = getValueSources(fd.value, operator, { fieldData: fd });
+	if (!valueSourcesNEW) return defaultValueSourcesArray;
+	if (isFlexibleOptionArray(valueSourcesNEW)) return toFullOptionList(valueSourcesNEW);
+	return valueSourcesNEW.map((vs) => defaultValueSourcesArray.find((dmm) => dmm.value === lc(vs)) ?? {
+		name: vs,
+		value: vs,
+		label: vs
+	});
+};
+
+//#endregion
+//#region src/utils/mergeClassnames.ts
+const joinClassnamesByName = (name, args) => clsx(args.map((c) => clsx(c?.[name])));
+/**
+* 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),
+	dragHandle: joinClassnamesByName("dragHandle", args),
+	lockRule: joinClassnamesByName("lockRule", args),
+	lockGroup: joinClassnamesByName("lockGroup", 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),
+	disabled: joinClassnamesByName("disabled", args),
+	valueListItem: joinClassnamesByName("valueListItem", args),
+	matchMode: joinClassnamesByName("matchMode", args),
+	matchThreshold: joinClassnamesByName("matchThreshold", args),
+	branches: joinClassnamesByName("branches", args),
+	hasSubQuery: joinClassnamesByName("hasSubQuery", args)
+});
+
+//#endregion
+//#region src/utils/objectUtils.ts
+/**
+* A strongly-typed version of `Object.keys()`.
+*
+* [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts)
+*/
+const objectKeys = Object.keys;
+/**
+* A strongly-typed version of `Object.entries()`.
+*
+* [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-entries.ts)
+*/
+const objectEntries = Object.entries;
+
+//#endregion
+//#region src/utils/prepareQueryObjects.ts
+/**
+* Ensures that a rule is valid by adding an `id` property if it does not already exist.
+*/
+const prepareRule = (rule, { idGenerator = generateID } = {}) => (0, immer.produce)(rule, (draft) => {
+	if (!draft.id) draft.id = idGenerator();
+});
+/**
+* Ensures that a rule group is valid by recursively adding an `id` property to the group itself
+* and all its rules and subgroups where one does not already exist.
+*/
+const prepareRuleGroup = (queryObject, { idGenerator = generateID } = {}) => (0, immer.produce)(queryObject, (draft) => {
+	if (!draft.id) draft.id = idGenerator();
+	draft.rules = draft.rules.map((r) => typeof r === "string" ? r : isRuleGroup(r) ? prepareRuleGroup(r, { idGenerator }) : prepareRule(r, { idGenerator }));
+});
+/**
+* Ensures that a rule or group is valid. See {@link prepareRule} and {@link prepareRuleGroup}.
+*/
+const prepareRuleOrGroup = (rg, { idGenerator = generateID } = {}) => isRuleGroup(rg) ? prepareRuleGroup(rg, { idGenerator }) : prepareRule(rg, { idGenerator });
+
+//#endregion
+//#region src/utils/regenerateIDs.ts
+/**
+* Generates a new `id` property for a rule.
+*/
+const regenerateID = (rule, { idGenerator = generateID } = {}) => structuredClone({
+	...rule,
+	id: idGenerator()
+});
+/**
+* Recursively generates new `id` properties for a group and all its rules and subgroups.
+*/
+const regenerateIDs = (ruleOrGroup, { idGenerator = generateID } = {}) => {
+	if (!isPojo(ruleOrGroup)) return ruleOrGroup;
+	if (!isRuleGroup(ruleOrGroup)) return structuredClone({
+		...ruleOrGroup,
+		id: idGenerator()
+	});
+	if (isRuleGroupType(ruleOrGroup)) {
+		const rules$1 = ruleOrGroup.rules.map((r) => isRuleGroup(r) ? regenerateIDs(r, { idGenerator }) : regenerateID(r, { idGenerator }));
+		return {
+			...ruleOrGroup,
+			id: idGenerator(),
+			rules: rules$1
+		};
+	}
+	const rules = ruleOrGroup.rules.map((r) => typeof r === "string" ? r : isRuleGroup(r) ? regenerateIDs(r, { idGenerator }) : regenerateID(r, { idGenerator }));
+	return {
+		...ruleOrGroup,
+		id: idGenerator(),
+		rules
+	};
+};
+
+//#endregion
+//#region src/utils/queryTools.ts
+/**
+* Adds a rule or group to a query.
+* @returns The new query with the rule or group added.
+*
+* @group Query Tools
+*/
+const add = (query, ruleOrGroup, parentPathOrID, { combinators = defaultCombinators, combinatorPreceding, idGenerator = generateID } = {}) => (0, immer.produce)(query, (draft) => {
+	const parent = Array.isArray(parentPathOrID) ? findPath(parentPathOrID, draft) : findID(parentPathOrID, draft);
+	if (!parent || !isRuleGroup(parent)) return;
+	if (isRuleGroupTypeIC(parent) && parent.rules.length > 0) {
+		const prevCombinator = parent.rules.at(-2);
+		parent.rules.push(combinatorPreceding ?? (typeof prevCombinator === "string" ? prevCombinator : getFirstOption(combinators)));
+	}
+	parent.rules.push(prepareRuleOrGroup(ruleOrGroup, { idGenerator }));
+});
+/**
+* Updates a property of a rule or group within a query.
+* @returns The new query with the rule or group property updated.
+*
+* @group Query Tools
+*/
+const update = (query, prop, value, pathOrID, { resetOnFieldChange = true, resetOnOperatorChange = false, getRuleDefaultOperator = () => "=", getValueSources = () => ["value"], getRuleDefaultValue = () => "", getMatchModes = () => [] } = {}) => (0, immer.produce)(query, (draft) => {
+	const path = Array.isArray(pathOrID) ? pathOrID : getPathOfID(pathOrID, draft);
+	if (!path) return;
+	if (prop === "combinator" && !isRuleGroupType(draft)) {
+		const parentRules = findPath(getParentPath(path), draft).rules;
+		if (path.at(-1) % 2 === 1) parentRules[path.at(-1)] = value;
+		return;
+	}
+	const ruleOrGroup = findPath(path, draft);
+	if (!ruleOrGroup) return;
+	const isGroup = isRuleGroup(ruleOrGroup);
+	if (ruleOrGroup[prop] === value) return;
+	if (prop !== "valueSource") ruleOrGroup[prop] = value;
+	if (isGroup) return;
+	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 && getOption(toFieldMatchModes, ruleOrGroup.match.mode) ? null : 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 = getValueSourcesUtil({
+		name: ruleOrGroup.field,
+		value: ruleOrGroup.field,
+		label: ""
+	}, ruleOrGroup.operator, getValueSources);
+	const defaultValueSource = 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);
+});
+/**
+* Removes a rule or group from a query.
+* @returns The new query with the rule or group removed.
+*
+* @group Query Tools
+*/
+const remove = (query, pathOrID) => {
+	const path = Array.isArray(pathOrID) ? pathOrID : getPathOfID(pathOrID, query);
+	if (!path) return query;
+	if (path.length === 0 || !isRuleGroupType(query) && !findPath(path, query)) return query;
+	return (0, immer.produce)(query, (draft) => {
+		const index = path.at(-1);
+		const parent = findPath(getParentPath(path), draft);
+		if (parent && isRuleGroup(parent)) if (!isRuleGroupType(parent) && parent.rules.length > 1) {
+			const idxStartDelete = index === 0 ? 0 : index - 1;
+			parent.rules.splice(idxStartDelete, 2);
+		} else parent.rules.splice(index, 1);
+	});
+};
+const getNextPath = (query, currentPath, newPathOrShiftDirection) => {
+	if (Array.isArray(newPathOrShiftDirection)) return newPathOrShiftDirection;
+	const ic = isRuleGroupTypeIC(query);
+	if (newPathOrShiftDirection === "up") if (pathsAreEqual(currentPath, [0])) return currentPath;
+	else if (currentPath.at(-1) === 0) {
+		const parentPath = getParentPath(currentPath);
+		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 (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 (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. In the options parameter, pass
+* `{ clone: true }` to copy instead of move.
+* @returns The new query with the rule or group moved or cloned.
+*
+* @group Query Tools
+*/
+const move = (query, oldPathOrID, newPath, { clone = false, combinators = defaultCombinators, idGenerator = generateID } = {}) => {
+	const oldPath = Array.isArray(oldPathOrID) ? oldPathOrID : getPathOfID(oldPathOrID, query);
+	if (!oldPath) return query;
+	const nextPath = getNextPath(query, oldPath, newPath);
+	if (oldPath.length === 0 || pathsAreEqual(oldPath, nextPath) || !findPath(getParentPath(nextPath), query)) return query;
+	const ruleOrGroupOriginal = findPath(oldPath, query);
+	if (!ruleOrGroupOriginal) return query;
+	const ruleOrGroup = clone ? regenerateIDs(ruleOrGroupOriginal, { idGenerator }) : ruleOrGroupOriginal;
+	return (0, immer.produce)(query, (draft) => {
+		const independentCombinators = isRuleGroupTypeIC(draft);
+		const parentOfRuleToRemove = findPath(getParentPath(oldPath), draft);
+		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];
+		const commonAncestorPath = getCommonAncestorPath(oldPath, nextPath);
+		if (!clone && oldPath.length === commonAncestorPath.length + 1 && nextPath[commonAncestorPath.length] > oldPath[commonAncestorPath.length]) newNewPath[commonAncestorPath.length] -= independentCombinators ? 2 : 1;
+		const newNewParentPath = getParentPath(newNewPath);
+		const parentToInsertInto = findPath(newNewParentPath, draft);
+		const newIndex = newNewPath.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 = (...args) => parentToInsertInto.rules.splice(newIndex, 0, ...args);
+		if (parentToInsertInto.rules.length === 0 || !independentCombinators) insertRuleOrGroup(ruleOrGroup);
+		else if (newIndex === 0) if (ruleToRemoveIndex === 0 && oldNextCombinator) insertRuleOrGroup(ruleOrGroup, oldNextCombinator);
+		else {
+			const newNextCombinator = parentToInsertInto.rules[1] ?? oldPrevCombinator ?? getFirstOption(combinators);
+			insertRuleOrGroup(ruleOrGroup, newNextCombinator);
+		}
+		else if (oldPrevCombinator) insertRuleOrGroup(oldPrevCombinator, ruleOrGroup);
+		else {
+			const newPrevCombinator = parentToInsertInto.rules[newIndex - 2] ?? oldNextCombinator ?? getFirstOption(combinators);
+			insertRuleOrGroup(newPrevCombinator, ruleOrGroup);
+		}
+	});
+};
+/**
+* Inserts a rule or group into a query.
+* @returns The new query with the rule or group inserted.
+*
+* @group Query Tools
+*/
+const insert = (query, ruleOrGroup, path, { combinators = defaultCombinators, combinatorPreceding, combinatorSucceeding, idGenerator = generateID, replace = false } = {}) => (0, immer.produce)(query, (draft) => {
+	const parentToInsertInto = findPath(getParentPath(path), draft);
+	if (!parentToInsertInto || !isRuleGroup(parentToInsertInto)) return;
+	const rorg = regenerateIDs(ruleOrGroup, { idGenerator });
+	const independentCombinators = isRuleGroupTypeIC(draft);
+	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 {
+		const newNextCombinator = parentToInsertInto.rules[1] ?? combinatorPreceding ?? getFirstOption(combinators);
+		insertRuleOrGroup(newIndex, rorg, newNextCombinator);
+	}
+	else {
+		const normalizedNewIndex = newIndex % 2 === 0 ? newIndex - 1 : newIndex;
+		if (combinatorPreceding) insertRuleOrGroup(normalizedNewIndex, combinatorPreceding, rorg);
+		else {
+			const newPrevCombinator = parentToInsertInto.rules[normalizedNewIndex - 2] ?? combinatorSucceeding ?? getFirstOption(combinators);
+			insertRuleOrGroup(normalizedNewIndex, newPrevCombinator, rorg);
+		}
+	}
+});
+/**
+* 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 the options parameter, pass
+* `{ clone: true }` to copy the source rule/group instead of move.
+*
+* @returns The new query with the rules or groups grouped.
+*
+* @group Query Tools
+*/
+const group = (query, sourcePathOrID, targetPathOrID, { clone = false, combinators = defaultCombinators, idGenerator = generateID } = {}) => {
+	const sourcePath = Array.isArray(sourcePathOrID) ? sourcePathOrID : getPathOfID(sourcePathOrID, query);
+	const targetPath = Array.isArray(targetPathOrID) ? targetPathOrID : getPathOfID(targetPathOrID, query);
+	if (!sourcePath || !targetPath) return query;
+	const nextPath = getNextPath(query, sourcePath, targetPath);
+	if (sourcePath.length === 0 || pathsAreEqual(sourcePath, nextPath) || !findPath(getParentPath(nextPath), query)) return query;
+	const sourceRuleOrGroupOriginal = findPath(sourcePath, query);
+	const targetRuleOrGroup = findPath(targetPath, query);
+	if (!sourceRuleOrGroupOriginal || !targetRuleOrGroup) return query;
+	const sourceRuleOrGroup = clone ? regenerateIDs(sourceRuleOrGroupOriginal, { idGenerator }) : sourceRuleOrGroupOriginal;
+	return (0, immer.produce)(query, (draft) => {
+		const independentCombinators = isRuleGroupTypeIC(draft);
+		const parentOfRuleToRemove = findPath(getParentPath(sourcePath), draft);
+		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, draft);
+		const targetPathIndex = newNewPath.at(-1);
+		parentOfTargetPath.rules.splice(targetPathIndex, 1, prepareRuleOrGroup(independentCombinators ? { rules: [
+			targetRuleOrGroup,
+			getFirstOption(combinators),
+			sourceRuleOrGroup
+		] } : {
+			combinator: getFirstOption(combinators),
+			rules: [targetRuleOrGroup, sourceRuleOrGroup]
+		}, { idGenerator }));
+	});
+};
+
+//#endregion
+exports.LogType = LogType;
+exports.TestID = TestID;
+exports.add = add;
+exports.bigIntJsonParseReviver = bigIntJsonParseReviver;
+exports.bigIntJsonStringifyReplacer = bigIntJsonStringifyReplacer;
+exports.celCombinatorMap = celCombinatorMap;
+exports.clsx = clsx;
+exports.convertFromIC = convertFromIC;
+exports.convertQuery = convertQuery;
+exports.convertToIC = convertToIC;
+exports.defaultCELValueProcessor = defaultCELValueProcessor;
+exports.defaultCombinatorLabelMap = defaultCombinatorLabelMap;
+exports.defaultCombinators = defaultCombinators;
+exports.defaultCombinatorsExtended = defaultCombinatorsExtended;
+exports.defaultControlClassnames = defaultControlClassnames;
+exports.defaultExportOperatorMap = defaultExportOperatorMap;
+exports.defaultJoinChar = defaultJoinChar;
+exports.defaultMatchModes = defaultMatchModes;
+exports.defaultMongoDBValueProcessor = defaultMongoDBValueProcessor;
+exports.defaultNLTranslations = defaultNLTranslations;
+exports.defaultOperatorLabelMap = defaultOperatorLabelMap;
+exports.defaultOperatorNegationMap = defaultOperatorNegationMap;
+exports.defaultOperatorProcessorNL = defaultOperatorProcessorNL;
+exports.defaultOperatorProcessorSQL = defaultOperatorProcessorSQL;
+exports.defaultOperators = defaultOperators;
+exports.defaultPlaceholderFieldGroupLabel = defaultPlaceholderFieldGroupLabel;
+exports.defaultPlaceholderFieldLabel = defaultPlaceholderFieldLabel;
+exports.defaultPlaceholderFieldName = defaultPlaceholderFieldName;
+exports.defaultPlaceholderLabel = defaultPlaceholderLabel;
+exports.defaultPlaceholderName = defaultPlaceholderName;
+exports.defaultPlaceholderOperatorGroupLabel = defaultPlaceholderOperatorGroupLabel;
+exports.defaultPlaceholderOperatorLabel = defaultPlaceholderOperatorLabel;
+exports.defaultPlaceholderOperatorName = defaultPlaceholderOperatorName;
+exports.defaultPlaceholderValueGroupLabel = defaultPlaceholderValueGroupLabel;
+exports.defaultPlaceholderValueLabel = defaultPlaceholderValueLabel;
+exports.defaultPlaceholderValueName = defaultPlaceholderValueName;
+exports.defaultRuleGroupProcessorCEL = defaultRuleGroupProcessorCEL;
+exports.defaultRuleGroupProcessorDrizzle = defaultRuleGroupProcessorDrizzle;
+exports.defaultRuleGroupProcessorElasticSearch = defaultRuleGroupProcessorElasticSearch;
+exports.defaultRuleGroupProcessorJSONata = defaultRuleGroupProcessorJSONata;
+exports.defaultRuleGroupProcessorJsonLogic = defaultRuleGroupProcessorJsonLogic;
+exports.defaultRuleGroupProcessorLDAP = defaultRuleGroupProcessorLDAP;
+exports.defaultRuleGroupProcessorMongoDB = defaultRuleGroupProcessorMongoDB;
+exports.defaultRuleGroupProcessorMongoDBQuery = defaultRuleGroupProcessorMongoDBQuery;
+exports.defaultRuleGroupProcessorNL = defaultRuleGroupProcessorNL;
+exports.defaultRuleGroupProcessorParameterized = defaultRuleGroupProcessorParameterized;
+exports.defaultRuleGroupProcessorPrisma = defaultRuleGroupProcessorPrisma;
+exports.defaultRuleGroupProcessorSQL = defaultRuleGroupProcessorSQL;
+exports.defaultRuleGroupProcessorSequelize = defaultRuleGroupProcessorSequelize;
+exports.defaultRuleGroupProcessorSpEL = defaultRuleGroupProcessorSpEL;
+exports.defaultRuleProcessorCEL = defaultRuleProcessorCEL;
+exports.defaultRuleProcessorDrizzle = defaultRuleProcessorDrizzle;
+exports.defaultRuleProcessorElasticSearch = defaultRuleProcessorElasticSearch;
+exports.defaultRuleProcessorJSONata = defaultRuleProcessorJSONata;
+exports.defaultRuleProcessorJsonLogic = defaultRuleProcessorJsonLogic;
+exports.defaultRuleProcessorLDAP = defaultRuleProcessorLDAP;
+exports.defaultRuleProcessorMongoDB = defaultRuleProcessorMongoDB;
+exports.defaultRuleProcessorMongoDBQuery = defaultRuleProcessorMongoDBQuery;
+exports.defaultRuleProcessorNL = defaultRuleProcessorNL;
+exports.defaultRuleProcessorParameterized = defaultRuleProcessorParameterized;
+exports.defaultRuleProcessorPrisma = defaultRuleProcessorPrisma;
+exports.defaultRuleProcessorSQL = defaultRuleProcessorSQL;
+exports.defaultRuleProcessorSequelize = defaultRuleProcessorSequelize;
+exports.defaultRuleProcessorSpEL = defaultRuleProcessorSpEL;
+exports.defaultSpELValueProcessor = defaultSpELValueProcessor;
+exports.defaultValidator = defaultValidator;
+exports.defaultValueProcessor = defaultValueProcessor;
+exports.defaultValueProcessorByRule = defaultValueProcessorByRule;
+exports.defaultValueProcessorCELByRule = defaultValueProcessorCELByRule;
+exports.defaultValueProcessorMongoDBByRule = defaultValueProcessorMongoDBByRule;
+exports.defaultValueProcessorNL = defaultValueProcessorNL;
+exports.defaultValueProcessorSpELByRule = defaultValueProcessorSpELByRule;
+exports.filterFieldsByComparator = filterFieldsByComparator;
+exports.findID = findID;
+exports.findPath = findPath;
+exports.formatQuery = formatQuery;
+exports.formatQueryOptionPresets = formatQueryOptionPresets;
+exports.generateAccessibleDescription = generateAccessibleDescription;
+Object.defineProperty(exports, 'generateID', {
+  enumerable: true,
+  get: function () {
+    return generateID;
+  }
+});
+exports.getCommonAncestorPath = getCommonAncestorPath;
+exports.getFirstOption = getFirstOption;
+exports.getMatchModesUtil = getMatchModesUtil;
+exports.getNLTranslataion = getNLTranslataion;
+exports.getOption = getOption;
+exports.getParentPath = getParentPath;
+exports.getParseNumberMethod = getParseNumberMethod;
+exports.getPathOfID = getPathOfID;
+exports.getQuoteFieldNamesWithArray = getQuoteFieldNamesWithArray;
+exports.getQuotedFieldName = getQuotedFieldName;
+exports.getValidationClassNames = getValidationClassNames;
+exports.getValueSourcesUtil = getValueSourcesUtil;
+exports.group = group;
+exports.groupInvalidReasons = groupInvalidReasons;
+exports.insert = insert;
+exports.isAncestor = isAncestor;
+exports.isFlexibleOptionArray = isFlexibleOptionArray;
+exports.isFlexibleOptionGroupArray = isFlexibleOptionGroupArray;
+exports.isFullOptionArray = isFullOptionArray;
+exports.isFullOptionGroupArray = isFullOptionGroupArray;
+exports.isOptionGroupArray = isOptionGroupArray;
+exports.isPojo = isPojo;
+exports.isRuleGroup = isRuleGroup;
+exports.isRuleGroupType = isRuleGroupType;
+exports.isRuleGroupTypeIC = isRuleGroupTypeIC;
+exports.isRuleOrGroupValid = isRuleOrGroupValid;
+exports.isValidValue = isValidValue;
+exports.isValidationResult = isValidationResult;
+exports.isValueProcessorLegacy = isValueProcessorLegacy;
+exports.joinWith = joinWith;
+exports.jsonLogicAdditionalOperators = jsonLogicAdditionalOperators;
+exports.lc = lc;
+exports.mapSQLOperator = mapSQLOperator;
+exports.mergeClassnames = mergeClassnames;
+exports.mongoDbFallback = mongoDbFallback;
+exports.mongoOperators = mongoOperators;
+exports.move = move;
+exports.normalizeConstituentWordOrder = normalizeConstituentWordOrder;
+exports.nullFreeArray = nullFreeArray;
+exports.nullOrUndefinedOrEmpty = nullOrUndefinedOrEmpty;
+exports.numericRegex = numericRegex;
+exports.numerifyValues = numerifyValues;
+exports.objectEntries = objectEntries;
+exports.objectKeys = objectKeys;
+exports.parseNumber = parseNumber;
+exports.pathIsDisabled = pathIsDisabled;
+exports.pathsAreEqual = pathsAreEqual;
+exports.prepareRule = prepareRule;
+exports.prepareRuleGroup = prepareRuleGroup;
+exports.prepareRuleOrGroup = prepareRuleOrGroup;
+exports.prismaFallback = prismaFallback;
+exports.prismaOperators = prismaOperators;
+exports.processMatchMode = processMatchMode;
+exports.regenerateID = regenerateID;
+exports.regenerateIDs = regenerateIDs;
+exports.remove = remove;
+exports.rootPath = rootPath;
+exports.shouldRenderAsNumber = shouldRenderAsNumber;
+exports.splitBy = splitBy;
+exports.sqlDialectPresets = sqlDialectPresets;
+exports.standardClassnames = standardClassnames;
+exports.toArray = toArray;
+exports.toFlatOptionArray = toFlatOptionArray;
+exports.toFullOption = toFullOption;
+exports.toFullOptionList = toFullOptionList;
+exports.toFullOptionMap = toFullOptionMap;
+exports.transformQuery = transformQuery;
+exports.trimIfString = trimIfString;
+exports.uniqByIdentifier = uniqByIdentifier;
+exports.uniqByName = uniqByName;
+exports.uniqOptGroups = uniqOptGroups;
+exports.uniqOptList = uniqOptList;
+exports.update = update;
+//# sourceMappingURL=react-querybuilder_core.cjs.development.js.map