@react-querybuilder/core 8.15.0 → 8.16.1

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

@@ -1482,7 +1482,7 @@ const defaultRuleGroupProcessorCEL = (ruleGroup, options) => {
 //#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(`"`, `\\"`);
+const escapeDoubleQuotes$1 = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`"`, `\\"`);
 /**
 * Default rule processor used by {@link formatQuery} for "cel" format.
 *
@@ -1524,19 +1524,19 @@ const defaultRuleProcessorCEL = (rule, opts = {}) => {
 		case "==":
 		case "!=":
 		case ">":
-		case ">=": return `${field} ${operatorTL} ${valueIsField || useBareValue ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`}`;
+		case ">=": return `${field} ${operatorTL} ${valueIsField || useBareValue ? trimIfString(value) : `"${escapeDoubleQuotes$1(value, escapeQuotes)}"`}`;
 		case "contains":
-		case "doesnotcontain": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.contains(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`})`;
+		case "doesnotcontain": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.contains(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes$1(value, escapeQuotes)}"`})`;
 		case "beginswith":
-		case "doesnotbeginwith": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.startsWith(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`})`;
+		case "doesnotbeginwith": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.startsWith(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes$1(value, escapeQuotes)}"`})`;
 		case "endswith":
-		case "doesnotendwith": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.endsWith(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`})`;
+		case "doesnotendwith": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.endsWith(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes$1(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}`;
+			return `${prefix}${field} in [${toArray(value).map((val) => valueIsField || shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : `"${escapeDoubleQuotes$1(val, escapeQuotes)}"`).join(", ")}]${suffix}`;
 		}
 		case "between":
 		case "notbetween": {
@@ -1546,8 +1546,8 @@ const defaultRuleProcessorCEL = (rule, opts = {}) => {
 				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;
+				let firstValue = Number.isNaN(firstNum) ? valueIsField ? `${first}` : `"${escapeDoubleQuotes$1(first, escapeQuotes)}"` : firstNum;
+				let secondValue = Number.isNaN(secondNum) ? valueIsField ? `${second}` : `"${escapeDoubleQuotes$1(second, escapeQuotes)}"` : secondNum;
 				if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
 					const tempNum = secondNum;
 					secondValue = firstNum;
@@ -1803,7 +1803,7 @@ const defaultRuleGroupProcessorSpEL = (ruleGroup, options) => {
 //#region src/utils/formatQuery/defaultRuleProcessorSpEL.ts
 const shouldNegate$1 = (op) => op.startsWith("not") || op.startsWith("doesnot");
 const wrapInNegation = (clause, negate) => negate ? `!(${clause})` : clause;
-const escapeSingleQuotes = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`'`, `\\'`);
+const escapeSingleQuotes$2 = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`'`, `\\'`);
 /**
 * Default rule processor used by {@link formatQuery} for "spel" format.
 *
@@ -1844,20 +1844,20 @@ const defaultRuleProcessorSpEL = (rule, opts = {}) => {
 		case "==":
 		case "!=":
 		case ">":
-		case ">=": return `${field} ${operatorTL} ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes(value, escapeQuotes)}'`}`;
+		case ">=": return `${field} ${operatorTL} ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes$2(value, escapeQuotes)}'`}`;
 		case "contains":
-		case "doesnotcontain": return wrapInNegation(`${field} matches ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes(value, escapeQuotes)}'`}`, shouldNegate$1(operatorTL));
+		case "doesnotcontain": return wrapInNegation(`${field} matches ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes$2(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 "doesnotbeginwith": return wrapInNegation(`${field} matches ${valueIsField ? `'^'.concat(${trimIfString(value)})` : `'${typeof value === "string" && !value.startsWith("^") || useBareValue ? "^" : ""}${escapeSingleQuotes$2(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 "doesnotendwith": return wrapInNegation(`${field} matches ${valueIsField ? `${trimIfString(value)}.concat('$')` : `'${escapeSingleQuotes$2(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 = shouldNegate$1(operatorTL) ? "!" : "";
 			const valueAsArray = toArray(value);
-			return valueAsArray.length > 0 ? `${negate}(${valueAsArray.map((val) => `${field} == ${valueIsField || shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : `'${escapeSingleQuotes(val, escapeQuotes)}'`}`).join(" or ")})` : "";
+			return valueAsArray.length > 0 ? `${negate}(${valueAsArray.map((val) => `${field} == ${valueIsField || shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : `'${escapeSingleQuotes$2(val, escapeQuotes)}'`}`).join(" or ")})` : "";
 		}
 		case "between":
 		case "notbetween": {
@@ -1867,8 +1867,8 @@ const defaultRuleProcessorSpEL = (rule, opts = {}) => {
 				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;
+				let firstValue = Number.isNaN(firstNum) ? valueIsField ? `${first}` : `'${escapeSingleQuotes$2(first, escapeQuotes)}'` : firstNum;
+				let secondValue = Number.isNaN(secondNum) ? valueIsField ? `${second}` : `'${escapeSingleQuotes$2(second, escapeQuotes)}'` : secondNum;
 				if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
 					const tempNum = secondNum;
 					secondValue = firstNum;
@@ -1923,7 +1923,7 @@ const defaultValueProcessorByRule = ({ operator, value, valueSource }, { escapeQ
 				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"} `);
+			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?.betweenAnd ?? translations?.and ?? "and"} `);
 		}
 		case "contains":
 		case "doesnotcontain": return valueIsField ? concat(quoteValue("%"), wrapFieldName(value), quoteValue("%")) : quoteValue(`%${escapeValue(value)}%`);
@@ -1936,6 +1936,70 @@ const defaultValueProcessorByRule = ({ operator, value, valueSource }, { escapeQ
 	return valueIsField ? wrapFieldName(value) : shouldRenderAsNumber(value, parseNumbers) ? `${trimIfString(value)}` : `${wrapAndEscape(value)}`;
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorCypher.ts
+/**
+* Maps a {@link DefaultCombinatorName} to a Cypher combinator keyword.
+*
+* @group Export
+*/
+const cypherCombinatorMap = {
+	and: "AND",
+	or: "OR"
+};
+/**
+* Rule group processor used by {@link formatQuery} for "cypher" and "gql" formats.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorCypher = (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 = cypherCombinatorMap[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) ? ` ${cypherCombinatorMap[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/defaultRuleProcessorDrizzle.ts
 /**
 * Default rule processor used by {@link formatQuery} for the "drizzle" format.
@@ -2103,6 +2167,67 @@ const defaultRuleGroupProcessorElasticSearch = (ruleGroup, options) => {
 	return processedRuleGroup === false ? {} : processedRuleGroup;
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorGremlin.ts
+/**
+* Rule group processor used by {@link formatQuery} for "gremlin" format.
+*
+* At the top level, filter rules produce chained `.has()` steps (implicit AND).
+* Nested groups use `.and()` / `.or()` / `.not()` compound traversals with
+* `__` anonymous traversal prefixes.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorGremlin = (ruleGroup, options) => {
+	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const validateAndProcess = (rule) => {
+		// v8 ignore next -- @preserve
+		if (typeof rule === "string" || isRuleGroup(rule)) return void 0;
+		const [validationResult, fieldValidator] = validateRule(rule);
+		if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return;
+		const fieldData = getOption(fields, rule.field);
+		return ruleProcessor(rule, {
+			...options,
+			parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+			escapeQuotes: (rule.valueSource ?? "value") === "value",
+			fieldData
+		});
+	};
+	/** Recursively processes a nested group into `.and()`/`.or()`/`.not()` form. */
+	const processNested = (rg) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return "";
+		const predicates = [];
+		for (const rule of rg.rules) {
+			if (typeof rule === "string") continue;
+			if (isRuleGroup(rule)) {
+				const nested = processNested(rule);
+				if (nested) predicates.push(nested);
+				continue;
+			}
+			const processed = validateAndProcess(rule);
+			if (processed) predicates.push(processed);
+		}
+		if (predicates.length === 0) return "";
+		const combinator = rg.combinator ?? "and";
+		const prefix = rg.not ? "not" : combinator;
+		if (predicates.length === 1 && !rg.not) return predicates[0];
+		return `.${prefix}(${predicates.map((p) => p.startsWith(".") ? `__${p}` : p).join(", ")})`;
+	};
+	if (!isRuleOrGroupValid(ruleGroup, validationMap[ruleGroup.id ?? ""])) return fallbackExpression;
+	const steps = [];
+	for (const rule of ruleGroup.rules) {
+		if (typeof rule === "string") continue;
+		if (isRuleGroup(rule)) {
+			const compound = processNested(rule);
+			if (compound) steps.push(compound);
+			continue;
+		}
+		const processed = validateAndProcess(rule);
+		if (processed) steps.push(processed);
+	}
+	if (steps.length === 0) return fallbackExpression;
+	return steps.join("");
+};
+//#endregion
 //#region src/utils/formatQuery/defaultRuleGroupProcessorJSONata.ts
 /**
 * Rule group processor used by {@link formatQuery} for "jsonata" format.
@@ -2273,7 +2398,7 @@ const defaultRuleGroupProcessorNL = (ruleGroup, options) => {
 		let firstRule = true;
 		for (const rule of rg2.rules) {
 			if (typeof rule === "string") {
-				precedingCombinator = `, ${translations[rule] ?? rule} `;
+				precedingCombinator = `${translations.ruleSeparator ?? ", "}${translations[rule] ?? rule} `;
 				continue;
 			}
 			if (isRuleGroup(rule)) {
@@ -2315,7 +2440,8 @@ 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.join(isRuleGroupType(rg2) ? `, ${translations[combinator] ?? combinator} ` : "")}${suffix}`;
+		const sep = translations.ruleSeparator ?? ", ";
+		return `${prefix}${processedRules.join(isRuleGroupType(rg2) ? `${sep}${translations[combinator] ?? combinator} ` : "")}${suffix}`;
 	};
 	return processRuleGroup(ruleGroup, true);
 };
@@ -2490,6 +2616,63 @@ const defaultRuleGroupProcessorSequelize = (ruleGroup, options) => {
 	return processRuleGroup(convertFromIC(ruleGroup), true);
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSPARQL.ts
+/**
+* Rule group processor used by {@link formatQuery} for "sparql" format.
+*
+* SPARQL uses the same combinators as CEL (`&&` / `||`) and `!()` for negation.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorSPARQL = (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/defaultRuleGroupProcessorSQL.ts
 /**
 * Default rule processor used by {@link formatQuery} for "sql" format.
@@ -2865,6 +3048,59 @@ const getFieldValidatorReasons = (rule, fieldValidator) => {
 	}
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorCypher.ts
+const escapeSingleQuotes$1 = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll("'", "\\'");
+/**
+* Default rule processor used by {@link formatQuery} for "cypher" and "gql" formats.
+*
+* @group Export
+*/
+const defaultRuleProcessorCypher = (rule, opts = {}) => {
+	const { escapeQuotes, parseNumbers } = opts;
+	const { field, operator, value, valueSource } = rule;
+	const valueIsField = valueSource === "field";
+	const operatorTL = operator.toLowerCase();
+	const fmtVal = (v) => {
+		if (v === null || v === void 0) return "null";
+		if (typeof v === "boolean" || typeof v === "bigint") return String(v);
+		if (valueIsField) return trimIfString(v);
+		if (typeof v === "number" || shouldRenderAsNumber(v, parseNumbers)) return trimIfString(v);
+		return `'${escapeSingleQuotes$1(v, escapeQuotes)}'`;
+	};
+	switch (operatorTL) {
+		case "=": return `${field} = ${fmtVal(value)}`;
+		case "!=":
+		case "<>": return `${field} <> ${fmtVal(value)}`;
+		case "<":
+		case ">":
+		case "<=":
+		case ">=": return `${field} ${operatorTL} ${fmtVal(value)}`;
+		case "contains": return `${field} CONTAINS ${fmtVal(value)}`;
+		case "doesnotcontain": return `NOT ${field} CONTAINS ${fmtVal(value)}`;
+		case "beginswith": return `${field} STARTS WITH ${fmtVal(value)}`;
+		case "doesnotbeginwith": return `NOT ${field} STARTS WITH ${fmtVal(value)}`;
+		case "endswith": return `${field} ENDS WITH ${fmtVal(value)}`;
+		case "doesnotendwith": return `NOT ${field} ENDS WITH ${fmtVal(value)}`;
+		case "null": return `${field} IS NULL`;
+		case "notnull": return `${field} IS NOT NULL`;
+		case "in":
+		case "notin": {
+			const values = toArray(value).map(fmtVal);
+			if (!values.length) return "";
+			return `${operatorTL === "notin" ? "NOT " : ""}${field} IN [${values.join(", ")}]`;
+		}
+		case "between":
+		case "notbetween": {
+			const arr = toArray(value);
+			if (arr.length < 2) return "";
+			const [low, high] = [fmtVal(arr[0]), fmtVal(arr[1])];
+			const expr = `${low} <= ${field} AND ${field} <= ${high}`;
+			return operatorTL === "notbetween" ? `NOT (${expr})` : expr;
+		}
+		default: return `${field} ${operator} ${fmtVal(value)}`;
+	}
+};
+//#endregion
 //#region src/utils/formatQuery/defaultRuleProcessorElasticSearch.ts
 const rangeOperatorMap = {
 	"<": "lt",
@@ -3016,6 +3252,68 @@ const defaultRuleProcessorElasticSearch = (rule, options = {}) => {
 	return false;
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorGremlin.ts
+const escapeSingleQuotes = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll("'", "\\'");
+/**
+* Default rule processor used by {@link formatQuery} for "gremlin" format.
+*
+* Each rule becomes a `.has()` step (or `.hasNot()`/`.has()` for null checks).
+*
+* @group Export
+*/
+const defaultRuleProcessorGremlin = (rule, opts = {}) => {
+	const { escapeQuotes, parseNumbers } = opts;
+	const { field, operator, value, valueSource } = rule;
+	const valueIsField = valueSource === "field";
+	const operatorTL = operator.toLowerCase();
+	const prop = field.includes(".") ? field.split(".").pop() : field;
+	const fmtVal = (v) => {
+		if (v === null || v === void 0) return "null";
+		if (typeof v === "boolean" || typeof v === "bigint") return String(v);
+		if (valueIsField) return trimIfString(v);
+		if (typeof v === "number" || shouldRenderAsNumber(v, parseNumbers)) return trimIfString(v);
+		return `'${escapeSingleQuotes(v, escapeQuotes)}'`;
+	};
+	switch (operatorTL) {
+		case "=": return `.has('${prop}', ${fmtVal(value)})`;
+		case "!=":
+		case "<>": return `.has('${prop}', neq(${fmtVal(value)}))`;
+		case "<": return `.has('${prop}', lt(${fmtVal(value)}))`;
+		case ">": return `.has('${prop}', gt(${fmtVal(value)}))`;
+		case "<=": return `.has('${prop}', lte(${fmtVal(value)}))`;
+		case ">=": return `.has('${prop}', gte(${fmtVal(value)}))`;
+		case "contains": return `.has('${prop}', containing(${fmtVal(value)}))`;
+		case "doesnotcontain": return `.has('${prop}', notContaining(${fmtVal(value)}))`;
+		case "beginswith": return `.has('${prop}', startingWith(${fmtVal(value)}))`;
+		case "doesnotbeginwith": return `.has('${prop}', notStartingWith(${fmtVal(value)}))`;
+		case "endswith": return `.has('${prop}', endingWith(${fmtVal(value)}))`;
+		case "doesnotendwith": return `.has('${prop}', notEndingWith(${fmtVal(value)}))`;
+		case "null": return `.hasNot('${prop}')`;
+		case "notnull": return `.has('${prop}')`;
+		case "in": {
+			const items = toArray(value).map(fmtVal);
+			if (!items.length) return "";
+			return `.has('${prop}', within(${items.join(", ")}))`;
+		}
+		case "notin": {
+			const items = toArray(value).map(fmtVal);
+			if (!items.length) return "";
+			return `.has('${prop}', without(${items.join(", ")}))`;
+		}
+		case "between": {
+			const arr = toArray(value);
+			if (arr.length < 2) return "";
+			return `.has('${prop}', between(${fmtVal(arr[0])}, ${fmtVal(arr[1])}))`;
+		}
+		case "notbetween": {
+			const arr = toArray(value);
+			if (arr.length < 2) return "";
+			return `.has('${prop}', outside(${fmtVal(arr[0])}, ${fmtVal(arr[1])}))`;
+		}
+		default: return `.has('${prop}', ${fmtVal(value)})`;
+	}
+};
+//#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(`"`, `\\"`)}"`;
@@ -3270,6 +3568,8 @@ const defaultValueProcessorNL = (rule, opts = {}) => {
 	const orTL = t.or ?? "or";
 	const trueTL = t.true ?? "true";
 	const falseTL = t.false ?? "false";
+	const listSep = t.listSeparator ?? ", ";
+	const useOxfordComma = !t.listSeparator;
 	switch (operatorLowerCase) {
 		case "null":
 		case "notnull": return "";
@@ -3289,7 +3589,8 @@ const defaultValueProcessorNL = (rule, opts = {}) => {
 			if (valueAsArray.length === 0) return "";
 			const valStringArray = valueAsArray.map((v) => valueIsField ? wrapFieldName(getOption(fields ?? [], v)?.label ?? v) : shouldRenderAsNumber(v, parseNumbers) ? `${trimIfString(v)}` : `${wrapAndEscape(v)}`);
 			if (valStringArray.length === 1) return valStringArray[0];
-			return `(${`${valStringArray.slice(0, -1).join(", ")}${valStringArray.length > 2 ? "," : ""} ${orTL} ${valStringArray.at(-1)}`})`;
+			const oxfordComma = useOxfordComma && valStringArray.length > 2 ? "," : "";
+			return `(${`${valStringArray.slice(0, -1).join(listSep)}${oxfordComma} ${orTL} ${valStringArray.at(-1)}`})`;
 		}
 	}
 	if (typeof rule.value === "boolean") return rule.value ? trueTL : falseTL;
@@ -3402,7 +3703,14 @@ const defaultRuleProcessorNL = (rule, opts) => {
 		V: operatorProcessor(rule, opts),
 		O: value
 	};
-	return normalizeConstituentWordOrder(wordOrder).map((term) => `${wordOrderMap[term]}`).join(" ").trim();
+	const translations = opts?.translations ?? {};
+	const suffixMap = {
+		S: translations.afterSubject ?? " ",
+		V: translations.afterVerb ?? " ",
+		O: translations.afterObject ?? " "
+	};
+	const wordOrderTuple = normalizeConstituentWordOrder(wordOrder).filter((term) => wordOrderMap[term] !== "");
+	return wordOrderTuple.map((term, i) => `${wordOrderMap[term]}${i < wordOrderTuple.length - 1 ? suffixMap[term] : ""}`).join("").trim();
 };
 //#endregion
 //#region src/utils/formatQuery/defaultRuleProcessorSQL.ts
@@ -3638,8 +3946,11 @@ const defaultRuleProcessorSequelize = (rule, { parseNumbers, preserveValueOrder,
 	const valueIsField = valueSource === "field";
 	const operatorLC = lc(operator);
 	if (!Op || valueIsField && (!col || !fn && [
+		"contains",
 		"doesnotcontain",
+		"beginswith",
 		"doesnotbeginwith",
+		"endswith",
 		"doesnotendwith"
 	].includes(operatorLC))) return;
 	switch (operatorLC) {
@@ -3659,9 +3970,9 @@ const defaultRuleProcessorSequelize = (rule, { parseNumbers, preserveValueOrder,
 			}[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 "contains": return { [field]: { [valueIsField ? Op.like : Op.substring]: valueIsField ? fn("CONCAT", "%", col(value), "%") : `${value}` } };
+		case "beginswith": return { [field]: { [valueIsField ? Op.like : Op.startsWith]: valueIsField ? fn("CONCAT", col(value), "%") : `${value}` } };
+		case "endswith": return { [field]: { [valueIsField ? Op.like : Op.endsWith]: valueIsField ? fn("CONCAT", "%", 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}` } };
@@ -3691,6 +4002,74 @@ const defaultRuleProcessorSequelize = (rule, { parseNumbers, preserveValueOrder,
 	}
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorSPARQL.ts
+const escapeDoubleQuotes = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`"`, `\\"`);
+/** Auto-prefix a SPARQL variable name with `?` unless it's already prefixed, a URI, or a prefixed name.
+*
+* @group Export
+*/
+const sparqlVar = (name) => /^[?<]/.test(name) || name.includes(":") ? name : `?${name}`;
+/**
+* Default rule processor used by {@link formatQuery} for "sparql" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorSPARQL = (rule, opts = {}) => {
+	const { escapeQuotes, parseNumbers } = opts;
+	const { field: rawField, operator, value, valueSource } = rule;
+	const valueIsField = valueSource === "field";
+	const operatorTL = operator.toLowerCase();
+	const field = sparqlVar(rawField);
+	const fmtVal = (v) => {
+		if (v === null || v === void 0) return "\"\"";
+		if (typeof v === "boolean") return `"${v}"^^xsd:boolean`;
+		if (typeof v === "bigint") return String(v);
+		if (valueIsField) return sparqlVar(trimIfString(v));
+		if (typeof v === "number" || shouldRenderAsNumber(v, parseNumbers)) return trimIfString(v);
+		const s = typeof v === "string" ? v : JSON.stringify(v) ?? "";
+		if (s.startsWith("?") || s.startsWith("<") || s.includes(":")) return s;
+		return `"${escapeDoubleQuotes(s, escapeQuotes)}"`;
+	};
+	switch (operatorTL) {
+		case "=":
+		case "!=":
+		case "<":
+		case ">":
+		case "<=":
+		case ">=": return `${field} ${operatorTL} ${fmtVal(value)}`;
+		case "<>": return `${field} != ${fmtVal(value)}`;
+		case "contains": return `CONTAINS(${field}, ${fmtVal(value)})`;
+		case "doesnotcontain": return `!CONTAINS(${field}, ${fmtVal(value)})`;
+		case "beginswith": return `STRSTARTS(${field}, ${fmtVal(value)})`;
+		case "doesnotbeginwith": return `!STRSTARTS(${field}, ${fmtVal(value)})`;
+		case "endswith": return `STRENDS(${field}, ${fmtVal(value)})`;
+		case "doesnotendwith": return `!STRENDS(${field}, ${fmtVal(value)})`;
+		case "null": return `!BOUND(${field})`;
+		case "notnull": return `BOUND(${field})`;
+		case "in": {
+			const items = toArray(value).map(fmtVal);
+			if (!items.length) return "";
+			return `${field} IN (${items.join(", ")})`;
+		}
+		case "notin": {
+			const items = toArray(value).map(fmtVal);
+			if (!items.length) return "";
+			return `${field} NOT IN (${items.join(", ")})`;
+		}
+		case "between": {
+			const arr = toArray(value);
+			if (arr.length < 2) return "";
+			return `${field} >= ${fmtVal(arr[0])} && ${field} <= ${fmtVal(arr[1])}`;
+		}
+		case "notbetween": {
+			const arr = toArray(value);
+			if (arr.length < 2) return "";
+			return `(${field} < ${fmtVal(arr[0])} || ${field} > ${fmtVal(arr[1])})`;
+		}
+		default: return `${field} ${operator} ${fmtVal(value)}`;
+	}
+};
+//#endregion
 //#region src/utils/formatQuery/formatQuery.ts
 /**
 * A collection of option presets for {@link formatQuery}, specifically for SQL-based formats.
@@ -3738,6 +4117,10 @@ const defaultRuleProcessors = {
 	sequelize: defaultRuleProcessorSequelize,
 	spel: defaultRuleProcessorSpEL,
 	sql: defaultRuleProcessorSQL,
+	cypher: defaultRuleProcessorCypher,
+	gql: defaultRuleProcessorCypher,
+	sparql: defaultRuleProcessorSPARQL,
+	gremlin: defaultRuleProcessorGremlin,
 	diagnostics: defaultRuleProcessorSQL
 };
 /* v8 ignore next -- @preserve */
@@ -3760,6 +4143,10 @@ const defaultOperatorProcessors = {
 	sequelize: defaultOperatorProcessor,
 	spel: defaultOperatorProcessor,
 	sql: defaultOperatorProcessorSQL,
+	cypher: defaultOperatorProcessor,
+	gql: defaultOperatorProcessor,
+	sparql: defaultOperatorProcessor,
+	gremlin: defaultOperatorProcessor,
 	diagnostics: defaultOperatorProcessor
 };
 const defaultFallbackExpressions = {
@@ -3767,6 +4154,8 @@ const defaultFallbackExpressions = {
 	ldap: "",
 	mongodb: "\"$and\":[{\"$expr\":true}]",
 	natural_language: "1 is 1",
+	sparql: "1 = 1",
+	gremlin: "",
 	spel: "1 == 1",
 	sql: "(1 = 1)"
 };
@@ -3907,6 +4296,10 @@ function formatQuery(ruleGroup, optionParam = {}) {
 		case "prisma": return defaultRuleGroupProcessorPrisma(ruleGroup, finalOptions);
 		case "drizzle": return defaultRuleGroupProcessorDrizzle(ruleGroup, finalOptions);
 		case "sequelize": return defaultRuleGroupProcessorSequelize(ruleGroup, finalOptions);
+		case "cypher":
+		case "gql": return defaultRuleGroupProcessorCypher(ruleGroup, finalOptions);
+		case "sparql": return defaultRuleGroupProcessorSPARQL(ruleGroup, finalOptions);
+		case "gremlin": return defaultRuleGroupProcessorGremlin(ruleGroup, finalOptions);
 		case "diagnostics": return defaultRuleGroupProcessorDiagnostics(ruleGroup, finalOptions);
 		default: return "";
 	}
@@ -4630,6 +5023,7 @@ exports.clsx = clsx;
 exports.convertFromIC = convertFromIC;
 exports.convertQuery = convertQuery;
 exports.convertToIC = convertToIC;
+exports.cypherCombinatorMap = cypherCombinatorMap;
 exports.defaultCELValueProcessor = defaultCELValueProcessor;
 exports.defaultCombinatorLabelMap = defaultCombinatorLabelMap;
 exports.defaultCombinators = defaultCombinators;
@@ -4657,9 +5051,11 @@ exports.defaultPlaceholderValueGroupLabel = defaultPlaceholderValueGroupLabel;
 exports.defaultPlaceholderValueLabel = defaultPlaceholderValueLabel;
 exports.defaultPlaceholderValueName = defaultPlaceholderValueName;
 exports.defaultRuleGroupProcessorCEL = defaultRuleGroupProcessorCEL;
+exports.defaultRuleGroupProcessorCypher = defaultRuleGroupProcessorCypher;
 exports.defaultRuleGroupProcessorDiagnostics = defaultRuleGroupProcessorDiagnostics;
 exports.defaultRuleGroupProcessorDrizzle = defaultRuleGroupProcessorDrizzle;
 exports.defaultRuleGroupProcessorElasticSearch = defaultRuleGroupProcessorElasticSearch;
+exports.defaultRuleGroupProcessorGremlin = defaultRuleGroupProcessorGremlin;
 exports.defaultRuleGroupProcessorJSONata = defaultRuleGroupProcessorJSONata;
 exports.defaultRuleGroupProcessorJsonLogic = defaultRuleGroupProcessorJsonLogic;
 exports.defaultRuleGroupProcessorLDAP = defaultRuleGroupProcessorLDAP;
@@ -4668,12 +5064,15 @@ exports.defaultRuleGroupProcessorMongoDBQuery = defaultRuleGroupProcessorMongoDB
 exports.defaultRuleGroupProcessorNL = defaultRuleGroupProcessorNL;
 exports.defaultRuleGroupProcessorParameterized = defaultRuleGroupProcessorParameterized;
 exports.defaultRuleGroupProcessorPrisma = defaultRuleGroupProcessorPrisma;
+exports.defaultRuleGroupProcessorSPARQL = defaultRuleGroupProcessorSPARQL;
 exports.defaultRuleGroupProcessorSQL = defaultRuleGroupProcessorSQL;
 exports.defaultRuleGroupProcessorSequelize = defaultRuleGroupProcessorSequelize;
 exports.defaultRuleGroupProcessorSpEL = defaultRuleGroupProcessorSpEL;
 exports.defaultRuleProcessorCEL = defaultRuleProcessorCEL;
+exports.defaultRuleProcessorCypher = defaultRuleProcessorCypher;
 exports.defaultRuleProcessorDrizzle = defaultRuleProcessorDrizzle;
 exports.defaultRuleProcessorElasticSearch = defaultRuleProcessorElasticSearch;
+exports.defaultRuleProcessorGremlin = defaultRuleProcessorGremlin;
 exports.defaultRuleProcessorJSONata = defaultRuleProcessorJSONata;
 exports.defaultRuleProcessorJsonLogic = defaultRuleProcessorJsonLogic;
 exports.defaultRuleProcessorLDAP = defaultRuleProcessorLDAP;
@@ -4682,6 +5081,7 @@ exports.defaultRuleProcessorMongoDBQuery = defaultRuleProcessorMongoDBQuery;
 exports.defaultRuleProcessorNL = defaultRuleProcessorNL;
 exports.defaultRuleProcessorParameterized = defaultRuleProcessorParameterized;
 exports.defaultRuleProcessorPrisma = defaultRuleProcessorPrisma;
+exports.defaultRuleProcessorSPARQL = defaultRuleProcessorSPARQL;
 exports.defaultRuleProcessorSQL = defaultRuleProcessorSQL;
 exports.defaultRuleProcessorSequelize = defaultRuleProcessorSequelize;
 exports.defaultRuleProcessorSpEL = defaultRuleProcessorSpEL;
@@ -4777,6 +5177,7 @@ exports.remove = remove;
 exports.removeInPlace = removeInPlace;
 exports.rootPath = rootPath;
 exports.shouldRenderAsNumber = shouldRenderAsNumber;
+exports.sparqlVar = sparqlVar;
 exports.splitBy = splitBy;
 exports.sqlDialectPresets = sqlDialectPresets;
 exports.standardClassnames = standardClassnames;