@react-querybuilder/core 8.22.5 → 8.23.0

package/dist/utils-CP5Jqy1P.mjs

@@ -0,0 +1,1294 @@
+import { c as isPojo, d as numericRegex$1, i as isRuleGroup, l as lc, r as objectKeys } from "./objectUtils-DDZ-KhV5.mjs";
+import { numericQuantity } from "numeric-quantity";
+//#region src/defaults.ts
+/**
+* @group Defaults
+*/
+const defaultPlaceholderName = "~";
+/**
+* @group Defaults
+*/
+const defaultPlaceholderLabel = "------";
+/**
+* Default `name` for placeholder option in the `fields` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderFieldName = "~";
+/**
+* Default `label` for placeholder option in the `fields` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderFieldLabel = defaultPlaceholderLabel;
+/**
+* Default `label` for placeholder option group in the `fields` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderFieldGroupLabel = defaultPlaceholderLabel;
+/**
+* Default `name` for placeholder option in the `operators` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderOperatorName = "~";
+/**
+* Default `label` for placeholder option in the `operators` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderOperatorLabel = defaultPlaceholderLabel;
+/**
+* Default `label` for placeholder option group in the `operators` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderOperatorGroupLabel = defaultPlaceholderLabel;
+/**
+* Default `name` for placeholder option in the `values` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderValueName = "~";
+/**
+* Default `label` for placeholder option in the `values` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderValueLabel = defaultPlaceholderLabel;
+/**
+* Default `label` for placeholder option group in the `values` array.
+*
+* @group Defaults
+*/
+const defaultPlaceholderValueGroupLabel = defaultPlaceholderLabel;
+/**
+* Default configuration of translatable strings.
+*
+* @group Defaults
+*/
+const defaultTranslations = {
+	fields: {
+		title: "Field",
+		placeholderName: "~",
+		placeholderLabel: defaultPlaceholderFieldLabel,
+		placeholderGroupLabel: defaultPlaceholderFieldGroupLabel
+	},
+	operators: {
+		title: "Operator",
+		placeholderName: "~",
+		placeholderLabel: defaultPlaceholderOperatorLabel,
+		placeholderGroupLabel: defaultPlaceholderOperatorGroupLabel
+	},
+	values: {
+		title: "Values",
+		placeholderName: "~",
+		placeholderLabel: defaultPlaceholderValueLabel,
+		placeholderGroupLabel: defaultPlaceholderValueGroupLabel
+	},
+	matchMode: { title: "Match mode" },
+	matchThreshold: {
+		title: "Match threshold",
+		placeholderName: "#"
+	},
+	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"
+	},
+	undo: {
+		label: "↶",
+		title: "Undo"
+	},
+	redo: {
+		label: "↷",
+		title: "Redo"
+	},
+	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
+*/
+const defaultJoinChar = ",";
+const defaultOperatorLabelMap = {
+	"=": "=",
+	"!=": "!=",
+	"<": "<",
+	">": ">",
+	"<=": "<=",
+	">=": ">=",
+	contains: "contains",
+	beginsWith: "begins with",
+	endsWith: "ends with",
+	doesNotContain: "does not contain",
+	doesNotBeginWith: "does not begin with",
+	doesNotEndWith: "does not end with",
+	null: "is null",
+	notNull: "is not null",
+	in: "in",
+	notIn: "not in",
+	between: "between",
+	notBetween: "not between"
+};
+const defaultCombinatorLabelMap = {
+	and: "AND",
+	or: "OR",
+	xor: "XOR"
+};
+/**
+* Default operator list.
+*
+* @group Defaults
+*/
+const defaultOperators = [
+	{
+		name: "=",
+		value: "=",
+		label: "="
+	},
+	{
+		name: "!=",
+		value: "!=",
+		label: "!="
+	},
+	{
+		name: "<",
+		value: "<",
+		label: "<"
+	},
+	{
+		name: ">",
+		value: ">",
+		label: ">"
+	},
+	{
+		name: "<=",
+		value: "<=",
+		label: "<="
+	},
+	{
+		name: ">=",
+		value: ">=",
+		label: ">="
+	},
+	{
+		name: "contains",
+		value: "contains",
+		label: "contains"
+	},
+	{
+		name: "beginsWith",
+		value: "beginsWith",
+		label: "begins with"
+	},
+	{
+		name: "endsWith",
+		value: "endsWith",
+		label: "ends with"
+	},
+	{
+		name: "doesNotContain",
+		value: "doesNotContain",
+		label: "does not contain"
+	},
+	{
+		name: "doesNotBeginWith",
+		value: "doesNotBeginWith",
+		label: "does not begin with"
+	},
+	{
+		name: "doesNotEndWith",
+		value: "doesNotEndWith",
+		label: "does not end with"
+	},
+	{
+		name: "null",
+		value: "null",
+		label: "is null"
+	},
+	{
+		name: "notNull",
+		value: "notNull",
+		label: "is not null"
+	},
+	{
+		name: "in",
+		value: "in",
+		label: "in"
+	},
+	{
+		name: "notIn",
+		value: "notIn",
+		label: "not in"
+	},
+	{
+		name: "between",
+		value: "between",
+		label: "between"
+	},
+	{
+		name: "notBetween",
+		value: "notBetween",
+		label: "not between"
+	}
+];
+/**
+* Map of default operators to their respective opposite/negating operators.
+*
+* @group Defaults
+*/
+const defaultOperatorNegationMap = {
+	"=": "!=",
+	"!=": "=",
+	"<": ">=",
+	"<=": ">",
+	">": "<=",
+	">=": "<",
+	beginsWith: "doesNotBeginWith",
+	doesNotBeginWith: "beginsWith",
+	endsWith: "doesNotEndWith",
+	doesNotEndWith: "endsWith",
+	contains: "doesNotContain",
+	doesNotContain: "contains",
+	between: "notBetween",
+	notBetween: "between",
+	in: "notIn",
+	notIn: "in",
+	notNull: "null",
+	null: "notNull"
+};
+/**
+* Relational/comparison operators (`=`, `!=`, `<`, `>`, `<=`, `>=`).
+*
+* @group Defaults
+*/
+const relationalOperators = /* @__PURE__ */ new Set([
+	"=",
+	"!=",
+	"<",
+	">",
+	"<=",
+	">="
+]);
+/**
+* Substring/text-matching operators (`contains`, `beginsWith`, `endsWith`, and negations).
+*
+* @group Defaults
+*/
+const substringOperators = /* @__PURE__ */ new Set([
+	"contains",
+	"beginsWith",
+	"endsWith",
+	"doesNotContain",
+	"doesNotBeginWith",
+	"doesNotEndWith"
+]);
+/**
+* Null-check operators (`null`, `notNull`).
+*
+* @group Defaults
+*/
+const nullOperators = /* @__PURE__ */ new Set(["null", "notNull"]);
+/**
+* List-membership operators (`in`, `notIn`).
+*
+* @group Defaults
+*/
+const inOperators = /* @__PURE__ */ new Set(["in", "notIn"]);
+/**
+* Range operators (`between`, `notBetween`).
+*
+* @group Defaults
+*/
+const betweenOperators = /* @__PURE__ */ new Set(["between", "notBetween"]);
+/**
+* Default combinator list.
+*
+* @group Defaults
+*/
+const defaultCombinators = [{
+	name: "and",
+	value: "and",
+	label: "AND"
+}, {
+	name: "or",
+	value: "or",
+	label: "OR"
+}];
+/**
+* Default combinator list, with `XOR` added.
+*
+* @group Defaults
+*/
+const defaultCombinatorsExtended = [...defaultCombinators, {
+	name: "xor",
+	value: "xor",
+	label: "XOR"
+}];
+/**
+* Default match modes.
+*
+* @group Defaults
+*/
+const defaultMatchModes = [
+	{
+		name: "all",
+		value: "all",
+		label: "all"
+	},
+	{
+		name: "some",
+		value: "some",
+		label: "some"
+	},
+	{
+		name: "none",
+		value: "none",
+		label: "none"
+	},
+	{
+		name: "atLeast",
+		value: "atLeast",
+		label: "at least"
+	},
+	{
+		name: "atMost",
+		value: "atMost",
+		label: "at most"
+	},
+	{
+		name: "exactly",
+		value: "exactly",
+		label: "exactly"
+	}
+];
+/**
+* Standard classnames applied to each component.
+*
+* @group Defaults
+*/
+const standardClassnames = {
+	queryBuilder: "queryBuilder",
+	ruleGroup: "ruleGroup",
+	header: "ruleGroup-header",
+	body: "ruleGroup-body",
+	combinators: "ruleGroup-combinators",
+	addRule: "ruleGroup-addRule",
+	addGroup: "ruleGroup-addGroup",
+	cloneRule: "rule-cloneRule",
+	cloneGroup: "ruleGroup-cloneGroup",
+	removeGroup: "ruleGroup-remove",
+	notToggle: "ruleGroup-notToggle",
+	rule: "rule",
+	fields: "rule-fields",
+	matchMode: "rule-matchMode",
+	matchThreshold: "rule-matchThreshold",
+	operators: "rule-operators",
+	value: "rule-value",
+	removeRule: "rule-remove",
+	betweenRules: "betweenRules",
+	valid: "queryBuilder-valid",
+	invalid: "queryBuilder-invalid",
+	shiftActions: "shiftActions",
+	undoRedoActions: "undoRedoActions",
+	undoAction: "undoRedoActions-undo",
+	redoAction: "undoRedoActions-redo",
+	dndDragging: "dndDragging",
+	dndOver: "dndOver",
+	dndCopy: "dndCopy",
+	dndGroup: "dndGroup",
+	dndDropNotAllowed: "dndDropNotAllowed",
+	dndPreviewPosition: "dndPreviewPosition",
+	dndHidden: "dndHidden",
+	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",
+	justified: "queryBuilder-justified",
+	responsive: "queryBuilder-responsive",
+	hasSubQuery: "rule-hasSubQuery",
+	loading: "queryBuilder-loading",
+	valueDateTimeRelative: "rule-value-dateTimeRelative"
+};
+/**
+* Default classnames for each component.
+*
+* @group Defaults
+*/
+const defaultControlClassnames = {
+	queryBuilder: "",
+	ruleGroup: "",
+	header: "",
+	body: "",
+	combinators: "",
+	addRule: "",
+	addGroup: "",
+	cloneRule: "",
+	cloneGroup: "",
+	removeGroup: "",
+	notToggle: "",
+	rule: "",
+	fields: "",
+	matchMode: "",
+	matchThreshold: "",
+	operators: "",
+	value: "",
+	removeRule: "",
+	shiftActions: "",
+	undoRedoActions: "",
+	undoAction: "",
+	redoAction: "",
+	dragHandle: "",
+	lockRule: "",
+	lockGroup: "",
+	muteRule: "",
+	muteGroup: "",
+	muted: "",
+	valueSource: "",
+	actionElement: "",
+	valueSelector: "",
+	betweenRules: "",
+	valid: "",
+	invalid: "",
+	dndDragging: "",
+	dndOver: "",
+	dndGroup: "",
+	dndCopy: "",
+	dndDropNotAllowed: "",
+	dndPreviewPosition: "",
+	dndHidden: "",
+	disabled: "",
+	valueListItem: "",
+	branches: "",
+	hasSubQuery: "",
+	loading: "",
+	valueDateTimeRelative: ""
+};
+/**
+* Default reason codes for a group being invalid.
+*
+* @group Defaults
+*/
+const groupInvalidReasons = {
+	empty: "empty",
+	invalidCombinator: "invalid combinator",
+	invalidIndependentCombinators: "invalid independent combinators"
+};
+/**
+* Component identifiers for testing.
+*
+* @group Defaults
+*/
+const TestID = {
+	rule: "rule",
+	ruleGroup: "rule-group",
+	inlineCombinator: "inline-combinator",
+	addGroup: "add-group",
+	removeGroup: "remove-group",
+	cloneGroup: "clone-group",
+	cloneRule: "clone-rule",
+	addRule: "add-rule",
+	removeRule: "remove-rule",
+	combinators: "combinators",
+	fields: "fields",
+	operators: "operators",
+	valueEditor: "value-editor",
+	notToggle: "not-toggle",
+	shiftActions: "shift-actions",
+	undoRedoActions: "undo-redo-actions",
+	undoAction: "undo-action",
+	redoAction: "redo-action",
+	dragHandle: "drag-handle",
+	lockRule: "lock-rule",
+	lockGroup: "lock-group",
+	muteRule: "mute-rule",
+	muteGroup: "mute-group",
+	valueSourceSelector: "value-source-selector",
+	matchModeEditor: "match-mode-editor"
+};
+const LogType = {
+	parentPathDisabled: "action aborted: parent path disabled",
+	pathDisabled: "action aborted: path is disabled",
+	queryUpdate: "query updated",
+	onAddRuleFalse: "onAddRule callback returned false",
+	onAddGroupFalse: "onAddGroup callback returned false",
+	onGroupRuleFalse: "onGroupRule callback returned false",
+	onGroupGroupFalse: "onGroupGroup callback returned false",
+	onMoveRuleFalse: "onMoveRule callback returned false",
+	onMoveGroupFalse: "onMoveGroup callback returned false",
+	onRemoveFalse: "onRemove callback returned false",
+	add: "rule or group added",
+	remove: "rule or group removed",
+	update: "rule or group updated",
+	move: "rule or group moved",
+	group: "rule or group grouped with another"
+};
+/**
+* The {@link Path} of the root group.
+*
+* @group Defaults
+*/
+const rootPath = [];
+/**
+* Default values for all `boolean`
+* {@link react-querybuilder!QueryBuilder QueryBuilder} options.
+*
+* @group Defaults
+*/
+const queryBuilderFlagDefaults = {
+	addRuleToNewGroups: false,
+	autoSelectField: true,
+	autoSelectOperator: true,
+	autoSelectValue: false,
+	debugMode: false,
+	enableDragAndDrop: false,
+	enableMountQueryChange: true,
+	listsAsArrays: false,
+	preserveQueryStateOnUnmount: false,
+	resetOnFieldChange: true,
+	resetOnOperatorChange: false,
+	showCloneButtons: false,
+	showCombinatorsBetweenRules: false,
+	showLockButtons: false,
+	showMuteButtons: false,
+	showNotToggle: false,
+	showShiftActions: false,
+	showUndoRedo: false,
+	suppressStandardClassnames: false
+};
+/**
+* Default maximum number of undo steps retained by query history.
+*
+* @group Defaults
+*/
+const defaultMaxHistory = 50;
+/**
+* Default time window (in milliseconds) within which consecutive changes to the same
+* property of the same rule are coalesced into a single undo step.
+*
+* @group Defaults
+*/
+const defaultCoalesceMs = 500;
+//#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] : [];
+/**
+* Determines if an array is free of `null`/`undefined`.
+*/
+const nullFreeArray = (arr) => arr.every((el) => el === false || (el ?? false) !== false);
+//#endregion
+//#region src/utils/optGroupUtils.ts
+const isOptionWithName = (opt) => isPojo(opt) && "name" in opt && typeof opt.name === "string";
+const isOptionWithValue = (opt) => isPojo(opt) && "value" in opt && typeof opt.value === "string";
+/**
+* Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})
+* into a {@link FullOption}. Full options are left unchanged.
+*
+* @group Option Lists
+*/
+function toFullOption(opt, baseProperties, labelMap) {
+	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));
+}
+/**
+* Converts a {@link FlexibleOptionList} into a {@link FullOptionList}.
+* Lists of full options are left unchanged.
+*
+* @group Option Lists
+*/
+function toFullOptionMap(optMap, baseProperties) {
+	return Object.fromEntries(Object.entries(optMap).map(([k, v]) => [k, toFullOption(v, baseProperties)]));
+}
+/**
+* @deprecated Renamed to {@link uniqByIdentifier}.
+*
+* @group Option Lists
+*/
+const uniqByName = (originalArray) => uniqByIdentifier(originalArray);
+/**
+* Generates a new array of objects with duplicates removed based
+* on the identifying property (`value` or `name`)
+*
+* @group Option Lists
+*/
+const uniqByIdentifier = (originalArray) => {
+	const names = /* @__PURE__ */ new Set();
+	const newArray = [];
+	for (const el of originalArray) if (!names.has(el.value ?? el.name)) {
+		names.add(el.value ?? el.name);
+		newArray.push(el);
+	}
+	return originalArray.length === newArray.length ? originalArray : newArray;
+};
+/**
+* Determines if an {@link OptionList} is an {@link OptionGroup} array.
+*
+* @group Option Lists
+*/
+const isOptionGroupArray = (arr) => Array.isArray(arr) && arr.length > 0 && isPojo(arr[0]) && "options" in arr[0] && Array.isArray(arr[0].options);
+/**
+* Determines if an array is a flat array of {@link FlexibleOption}.
+*
+* @group Option Lists
+*/
+const isFlexibleOptionArray = (arr) => {
+	let isFOA = false;
+	if (Array.isArray(arr)) for (const o of arr) if (isOptionWithName(o) || isOptionWithValue(o)) isFOA = true;
+	else return false;
+	return isFOA;
+};
+/**
+* Determines if an array is a flat array of {@link FullOption}.
+*
+* @group Option Lists
+*/
+const isFullOptionArray = (arr) => {
+	let isFOA = false;
+	if (Array.isArray(arr)) for (const o of arr) if (isOptionWithName(o) && isOptionWithValue(o)) isFOA = true;
+	else return false;
+	return isFOA;
+};
+/**
+* Determines if a {@link FlexibleOptionList} is a {@link FlexibleOptionGroup} array.
+*
+* @group Option Lists
+*/
+const isFlexibleOptionGroupArray = (arr, { allowEmpty = false } = {}) => {
+	let isFOGA = false;
+	if (Array.isArray(arr)) for (const og of arr) if (isPojo(og) && "options" in og && (isFlexibleOptionArray(og.options) || allowEmpty && Array.isArray(og.options) && og.options.length === 0)) isFOGA = true;
+	else return false;
+	return isFOGA;
+};
+/**
+* Determines if a {@link FlexibleOptionList} is a {@link OptionGroup} array of {@link FullOption}.
+*
+* @group Option Lists
+*/
+const isFullOptionGroupArray = (arr, { allowEmpty = false } = {}) => {
+	let isFOGA = false;
+	if (Array.isArray(arr)) for (const og of arr) if (isPojo(og) && "options" in og && (isFullOptionArray(og.options) || allowEmpty && Array.isArray(og.options) && og.options.length === 0)) isFOGA = true;
+	else return false;
+	return isFOGA;
+};
+function getOption(arr, name) {
+	return (isFlexibleOptionGroupArray(arr, { allowEmpty: true }) ? arr.flatMap((og) => og.options) : arr).find((op) => op.value === name || op.name === name);
+}
+function getFirstOption(arr) {
+	if (!Array.isArray(arr) || arr.length === 0) return null;
+	else if (isFlexibleOptionGroupArray(arr, { allowEmpty: true })) {
+		for (const og of arr) if (og.options.length > 0) return og.options[0].value ?? og.options[0].name;
+		// v8 ignore next
+		return null;
+	}
+	return arr[0].value ?? arr[0].name;
+}
+/**
+* Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.
+* If the array is already flat, it is returned as is.
+*
+* @group Option Lists
+*/
+const toFlatOptionArray = (arr) => uniqByIdentifier(isOptionGroupArray(arr) ? arr.flatMap((og) => og.options) : arr);
+/**
+* Generates a new {@link OptionGroup} array with duplicates
+* removed based on the identifying property (`value` or `name`).
+*
+* @group Option Lists
+*/
+const uniqOptGroups = (originalArray) => {
+	const labels = /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	const newArray = [];
+	for (const el of originalArray) if (!labels.has(el.label)) {
+		labels.add(el.label);
+		const optionsForThisGroup = [];
+		for (const opt of el.options) if (!names.has(opt.value ?? opt.name)) {
+			names.add(opt.value ?? opt.name);
+			optionsForThisGroup.push(toFullOption(opt));
+		}
+		newArray.push({
+			...el,
+			options: optionsForThisGroup
+		});
+	}
+	return newArray;
+};
+/**
+* Generates a new {@link Option} or {@link OptionGroup} array with duplicates
+* removed based on the identifier property (`value` or `name`).
+*
+* @group Option Lists
+*/
+const uniqOptList = (originalArray) => {
+	if (isFlexibleOptionGroupArray(originalArray)) return uniqOptGroups(originalArray);
+	return uniqByIdentifier(originalArray.map((o) => toFullOption(o)));
+};
+/**
+* Normalizes any accepted option list shape—array, option groups, or a record—into a
+* `FullOptionList`, applying `baseOption` properties and (when `autoSelectOption` is `false`)
+* a leading placeholder option. Also returns the flattened lookup map and the option that
+* should be selected by default.
+*
+* Note: `labelMap` overrides only apply to array/option group input (where string options are
+* expanded); record input derives labels from the record values themselves.
+*
+* This is the same normalization `<QueryBuilder />` applies to `fields`, `operators`,
+* `combinators`, and value lists, so a non-React implementation resolves options identically.
+*
+* @group Option Lists
+*/
+const prepareOptionList = (props) => {
+	// v8 ignore next
+	const { optionList: optionListPropOriginal, baseOption = {}, labelMap = {}, placeholder: { placeholderName = "~", 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 ?? 
+	/* v8 ignore start -- @preserve */ opt.name] = toFullOption(opt, baseOption);
+	else for (const opt of optionList) optionsMap[opt.value ?? 
+	/* v8 ignore start -- @preserve */ opt.name] = toFullOption(opt, baseOption);
+	return {
+		defaultOption,
+		optionList,
+		optionsMap
+	};
+};
+//#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 = numericQuantity(val, {
+		allowTrailingInvalid: parseNumbers === "enhanced",
+		bigIntOnOverflow,
+		romanNumerals: false,
+		round: false
+	});
+	return typeof valAsNum === "bigint" || !Number.isNaN(valAsNum) ? valAsNum : val;
+};
+//#endregion
+//#region src/utils/getParseNumberMethod.ts
+const getParseNumberMethod = ({ parseNumbers, inputType }) => {
+	if (typeof parseNumbers === "string") {
+		const [method, level] = parseNumbers.split("-");
+		if (level === "limited") return inputType === "number" ? method : false;
+		return method;
+	}
+	return parseNumbers ? "strict" : false;
+};
+//#endregion
+//#region src/utils/formatQuery/utils.ts
+/**
+* Maps a {@link DefaultOperatorName} to a SQL operator.
+*
+* @group Export
+*/
+const mapSQLOperator = (rqbOperator) => {
+	switch (lc(rqbOperator)) {
+		case "null": return "is null";
+		case "notnull": return "is not null";
+		case "notin": return "not in";
+		case "notbetween": return "not between";
+		case "contains":
+		case "beginswith":
+		case "endswith": return "like";
+		case "doesnotcontain":
+		case "doesnotbeginwith":
+		case "doesnotendwith": return "not like";
+		default: return rqbOperator;
+	}
+};
+/**
+* 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 (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" && numericRegex$1.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 (!isRuleGroup(rule.value)) return false;
+	const matchModeLC = lc(mode);
+	const matchModeCoerced = matchModeLC === "atleast" && threshold === 1 ? "some" : matchModeLC === "atmost" && threshold === 0 ? "none" : matchModeLC;
+	if ((matchModeCoerced === "atleast" || matchModeCoerced === "atmost" || matchModeCoerced === "exactly") && (typeof threshold !== "number" || threshold < 0)) return false;
+	return {
+		mode: matchModeCoerced,
+		threshold
+	};
+};
+/**
+* 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) => isPojo(value) && Object.keys(value).length === 1 && typeof value.$bigint === "string" ? BigInt(value.$bigint) : value;
+//#endregion
+export { defaultCombinators as $, isFlexibleOptionGroupArray as A, uniqByName as B, withParamPrefix as C, queryBuilderFlagDefaults as Ct, getFirstOption as D, substringOperators as Dt, parseNumber as E, standardClassnames as Et, toFlatOptionArray as F, splitBy as G, uniqOptList as H, toFullOption as I, LogType as J, toArray as K, toFullOptionList as L, isFullOptionGroupArray as M, isOptionGroupArray as N, getOption as O, prepareOptionList as P, defaultCombinatorLabelMap as Q, toFullOptionMap as R, subqueryElementAliasBase as S, nullOperators as St, getParseNumberMethod as T, rootPath as Tt, joinWith as U, uniqOptGroups as V, nullFreeArray as W, betweenOperators as X, TestID as Y, defaultCoalesceMs as Z, numerifyValues as _, defaultPlaceholderValueLabel as _t, getLikeWildcards as a, defaultOperatorLabelMap as at, shouldRenderAsNumber as b, groupInvalidReasons as bt, getQuotedFieldName as c, defaultPlaceholderFieldGroupLabel as ct, isValidValue as d, defaultPlaceholderLabel as dt, defaultCombinatorsExtended as et, isValueProcessorLegacy as f, defaultPlaceholderName as ft, normalizeConstituentWordOrder as g, defaultPlaceholderValueGroupLabel as gt, mongoOperators as h, defaultPlaceholderOperatorName as ht, defaultNLTranslations as i, defaultMaxHistory as it, isFullOptionArray as j, isFlexibleOptionArray as k, getSQLConcat as l, defaultPlaceholderFieldLabel as lt, mapSQLOperator as m, defaultPlaceholderOperatorLabel as mt, bigIntJsonStringifyReplacer as n, defaultJoinChar as nt, getNLTranslataion as o, defaultOperatorNegationMap as ot, jsonLogicAdditionalOperators as p, defaultPlaceholderOperatorGroupLabel as pt, trimIfString as q, celCombinatorMap as r, defaultMatchModes as rt, getQuoteFieldNamesWithArray as s, defaultOperators as st, bigIntJsonParseReviver as t, defaultControlClassnames as tt, getSubqueryElementAlias as u, defaultPlaceholderFieldName as ut, prismaOperators as v, defaultPlaceholderValueName as vt, wrapLikeFragment as w, relationalOperators as wt, stripParamPrefix as x, inOperators as xt, processMatchMode as y, defaultTranslations as yt, uniqByIdentifier as z };
+
+//# sourceMappingURL=utils-CP5Jqy1P.mjs.map