@react-querybuilder/core 8.9.1 → 8.10.0

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

@@ -90,6 +90,108 @@ const defaultPlaceholderValueLabel = defaultPlaceholderLabel;
 */
 const defaultPlaceholderValueGroupLabel = defaultPlaceholderLabel;
 /**
+* Default configuration of translatable strings.
+*
+* @group Defaults
+*/
+const defaultTranslations = {
+	fields: {
+		title: "Field",
+		placeholderName: defaultPlaceholderFieldName,
+		placeholderLabel: defaultPlaceholderFieldLabel,
+		placeholderGroupLabel: defaultPlaceholderFieldGroupLabel
+	},
+	operators: {
+		title: "Operator",
+		placeholderName: defaultPlaceholderOperatorName,
+		placeholderLabel: defaultPlaceholderOperatorLabel,
+		placeholderGroupLabel: defaultPlaceholderOperatorGroupLabel
+	},
+	values: {
+		title: "Values",
+		placeholderName: defaultPlaceholderValueName,
+		placeholderLabel: defaultPlaceholderValueLabel,
+		placeholderGroupLabel: defaultPlaceholderValueGroupLabel
+	},
+	matchMode: { title: "Match mode" },
+	matchThreshold: { title: "Match threshold" },
+	value: { title: "Value" },
+	removeRule: {
+		label: "⨯",
+		title: "Remove rule"
+	},
+	removeGroup: {
+		label: "⨯",
+		title: "Remove group"
+	},
+	addRule: {
+		label: "+ Rule",
+		title: "Add rule"
+	},
+	addGroup: {
+		label: "+ Group",
+		title: "Add group"
+	},
+	combinators: { title: "Combinator" },
+	notToggle: {
+		label: "Not",
+		title: "Invert this group"
+	},
+	cloneRule: {
+		label: "⧉",
+		title: "Clone rule"
+	},
+	cloneRuleGroup: {
+		label: "⧉",
+		title: "Clone group"
+	},
+	shiftActionUp: {
+		label: "˄",
+		title: "Shift up"
+	},
+	shiftActionDown: {
+		label: "˅",
+		title: "Shift down"
+	},
+	dragHandle: {
+		label: "⁞⁞",
+		title: "Drag handle"
+	},
+	lockRule: {
+		label: "🔓",
+		title: "Lock rule"
+	},
+	lockGroup: {
+		label: "🔓",
+		title: "Lock group"
+	},
+	lockRuleDisabled: {
+		label: "🔒",
+		title: "Unlock rule"
+	},
+	lockGroupDisabled: {
+		label: "🔒",
+		title: "Unlock group"
+	},
+	muteRule: {
+		label: "🔊",
+		title: "Mute rule"
+	},
+	muteGroup: {
+		label: "🔊",
+		title: "Mute group"
+	},
+	unmuteRule: {
+		label: "🔇",
+		title: "Unmute rule"
+	},
+	unmuteGroup: {
+		label: "🔇",
+		title: "Unmute group"
+	},
+	valueSourceSelector: { title: "Value source" }
+};
+/**
 * Default character used to `.join` and `.split` arrays.
 *
 * @group Defaults
@@ -338,8 +440,11 @@ const standardClassnames = {
 	dndDropNotAllowed: "dndDropNotAllowed",
 	dragHandle: "queryBuilder-dragHandle",
 	disabled: "queryBuilder-disabled",
+	muted: "queryBuilder-muted",
 	lockRule: "rule-lock",
 	lockGroup: "ruleGroup-lock",
+	muteRule: "rule-mute",
+	muteGroup: "ruleGroup-mute",
 	valueSource: "rule-valueSource",
 	valueListItem: "rule-value-list-item",
 	branches: "queryBuilder-branches",
@@ -374,6 +479,9 @@ const defaultControlClassnames = {
 	dragHandle: "",
 	lockRule: "",
 	lockGroup: "",
+	muteRule: "",
+	muteGroup: "",
+	muted: "",
 	valueSource: "",
 	actionElement: "",
 	valueSelector: "",
@@ -424,6 +532,8 @@ const TestID = {
 	dragHandle: "drag-handle",
 	lockRule: "lock-rule",
 	lockGroup: "lock-group",
+	muteRule: "mute-rule",
+	muteGroup: "mute-group",
 	valueSourceSelector: "value-source-selector",
 	matchModeEditor: "match-mode-editor"
 };
@@ -523,6 +633,11 @@ function toVal(mix) {
 	}
 	return str;
 }
+/**
+* Vendored/adapted version of the `clsx` package.
+*
+* **NOTE:** Prefer the official package from npm outside the context of React Query Builder.
+*/
 // istanbul ignore next
 function clsx(...args) {
 	let i = 0;
@@ -561,6 +676,10 @@ const nullOrUndefinedOrEmpty = (value) => value === null || value === void 0 ||
 //#endregion
 //#region src/utils/isRuleGroup.ts
 /**
+* Determines if an object is a {@link RuleType} (only checks for a `field` property).
+*/
+const isRuleType = (s) => isPojo(s) && "field" in s && typeof s.field === "string";
+/**
 * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.
 */
 const isRuleGroup = (rg) => isPojo(rg) && Array.isArray(rg.rules);
@@ -683,6 +802,21 @@ const defaultValidator = (query) => {
 	return result;
 };
 
+//#endregion
+//#region src/utils/objectUtils.ts
+/**
+* A strongly-typed version of `Object.keys()`.
+*
+* [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts)
+*/
+const objectKeys = Object.keys;
+/**
+* A strongly-typed version of `Object.entries()`.
+*
+* [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-entries.ts)
+*/
+const objectEntries = Object.entries;
+
 //#endregion
 //#region src/utils/optGroupUtils.ts
 const isOptionWithName = (opt) => isPojo(opt) && "name" in opt && typeof opt.name === "string";
@@ -859,6 +993,42 @@ const uniqOptList = (originalArray) => {
 	if (isFlexibleOptionGroupArray(originalArray)) return uniqOptGroups(originalArray);
 	return uniqByIdentifier(originalArray.map((o) => toFullOption(o)));
 };
+const prepareOptionList = (props) => {
+	// istanbul ignore next
+	const { optionList: optionListPropOriginal, baseOption = {}, labelMap = {}, placeholder: { placeholderName = defaultPlaceholderName, placeholderLabel = defaultPlaceholderLabel, placeholderGroupLabel = defaultPlaceholderLabel } = {}, autoSelectOption = true } = props;
+	const defaultOption = {
+		id: placeholderName,
+		name: placeholderName,
+		value: placeholderName,
+		label: placeholderLabel
+	};
+	const optionsProp = optionListPropOriginal ?? [defaultOption];
+	let optionList = [];
+	const opts = Array.isArray(optionsProp) ? toFullOptionList(optionsProp, baseOption, labelMap) : objectKeys(toFullOptionMap(optionsProp, baseOption)).map((opt) => ({
+		...optionsProp[opt],
+		name: opt,
+		value: opt
+	})).sort((a, b) => a.label.localeCompare(b.label));
+	if (isFlexibleOptionGroupArray(opts)) optionList = autoSelectOption ? uniqOptGroups(opts) : uniqOptGroups([{
+		label: placeholderGroupLabel,
+		options: [defaultOption]
+	}, ...opts]);
+	else optionList = autoSelectOption ? uniqByIdentifier(opts) : uniqByIdentifier([defaultOption, ...opts]);
+	let optionsMap = {};
+	if (!Array.isArray(optionsProp)) {
+		const op = toFullOptionMap(optionsProp, baseOption);
+		optionsMap = autoSelectOption ? op : {
+			...op,
+			[placeholderName]: defaultOption
+		};
+	} else if (isFlexibleOptionGroupArray(optionList)) for (const og of optionList) for (const opt of og.options) optionsMap[opt.value ?? opt.name] = toFullOption(opt, baseOption);
+	else for (const opt of optionList) optionsMap[opt.value ?? opt.name] = toFullOption(opt, baseOption);
+	return {
+		defaultOption,
+		optionList,
+		optionsMap
+	};
+};
 
 //#endregion
 //#region src/utils/filterFieldsByComparator.ts
@@ -960,9 +1130,11 @@ function transformQuery(query, options = {}) {
 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.
+* 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)) {
@@ -1236,19 +1408,45 @@ const defaultRuleGroupProcessorCEL = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermost) => {
 		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? fallbackExpression : "";
-		const expression = rg.rules.map((rule) => {
-			if (typeof rule === "string") return celCombinatorMap[rule];
-			if (isRuleGroup(rule)) return processRuleGroup(rule);
+		const 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) return "";
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) continue;
 			const fieldData = getOption(fields, rule.field);
-			return ruleProcessor(rule, {
+			const processedRule = ruleProcessor(rule, {
 				...options,
 				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
 				escapeQuotes: (rule.valueSource ?? "value") === "value",
 				fieldData
 			});
-		}).filter(Boolean).join(isRuleGroupType(rg) ? ` ${celCombinatorMap[rg.combinator]} ` : " ");
+			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;
 	};
@@ -1275,11 +1473,10 @@ const defaultRuleProcessorCEL = (rule, opts = {}) => {
 	else if (matchEval) {
 		const { mode, threshold } = matchEval;
 		const arrayElementAlias = "elem_alias";
-		const celQuery = transformQuery(rule.value, { ruleProcessor: (r) => ({
+		const nestedArrayFilter = defaultRuleGroupProcessorCEL(transformQuery(rule.value, { ruleProcessor: (r) => ({
 			...r,
 			field: `${arrayElementAlias}${r.field ? `.${r.field}` : ""}`
-		}) });
-		const nestedArrayFilter = defaultRuleGroupProcessorCEL(celQuery, opts);
+		}) }), opts);
 		switch (mode) {
 			case "all": return `${field}.all(${arrayElementAlias}, ${nestedArrayFilter})`;
 			case "none":
@@ -1313,8 +1510,7 @@ const defaultRuleProcessorCEL = (rule, opts = {}) => {
 		case "in":
 		case "notin": {
 			const [prefix, suffix] = shouldNegate$2(operatorTL) ? ["!(", ")"] : ["", ""];
-			const valueAsArray = toArray(value);
-			return `${prefix}${field} in [${valueAsArray.map((val) => valueIsField || shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : `"${escapeDoubleQuotes(val, escapeQuotes)}"`).join(", ")}]${suffix}`;
+			return `${prefix}${field} in [${toArray(value).map((val) => valueIsField || shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : `"${escapeDoubleQuotes(val, escapeQuotes)}"`).join(", ")}]${suffix}`;
 		}
 		case "between":
 		case "notbetween": {
@@ -1534,19 +1730,45 @@ const defaultRuleGroupProcessorSpEL = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermost) => {
 		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? fallbackExpression : "";
-		const expression = rg.rules.map((rule) => {
-			if (typeof rule === "string") return rule;
-			if (isRuleGroup(rule)) return processRuleGroup(rule);
+		const 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) return "";
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) continue;
 			const fieldData = getOption(fields, rule.field);
-			return ruleProcessor(rule, {
+			const processedRule = ruleProcessor(rule, {
 				...options,
 				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
 				escapeQuotes: (rule.valueSource ?? "value") === "value",
 				fieldData
 			});
-		}).filter(Boolean).join(isRuleGroupType(rg) ? ` ${rg.combinator} ` : " ");
+			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;
 	};
@@ -1602,15 +1824,9 @@ const defaultRuleProcessorSpEL = (rule, opts = {}) => {
 		case "contains":
 		case "doesnotcontain": return wrapInNegation(`${field} matches ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes(value, escapeQuotes)}'`}`, shouldNegate$1(operatorTL));
 		case "beginswith":
-		case "doesnotbeginwith": {
-			const valueTL = valueIsField ? `'^'.concat(${trimIfString(value)})` : `'${typeof value === "string" && !value.startsWith("^") || useBareValue ? "^" : ""}${escapeSingleQuotes(value, escapeQuotes)}'`;
-			return wrapInNegation(`${field} matches ${valueTL}`, shouldNegate$1(operatorTL));
-		}
+		case "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": {
-			const valueTL = valueIsField ? `${trimIfString(value)}.concat('$')` : `'${escapeSingleQuotes(value, escapeQuotes)}${typeof value === "string" && !value.endsWith("$") || useBareValue ? "$" : ""}'`;
-			return wrapInNegation(`${field} matches ${valueTL}`, shouldNegate$1(operatorTL));
-		}
+		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":
@@ -1723,11 +1939,10 @@ const defaultRuleProcessorDrizzle = (rule, _options) => {
 		if (opts.preset !== "postgresql") return;
 		const { mode, threshold } = matchEval;
 		const arrayElementAlias = "elem_alias";
-		const sqlQuery = transformQuery(rule.value, { ruleProcessor: (r) => ({
+		const nestedArrayFilter = defaultRuleGroupProcessorDrizzle(transformQuery(rule.value, { ruleProcessor: (r) => ({
 			...r,
 			field: arrayElementAlias
-		}) });
-		const nestedArrayFilter = defaultRuleGroupProcessorDrizzle(sqlQuery, {
+		}) }), {
 			...opts,
 			context: {
 				...opts.context,
@@ -1813,7 +2028,6 @@ const defaultRuleGroupProcessorDrizzle = (ruleGroup, options, _meta) => (columns
 	const { fields, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, validateRule, validationMap } = options;
 	if (!columns || !drizzleOperators) return;
 	const { and, not, or } = drizzleOperators;
-	const query = isRuleGroupType(ruleGroup) ? ruleGroup : convertFromIC(ruleGroup);
 	const ruleProcessor = defaultRuleProcessorDrizzle;
 	const processRuleGroup = (rg, _outermost) => {
 		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return;
@@ -1837,7 +2051,7 @@ const defaultRuleGroupProcessorDrizzle = (ruleGroup, options, _meta) => (columns
 		const ruleGroupSQL = rg.combinator === "or" ? or(...processedRules) : and(...processedRules);
 		return rg.not ? not(ruleGroupSQL) : ruleGroupSQL;
 	};
-	return processRuleGroup(query, true);
+	return processRuleGroup(convertFromIC(ruleGroup), true);
 };
 
 //#endregion
@@ -1849,7 +2063,6 @@ const defaultRuleGroupProcessorDrizzle = (ruleGroup, options, _meta) => (columns
 */
 const defaultRuleGroupProcessorElasticSearch = (ruleGroup, options) => {
 	const { fields, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
-	const query = convertFromIC(ruleGroup);
 	const processRuleGroup = (rg) => {
 		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return false;
 		const processedRules = rg.rules.map((rule) => {
@@ -1866,7 +2079,7 @@ const defaultRuleGroupProcessorElasticSearch = (ruleGroup, options) => {
 		if (processedRules.length === 0) return false;
 		return { bool: rg.not ? { must_not: /^or$/i.test(rg.combinator) ? { bool: { should: processedRules } } : processedRules } : { [/^or$/i.test(rg.combinator) ? "should" : "must"]: processedRules } };
 	};
-	const processedRuleGroup = processRuleGroup(query);
+	const processedRuleGroup = processRuleGroup(convertFromIC(ruleGroup));
 	return processedRuleGroup === false ? {} : processedRuleGroup;
 };
 
@@ -1881,19 +2094,45 @@ const defaultRuleGroupProcessorJSONata = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermost) => {
 		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? fallbackExpression : "";
-		const expression = rg.rules.map((rule) => {
-			if (typeof rule === "string") return rule;
-			if (isRuleGroup(rule)) return processRuleGroup(rule);
+		const 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) return "";
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) continue;
 			const fieldData = getOption(fields, rule.field);
-			return ruleProcessor(rule, {
+			const processedRule = ruleProcessor(rule, {
 				...options,
 				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
 				escapeQuotes: (rule.valueSource ?? "value") === "value",
 				fieldData
 			});
-		}).filter(Boolean).join(isRuleGroupType(rg) ? ` ${rg.combinator} ` : " ");
+			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;
 	};
@@ -1939,7 +2178,6 @@ const defaultRuleGroupProcessorJsonLogic = (ruleGroup, options) => {
 */
 const defaultRuleGroupProcessorLDAP = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
-	const query = convertFromIC(ruleGroup);
 	const processRuleGroup = (rg, outermost) => {
 		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? fallbackExpression : "";
 		const rules = rg.rules.map((rule) => {
@@ -1959,7 +2197,7 @@ const defaultRuleGroupProcessorLDAP = (ruleGroup, options) => {
 		const [prefix, suffix] = rules.length > 1 ? [`${notPrefix}(${rg.combinator === "or" ? "|" : "&"}`, `)${notSuffix}`] : [notPrefix, notSuffix];
 		return expression ? `${prefix}${expression}${suffix}` : fallbackExpression;
 	};
-	return processRuleGroup(query, true);
+	return processRuleGroup(convertFromIC(ruleGroup), true);
 };
 
 //#endregion
@@ -2014,20 +2252,46 @@ const defaultRuleGroupProcessorNL = (ruleGroup, options) => {
 	const processRuleGroup = (rg, outermostOrLonelyInGroup) => {
 		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
 		const rg2 = isRuleGroupTypeIC(rg) && rg.rules.some((r) => typeof r === "string" && lc(r) === "xor") ? convertFromIC(rg) : rg;
-		const processedRules = rg2.rules.map((rule) => {
-			if (typeof rule === "string") return `, ${translations[rule] ?? rule} `;
-			if (isRuleGroup(rule)) return processRuleGroup(rule, rg2.rules.length === 1 && !(rg2.not || /^xor$/i.test(rg2.combinator ?? "")));
+		const 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) return "";
+			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);
-			return ruleProcessor(rule, {
+			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;
@@ -2035,7 +2299,7 @@ const defaultRuleGroupProcessorNL = (ruleGroup, options) => {
 		const [prefixTL, suffixTL] = ["groupPrefix", "groupSuffix"].map((key) => rg2.not ? isXOR ? getNLTranslataion(key, translations, ["not", "xor"]) : getNLTranslataion(key, translations, ["not"]) : isXOR ? getNLTranslataion(key, translations, ["xor"]) : getNLTranslataion(key, translations));
 		const prefix = mustWrap ? `${prefixTL} (`.trim() : "";
 		const suffix = mustWrap ? `) ${suffixTL}`.trim() : "";
-		return `${prefix}${processedRules.filter(Boolean).join(isRuleGroupType(rg2) ? `, ${translations[combinator] ?? combinator} ` : "")}${suffix}`;
+		return `${prefix}${processedRules.join(isRuleGroupType(rg2) ? `, ${translations[combinator] ?? combinator} ` : "")}${suffix}`;
 	};
 	return processRuleGroup(ruleGroup, true);
 };
@@ -2085,11 +2349,37 @@ const defaultRuleGroupProcessorParameterized = (ruleGroup, options) => {
 	};
 	const processRuleGroup = (rg, outermostOrLonelyInGroup) => {
 		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
-		const processedRules = rg.rules.map((rule) => {
-			if (typeof rule === "string") return rule;
-			if (isRuleGroup(rule)) return processRuleGroup(rule, rg.rules.length === 1);
-			return processRule(rule);
-		}).filter(Boolean);
+		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} ` : " ")})`;
 	};
@@ -2198,20 +2488,46 @@ const defaultRuleGroupProcessorSQL = (ruleGroup, options) => {
 	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
 	const processRuleGroup = (rg, outermostOrLonelyInGroup) => {
 		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermostOrLonelyInGroup ? fallbackExpression : "";
-		const processedRules = rg.rules.map((rule) => {
-			if (typeof rule === "string") return rule;
-			if (isRuleGroup(rule)) return processRuleGroup(rule, rg.rules.length === 1);
+		const 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) return "";
+			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);
-			return ruleProcessor(rule, {
+			const processedRule = ruleProcessor(rule, {
 				...options,
 				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
 				escapeQuotes,
 				fieldData
 			});
-		}).filter(Boolean);
+			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} ` : " ")})`;
 	};
@@ -2489,10 +2805,7 @@ const defaultRuleProcessorJsonLogic = (rule, options = {}) => {
 		case "null":
 		case "notnull": return { [`${operatorLC === "notnull" ? "!" : "="}=`]: [fieldObject, null] };
 		case "in":
-		case "notin": {
-			const valueAsArray = toArray(value).map((v) => fieldOrNumberRenderer(v));
-			return negateIfNotOp(operatorLC, { in: [fieldObject, valueAsArray] });
-		}
+		case "notin": return negateIfNotOp(operatorLC, { in: [fieldObject, toArray(value).map((v) => fieldOrNumberRenderer(v))] });
 		case "between":
 		case "notbetween": {
 			const valueAsArray = toArray(value);
@@ -2523,20 +2836,11 @@ const defaultRuleProcessorJsonLogic = (rule, options = {}) => {
 			return false;
 		}
 		case "contains":
-		case "doesnotcontain": {
-			const jsonRule = { in: [fieldOrNumberRenderer(value), fieldObject] };
-			return negateIfNotOp(operatorLC, jsonRule);
-		}
+		case "doesnotcontain": return negateIfNotOp(operatorLC, { in: [fieldOrNumberRenderer(value), fieldObject] });
 		case "beginswith":
-		case "doesnotbeginwith": {
-			const jsonRule = { startsWith: [fieldObject, fieldOrNumberRenderer(value)] };
-			return negateIfNotOp(operatorLC, jsonRule);
-		}
+		case "doesnotbeginwith": return negateIfNotOp(operatorLC, { startsWith: [fieldObject, fieldOrNumberRenderer(value)] });
 		case "endswith":
-		case "doesnotendwith": {
-			const jsonRule = { endsWith: [fieldObject, fieldOrNumberRenderer(value)] };
-			return negateIfNotOp(operatorLC, jsonRule);
-		}
+		case "doesnotendwith": return negateIfNotOp(operatorLC, { endsWith: [fieldObject, fieldOrNumberRenderer(value)] });
 	}
 	return false;
 };
@@ -2571,10 +2875,7 @@ const defaultRuleProcessorLDAP = (rule, options = {}) => {
 		case "null":
 		case "notnull": return negateIf(`(${field}=*)`, operatorLC === "notnull");
 		case "in":
-		case "notin": {
-			const valueAsArray = toArray(value);
-			return negateIf(`(|${valueAsArray.map((val) => `(${field}=${ldapEscape(val)})`).join("")})`, operatorLC === "notin");
-		}
+		case "notin": return negateIf(`(|${toArray(value).map((val) => `(${field}=${ldapEscape(val)})`).join("")})`, operatorLC === "notin");
 		case "between":
 		case "notbetween": {
 			const valueAsArray = toArray(value);
@@ -2742,10 +3043,9 @@ const defaultRuleProcessorNL = (rule, opts) => {
 	});
 	const operatorLC = lc(operator);
 	if ((operatorLC === "in" || operatorLC === "notin" || operatorLC === "between" || operatorLC === "notbetween") && !value) return "";
-	const processedOperator = operatorProcessor(rule, opts);
 	const wordOrderMap = {
 		S: processedField,
-		V: processedOperator,
+		V: operatorProcessor(rule, opts),
 		O: value
 	};
 	return normalizeConstituentWordOrder(wordOrder).map((term) => `${wordOrderMap[term]}`).join(" ").trim();
@@ -3322,7 +3622,7 @@ const findPath = (path, query) => {
 		target = typeof t === "string" ? null : t;
 		level++;
 	}
-	return target;
+	return level < path.length ? null : target;
 };
 /**
 * Returns the {@link RuleType} or {@link RuleGroupType}/{@link RuleGroupTypeIC}
@@ -3511,6 +3811,26 @@ const getValueSourcesUtil = (fieldData, operator, getValueSources) => {
 	});
 };
 
+//#endregion
+//#region src/utils/mergeAnyTranslations.ts
+/**
+* Merges any number of partial translations into a single definition.
+*/
+const mergeAnyTranslations = (base, ...otherTranslations) => (0, immer.produce)(base, (draft) => {
+	for (const translations of otherTranslations)
+ // istanbul ignore else
+	if (translations) for (const t of objectKeys(translations)) if (draft[t]) Object.assign(draft[t], translations[t]);
+	else Object.assign(draft, { [t]: translations[t] });
+});
+const mergeAnyTranslation = (el, keyPropContextMap, defaults) => {
+	const finalKeys = objectEntries(keyPropContextMap).map(([key, [pT, cT]]) => [key, pT ?? cT ?? defaults?.[el]?.[key]]).filter((k) => !!k[1]);
+	if (finalKeys.length > 0 || defaults) {
+		const defaultProperties = defaults?.[el] ?? {};
+		const finalObject = Object.assign({}, defaultProperties, Object.fromEntries(finalKeys));
+		return { [el]: finalObject };
+	}
+};
+
 //#endregion
 //#region src/utils/mergeClassnames.ts
 const joinClassnamesByName = (name, args) => clsx(args.map((c) => clsx(c?.[name])));
@@ -3538,6 +3858,9 @@ const mergeClassnames = (...args) => ({
 	dragHandle: joinClassnamesByName("dragHandle", args),
 	lockRule: joinClassnamesByName("lockRule", args),
 	lockGroup: joinClassnamesByName("lockGroup", args),
+	muteRule: joinClassnamesByName("muteRule", args),
+	muteGroup: joinClassnamesByName("muteGroup", args),
+	muted: joinClassnamesByName("muted", args),
 	valueSource: joinClassnamesByName("valueSource", args),
 	actionElement: joinClassnamesByName("actionElement", args),
 	valueSelector: joinClassnamesByName("valueSelector", args),
@@ -3557,21 +3880,6 @@ const mergeClassnames = (...args) => ({
 	hasSubQuery: joinClassnamesByName("hasSubQuery", args)
 });
 
-//#endregion
-//#region src/utils/objectUtils.ts
-/**
-* A strongly-typed version of `Object.keys()`.
-*
-* [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts)
-*/
-const objectKeys = Object.keys;
-/**
-* A strongly-typed version of `Object.entries()`.
-*
-* [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-entries.ts)
-*/
-const objectEntries = Object.entries;
-
 //#endregion
 //#region src/utils/prepareQueryObjects.ts
 /**
@@ -3603,28 +3911,21 @@ const regenerateID = (rule, { idGenerator = generateID } = {}) => structuredClon
 	id: idGenerator()
 });
 /**
-* Recursively generates new `id` properties for a group and all its rules and subgroups.
+* Recursively generates new `id` properties for a rule group and all its rules and subgroups.
 */
-const regenerateIDs = (ruleOrGroup, { idGenerator = generateID } = {}) => {
-	if (!isPojo(ruleOrGroup)) return ruleOrGroup;
-	if (!isRuleGroup(ruleOrGroup)) return structuredClone({
-		...ruleOrGroup,
+const regenerateIDs = (subject, { idGenerator = generateID } = {}) => {
+	if (!isPojo(subject)) return subject;
+	if (!isRuleGroup(subject)) return structuredClone({
+		...subject,
 		id: idGenerator()
 	});
-	if (isRuleGroupType(ruleOrGroup)) {
-		const rules$1 = ruleOrGroup.rules.map((r) => isRuleGroup(r) ? regenerateIDs(r, { idGenerator }) : regenerateID(r, { idGenerator }));
-		return {
-			...ruleOrGroup,
-			id: idGenerator(),
-			rules: rules$1
-		};
-	}
-	const rules = ruleOrGroup.rules.map((r) => typeof r === "string" ? r : isRuleGroup(r) ? regenerateIDs(r, { idGenerator }) : regenerateID(r, { idGenerator }));
-	return {
-		...ruleOrGroup,
-		id: idGenerator(),
-		rules
+	const newGroup = {
+		...subject,
+		id: idGenerator()
 	};
+	// istanbul ignore else
+	if (Array.isArray(newGroup.rules)) newGroup.rules = subject.rules.map((r) => typeof r === "string" ? r : isRuleGroup(r) ? regenerateIDs(r, { idGenerator }) : regenerateID(r, { idGenerator }));
+	return newGroup;
 };
 
 //#endregion
@@ -3688,12 +3989,11 @@ const update = (query, prop, value, pathOrID, { resetOnFieldChange = true, reset
 		resetValueSource = true;
 		resetValue = true;
 	}
-	const valueSources = getValueSourcesUtil({
+	const defaultValueSource = getFirstOption(getValueSourcesUtil({
 		name: ruleOrGroup.field,
 		value: ruleOrGroup.field,
 		label: ""
-	}, ruleOrGroup.operator, getValueSources);
-	const defaultValueSource = getFirstOption(valueSources);
+	}, ruleOrGroup.operator, getValueSources));
 	if (resetValueSource && ruleOrGroup.valueSource && defaultValueSource !== ruleOrGroup.valueSource || prop === "valueSource" && value !== ruleOrGroup.valueSource) {
 		resetValue = !!ruleOrGroup.valueSource || !ruleOrGroup.valueSource && value !== defaultValueSource;
 		ruleOrGroup.valueSource = resetValueSource ? defaultValueSource : value;
@@ -3738,8 +4038,7 @@ const getNextPath = (query, currentPath, newPathOrShiftDirection) => {
 		return [...getParentPath(parentPath), parentPath.at(-1) + 1];
 	} else {
 		const evaluationPath = [...getParentPath(currentPath), currentPath.at(-1) + (ic ? 2 : 1)];
-		const entityToEvaluate = findPath(evaluationPath, query);
-		if (isRuleGroup(entityToEvaluate)) return [...evaluationPath, 0];
+		if (isRuleGroup(findPath(evaluationPath, query))) return [...evaluationPath, 0];
 		else return [...getParentPath(currentPath), currentPath.at(-1) + (ic ? 3 : 2)];
 	}
 	return currentPath;
@@ -3773,8 +4072,7 @@ const move = (query, oldPathOrID, newPath, { clone = false, combinators = defaul
 		const newNewPath = [...nextPath];
 		const commonAncestorPath = getCommonAncestorPath(oldPath, nextPath);
 		if (!clone && oldPath.length === commonAncestorPath.length + 1 && nextPath[commonAncestorPath.length] > oldPath[commonAncestorPath.length]) newNewPath[commonAncestorPath.length] -= independentCombinators ? 2 : 1;
-		const newNewParentPath = getParentPath(newNewPath);
-		const parentToInsertInto = findPath(newNewParentPath, draft);
+		const parentToInsertInto = findPath(getParentPath(newNewPath), draft);
 		const newIndex = newNewPath.at(-1);
 		/**
 		* This function 1) glosses over the need for type assertions to splice directly
@@ -3783,15 +4081,9 @@ const move = (query, oldPathOrID, newPath, { clone = false, combinators = defaul
 		const insertRuleOrGroup = (...args) => parentToInsertInto.rules.splice(newIndex, 0, ...args);
 		if (parentToInsertInto.rules.length === 0 || !independentCombinators) insertRuleOrGroup(ruleOrGroup);
 		else if (newIndex === 0) if (ruleToRemoveIndex === 0 && oldNextCombinator) insertRuleOrGroup(ruleOrGroup, oldNextCombinator);
-		else {
-			const newNextCombinator = parentToInsertInto.rules[1] ?? oldPrevCombinator ?? getFirstOption(combinators);
-			insertRuleOrGroup(ruleOrGroup, newNextCombinator);
-		}
+		else insertRuleOrGroup(ruleOrGroup, parentToInsertInto.rules[1] ?? oldPrevCombinator ?? getFirstOption(combinators));
 		else if (oldPrevCombinator) insertRuleOrGroup(oldPrevCombinator, ruleOrGroup);
-		else {
-			const newPrevCombinator = parentToInsertInto.rules[newIndex - 2] ?? oldNextCombinator ?? getFirstOption(combinators);
-			insertRuleOrGroup(newPrevCombinator, ruleOrGroup);
-		}
+		else insertRuleOrGroup(parentToInsertInto.rules[newIndex - 2] ?? oldNextCombinator ?? getFirstOption(combinators), ruleOrGroup);
 	});
 };
 /**
@@ -3814,17 +4106,11 @@ const insert = (query, ruleOrGroup, path, { combinators = defaultCombinators, co
 	if (parentToInsertInto.rules.length === 0 || !independentCombinators) insertRuleOrGroup(newIndex, rorg);
 	else if (replace && independentCombinators) insertRuleOrGroup(newIndex + newIndex % 2, rorg);
 	else if (newIndex === 0) if (rorg.path?.at(-1) === 0 && combinatorSucceeding) insertRuleOrGroup(newIndex, rorg, combinatorSucceeding);
-	else {
-		const newNextCombinator = parentToInsertInto.rules[1] ?? combinatorPreceding ?? getFirstOption(combinators);
-		insertRuleOrGroup(newIndex, rorg, newNextCombinator);
-	}
+	else insertRuleOrGroup(newIndex, rorg, parentToInsertInto.rules[1] ?? combinatorPreceding ?? getFirstOption(combinators));
 	else {
 		const normalizedNewIndex = newIndex % 2 === 0 ? newIndex - 1 : newIndex;
 		if (combinatorPreceding) insertRuleOrGroup(normalizedNewIndex, combinatorPreceding, rorg);
-		else {
-			const newPrevCombinator = parentToInsertInto.rules[normalizedNewIndex - 2] ?? combinatorSucceeding ?? getFirstOption(combinators);
-			insertRuleOrGroup(normalizedNewIndex, newPrevCombinator, rorg);
-		}
+		else insertRuleOrGroup(normalizedNewIndex, parentToInsertInto.rules[normalizedNewIndex - 2] ?? combinatorSucceeding ?? getFirstOption(combinators), rorg);
 	}
 });
 /**
@@ -3858,8 +4144,7 @@ const group = (query, sourcePathOrID, targetPathOrID, { clone = false, combinato
 		const newNewPath = [...nextPath];
 		const commonAncestorPath = getCommonAncestorPath(sourcePath, nextPath);
 		if (!clone && sourcePath.length === commonAncestorPath.length + 1 && nextPath[commonAncestorPath.length] > sourcePath[commonAncestorPath.length]) newNewPath[commonAncestorPath.length] -= independentCombinators ? 2 : 1;
-		const newNewParentPath = getParentPath(newNewPath);
-		const parentOfTargetPath = findPath(newNewParentPath, draft);
+		const parentOfTargetPath = findPath(getParentPath(newNewPath), draft);
 		const targetPathIndex = newNewPath.at(-1);
 		parentOfTargetPath.rules.splice(targetPathIndex, 1, prepareRuleOrGroup(independentCombinators ? { rules: [
 			targetRuleOrGroup,
@@ -3938,6 +4223,7 @@ exports.defaultRuleProcessorSQL = defaultRuleProcessorSQL;
 exports.defaultRuleProcessorSequelize = defaultRuleProcessorSequelize;
 exports.defaultRuleProcessorSpEL = defaultRuleProcessorSpEL;
 exports.defaultSpELValueProcessor = defaultSpELValueProcessor;
+exports.defaultTranslations = defaultTranslations;
 exports.defaultValidator = defaultValidator;
 exports.defaultValueProcessor = defaultValueProcessor;
 exports.defaultValueProcessorByRule = defaultValueProcessorByRule;
@@ -3983,6 +4269,7 @@ exports.isRuleGroup = isRuleGroup;
 exports.isRuleGroupType = isRuleGroupType;
 exports.isRuleGroupTypeIC = isRuleGroupTypeIC;
 exports.isRuleOrGroupValid = isRuleOrGroupValid;
+exports.isRuleType = isRuleType;
 exports.isValidValue = isValidValue;
 exports.isValidationResult = isValidationResult;
 exports.isValueProcessorLegacy = isValueProcessorLegacy;
@@ -3990,6 +4277,8 @@ exports.joinWith = joinWith;
 exports.jsonLogicAdditionalOperators = jsonLogicAdditionalOperators;
 exports.lc = lc;
 exports.mapSQLOperator = mapSQLOperator;
+exports.mergeAnyTranslation = mergeAnyTranslation;
+exports.mergeAnyTranslations = mergeAnyTranslations;
 exports.mergeClassnames = mergeClassnames;
 exports.mongoDbFallback = mongoDbFallback;
 exports.mongoOperators = mongoOperators;
@@ -4004,6 +4293,7 @@ exports.objectKeys = objectKeys;
 exports.parseNumber = parseNumber;
 exports.pathIsDisabled = pathIsDisabled;
 exports.pathsAreEqual = pathsAreEqual;
+exports.prepareOptionList = prepareOptionList;
 exports.prepareRule = prepareRule;
 exports.prepareRuleGroup = prepareRuleGroup;
 exports.prepareRuleOrGroup = prepareRuleOrGroup;