@react-querybuilder/core 8.9.1 → 8.10.0

package/dist/formatQuery.mjs

@@ -0,0 +1,2496 @@
+import { defaultPlaceholderFieldName, defaultPlaceholderOperatorName, getOption, toFlatOptionArray, toFullOptionList } from "./optGroupUtils-DrubUpx0.mjs";
+import { joinWith, splitBy, toArray, trimIfString } from "./arrayUtils-C9sO4qLO.mjs";
+import { isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, lc, nullOrUndefinedOrEmpty, numericRegex } from "./isRuleGroup-CGe_rb2w.mjs";
+import { parseNumber } from "./parseNumber-B_-sR6d5.mjs";
+import { transformQuery } from "./transformQuery-DHvtgDgZ.mjs";
+import { convertFromIC } from "./convertQuery-BUgyz1GA.mjs";
+import { produce } from "immer";
+
+//#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 and the `muted`
+* property is not `true`.
+*/
+const isRuleOrGroupValid = (rg, validationResult, validator) => {
+	if (rg.muted) return false;
+	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 processedRules = [];
+		let precedingCombinator = "";
+		let firstRule = true;
+		for (const rule of rg.rules) {
+			if (typeof rule === "string") {
+				precedingCombinator = celCombinatorMap[rule];
+				continue;
+			}
+			if (isRuleGroup(rule)) {
+				const processedGroup = processRuleGroup(rule);
+				if (processedGroup) {
+					if (!firstRule && precedingCombinator) {
+						processedRules.push(precedingCombinator);
+						precedingCombinator = "";
+					}
+					firstRule = false;
+					processedRules.push(processedGroup);
+				}
+				continue;
+			}
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) continue;
+			const fieldData = getOption(fields, rule.field);
+			const processedRule = ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes: (rule.valueSource ?? "value") === "value",
+				fieldData
+			});
+			if (processedRule) {
+				if (!firstRule && precedingCombinator) {
+					processedRules.push(precedingCombinator);
+					precedingCombinator = "";
+				}
+				firstRule = false;
+				processedRules.push(processedRule);
+			}
+		}
+		const expression = processedRules.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 nestedArrayFilter = defaultRuleGroupProcessorCEL(transformQuery(rule.value, { ruleProcessor: (r) => ({
+			...r,
+			field: `${arrayElementAlias}${r.field ? `.${r.field}` : ""}`
+		}) }), 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) ? ["!(", ")"] : ["", ""];
+			return `${prefix}${field} in [${toArray(value).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 processedRules = [];
+		let precedingCombinator = "";
+		let firstRule = true;
+		for (const rule of rg.rules) {
+			if (typeof rule === "string") {
+				precedingCombinator = rule;
+				continue;
+			}
+			if (isRuleGroup(rule)) {
+				const processedGroup = processRuleGroup(rule);
+				if (processedGroup) {
+					if (!firstRule && precedingCombinator) {
+						processedRules.push(precedingCombinator);
+						precedingCombinator = "";
+					}
+					firstRule = false;
+					processedRules.push(processedGroup);
+				}
+				continue;
+			}
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) continue;
+			const fieldData = getOption(fields, rule.field);
+			const processedRule = ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes: (rule.valueSource ?? "value") === "value",
+				fieldData
+			});
+			if (processedRule) {
+				if (!firstRule && precedingCombinator) {
+					processedRules.push(precedingCombinator);
+					precedingCombinator = "";
+				}
+				firstRule = false;
+				processedRules.push(processedRule);
+			}
+		}
+		const expression = processedRules.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": return wrapInNegation(`${field} matches ${valueIsField ? `'^'.concat(${trimIfString(value)})` : `'${typeof value === "string" && !value.startsWith("^") || useBareValue ? "^" : ""}${escapeSingleQuotes(value, escapeQuotes)}'`}`, shouldNegate$1(operatorTL));
+		case "endswith":
+		case "doesnotendwith": return wrapInNegation(`${field} matches ${valueIsField ? `${trimIfString(value)}.concat('$')` : `'${escapeSingleQuotes(value, escapeQuotes)}${typeof value === "string" && !value.endsWith("$") || useBareValue ? "$" : ""}'`}`, 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 nestedArrayFilter = defaultRuleGroupProcessorDrizzle(transformQuery(rule.value, { ruleProcessor: (r) => ({
+			...r,
+			field: arrayElementAlias
+		}) }), {
+			...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 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(convertFromIC(ruleGroup), 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 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(convertFromIC(ruleGroup));
+	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 processedRules = [];
+		let precedingCombinator = "";
+		let firstRule = true;
+		for (const rule of rg.rules) {
+			if (typeof rule === "string") {
+				precedingCombinator = rule;
+				continue;
+			}
+			if (isRuleGroup(rule)) {
+				const processedGroup = processRuleGroup(rule);
+				if (processedGroup) {
+					if (!firstRule && precedingCombinator) {
+						processedRules.push(precedingCombinator);
+						precedingCombinator = "";
+					}
+					firstRule = false;
+					processedRules.push(processedGroup);
+				}
+				continue;
+			}
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) continue;
+			const fieldData = getOption(fields, rule.field);
+			const processedRule = ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes: (rule.valueSource ?? "value") === "value",
+				fieldData
+			});
+			if (processedRule) {
+				if (!firstRule && precedingCombinator) {
+					processedRules.push(precedingCombinator);
+					precedingCombinator = "";
+				}
+				firstRule = false;
+				processedRules.push(processedRule);
+			}
+		}
+		const expression = processedRules.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 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(convertFromIC(ruleGroup), 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 = [];
+		let precedingCombinator = "";
+		let firstRule = true;
+		for (const rule of rg2.rules) {
+			if (typeof rule === "string") {
+				precedingCombinator = `, ${translations[rule] ?? rule} `;
+				continue;
+			}
+			if (isRuleGroup(rule)) {
+				const processedGroup = processRuleGroup(rule, rg2.rules.length === 1 && !(rg2.not || /^xor$/i.test(rg2.combinator ?? "")));
+				// istanbul ignore else
+				if (processedGroup) {
+					if (!firstRule && precedingCombinator) {
+						processedRules.push(precedingCombinator);
+						precedingCombinator = "";
+					}
+					firstRule = false;
+					processedRules.push(processedGroup);
+				}
+				continue;
+			}
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) continue;
+			const escapeQuotes = (rule.valueSource ?? "value") === "value";
+			const fieldData = getOption(fields, rule.field);
+			const processedRule = ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes,
+				fieldData
+			});
+			if (processedRule) {
+				if (!firstRule && precedingCombinator) {
+					processedRules.push(precedingCombinator);
+					precedingCombinator = "";
+				}
+				firstRule = false;
+				processedRules.push(processedRule);
+			}
+		}
+		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.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 = [];
+		let precedingCombinator = "";
+		let firstRule = true;
+		for (const rule of rg.rules) {
+			if (typeof rule === "string") {
+				precedingCombinator = rule;
+				continue;
+			}
+			if (isRuleGroup(rule)) {
+				const processedGroup = processRuleGroup(rule, rg.rules.length === 1);
+				// istanbul ignore else
+				if (processedGroup) {
+					if (!firstRule && precedingCombinator) {
+						processedRules.push(precedingCombinator);
+						precedingCombinator = "";
+					}
+					firstRule = false;
+					processedRules.push(processedGroup);
+				}
+				continue;
+			}
+			const processedRule = processRule(rule);
+			if (processedRule) {
+				if (!firstRule && precedingCombinator) {
+					processedRules.push(precedingCombinator);
+					precedingCombinator = "";
+				}
+				firstRule = false;
+				processedRules.push(processedRule);
+			}
+		}
+		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 = [];
+		let precedingCombinator = "";
+		let firstRule = true;
+		for (const rule of rg.rules) {
+			if (typeof rule === "string") {
+				precedingCombinator = rule;
+				continue;
+			}
+			if (isRuleGroup(rule)) {
+				const processedGroup = processRuleGroup(rule, rg.rules.length === 1);
+				// istanbul ignore else
+				if (processedGroup) {
+					if (!firstRule && precedingCombinator) {
+						processedRules.push(precedingCombinator);
+						precedingCombinator = "";
+					}
+					firstRule = false;
+					processedRules.push(processedGroup);
+				}
+				continue;
+			}
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) continue;
+			const escapeQuotes = (rule.valueSource ?? "value") === "value";
+			const fieldData = getOption(fields, rule.field);
+			const processedRule = ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes,
+				fieldData
+			});
+			if (processedRule) {
+				if (!firstRule && precedingCombinator) {
+					processedRules.push(precedingCombinator);
+					precedingCombinator = "";
+				}
+				firstRule = false;
+				processedRules.push(processedRule);
+			}
+		}
+		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": return negateIfNotOp(operatorLC, { in: [fieldObject, toArray(value).map((v) => fieldOrNumberRenderer(v))] });
+		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": return negateIfNotOp(operatorLC, { in: [fieldOrNumberRenderer(value), fieldObject] });
+		case "beginswith":
+		case "doesnotbeginwith": return negateIfNotOp(operatorLC, { startsWith: [fieldObject, fieldOrNumberRenderer(value)] });
+		case "endswith":
+		case "doesnotendwith": return negateIfNotOp(operatorLC, { endsWith: [fieldObject, fieldOrNumberRenderer(value)] });
+	}
+	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": return negateIf(`(|${toArray(value).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 wordOrderMap = {
+		S: processedField,
+		V: operatorProcessor(rule, opts),
+		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 ? 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
+export { bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, defaultCELValueProcessor, defaultExportOperatorMap, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleProcessorCEL, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultSpELValueProcessor, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, formatQuery, formatQueryOptionPresets, getNLTranslataion, getQuoteFieldNamesWithArray, getQuotedFieldName, isValidValue, isValueProcessorLegacy, jsonLogicAdditionalOperators, mapSQLOperator, mongoDbFallback, mongoOperators, normalizeConstituentWordOrder, numerifyValues, prismaFallback, prismaOperators, processMatchMode, shouldRenderAsNumber, sqlDialectPresets };
+//# sourceMappingURL=formatQuery.mjs.map