@react-querybuilder/core 8.20.2 → 8.21.0

package/dist/styles/_layout.scss

@@ -112,14 +112,10 @@
       top: calc(-1 * var(--#{$rqb-var-prefix}spacing));
       height: calc(50% + var(--#{$rqb-var-prefix}spacing));
       @if $direction == rtl {
-        border-width: 0
-          var(--#{$rqb-var-prefix}branch-width)
-          var(--#{$rqb-var-prefix}branch-width)
+        border-width: 0 var(--#{$rqb-var-prefix}branch-width) var(--#{$rqb-var-prefix}branch-width)
           0;
       } @else {
-        border-width: 0
-          0
-          var(--#{$rqb-var-prefix}branch-width)
+        border-width: 0 0 var(--#{$rqb-var-prefix}branch-width)
           var(--#{$rqb-var-prefix}branch-width);
       }
     }
@@ -145,10 +141,8 @@
     &::after {
       #{$margin-side}: calc(
         -1 *
-          (
-            var(--#{$rqb-var-prefix}branch-indent) + var(--#{$rqb-var-prefix}branch-width) +
-              var(--#{$rqb-var-prefix}border-width)
-          )
+          (var(--#{$rqb-var-prefix}branch-indent) + var(--#{$rqb-var-prefix}branch-width) +
+            var(--#{$rqb-var-prefix}border-width))
       );
     }
 

package/dist/transformQuery.d.mts

@@ -1,116 +1,115 @@
-import { C as RuleGroupTypeIC, D as RuleGroupType, O as RuleType, S as RuleGroupTypeAny } from "./index-DlVg-QXo.mjs";
-
+import { D as RuleGroupTypeIC, E as RuleGroupTypeAny, M as RuleGroupType, N as RuleType } from "./index-BSwFvkeI.mjs";
 //#region src/utils/transformQuery.d.ts
 /**
-* Options object for {@link index!transformQuery transformQuery}.
-*/
+ * Options object for {@link index!transformQuery transformQuery}.
+ */
 interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {
   /**
-  * When a rule is encountered in the hierarchy, it will be replaced
-  * with the result of this function.
-  *
-  * @defaultValue `r => r`
-  */
+   * When a rule is encountered in the hierarchy, it will be replaced
+   * with the result of this function.
+   *
+   * @defaultValue `r => r`
+   */
   ruleProcessor?: (rule: RuleType) => any;
   /**
-  * When a group is encountered in the hierarchy (including the root group, the
-  * query itself), it will be replaced with the result of this function.
-  *
-  * @defaultValue `rg => rg`
-  */
+   * When a group is encountered in the hierarchy (including the root group, the
+   * query itself), it will be replaced with the result of this function.
+   *
+   * @defaultValue `rg => rg`
+   */
   ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;
   /**
-  * For each rule and group in the query, any properties matching a key
-  * in this object will be renamed to the corresponding value. To retain both
-  * the new _and_ the original properties, set `deleteRemappedProperties`
-  * to `false`.
-  *
-  * If a key has a value of `false`, the corresponding property will be removed
-  * without being copied to a new property name. (Warning: `{ rules: false }`
-  * will prevent recursion and only return the processed root group.)
-  *
-  * @defaultValue `{}`
-  *
-  * @example
-  * ```
-  *   transformQuery(
-  *     { combinator: 'and', not: true, rules: [] },
-  *     { propertyMap: { combinator: 'AndOr', not: false } }
-  *   )
-  *   // Returns: { AndOr: 'and', rules: [] }
-  * ```
-  */
+   * For each rule and group in the query, any properties matching a key
+   * in this object will be renamed to the corresponding value. To retain both
+   * the new _and_ the original properties, set `deleteRemappedProperties`
+   * to `false`.
+   *
+   * If a key has a value of `false`, the corresponding property will be removed
+   * without being copied to a new property name. (Warning: `{ rules: false }`
+   * will prevent recursion and only return the processed root group.)
+   *
+   * @defaultValue `{}`
+   *
+   * @example
+   * ```
+   *   transformQuery(
+   *     { combinator: 'and', not: true, rules: [] },
+   *     { propertyMap: { combinator: 'AndOr', not: false } }
+   *   )
+   *   // Returns: { AndOr: 'and', rules: [] }
+   * ```
+   */
   propertyMap?: Record<string, string | false>;
   /**
-  * Any combinator values (including independent combinators) will be translated
-  * from the key in this object to the value.
-  *
-  * @defaultValue `{}`
-  *
-  * @example
-  * ```
-  *   transformQuery(
-  *     { combinator: 'and', rules: [] },
-  *     { combinatorMap: { and: '&&', or: '||' } }
-  *   )
-  *   // Returns: { combinator: '&&', rules: [] }
-  * ```
-  */
+   * Any combinator values (including independent combinators) will be translated
+   * from the key in this object to the value.
+   *
+   * @defaultValue `{}`
+   *
+   * @example
+   * ```
+   *   transformQuery(
+   *     { combinator: 'and', rules: [] },
+   *     { combinatorMap: { and: '&&', or: '||' } }
+   *   )
+   *   // Returns: { combinator: '&&', rules: [] }
+   * ```
+   */
   combinatorMap?: Record<string, string>;
   /**
-  * Any operator values will be translated from the key in this object to the value.
-  *
-  * @defaultValue `{}`
-  *
-  * @example
-  * ```
-  *   transformQuery(
-  *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },
-  *     { operatorMap: { '=': 'is' } }
-  *   )
-  *   // Returns:
-  *   // {
-  *   //   combinator: 'and',
-  *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]
-  *   // }
-  * ```
-  */
+   * Any operator values will be translated from the key in this object to the value.
+   *
+   * @defaultValue `{}`
+   *
+   * @example
+   * ```
+   *   transformQuery(
+   *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },
+   *     { operatorMap: { '=': 'is' } }
+   *   )
+   *   // Returns:
+   *   // {
+   *   //   combinator: 'and',
+   *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]
+   *   // }
+   * ```
+   */
   operatorMap?: Record<string, string>;
   /**
-  * Prevents the `path` property (see {@link index!Path Path}) from being added to each
-  * rule and group in the hierarchy.
-  *
-  * @defaultValue `false`
-  */
+   * Prevents the `path` property (see {@link index!Path Path}) from being added to each
+   * rule and group in the hierarchy.
+   *
+   * @defaultValue `false`
+   */
   omitPath?: boolean;
   /**
-  * Original properties remapped according to the `propertyMap` option will be removed.
-  *
-  * @defaultValue `true`
-  *
-  * @example
-  * ```
-  *   transformQuery(
-  *     { combinator: 'and', rules: [] },
-  *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }
-  *   )
-  *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }
-  * ```
-  */
+   * Original properties remapped according to the `propertyMap` option will be removed.
+   *
+   * @defaultValue `true`
+   *
+   * @example
+   * ```
+   *   transformQuery(
+   *     { combinator: 'and', rules: [] },
+   *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }
+   *   )
+   *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }
+   * ```
+   */
   deleteRemappedProperties?: boolean;
 }
 /**
-* Recursively process a query heirarchy using this versatile utility function.
-*
-* [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)
-*/
+ * Recursively process a query heirarchy using this versatile utility function.
+ *
+ * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)
+ */
 declare function transformQuery(query: RuleGroupType, options?: TransformQueryOptions): any;
 /**
-* Recursively process a query heirarchy with independent combinators using this
-* versatile utility function.
-*
-* [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)
-*/
+ * Recursively process a query heirarchy with independent combinators using this
+ * versatile utility function.
+ *
+ * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)
+ */
 declare function transformQuery(query: RuleGroupTypeIC, options?: TransformQueryOptions<RuleGroupTypeIC>): any;
 //#endregion
 export { TransformQueryOptions, transformQuery };

package/dist/transformQuery.d.ts

@@ -1,116 +1,115 @@
-import { C as RuleGroupTypeIC, D as RuleGroupType, O as RuleType, S as RuleGroupTypeAny } from "./index-DlVg-QXo.js";
-
+import { D as RuleGroupTypeIC, E as RuleGroupTypeAny, M as RuleGroupType, N as RuleType } from "./index-BSwFvkeI.js";
 //#region src/utils/transformQuery.d.ts
 /**
-* Options object for {@link index!transformQuery transformQuery}.
-*/
+ * Options object for {@link index!transformQuery transformQuery}.
+ */
 interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {
   /**
-  * When a rule is encountered in the hierarchy, it will be replaced
-  * with the result of this function.
-  *
-  * @defaultValue `r => r`
-  */
+   * When a rule is encountered in the hierarchy, it will be replaced
+   * with the result of this function.
+   *
+   * @defaultValue `r => r`
+   */
   ruleProcessor?: (rule: RuleType) => any;
   /**
-  * When a group is encountered in the hierarchy (including the root group, the
-  * query itself), it will be replaced with the result of this function.
-  *
-  * @defaultValue `rg => rg`
-  */
+   * When a group is encountered in the hierarchy (including the root group, the
+   * query itself), it will be replaced with the result of this function.
+   *
+   * @defaultValue `rg => rg`
+   */
   ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;
   /**
-  * For each rule and group in the query, any properties matching a key
-  * in this object will be renamed to the corresponding value. To retain both
-  * the new _and_ the original properties, set `deleteRemappedProperties`
-  * to `false`.
-  *
-  * If a key has a value of `false`, the corresponding property will be removed
-  * without being copied to a new property name. (Warning: `{ rules: false }`
-  * will prevent recursion and only return the processed root group.)
-  *
-  * @defaultValue `{}`
-  *
-  * @example
-  * ```
-  *   transformQuery(
-  *     { combinator: 'and', not: true, rules: [] },
-  *     { propertyMap: { combinator: 'AndOr', not: false } }
-  *   )
-  *   // Returns: { AndOr: 'and', rules: [] }
-  * ```
-  */
+   * For each rule and group in the query, any properties matching a key
+   * in this object will be renamed to the corresponding value. To retain both
+   * the new _and_ the original properties, set `deleteRemappedProperties`
+   * to `false`.
+   *
+   * If a key has a value of `false`, the corresponding property will be removed
+   * without being copied to a new property name. (Warning: `{ rules: false }`
+   * will prevent recursion and only return the processed root group.)
+   *
+   * @defaultValue `{}`
+   *
+   * @example
+   * ```
+   *   transformQuery(
+   *     { combinator: 'and', not: true, rules: [] },
+   *     { propertyMap: { combinator: 'AndOr', not: false } }
+   *   )
+   *   // Returns: { AndOr: 'and', rules: [] }
+   * ```
+   */
   propertyMap?: Record<string, string | false>;
   /**
-  * Any combinator values (including independent combinators) will be translated
-  * from the key in this object to the value.
-  *
-  * @defaultValue `{}`
-  *
-  * @example
-  * ```
-  *   transformQuery(
-  *     { combinator: 'and', rules: [] },
-  *     { combinatorMap: { and: '&&', or: '||' } }
-  *   )
-  *   // Returns: { combinator: '&&', rules: [] }
-  * ```
-  */
+   * Any combinator values (including independent combinators) will be translated
+   * from the key in this object to the value.
+   *
+   * @defaultValue `{}`
+   *
+   * @example
+   * ```
+   *   transformQuery(
+   *     { combinator: 'and', rules: [] },
+   *     { combinatorMap: { and: '&&', or: '||' } }
+   *   )
+   *   // Returns: { combinator: '&&', rules: [] }
+   * ```
+   */
   combinatorMap?: Record<string, string>;
   /**
-  * Any operator values will be translated from the key in this object to the value.
-  *
-  * @defaultValue `{}`
-  *
-  * @example
-  * ```
-  *   transformQuery(
-  *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },
-  *     { operatorMap: { '=': 'is' } }
-  *   )
-  *   // Returns:
-  *   // {
-  *   //   combinator: 'and',
-  *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]
-  *   // }
-  * ```
-  */
+   * Any operator values will be translated from the key in this object to the value.
+   *
+   * @defaultValue `{}`
+   *
+   * @example
+   * ```
+   *   transformQuery(
+   *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },
+   *     { operatorMap: { '=': 'is' } }
+   *   )
+   *   // Returns:
+   *   // {
+   *   //   combinator: 'and',
+   *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]
+   *   // }
+   * ```
+   */
   operatorMap?: Record<string, string>;
   /**
-  * Prevents the `path` property (see {@link index!Path Path}) from being added to each
-  * rule and group in the hierarchy.
-  *
-  * @defaultValue `false`
-  */
+   * Prevents the `path` property (see {@link index!Path Path}) from being added to each
+   * rule and group in the hierarchy.
+   *
+   * @defaultValue `false`
+   */
   omitPath?: boolean;
   /**
-  * Original properties remapped according to the `propertyMap` option will be removed.
-  *
-  * @defaultValue `true`
-  *
-  * @example
-  * ```
-  *   transformQuery(
-  *     { combinator: 'and', rules: [] },
-  *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }
-  *   )
-  *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }
-  * ```
-  */
+   * Original properties remapped according to the `propertyMap` option will be removed.
+   *
+   * @defaultValue `true`
+   *
+   * @example
+   * ```
+   *   transformQuery(
+   *     { combinator: 'and', rules: [] },
+   *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }
+   *   )
+   *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }
+   * ```
+   */
   deleteRemappedProperties?: boolean;
 }
 /**
-* Recursively process a query heirarchy using this versatile utility function.
-*
-* [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)
-*/
+ * Recursively process a query heirarchy using this versatile utility function.
+ *
+ * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)
+ */
 declare function transformQuery(query: RuleGroupType, options?: TransformQueryOptions): any;
 /**
-* Recursively process a query heirarchy with independent combinators using this
-* versatile utility function.
-*
-* [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)
-*/
+ * Recursively process a query heirarchy with independent combinators using this
+ * versatile utility function.
+ *
+ * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)
+ */
 declare function transformQuery(query: RuleGroupTypeIC, options?: TransformQueryOptions<RuleGroupTypeIC>): any;
 //#endregion
 export { TransformQueryOptions, transformQuery };

package/dist/transformQuery.js

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_objectUtils = require("./objectUtils-DBJI82bl.js");
+const require_isRuleGroup = require("./isRuleGroup-0JNiQgLg.js");
+const require_objectUtils = require("./objectUtils-Cr02aGxb.js");
 //#region src/utils/transformQuery.ts
 const remapProperties = (obj, propertyMap, deleteRemappedProperties) => {
 	const result = {};
@@ -19,12 +20,12 @@ function transformQuery(query, options = {}) {
 	const processGroup = (rg) => ({
 		...ruleGroupProcessor(remapProperties({
 			...rg,
-			...require_objectUtils.isRuleGroupType(rg) ? { combinator: combinatorMap[rg.combinator] ?? rg.combinator } : {}
+			...require_isRuleGroup.isRuleGroupType(rg) ? { combinator: combinatorMap[rg.combinator] ?? rg.combinator } : {}
 		}, propertyMap, deleteRemappedProperties)),
 		...propertyMap["rules"] === false ? null : { [propertyMap["rules"] ?? "rules"]: rg.rules.map((r, idx) => {
 			const pathObject = omitPath ? null : { path: [...rg.path, idx] };
 			if (typeof r === "string") return combinatorMap[r] ?? r;
-			else if (require_objectUtils.isRuleGroup(r)) return processGroup({
+			else if (require_isRuleGroup.isRuleGroup(r)) return processGroup({
 				...r,
 				...pathObject
 			});

package/dist/transformQuery.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformQuery.js","names":["isUnsafeKey","isRuleGroupType","isRuleGroup"],"sources":["../src/utils/transformQuery.ts"],"sourcesContent":["/**\n * Recursively steps through a query object ({@link index!RuleGroupType RuleGroupType} or {@link index!RuleGroupTypeIC RuleGroupTypeIC}),\n * passing each {@link index!RuleType RuleType} object to a provided `ruleProcessor` function and returning a\n * new query object if there were any referential changes.\n *\n * @module transformQuery\n */\n\nimport type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isRuleGroup, isRuleGroupType } from './isRuleGroup';\nimport { isUnsafeKey } from './objectUtils';\n\nconst remapProperties = (\n  obj: Record<string, unknown>,\n  propertyMap: Record<string, string | false>,\n  deleteRemappedProperties: boolean\n): Record<string, unknown> => {\n  const result: Record<string, unknown> = {};\n\n  for (const key in obj) {\n    if (isUnsafeKey(key)) continue;\n    const mappedKey = propertyMap[key];\n    if (mappedKey === false) {\n      continue;\n    }\n    if (mappedKey && key !== mappedKey) {\n      if (!isUnsafeKey(mappedKey)) {\n        result[mappedKey] = obj[key];\n      }\n      if (!deleteRemappedProperties) {\n        result[key] = obj[key];\n      }\n    } else {\n      result[key] = obj[key];\n    }\n  }\n\n  return result;\n};\n\n/**\n * Options object for {@link index!transformQuery transformQuery}.\n */\nexport interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {\n  /**\n   * When a rule is encountered in the hierarchy, it will be replaced\n   * with the result of this function.\n   *\n   * @defaultValue `r => r`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleProcessor?: (rule: RuleType) => any;\n  /**\n   * When a group is encountered in the hierarchy (including the root group, the\n   * query itself), it will be replaced with the result of this function.\n   *\n   * @defaultValue `rg => rg`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;\n  /**\n   * For each rule and group in the query, any properties matching a key\n   * in this object will be renamed to the corresponding value. To retain both\n   * the new _and_ the original properties, set `deleteRemappedProperties`\n   * to `false`.\n   *\n   * If a key has a value of `false`, the corresponding property will be removed\n   * without being copied to a new property name. (Warning: `{ rules: false }`\n   * will prevent recursion and only return the processed root group.)\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', not: true, rules: [] },\n   *     { propertyMap: { combinator: 'AndOr', not: false } }\n   *   )\n   *   // Returns: { AndOr: 'and', rules: [] }\n   * ```\n   */\n  propertyMap?: Record<string, string | false>;\n  /**\n   * Any combinator values (including independent combinators) will be translated\n   * from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { combinatorMap: { and: '&&', or: '||' } }\n   *   )\n   *   // Returns: { combinator: '&&', rules: [] }\n   * ```\n   */\n  combinatorMap?: Record<string, string>;\n  /**\n   * Any operator values will be translated from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },\n   *     { operatorMap: { '=': 'is' } }\n   *   )\n   *   // Returns:\n   *   // {\n   *   //   combinator: 'and',\n   *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]\n   *   // }\n   * ```\n   */\n  operatorMap?: Record<string, string>;\n  /**\n   * Prevents the `path` property (see {@link index!Path Path}) from being added to each\n   * rule and group in the hierarchy.\n   *\n   * @defaultValue `false`\n   */\n  omitPath?: boolean;\n  /**\n   * Original properties remapped according to the `propertyMap` option will be removed.\n   *\n   * @defaultValue `true`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }\n   *   )\n   *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }\n   * ```\n   */\n  deleteRemappedProperties?: boolean;\n}\n\n/**\n * Recursively process a query heirarchy using this versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupType,\n  options?: TransformQueryOptions\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\n/**\n * Recursively process a query heirarchy with independent combinators using this\n * versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupTypeIC,\n  options?: TransformQueryOptions<RuleGroupTypeIC>\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\nexport function transformQuery<RG extends RuleGroupTypeAny>(\n  query: RG,\n  options: TransformQueryOptions<RG> = {}\n) {\n  const {\n    ruleProcessor = r => r,\n    ruleGroupProcessor = rg => rg,\n    propertyMap = {},\n    combinatorMap = {},\n    operatorMap = {},\n    omitPath = false,\n    deleteRemappedProperties = true,\n  } = options;\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  const processGroup = (rg: RuleGroupTypeAny): any => ({\n    ...ruleGroupProcessor(\n      remapProperties(\n        {\n          ...rg,\n          ...(isRuleGroupType(rg)\n            ? { combinator: combinatorMap[rg.combinator] ?? rg.combinator }\n            : {}),\n        },\n        propertyMap,\n        deleteRemappedProperties\n      ) as RG\n    ),\n    ...(propertyMap['rules'] === false\n      ? null\n      : {\n          // oxlint-disable-next-line typescript/no-explicit-any\n          [propertyMap['rules'] ?? 'rules']: rg.rules.map((r: any, idx) => {\n            const pathObject = omitPath ? null : { path: [...rg.path!, idx] };\n            if (typeof r === 'string') {\n              // independent combinators\n              return combinatorMap[r] ?? r;\n            } else if (isRuleGroup(r)) {\n              // sub-groups\n              return processGroup({ ...r, ...pathObject });\n            }\n            // rules\n            return ruleProcessor(\n              remapProperties(\n                {\n                  ...r,\n                  ...pathObject,\n                  ...('operator' in r ? { operator: operatorMap[r.operator] ?? r.operator } : {}),\n                },\n                propertyMap,\n                deleteRemappedProperties\n              ) as unknown as RuleType\n            );\n          }),\n        }),\n  });\n\n  return processGroup({ ...query, ...(omitPath ? null : { path: [] }) });\n}\n"],"mappings":";;;AAYA,MAAM,mBACJ,KACA,aACA,6BAC4B;CAC5B,MAAM,SAAkC,CAAC;CAEzC,KAAK,MAAM,OAAO,KAAK;EACrB,IAAIA,oBAAAA,YAAY,GAAG,GAAG;EACtB,MAAM,YAAY,YAAY;EAC9B,IAAI,cAAc,OAChB;EAEF,IAAI,aAAa,QAAQ,WAAW;GAClC,IAAI,CAACA,oBAAAA,YAAY,SAAS,GACxB,OAAO,aAAa,IAAI;GAE1B,IAAI,CAAC,0BACH,OAAO,OAAO,IAAI;EAEtB,OACE,OAAO,OAAO,IAAI;CAEtB;CAEA,OAAO;AACT;AA4HA,SAAgB,eACd,OACA,UAAqC,CAAC,GACtC;CACA,MAAM,EACJ,iBAAgB,MAAK,GACrB,sBAAqB,OAAM,IAC3B,cAAc,CAAC,GACf,gBAAgB,CAAC,GACjB,cAAc,CAAC,GACf,WAAW,OACX,2BAA2B,SACzB;CAGJ,MAAM,gBAAgB,QAA+B;EACnD,GAAG,mBACD,gBACE;GACE,GAAG;GACH,GAAIC,oBAAAA,gBAAgB,EAAE,IAClB,EAAE,YAAY,cAAc,GAAG,eAAe,GAAG,WAAW,IAC5D,CAAC;EACP,GACA,aACA,wBACF,CACF;EACA,GAAI,YAAY,aAAa,QACzB,OACA,GAEG,YAAY,YAAY,UAAU,GAAG,MAAM,KAAK,GAAQ,QAAQ;GAC/D,MAAM,aAAa,WAAW,OAAO,EAAE,MAAM,CAAC,GAAG,GAAG,MAAO,GAAG,EAAE;GAChE,IAAI,OAAO,MAAM,UAEf,OAAO,cAAc,MAAM;QACtB,IAAIC,oBAAAA,YAAY,CAAC,GAEtB,OAAO,aAAa;IAAE,GAAG;IAAG,GAAG;GAAW,CAAC;GAG7C,OAAO,cACL,gBACE;IACE,GAAG;IACH,GAAG;IACH,GAAI,cAAc,IAAI,EAAE,UAAU,YAAY,EAAE,aAAa,EAAE,SAAS,IAAI,CAAC;GAC/E,GACA,aACA,wBACF,CACF;EACF,CAAC,EACH;CACN;CAEA,OAAO,aAAa;EAAE,GAAG;EAAO,GAAI,WAAW,OAAO,EAAE,MAAM,CAAC,EAAE;CAAG,CAAC;AACvE"}
+{"version":3,"file":"transformQuery.js","names":["isUnsafeKey","isRuleGroupType","isRuleGroup"],"sources":["../src/utils/transformQuery.ts"],"sourcesContent":["/**\n * Recursively steps through a query object ({@link index!RuleGroupType RuleGroupType} or {@link index!RuleGroupTypeIC RuleGroupTypeIC}),\n * passing each {@link index!RuleType RuleType} object to a provided `ruleProcessor` function and returning a\n * new query object if there were any referential changes.\n *\n * @module transformQuery\n */\n\nimport type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isRuleGroup, isRuleGroupType } from './isRuleGroup';\nimport { isUnsafeKey } from './objectUtils';\n\nconst remapProperties = (\n  obj: Record<string, unknown>,\n  propertyMap: Record<string, string | false>,\n  deleteRemappedProperties: boolean\n): Record<string, unknown> => {\n  const result: Record<string, unknown> = {};\n\n  for (const key in obj) {\n    if (isUnsafeKey(key)) continue;\n    const mappedKey = propertyMap[key];\n    if (mappedKey === false) {\n      continue;\n    }\n    if (mappedKey && key !== mappedKey) {\n      if (!isUnsafeKey(mappedKey)) {\n        result[mappedKey] = obj[key];\n      }\n      if (!deleteRemappedProperties) {\n        result[key] = obj[key];\n      }\n    } else {\n      result[key] = obj[key];\n    }\n  }\n\n  return result;\n};\n\n/**\n * Options object for {@link index!transformQuery transformQuery}.\n */\nexport interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {\n  /**\n   * When a rule is encountered in the hierarchy, it will be replaced\n   * with the result of this function.\n   *\n   * @defaultValue `r => r`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleProcessor?: (rule: RuleType) => any;\n  /**\n   * When a group is encountered in the hierarchy (including the root group, the\n   * query itself), it will be replaced with the result of this function.\n   *\n   * @defaultValue `rg => rg`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;\n  /**\n   * For each rule and group in the query, any properties matching a key\n   * in this object will be renamed to the corresponding value. To retain both\n   * the new _and_ the original properties, set `deleteRemappedProperties`\n   * to `false`.\n   *\n   * If a key has a value of `false`, the corresponding property will be removed\n   * without being copied to a new property name. (Warning: `{ rules: false }`\n   * will prevent recursion and only return the processed root group.)\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', not: true, rules: [] },\n   *     { propertyMap: { combinator: 'AndOr', not: false } }\n   *   )\n   *   // Returns: { AndOr: 'and', rules: [] }\n   * ```\n   */\n  propertyMap?: Record<string, string | false>;\n  /**\n   * Any combinator values (including independent combinators) will be translated\n   * from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { combinatorMap: { and: '&&', or: '||' } }\n   *   )\n   *   // Returns: { combinator: '&&', rules: [] }\n   * ```\n   */\n  combinatorMap?: Record<string, string>;\n  /**\n   * Any operator values will be translated from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },\n   *     { operatorMap: { '=': 'is' } }\n   *   )\n   *   // Returns:\n   *   // {\n   *   //   combinator: 'and',\n   *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]\n   *   // }\n   * ```\n   */\n  operatorMap?: Record<string, string>;\n  /**\n   * Prevents the `path` property (see {@link index!Path Path}) from being added to each\n   * rule and group in the hierarchy.\n   *\n   * @defaultValue `false`\n   */\n  omitPath?: boolean;\n  /**\n   * Original properties remapped according to the `propertyMap` option will be removed.\n   *\n   * @defaultValue `true`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }\n   *   )\n   *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }\n   * ```\n   */\n  deleteRemappedProperties?: boolean;\n}\n\n/**\n * Recursively process a query heirarchy using this versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupType,\n  options?: TransformQueryOptions\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\n/**\n * Recursively process a query heirarchy with independent combinators using this\n * versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupTypeIC,\n  options?: TransformQueryOptions<RuleGroupTypeIC>\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\nexport function transformQuery<RG extends RuleGroupTypeAny>(\n  query: RG,\n  options: TransformQueryOptions<RG> = {}\n) {\n  const {\n    ruleProcessor = r => r,\n    ruleGroupProcessor = rg => rg,\n    propertyMap = {},\n    combinatorMap = {},\n    operatorMap = {},\n    omitPath = false,\n    deleteRemappedProperties = true,\n  } = options;\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  const processGroup = (rg: RuleGroupTypeAny): any => ({\n    ...ruleGroupProcessor(\n      remapProperties(\n        {\n          ...rg,\n          ...(isRuleGroupType(rg)\n            ? { combinator: combinatorMap[rg.combinator] ?? rg.combinator }\n            : {}),\n        },\n        propertyMap,\n        deleteRemappedProperties\n      ) as RG\n    ),\n    ...(propertyMap['rules'] === false\n      ? null\n      : {\n          // oxlint-disable-next-line typescript/no-explicit-any\n          [propertyMap['rules'] ?? 'rules']: rg.rules.map((r: any, idx) => {\n            const pathObject = omitPath ? null : { path: [...rg.path!, idx] };\n            if (typeof r === 'string') {\n              // independent combinators\n              return combinatorMap[r] ?? r;\n            } else if (isRuleGroup(r)) {\n              // sub-groups\n              return processGroup({ ...r, ...pathObject });\n            }\n            // rules\n            return ruleProcessor(\n              remapProperties(\n                {\n                  ...r,\n                  ...pathObject,\n                  ...('operator' in r ? { operator: operatorMap[r.operator] ?? r.operator } : {}),\n                },\n                propertyMap,\n                deleteRemappedProperties\n              ) as unknown as RuleType\n            );\n          }),\n        }),\n  });\n\n  return processGroup({ ...query, ...(omitPath ? null : { path: [] }) });\n}\n"],"mappings":";;;;AAYA,MAAM,mBACJ,KACA,aACA,6BAC4B;CAC5B,MAAM,SAAkC,CAAC;CAEzC,KAAK,MAAM,OAAO,KAAK;EACrB,IAAIA,oBAAAA,YAAY,GAAG,GAAG;EACtB,MAAM,YAAY,YAAY;EAC9B,IAAI,cAAc,OAChB;EAEF,IAAI,aAAa,QAAQ,WAAW;GAClC,IAAI,CAACA,oBAAAA,YAAY,SAAS,GACxB,OAAO,aAAa,IAAI;GAE1B,IAAI,CAAC,0BACH,OAAO,OAAO,IAAI;EAEtB,OACE,OAAO,OAAO,IAAI;CAEtB;CAEA,OAAO;AACT;AA4HA,SAAgB,eACd,OACA,UAAqC,CAAC,GACtC;CACA,MAAM,EACJ,iBAAgB,MAAK,GACrB,sBAAqB,OAAM,IAC3B,cAAc,CAAC,GACf,gBAAgB,CAAC,GACjB,cAAc,CAAC,GACf,WAAW,OACX,2BAA2B,SACzB;CAGJ,MAAM,gBAAgB,QAA+B;EACnD,GAAG,mBACD,gBACE;GACE,GAAG;GACH,GAAIC,oBAAAA,gBAAgB,EAAE,IAClB,EAAE,YAAY,cAAc,GAAG,eAAe,GAAG,WAAW,IAC5D,CAAC;EACP,GACA,aACA,wBACF,CACF;EACA,GAAI,YAAY,aAAa,QACzB,OACA,GAEG,YAAY,YAAY,UAAU,GAAG,MAAM,KAAK,GAAQ,QAAQ;GAC/D,MAAM,aAAa,WAAW,OAAO,EAAE,MAAM,CAAC,GAAG,GAAG,MAAO,GAAG,EAAE;GAChE,IAAI,OAAO,MAAM,UAEf,OAAO,cAAc,MAAM;QACtB,IAAIC,oBAAAA,YAAY,CAAC,GAEtB,OAAO,aAAa;IAAE,GAAG;IAAG,GAAG;GAAW,CAAC;GAG7C,OAAO,cACL,gBACE;IACE,GAAG;IACH,GAAG;IACH,GAAI,cAAc,IAAI,EAAE,UAAU,YAAY,EAAE,aAAa,EAAE,SAAS,IAAI,CAAC;GAC/E,GACA,aACA,wBACF,CACF;EACF,CAAC,EACH;CACN;CAEA,OAAO,aAAa;EAAE,GAAG;EAAO,GAAI,WAAW,OAAO,EAAE,MAAM,CAAC,EAAE;CAAG,CAAC;AACvE"}

package/dist/transformQuery.mjs

@@ -1,4 +1,5 @@
-import { i as isRuleGroupType, r as isRuleGroup, t as isUnsafeKey } from "./objectUtils-ZvPkF6u6.mjs";
+import { n as isRuleGroupType, t as isRuleGroup } from "./isRuleGroup-CqLThsbu.mjs";
+import { t as isUnsafeKey } from "./objectUtils-DBlmJgBf.mjs";
 //#region src/utils/transformQuery.ts
 const remapProperties = (obj, propertyMap, deleteRemappedProperties) => {
 	const result = {};

package/dist/transformQuery.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"transformQuery.mjs","names":[],"sources":["../src/utils/transformQuery.ts"],"sourcesContent":["/**\n * Recursively steps through a query object ({@link index!RuleGroupType RuleGroupType} or {@link index!RuleGroupTypeIC RuleGroupTypeIC}),\n * passing each {@link index!RuleType RuleType} object to a provided `ruleProcessor` function and returning a\n * new query object if there were any referential changes.\n *\n * @module transformQuery\n */\n\nimport type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isRuleGroup, isRuleGroupType } from './isRuleGroup';\nimport { isUnsafeKey } from './objectUtils';\n\nconst remapProperties = (\n  obj: Record<string, unknown>,\n  propertyMap: Record<string, string | false>,\n  deleteRemappedProperties: boolean\n): Record<string, unknown> => {\n  const result: Record<string, unknown> = {};\n\n  for (const key in obj) {\n    if (isUnsafeKey(key)) continue;\n    const mappedKey = propertyMap[key];\n    if (mappedKey === false) {\n      continue;\n    }\n    if (mappedKey && key !== mappedKey) {\n      if (!isUnsafeKey(mappedKey)) {\n        result[mappedKey] = obj[key];\n      }\n      if (!deleteRemappedProperties) {\n        result[key] = obj[key];\n      }\n    } else {\n      result[key] = obj[key];\n    }\n  }\n\n  return result;\n};\n\n/**\n * Options object for {@link index!transformQuery transformQuery}.\n */\nexport interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {\n  /**\n   * When a rule is encountered in the hierarchy, it will be replaced\n   * with the result of this function.\n   *\n   * @defaultValue `r => r`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleProcessor?: (rule: RuleType) => any;\n  /**\n   * When a group is encountered in the hierarchy (including the root group, the\n   * query itself), it will be replaced with the result of this function.\n   *\n   * @defaultValue `rg => rg`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;\n  /**\n   * For each rule and group in the query, any properties matching a key\n   * in this object will be renamed to the corresponding value. To retain both\n   * the new _and_ the original properties, set `deleteRemappedProperties`\n   * to `false`.\n   *\n   * If a key has a value of `false`, the corresponding property will be removed\n   * without being copied to a new property name. (Warning: `{ rules: false }`\n   * will prevent recursion and only return the processed root group.)\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', not: true, rules: [] },\n   *     { propertyMap: { combinator: 'AndOr', not: false } }\n   *   )\n   *   // Returns: { AndOr: 'and', rules: [] }\n   * ```\n   */\n  propertyMap?: Record<string, string | false>;\n  /**\n   * Any combinator values (including independent combinators) will be translated\n   * from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { combinatorMap: { and: '&&', or: '||' } }\n   *   )\n   *   // Returns: { combinator: '&&', rules: [] }\n   * ```\n   */\n  combinatorMap?: Record<string, string>;\n  /**\n   * Any operator values will be translated from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },\n   *     { operatorMap: { '=': 'is' } }\n   *   )\n   *   // Returns:\n   *   // {\n   *   //   combinator: 'and',\n   *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]\n   *   // }\n   * ```\n   */\n  operatorMap?: Record<string, string>;\n  /**\n   * Prevents the `path` property (see {@link index!Path Path}) from being added to each\n   * rule and group in the hierarchy.\n   *\n   * @defaultValue `false`\n   */\n  omitPath?: boolean;\n  /**\n   * Original properties remapped according to the `propertyMap` option will be removed.\n   *\n   * @defaultValue `true`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }\n   *   )\n   *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }\n   * ```\n   */\n  deleteRemappedProperties?: boolean;\n}\n\n/**\n * Recursively process a query heirarchy using this versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupType,\n  options?: TransformQueryOptions\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\n/**\n * Recursively process a query heirarchy with independent combinators using this\n * versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupTypeIC,\n  options?: TransformQueryOptions<RuleGroupTypeIC>\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\nexport function transformQuery<RG extends RuleGroupTypeAny>(\n  query: RG,\n  options: TransformQueryOptions<RG> = {}\n) {\n  const {\n    ruleProcessor = r => r,\n    ruleGroupProcessor = rg => rg,\n    propertyMap = {},\n    combinatorMap = {},\n    operatorMap = {},\n    omitPath = false,\n    deleteRemappedProperties = true,\n  } = options;\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  const processGroup = (rg: RuleGroupTypeAny): any => ({\n    ...ruleGroupProcessor(\n      remapProperties(\n        {\n          ...rg,\n          ...(isRuleGroupType(rg)\n            ? { combinator: combinatorMap[rg.combinator] ?? rg.combinator }\n            : {}),\n        },\n        propertyMap,\n        deleteRemappedProperties\n      ) as RG\n    ),\n    ...(propertyMap['rules'] === false\n      ? null\n      : {\n          // oxlint-disable-next-line typescript/no-explicit-any\n          [propertyMap['rules'] ?? 'rules']: rg.rules.map((r: any, idx) => {\n            const pathObject = omitPath ? null : { path: [...rg.path!, idx] };\n            if (typeof r === 'string') {\n              // independent combinators\n              return combinatorMap[r] ?? r;\n            } else if (isRuleGroup(r)) {\n              // sub-groups\n              return processGroup({ ...r, ...pathObject });\n            }\n            // rules\n            return ruleProcessor(\n              remapProperties(\n                {\n                  ...r,\n                  ...pathObject,\n                  ...('operator' in r ? { operator: operatorMap[r.operator] ?? r.operator } : {}),\n                },\n                propertyMap,\n                deleteRemappedProperties\n              ) as unknown as RuleType\n            );\n          }),\n        }),\n  });\n\n  return processGroup({ ...query, ...(omitPath ? null : { path: [] }) });\n}\n"],"mappings":";;AAYA,MAAM,mBACJ,KACA,aACA,6BAC4B;CAC5B,MAAM,SAAkC,CAAC;CAEzC,KAAK,MAAM,OAAO,KAAK;EACrB,IAAI,YAAY,GAAG,GAAG;EACtB,MAAM,YAAY,YAAY;EAC9B,IAAI,cAAc,OAChB;EAEF,IAAI,aAAa,QAAQ,WAAW;GAClC,IAAI,CAAC,YAAY,SAAS,GACxB,OAAO,aAAa,IAAI;GAE1B,IAAI,CAAC,0BACH,OAAO,OAAO,IAAI;EAEtB,OACE,OAAO,OAAO,IAAI;CAEtB;CAEA,OAAO;AACT;AA4HA,SAAgB,eACd,OACA,UAAqC,CAAC,GACtC;CACA,MAAM,EACJ,iBAAgB,MAAK,GACrB,sBAAqB,OAAM,IAC3B,cAAc,CAAC,GACf,gBAAgB,CAAC,GACjB,cAAc,CAAC,GACf,WAAW,OACX,2BAA2B,SACzB;CAGJ,MAAM,gBAAgB,QAA+B;EACnD,GAAG,mBACD,gBACE;GACE,GAAG;GACH,GAAI,gBAAgB,EAAE,IAClB,EAAE,YAAY,cAAc,GAAG,eAAe,GAAG,WAAW,IAC5D,CAAC;EACP,GACA,aACA,wBACF,CACF;EACA,GAAI,YAAY,aAAa,QACzB,OACA,GAEG,YAAY,YAAY,UAAU,GAAG,MAAM,KAAK,GAAQ,QAAQ;GAC/D,MAAM,aAAa,WAAW,OAAO,EAAE,MAAM,CAAC,GAAG,GAAG,MAAO,GAAG,EAAE;GAChE,IAAI,OAAO,MAAM,UAEf,OAAO,cAAc,MAAM;QACtB,IAAI,YAAY,CAAC,GAEtB,OAAO,aAAa;IAAE,GAAG;IAAG,GAAG;GAAW,CAAC;GAG7C,OAAO,cACL,gBACE;IACE,GAAG;IACH,GAAG;IACH,GAAI,cAAc,IAAI,EAAE,UAAU,YAAY,EAAE,aAAa,EAAE,SAAS,IAAI,CAAC;GAC/E,GACA,aACA,wBACF,CACF;EACF,CAAC,EACH;CACN;CAEA,OAAO,aAAa;EAAE,GAAG;EAAO,GAAI,WAAW,OAAO,EAAE,MAAM,CAAC,EAAE;CAAG,CAAC;AACvE"}
+{"version":3,"file":"transformQuery.mjs","names":[],"sources":["../src/utils/transformQuery.ts"],"sourcesContent":["/**\n * Recursively steps through a query object ({@link index!RuleGroupType RuleGroupType} or {@link index!RuleGroupTypeIC RuleGroupTypeIC}),\n * passing each {@link index!RuleType RuleType} object to a provided `ruleProcessor` function and returning a\n * new query object if there were any referential changes.\n *\n * @module transformQuery\n */\n\nimport type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isRuleGroup, isRuleGroupType } from './isRuleGroup';\nimport { isUnsafeKey } from './objectUtils';\n\nconst remapProperties = (\n  obj: Record<string, unknown>,\n  propertyMap: Record<string, string | false>,\n  deleteRemappedProperties: boolean\n): Record<string, unknown> => {\n  const result: Record<string, unknown> = {};\n\n  for (const key in obj) {\n    if (isUnsafeKey(key)) continue;\n    const mappedKey = propertyMap[key];\n    if (mappedKey === false) {\n      continue;\n    }\n    if (mappedKey && key !== mappedKey) {\n      if (!isUnsafeKey(mappedKey)) {\n        result[mappedKey] = obj[key];\n      }\n      if (!deleteRemappedProperties) {\n        result[key] = obj[key];\n      }\n    } else {\n      result[key] = obj[key];\n    }\n  }\n\n  return result;\n};\n\n/**\n * Options object for {@link index!transformQuery transformQuery}.\n */\nexport interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {\n  /**\n   * When a rule is encountered in the hierarchy, it will be replaced\n   * with the result of this function.\n   *\n   * @defaultValue `r => r`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleProcessor?: (rule: RuleType) => any;\n  /**\n   * When a group is encountered in the hierarchy (including the root group, the\n   * query itself), it will be replaced with the result of this function.\n   *\n   * @defaultValue `rg => rg`\n   */\n  // oxlint-disable-next-line typescript/no-explicit-any\n  ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;\n  /**\n   * For each rule and group in the query, any properties matching a key\n   * in this object will be renamed to the corresponding value. To retain both\n   * the new _and_ the original properties, set `deleteRemappedProperties`\n   * to `false`.\n   *\n   * If a key has a value of `false`, the corresponding property will be removed\n   * without being copied to a new property name. (Warning: `{ rules: false }`\n   * will prevent recursion and only return the processed root group.)\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', not: true, rules: [] },\n   *     { propertyMap: { combinator: 'AndOr', not: false } }\n   *   )\n   *   // Returns: { AndOr: 'and', rules: [] }\n   * ```\n   */\n  propertyMap?: Record<string, string | false>;\n  /**\n   * Any combinator values (including independent combinators) will be translated\n   * from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { combinatorMap: { and: '&&', or: '||' } }\n   *   )\n   *   // Returns: { combinator: '&&', rules: [] }\n   * ```\n   */\n  combinatorMap?: Record<string, string>;\n  /**\n   * Any operator values will be translated from the key in this object to the value.\n   *\n   * @defaultValue `{}`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [{ field: 'name', operator: '=', value: 'Steve Vai' }] },\n   *     { operatorMap: { '=': 'is' } }\n   *   )\n   *   // Returns:\n   *   // {\n   *   //   combinator: 'and',\n   *   //   rules: [{ field: 'name', operator: 'is', value: 'Steve Vai' }]\n   *   // }\n   * ```\n   */\n  operatorMap?: Record<string, string>;\n  /**\n   * Prevents the `path` property (see {@link index!Path Path}) from being added to each\n   * rule and group in the hierarchy.\n   *\n   * @defaultValue `false`\n   */\n  omitPath?: boolean;\n  /**\n   * Original properties remapped according to the `propertyMap` option will be removed.\n   *\n   * @defaultValue `true`\n   *\n   * @example\n   * ```\n   *   transformQuery(\n   *     { combinator: 'and', rules: [] },\n   *     { propertyMap: { combinator: 'AndOr' }, deleteRemappedProperties: false }\n   *   )\n   *   // Returns: { combinator: 'and', AndOr: 'and', rules: [] }\n   * ```\n   */\n  deleteRemappedProperties?: boolean;\n}\n\n/**\n * Recursively process a query heirarchy using this versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupType,\n  options?: TransformQueryOptions\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\n/**\n * Recursively process a query heirarchy with independent combinators using this\n * versatile utility function.\n *\n * [Documentation](https://react-querybuilder.js.org/docs/utils/misc#transformquery)\n */\nexport function transformQuery(\n  query: RuleGroupTypeIC,\n  options?: TransformQueryOptions<RuleGroupTypeIC>\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any;\nexport function transformQuery<RG extends RuleGroupTypeAny>(\n  query: RG,\n  options: TransformQueryOptions<RG> = {}\n) {\n  const {\n    ruleProcessor = r => r,\n    ruleGroupProcessor = rg => rg,\n    propertyMap = {},\n    combinatorMap = {},\n    operatorMap = {},\n    omitPath = false,\n    deleteRemappedProperties = true,\n  } = options;\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  const processGroup = (rg: RuleGroupTypeAny): any => ({\n    ...ruleGroupProcessor(\n      remapProperties(\n        {\n          ...rg,\n          ...(isRuleGroupType(rg)\n            ? { combinator: combinatorMap[rg.combinator] ?? rg.combinator }\n            : {}),\n        },\n        propertyMap,\n        deleteRemappedProperties\n      ) as RG\n    ),\n    ...(propertyMap['rules'] === false\n      ? null\n      : {\n          // oxlint-disable-next-line typescript/no-explicit-any\n          [propertyMap['rules'] ?? 'rules']: rg.rules.map((r: any, idx) => {\n            const pathObject = omitPath ? null : { path: [...rg.path!, idx] };\n            if (typeof r === 'string') {\n              // independent combinators\n              return combinatorMap[r] ?? r;\n            } else if (isRuleGroup(r)) {\n              // sub-groups\n              return processGroup({ ...r, ...pathObject });\n            }\n            // rules\n            return ruleProcessor(\n              remapProperties(\n                {\n                  ...r,\n                  ...pathObject,\n                  ...('operator' in r ? { operator: operatorMap[r.operator] ?? r.operator } : {}),\n                },\n                propertyMap,\n                deleteRemappedProperties\n              ) as unknown as RuleType\n            );\n          }),\n        }),\n  });\n\n  return processGroup({ ...query, ...(omitPath ? null : { path: [] }) });\n}\n"],"mappings":";;;AAYA,MAAM,mBACJ,KACA,aACA,6BAC4B;CAC5B,MAAM,SAAkC,CAAC;CAEzC,KAAK,MAAM,OAAO,KAAK;EACrB,IAAI,YAAY,GAAG,GAAG;EACtB,MAAM,YAAY,YAAY;EAC9B,IAAI,cAAc,OAChB;EAEF,IAAI,aAAa,QAAQ,WAAW;GAClC,IAAI,CAAC,YAAY,SAAS,GACxB,OAAO,aAAa,IAAI;GAE1B,IAAI,CAAC,0BACH,OAAO,OAAO,IAAI;EAEtB,OACE,OAAO,OAAO,IAAI;CAEtB;CAEA,OAAO;AACT;AA4HA,SAAgB,eACd,OACA,UAAqC,CAAC,GACtC;CACA,MAAM,EACJ,iBAAgB,MAAK,GACrB,sBAAqB,OAAM,IAC3B,cAAc,CAAC,GACf,gBAAgB,CAAC,GACjB,cAAc,CAAC,GACf,WAAW,OACX,2BAA2B,SACzB;CAGJ,MAAM,gBAAgB,QAA+B;EACnD,GAAG,mBACD,gBACE;GACE,GAAG;GACH,GAAI,gBAAgB,EAAE,IAClB,EAAE,YAAY,cAAc,GAAG,eAAe,GAAG,WAAW,IAC5D,CAAC;EACP,GACA,aACA,wBACF,CACF;EACA,GAAI,YAAY,aAAa,QACzB,OACA,GAEG,YAAY,YAAY,UAAU,GAAG,MAAM,KAAK,GAAQ,QAAQ;GAC/D,MAAM,aAAa,WAAW,OAAO,EAAE,MAAM,CAAC,GAAG,GAAG,MAAO,GAAG,EAAE;GAChE,IAAI,OAAO,MAAM,UAEf,OAAO,cAAc,MAAM;QACtB,IAAI,YAAY,CAAC,GAEtB,OAAO,aAAa;IAAE,GAAG;IAAG,GAAG;GAAW,CAAC;GAG7C,OAAO,cACL,gBACE;IACE,GAAG;IACH,GAAG;IACH,GAAI,cAAc,IAAI,EAAE,UAAU,YAAY,EAAE,aAAa,EAAE,SAAS,IAAI,CAAC;GAC/E,GACA,aACA,wBACF,CACF;EACF,CAAC,EACH;CACN;CAEA,OAAO,aAAa;EAAE,GAAG;EAAO,GAAI,WAAW,OAAO,EAAE,MAAM,CAAC,EAAE;CAAG,CAAC;AACvE"}