@react-querybuilder/core 8.22.5 → 8.23.0

package/dist/utils-C79dxwZb.js

@@ -1,752 +0,0 @@
-const require_isRuleGroup = require("./isRuleGroup-0JNiQgLg.js");
-let numeric_quantity = require("numeric-quantity");
-//#region src/defaults.ts
-/**
-* Map of default operators to their respective opposite/negating operators.
-*
-* @group Defaults
-*/
-const defaultOperatorNegationMap = {
-	"=": "!=",
-	"!=": "=",
-	"<": ">=",
-	"<=": ">",
-	">": "<=",
-	">=": "<",
-	beginsWith: "doesNotBeginWith",
-	doesNotBeginWith: "beginsWith",
-	endsWith: "doesNotEndWith",
-	doesNotEndWith: "endsWith",
-	contains: "doesNotContain",
-	doesNotContain: "contains",
-	between: "notBetween",
-	notBetween: "between",
-	in: "notIn",
-	notIn: "in",
-	notNull: "null",
-	null: "notNull"
-};
-//#endregion
-//#region src/utils/arrayUtils.ts
-/**
-* Splits a string by a given character (see {@link defaultJoinChar}). Escaped characters
-* (characters preceded by a backslash) will not apply to the split, and the backslash will
-* be removed in the array element. Inverse of {@link joinWith}.
-*
-* @example
-* splitBy('this\\,\\,that,,the other,,,\\,')
-* // or
-* splitBy('this\\,\\,that,,the other,,,\\,', ',')
-* // would return
-* ['this,,that', '', 'the other', '', '', ',']
-*/
-const splitBy = (str, splitChar = ",") => typeof str === "string" ? str.split(`\\${splitChar}`).map((c) => c.split(splitChar)).reduce((prev, curr, idx) => {
-	if (idx === 0) return curr;
-	return [
-		...prev.slice(0, -1),
-		`${prev.at(-1)}${splitChar}${curr[0]}`,
-		...curr.slice(1)
-	];
-}, []) : [];
-/**
-* Joins an array of strings using the given character (see {@link defaultJoinChar}). When
-* the given character appears in an array element, a backslash will be added just before it
-* to distinguish it from the join character. Effectively the inverse of {@link splitBy}.
-*
-* TIP: The join character can actually be a string of any length. Only the first character
-* will be searched for in the array elements and preceded by a backslash.
-*
-* @example
-* joinWith(['this,,that', '', 'the other', '', '', ','], ', ')
-* // would return
-* 'this\\,\\,that, , the other, , , \\,'
-*/
-const joinWith = (strArr, joinChar = ",") => strArr.map((str) => `${str ?? ""}`.replaceAll(joinChar[0], `\\${joinChar[0]}`)).join(joinChar);
-/**
-* Trims the value if it is a string. Otherwise returns the value as is.
-*/
-const trimIfString = (val) => typeof val === "string" ? val.trim() : val;
-/**
-* Splits a string by comma then trims each element. Arrays are returned as is except
-* any string elements are trimmed.
-*/
-const toArray = (a, { retainEmptyStrings } = {}) => Array.isArray(a) ? a.map(trimIfString) : typeof a === "string" ? splitBy(a, ",").filter(retainEmptyStrings ? () => true : (s) => !/^\s*$/.test(s)).map((s) => s.trim()) : typeof a === "number" ? [a] : [];
-//#endregion
-//#region src/utils/parseNumber.ts
-/**
-* Converts a string to a number. Uses native `parseFloat` if `parseNumbers` is "native",
-* otherwise uses [`numeric-quantity`](https://jakeboone02.github.io/numeric-quantity/).
-* If that returns `NaN`, the string is returned unchanged. Numeric values are returned
-* as-is regardless of the `parseNumbers` option.
-*/
-const parseNumber = (val, { parseNumbers, bigIntOnOverflow } = {}) => {
-	if (!parseNumbers || typeof val === "bigint" || typeof val === "number") return val;
-	if (parseNumbers === "native") return Number.parseFloat(val);
-	const valAsNum = (0, numeric_quantity.numericQuantity)(val, {
-		allowTrailingInvalid: parseNumbers === "enhanced",
-		bigIntOnOverflow,
-		romanNumerals: false,
-		round: false
-	});
-	return typeof valAsNum === "bigint" || !Number.isNaN(valAsNum) ? valAsNum : val;
-};
-//#endregion
-//#region src/utils/optGroupUtils.ts
-const isOptionWithName = (opt) => require_isRuleGroup.isPojo(opt) && "name" in opt && typeof opt.name === "string";
-const isOptionWithValue = (opt) => require_isRuleGroup.isPojo(opt) && "value" in opt && typeof opt.value === "string";
-/**
-* Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})
-* into a {@link FullOption}. Full options are left unchanged.
-*
-* @group Option Lists
-*/
-function toFullOption(opt, baseProperties, labelMap) {
-	if (typeof opt === "string") return {
-		...baseProperties,
-		name: opt,
-		value: opt,
-		label: labelMap?.[opt] ?? opt
-	};
-	const idObj = {};
-	let needsUpdating = !!baseProperties;
-	if (isOptionWithName(opt) && !isOptionWithValue(opt)) {
-		idObj.value = opt.name;
-		needsUpdating = true;
-	} else if (!isOptionWithName(opt) && isOptionWithValue(opt)) {
-		idObj.name = opt.value;
-		needsUpdating = true;
-	}
-	if (needsUpdating) return Object.assign({}, baseProperties, opt, idObj);
-	return opt;
-}
-/**
-* Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.
-* Lists of full options are left unchanged.
-*
-* @group Option Lists
-*/
-function toFullOptionList(optList, baseProperties, labelMap) {
-	if (!Array.isArray(optList)) return [];
-	const list = optList;
-	if (isFlexibleOptionGroupArray(list)) return list.map((optGroup) => ({
-		...optGroup,
-		options: optGroup.options.map((opt) => toFullOption(opt, baseProperties, labelMap))
-	}));
-	return list.map((opt) => toFullOption(opt, baseProperties, labelMap));
-}
-/**
-* Generates a new array of objects with duplicates removed based
-* on the identifying property (`value` or `name`)
-*
-* @group Option Lists
-*/
-const uniqByIdentifier = (originalArray) => {
-	const names = /* @__PURE__ */ new Set();
-	const newArray = [];
-	for (const el of originalArray) if (!names.has(el.value ?? el.name)) {
-		names.add(el.value ?? el.name);
-		newArray.push(el);
-	}
-	return originalArray.length === newArray.length ? originalArray : newArray;
-};
-/**
-* Determines if an {@link OptionList} is an {@link OptionGroup} array.
-*
-* @group Option Lists
-*/
-const isOptionGroupArray = (arr) => Array.isArray(arr) && arr.length > 0 && require_isRuleGroup.isPojo(arr[0]) && "options" in arr[0] && Array.isArray(arr[0].options);
-/**
-* Determines if an array is a flat array of {@link FlexibleOption}.
-*
-* @group Option Lists
-*/
-const isFlexibleOptionArray = (arr) => {
-	let isFOA = false;
-	if (Array.isArray(arr)) for (const o of arr) if (isOptionWithName(o) || isOptionWithValue(o)) isFOA = true;
-	else return false;
-	return isFOA;
-};
-/**
-* Determines if a {@link FlexibleOptionList} is a {@link FlexibleOptionGroup} array.
-*
-* @group Option Lists
-*/
-const isFlexibleOptionGroupArray = (arr, { allowEmpty = false } = {}) => {
-	let isFOGA = false;
-	if (Array.isArray(arr)) for (const og of arr) if (require_isRuleGroup.isPojo(og) && "options" in og && (isFlexibleOptionArray(og.options) || allowEmpty && Array.isArray(og.options) && og.options.length === 0)) isFOGA = true;
-	else return false;
-	return isFOGA;
-};
-function getOption(arr, name) {
-	return (isFlexibleOptionGroupArray(arr, { allowEmpty: true }) ? arr.flatMap((og) => og.options) : arr).find((op) => op.value === name || op.name === name);
-}
-/**
-* Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.
-* If the array is already flat, it is returned as is.
-*
-* @group Option Lists
-*/
-const toFlatOptionArray = (arr) => uniqByIdentifier(isOptionGroupArray(arr) ? arr.flatMap((og) => og.options) : arr);
-//#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 (require_isRuleGroup.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;
-	}
-};
-/**
-* Returns a preset-aware SQL string-concatenation function. Emits `CONCAT(a, b, ...)` when
-* `concatOperator` is `"CONCAT"` (case-insensitive), otherwise joins with the infix operator
-* (e.g. `a || b`, `a + b`).
-*
-* @group Export
-*/
-const getSQLConcat = (concatOperator = "||") => (...values) => concatOperator.toUpperCase() === "CONCAT" ? `CONCAT(${values.join(", ")})` : values.join(` ${concatOperator} `);
-/**
-* Returns the `[prefix, suffix]` `LIKE` wildcards for a string-match operator (e.g. `contains`
-* → `['%', '%']`, `beginsWith` → `['', '%']`, `endsWith` → `['%', '']`). Unknown operators
-* yield `['', '']`.
-*
-* @group Export
-*/
-const getLikeWildcards = (operatorLC) => {
-	switch (operatorLC) {
-		case "contains":
-		case "doesnotcontain": return ["%", "%"];
-		case "beginswith":
-		case "doesnotbeginwith": return ["", "%"];
-		case "endswith":
-		case "doesnotendwith": return ["%", ""];
-		default: return ["", ""];
-	}
-};
-/**
-* Wraps an already-serialized SQL fragment (a quoted field name or an expression) with the
-* `LIKE` wildcards for the given (lowercase) string-match operator, concatenating the literal
-* `%` markers via the preset-aware {@link getSQLConcat}. Returns the fragment untouched for
-* operators without wildcards.
-*
-* @group Export
-*/
-const wrapLikeFragment = (fragment, operatorLC, { concatOperator = "||", quoteValuesWith, wrapValueWith = ["", ""] } = {}) => {
-	const [pre, post] = getLikeWildcards(operatorLC);
-	const quoteChar = quoteValuesWith || `'`;
-	const quote = (p) => `${wrapValueWith[0]}${quoteChar}${p}${quoteChar}${wrapValueWith[1]}`;
-	const parts = [
-		pre && quote(pre),
-		fragment,
-		post && quote(post)
-	].filter(Boolean);
-	return parts.length > 1 ? getSQLConcat(concatOperator)(...parts) : fragment;
-};
-/**
-* 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)
-};
-/**
-* Returns a new query object with all `string`-type `value` properties converted
-* to `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 (require_isRuleGroup.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")) {
-			// v8 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" && require_isRuleGroup.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;
-};
-/**
-* Prefixes a named-parameter value with the given `paramPrefix` unless the value already
-* begins with it. Used by {@link formatQuery} to render rules whose `valueSource` is
-* `"parameter"` (e.g. `"p1"` with prefix `":"` → `":p1"`; `":p1"` → `":p1"`).
-*
-* @group Export
-*/
-const withParamPrefix = (value, paramPrefix = ":") => {
-	const v = `${value ?? ""}`;
-	return paramPrefix && v.startsWith(paramPrefix) ? v : `${paramPrefix}${v}`;
-};
-/**
-* Strips a leading `paramPrefix` from a named-parameter value if present. Inverse of
-* {@link withParamPrefix}; used to normalize parameter names for validation/lookup.
-*
-* @group Export
-*/
-const stripParamPrefix = (value, paramPrefix = ":") => {
-	const v = `${value ?? ""}`;
-	return paramPrefix && v.startsWith(paramPrefix) ? v.slice(paramPrefix.length) : v;
-};
-/**
-* 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] ?? 
-/* v8 ignore start -- @preserve */ "" : Object.entries(translations).find(([keyToTest]) => translationMatchFilter(key, keyToTest, conditions))?.[1] ?? Object.entries(defaultNLTranslations).find(([keyToTest]) => translationMatchFilter(key, keyToTest, conditions))?.[1] ?? defaultNLTranslations[key] ?? 
-/* v8 ignore next -- @preserve */ "";
-/**
-* Transforms
-* - `match: { mode: "atLeast", threshold: 1 }` to `match: { mode: "some" }`
-* - `match: { mode: "atMost", threshold: 0 }` to `match: { mode: "none" }`.
-*
-* Returns:
-* - Processed `{ mode, threshold }` object for valid subqueries
-* - `null` if match mode is not applicable for the rule
-* - `false` if match mode is valid, but either
-*   1. `threshold` is required and invalid, or
-*   2. `value` is not a valid rule group.
-*/
-const processMatchMode = (rule) => {
-	const { mode, threshold } = rule.match ?? {};
-	if (!mode) return null;
-	if (!require_isRuleGroup.isRuleGroup(rule.value)) return false;
-	const matchModeLC = require_isRuleGroup.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
-	};
-};
-/**
-* Base alias assigned to the element binding of a subquery generated for a rule's
-* {@link MatchMode `match` mode} (e.g. `unnest(field) as elem_alias`).
-*/
-const subqueryElementAliasBase = "elem_alias";
-/**
-* Returns the element alias for a subquery at the given nesting depth. Depth 0 (the common,
-* non-nested case) uses {@link subqueryElementAliasBase} unchanged; deeper levels are suffixed
-* with the depth, so a subquery nested within a subquery cannot shadow its parent's binding.
-*
-* Deterministic by depth rather than randomized, so output remains stable and snapshot-friendly.
-*
-* @group Export
-*/
-const getSubqueryElementAlias = (subqueryDepth = 0) => subqueryDepth > 0 ? `${subqueryElementAliasBase}_${subqueryDepth}` : subqueryElementAliasBase;
-/**
-* "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) => require_isRuleGroup.isPojo(value) && Object.keys(value).length === 1 && typeof value.$bigint === "string" ? BigInt(value.$bigint) : value;
-//#endregion
-Object.defineProperty(exports, "bigIntJsonParseReviver", {
-	enumerable: true,
-	get: function() {
-		return bigIntJsonParseReviver;
-	}
-});
-Object.defineProperty(exports, "bigIntJsonStringifyReplacer", {
-	enumerable: true,
-	get: function() {
-		return bigIntJsonStringifyReplacer;
-	}
-});
-Object.defineProperty(exports, "celCombinatorMap", {
-	enumerable: true,
-	get: function() {
-		return celCombinatorMap;
-	}
-});
-Object.defineProperty(exports, "defaultNLTranslations", {
-	enumerable: true,
-	get: function() {
-		return defaultNLTranslations;
-	}
-});
-Object.defineProperty(exports, "defaultOperatorNegationMap", {
-	enumerable: true,
-	get: function() {
-		return defaultOperatorNegationMap;
-	}
-});
-Object.defineProperty(exports, "getLikeWildcards", {
-	enumerable: true,
-	get: function() {
-		return getLikeWildcards;
-	}
-});
-Object.defineProperty(exports, "getNLTranslataion", {
-	enumerable: true,
-	get: function() {
-		return getNLTranslataion;
-	}
-});
-Object.defineProperty(exports, "getOption", {
-	enumerable: true,
-	get: function() {
-		return getOption;
-	}
-});
-Object.defineProperty(exports, "getParseNumberMethod", {
-	enumerable: true,
-	get: function() {
-		return getParseNumberMethod;
-	}
-});
-Object.defineProperty(exports, "getQuoteFieldNamesWithArray", {
-	enumerable: true,
-	get: function() {
-		return getQuoteFieldNamesWithArray;
-	}
-});
-Object.defineProperty(exports, "getQuotedFieldName", {
-	enumerable: true,
-	get: function() {
-		return getQuotedFieldName;
-	}
-});
-Object.defineProperty(exports, "getSQLConcat", {
-	enumerable: true,
-	get: function() {
-		return getSQLConcat;
-	}
-});
-Object.defineProperty(exports, "getSubqueryElementAlias", {
-	enumerable: true,
-	get: function() {
-		return getSubqueryElementAlias;
-	}
-});
-Object.defineProperty(exports, "isFlexibleOptionArray", {
-	enumerable: true,
-	get: function() {
-		return isFlexibleOptionArray;
-	}
-});
-Object.defineProperty(exports, "isFlexibleOptionGroupArray", {
-	enumerable: true,
-	get: function() {
-		return isFlexibleOptionGroupArray;
-	}
-});
-Object.defineProperty(exports, "isValidValue", {
-	enumerable: true,
-	get: function() {
-		return isValidValue;
-	}
-});
-Object.defineProperty(exports, "isValueProcessorLegacy", {
-	enumerable: true,
-	get: function() {
-		return isValueProcessorLegacy;
-	}
-});
-Object.defineProperty(exports, "joinWith", {
-	enumerable: true,
-	get: function() {
-		return joinWith;
-	}
-});
-Object.defineProperty(exports, "jsonLogicAdditionalOperators", {
-	enumerable: true,
-	get: function() {
-		return jsonLogicAdditionalOperators;
-	}
-});
-Object.defineProperty(exports, "mapSQLOperator", {
-	enumerable: true,
-	get: function() {
-		return mapSQLOperator;
-	}
-});
-Object.defineProperty(exports, "mongoOperators", {
-	enumerable: true,
-	get: function() {
-		return mongoOperators;
-	}
-});
-Object.defineProperty(exports, "normalizeConstituentWordOrder", {
-	enumerable: true,
-	get: function() {
-		return normalizeConstituentWordOrder;
-	}
-});
-Object.defineProperty(exports, "numerifyValues", {
-	enumerable: true,
-	get: function() {
-		return numerifyValues;
-	}
-});
-Object.defineProperty(exports, "parseNumber", {
-	enumerable: true,
-	get: function() {
-		return parseNumber;
-	}
-});
-Object.defineProperty(exports, "prismaOperators", {
-	enumerable: true,
-	get: function() {
-		return prismaOperators;
-	}
-});
-Object.defineProperty(exports, "processMatchMode", {
-	enumerable: true,
-	get: function() {
-		return processMatchMode;
-	}
-});
-Object.defineProperty(exports, "shouldRenderAsNumber", {
-	enumerable: true,
-	get: function() {
-		return shouldRenderAsNumber;
-	}
-});
-Object.defineProperty(exports, "stripParamPrefix", {
-	enumerable: true,
-	get: function() {
-		return stripParamPrefix;
-	}
-});
-Object.defineProperty(exports, "subqueryElementAliasBase", {
-	enumerable: true,
-	get: function() {
-		return subqueryElementAliasBase;
-	}
-});
-Object.defineProperty(exports, "toArray", {
-	enumerable: true,
-	get: function() {
-		return toArray;
-	}
-});
-Object.defineProperty(exports, "toFlatOptionArray", {
-	enumerable: true,
-	get: function() {
-		return toFlatOptionArray;
-	}
-});
-Object.defineProperty(exports, "toFullOption", {
-	enumerable: true,
-	get: function() {
-		return toFullOption;
-	}
-});
-Object.defineProperty(exports, "toFullOptionList", {
-	enumerable: true,
-	get: function() {
-		return toFullOptionList;
-	}
-});
-Object.defineProperty(exports, "trimIfString", {
-	enumerable: true,
-	get: function() {
-		return trimIfString;
-	}
-});
-Object.defineProperty(exports, "withParamPrefix", {
-	enumerable: true,
-	get: function() {
-		return withParamPrefix;
-	}
-});
-Object.defineProperty(exports, "wrapLikeFragment", {
-	enumerable: true,
-	get: function() {
-		return wrapLikeFragment;
-	}
-});
-
-//# sourceMappingURL=utils-C79dxwZb.js.map