@react-querybuilder/core 8.15.0 → 8.16.1

package/dist/parseGremlin.d.ts

@@ -0,0 +1,35 @@
+import { E as DefaultRuleGroupType, x as DefaultRuleGroupTypeIC } from "./index-Ds06V0zO.js";
+
+//#region src/utils/parseGremlin/parseGremlin.d.ts
+/**
+* Options for {@link parseGremlin}.
+*/
+interface ParseGremlinOptions {
+  independentCombinators?: boolean;
+}
+/**
+* Parses a Gremlin traversal string into a {@link DefaultRuleGroupType}.
+*
+* Accepts a full Gremlin traversal or a chain of `.has()` steps.
+* Pattern steps (`.hasLabel()`, `.out()`, `.in()`, `.both()`, `.as()`) are
+* consumed but discarded — only `.has()` filter predicates are returned.
+*
+* @example
+* ```ts
+* // Full traversal — extracts .has() conditions only
+* parseGremlin("g.V().hasLabel('Person').has('age', gt(30))");
+*
+* // Bare .has() chain
+* parseGremlin(".has('age', gt(30)).has('name', 'Alice')");
+* ```
+*/
+declare function parseGremlin(gremlin: string): DefaultRuleGroupType;
+declare function parseGremlin(gremlin: string, options: Omit<ParseGremlinOptions, "independentCombinators"> & {
+  independentCombinators?: false;
+}): DefaultRuleGroupType;
+declare function parseGremlin(gremlin: string, options: Omit<ParseGremlinOptions, "independentCombinators"> & {
+  independentCombinators: true;
+}): DefaultRuleGroupTypeIC;
+//#endregion
+export { type ParseGremlinOptions, parseGremlin };
+//# sourceMappingURL=parseGremlin.d.ts.map

package/dist/parseGremlin.js

@@ -0,0 +1,192 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/utils/parseGremlin/parseGremlin.ts
+function parseGremlin(gremlin, _options) {
+	const trimmed = gremlin.trim();
+	if (!trimmed) return {
+		combinator: "and",
+		rules: []
+	};
+	const rules = [];
+	const steps = tokenizeGremlinSteps(trimmed);
+	for (const step of steps) {
+		if (step.startsWith("hasLabel(")) continue;
+		if (step.startsWith("as(")) continue;
+		if (/^(out|in|both)\(/.test(step)) continue;
+		if (/^[VE]\(/.test(step)) continue;
+		const hasNotMatch = step.match(/^hasNot\('([^']+)'\)$/);
+		if (hasNotMatch) {
+			rules.push({
+				field: hasNotMatch[1],
+				operator: "null",
+				value: null
+			});
+			continue;
+		}
+		const hasExistsMatch = step.match(/^has\('([^']+)'\)$/);
+		if (hasExistsMatch) {
+			rules.push({
+				field: hasExistsMatch[1],
+				operator: "notNull",
+				value: null
+			});
+			continue;
+		}
+		const hasEqMatch = step.match(/^has\('([^']+)',\s*(.+)\)$/);
+		if (hasEqMatch) {
+			const [, prop, rawValue] = hasEqMatch;
+			const parsed = parseGremlinPredicate(prop, rawValue.trim());
+			if (parsed) rules.push(parsed);
+			continue;
+		}
+	}
+	return {
+		combinator: "and",
+		rules
+	};
+}
+/** Tokenizes a Gremlin traversal string into individual step strings. */
+const tokenizeGremlinSteps = (gremlin) => {
+	const steps = [];
+	let str = gremlin.trim();
+	const sourceMatch = str.match(/^\w+\.V\(\)\./);
+	if (sourceMatch) str = str.slice(sourceMatch[0].length);
+	else if (str.startsWith(".")) str = str.slice(1);
+	let depth = 0;
+	let current = "";
+	for (let i = 0; i < str.length; i++) {
+		const ch = str[i];
+		if (ch === "(") depth++;
+		else if (ch === ")") depth--;
+		if (ch === "." && depth === 0) {
+			if (current.trim()) steps.push(current.trim());
+			current = "";
+			continue;
+		}
+		current += ch;
+	}
+	if (current.trim()) steps.push(current.trim());
+	return steps;
+};
+/** Parses a Gremlin predicate (the second argument of `.has()`). */
+const parseGremlinPredicate = (prop, rawValue) => {
+	const predicateMatch = rawValue.match(/^(\w+)\((.+)\)$/);
+	if (predicateMatch) {
+		const [, predName, args] = predicateMatch;
+		const parsedArgs = parseGremlinArgs(args);
+		switch (predName) {
+			case "gt": return {
+				field: prop,
+				operator: ">",
+				value: parsedArgs[0]
+			};
+			case "lt": return {
+				field: prop,
+				operator: "<",
+				value: parsedArgs[0]
+			};
+			case "gte": return {
+				field: prop,
+				operator: ">=",
+				value: parsedArgs[0]
+			};
+			case "lte": return {
+				field: prop,
+				operator: "<=",
+				value: parsedArgs[0]
+			};
+			case "neq": return {
+				field: prop,
+				operator: "!=",
+				value: parsedArgs[0]
+			};
+			case "within": return {
+				field: prop,
+				operator: "in",
+				value: parsedArgs
+			};
+			case "without": return {
+				field: prop,
+				operator: "notIn",
+				value: parsedArgs
+			};
+			case "between": return {
+				field: prop,
+				operator: "between",
+				value: parsedArgs.slice(0, 2)
+			};
+			case "outside": return {
+				field: prop,
+				operator: "notBetween",
+				value: parsedArgs.slice(0, 2)
+			};
+			case "containing": return {
+				field: prop,
+				operator: "contains",
+				value: parsedArgs[0]
+			};
+			case "notContaining": return {
+				field: prop,
+				operator: "doesNotContain",
+				value: parsedArgs[0]
+			};
+			case "startingWith": return {
+				field: prop,
+				operator: "beginsWith",
+				value: parsedArgs[0]
+			};
+			case "notStartingWith": return {
+				field: prop,
+				operator: "doesNotBeginWith",
+				value: parsedArgs[0]
+			};
+			case "endingWith": return {
+				field: prop,
+				operator: "endsWith",
+				value: parsedArgs[0]
+			};
+			case "notEndingWith": return {
+				field: prop,
+				operator: "doesNotEndWith",
+				value: parsedArgs[0]
+			};
+			default: return null;
+		}
+	}
+	return {
+		field: prop,
+		operator: "=",
+		value: parseGremlinLiteral(rawValue)
+	};
+};
+/** Parses a comma-separated argument list. */
+const parseGremlinArgs = (args) => {
+	const result = [];
+	let depth = 0;
+	let current = "";
+	for (const ch of args) {
+		if (ch === "(") depth++;
+		else if (ch === ")") depth--;
+		if (ch === "," && depth === 0) {
+			result.push(parseGremlinLiteral(current.trim()));
+			current = "";
+			continue;
+		}
+		current += ch;
+	}
+	if (current.trim()) result.push(parseGremlinLiteral(current.trim()));
+	return result;
+};
+/** Parses a Gremlin literal value. */
+const parseGremlinLiteral = (raw) => {
+	if (raw.startsWith("'") && raw.endsWith("'")) return raw.slice(1, -1).replace(/\\'/g, "'");
+	if (raw === "null") return null;
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+	const num = Number(raw);
+	if (!Number.isNaN(num)) return num;
+	return raw;
+};
+//#endregion
+exports.parseGremlin = parseGremlin;
+
+//# sourceMappingURL=parseGremlin.js.map

package/dist/parseGremlin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseGremlin.js","names":[],"sources":["../src/utils/parseGremlin/parseGremlin.ts"],"sourcesContent":["import type {\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n} from '../../types';\n\n/**\n * Options for {@link parseGremlin}.\n */\nexport interface ParseGremlinOptions {\n  independentCombinators?: boolean;\n}\n\n/**\n * Parses a Gremlin traversal string into a {@link DefaultRuleGroupType}.\n *\n * Accepts a full Gremlin traversal or a chain of `.has()` steps.\n * Pattern steps (`.hasLabel()`, `.out()`, `.in()`, `.both()`, `.as()`) are\n * consumed but discarded — only `.has()` filter predicates are returned.\n *\n * @example\n * ```ts\n * // Full traversal — extracts .has() conditions only\n * parseGremlin(\"g.V().hasLabel('Person').has('age', gt(30))\");\n *\n * // Bare .has() chain\n * parseGremlin(\".has('age', gt(30)).has('name', 'Alice')\");\n * ```\n */\nexport function parseGremlin(gremlin: string): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nexport function parseGremlin(\n  gremlin: string,\n  _options?: ParseGremlinOptions\n): DefaultRuleGroupTypeAny {\n  const trimmed = gremlin.trim();\n  if (!trimmed) return { combinator: 'and', rules: [] };\n\n  const rules: (DefaultRuleType | DefaultRuleGroupType)[] = [];\n  const steps = tokenizeGremlinSteps(trimmed);\n\n  for (const step of steps) {\n    // Skip pattern steps — only extract filter predicates\n    // .hasLabel('Label') — pattern step, skip\n    if (step.startsWith('hasLabel(')) continue;\n    // .as('alias') — pattern step, skip\n    if (step.startsWith('as(')) continue;\n    // .out('edge'), .in('edge'), .both('edge') — pattern step, skip\n    if (/^(out|in|both)\\(/.test(step)) continue;\n    // .V(), .E() — traversal source, skip\n    if (/^[VE]\\(/.test(step)) continue;\n\n    // .hasNot('prop') — null check\n    const hasNotMatch = step.match(/^hasNot\\('([^']+)'\\)$/);\n    if (hasNotMatch) {\n      rules.push({ field: hasNotMatch[1], operator: 'null', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop') — property exists\n    const hasExistsMatch = step.match(/^has\\('([^']+)'\\)$/);\n    if (hasExistsMatch) {\n      rules.push({ field: hasExistsMatch[1], operator: 'notNull', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop', value) — equality or predicate\n    const hasEqMatch = step.match(/^has\\('([^']+)',\\s*(.+)\\)$/);\n    if (hasEqMatch) {\n      const [, prop, rawValue] = hasEqMatch;\n      const parsed = parseGremlinPredicate(prop, rawValue.trim());\n      if (parsed) {\n        rules.push(parsed);\n      }\n      continue;\n    }\n  }\n\n  return { combinator: 'and', rules };\n}\n\n/** Tokenizes a Gremlin traversal string into individual step strings. */\nconst tokenizeGremlinSteps = (gremlin: string): string[] => {\n  const steps: string[] = [];\n\n  // Remove leading source (e.g., \"g.V().\")\n  let str = gremlin.trim();\n  const sourceMatch = str.match(/^\\w+\\.V\\(\\)\\./);\n  if (sourceMatch) {\n    str = str.slice(sourceMatch[0].length);\n  } else if (str.startsWith('.')) {\n    // Bare step chain starting with a dot\n    str = str.slice(1);\n  }\n\n  // Split on top-level dots\n  let depth = 0;\n  let current = '';\n\n  for (let i = 0; i < str.length; i++) {\n    const ch = str[i];\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n\n    if (ch === '.' && depth === 0) {\n      if (current.trim()) steps.push(current.trim());\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) steps.push(current.trim());\n\n  return steps;\n};\n\n/** Parses a Gremlin predicate (the second argument of `.has()`). */\nconst parseGremlinPredicate = (prop: string, rawValue: string): DefaultRuleType | null => {\n  // Predicate functions: gt(), lt(), gte(), lte(), neq(), within(), without(), between(), outside()\n  const predicateMatch = rawValue.match(/^(\\w+)\\((.+)\\)$/);\n  if (predicateMatch) {\n    const [, predName, args] = predicateMatch;\n    const parsedArgs = parseGremlinArgs(args);\n\n    switch (predName) {\n      case 'gt':\n        return { field: prop, operator: '>', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lt':\n        return { field: prop, operator: '<', value: parsedArgs[0] } as DefaultRuleType;\n      case 'gte':\n        return { field: prop, operator: '>=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lte':\n        return { field: prop, operator: '<=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'neq':\n        return { field: prop, operator: '!=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'within':\n        return { field: prop, operator: 'in', value: parsedArgs } as DefaultRuleType;\n      case 'without':\n        return { field: prop, operator: 'notIn', value: parsedArgs } as DefaultRuleType;\n      case 'between':\n        return {\n          field: prop,\n          operator: 'between',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'outside':\n        return {\n          field: prop,\n          operator: 'notBetween',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'containing':\n        return { field: prop, operator: 'contains', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notContaining':\n        return { field: prop, operator: 'doesNotContain', value: parsedArgs[0] } as DefaultRuleType;\n      case 'startingWith':\n        return { field: prop, operator: 'beginsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notStartingWith':\n        return {\n          field: prop,\n          operator: 'doesNotBeginWith',\n          value: parsedArgs[0],\n        } as DefaultRuleType;\n      case 'endingWith':\n        return { field: prop, operator: 'endsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notEndingWith':\n        return { field: prop, operator: 'doesNotEndWith', value: parsedArgs[0] } as DefaultRuleType;\n      default:\n        return null;\n    }\n  }\n\n  // Plain value — equality\n  return { field: prop, operator: '=', value: parseGremlinLiteral(rawValue) } as DefaultRuleType;\n};\n\n/** Parses a comma-separated argument list. */\nconst parseGremlinArgs = (args: string): unknown[] => {\n  const result: unknown[] = [];\n  let depth = 0;\n  let current = '';\n\n  for (const ch of args) {\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n    if (ch === ',' && depth === 0) {\n      result.push(parseGremlinLiteral(current.trim()));\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) result.push(parseGremlinLiteral(current.trim()));\n  return result;\n};\n\n/** Parses a Gremlin literal value. */\nconst parseGremlinLiteral = (raw: string): unknown => {\n  if (raw.startsWith(\"'\") && raw.endsWith(\"'\")) {\n    return raw.slice(1, -1).replace(/\\\\'/g, \"'\");\n  }\n  if (raw === 'null') return null;\n  if (raw === 'true') return true;\n  if (raw === 'false') return false;\n  const num = Number(raw);\n  if (!Number.isNaN(num)) return num;\n  return raw;\n};\n"],"mappings":"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"}

package/dist/parseGremlin.mjs

@@ -0,0 +1,191 @@
+//#region src/utils/parseGremlin/parseGremlin.ts
+function parseGremlin(gremlin, _options) {
+	const trimmed = gremlin.trim();
+	if (!trimmed) return {
+		combinator: "and",
+		rules: []
+	};
+	const rules = [];
+	const steps = tokenizeGremlinSteps(trimmed);
+	for (const step of steps) {
+		if (step.startsWith("hasLabel(")) continue;
+		if (step.startsWith("as(")) continue;
+		if (/^(out|in|both)\(/.test(step)) continue;
+		if (/^[VE]\(/.test(step)) continue;
+		const hasNotMatch = step.match(/^hasNot\('([^']+)'\)$/);
+		if (hasNotMatch) {
+			rules.push({
+				field: hasNotMatch[1],
+				operator: "null",
+				value: null
+			});
+			continue;
+		}
+		const hasExistsMatch = step.match(/^has\('([^']+)'\)$/);
+		if (hasExistsMatch) {
+			rules.push({
+				field: hasExistsMatch[1],
+				operator: "notNull",
+				value: null
+			});
+			continue;
+		}
+		const hasEqMatch = step.match(/^has\('([^']+)',\s*(.+)\)$/);
+		if (hasEqMatch) {
+			const [, prop, rawValue] = hasEqMatch;
+			const parsed = parseGremlinPredicate(prop, rawValue.trim());
+			if (parsed) rules.push(parsed);
+			continue;
+		}
+	}
+	return {
+		combinator: "and",
+		rules
+	};
+}
+/** Tokenizes a Gremlin traversal string into individual step strings. */
+const tokenizeGremlinSteps = (gremlin) => {
+	const steps = [];
+	let str = gremlin.trim();
+	const sourceMatch = str.match(/^\w+\.V\(\)\./);
+	if (sourceMatch) str = str.slice(sourceMatch[0].length);
+	else if (str.startsWith(".")) str = str.slice(1);
+	let depth = 0;
+	let current = "";
+	for (let i = 0; i < str.length; i++) {
+		const ch = str[i];
+		if (ch === "(") depth++;
+		else if (ch === ")") depth--;
+		if (ch === "." && depth === 0) {
+			if (current.trim()) steps.push(current.trim());
+			current = "";
+			continue;
+		}
+		current += ch;
+	}
+	if (current.trim()) steps.push(current.trim());
+	return steps;
+};
+/** Parses a Gremlin predicate (the second argument of `.has()`). */
+const parseGremlinPredicate = (prop, rawValue) => {
+	const predicateMatch = rawValue.match(/^(\w+)\((.+)\)$/);
+	if (predicateMatch) {
+		const [, predName, args] = predicateMatch;
+		const parsedArgs = parseGremlinArgs(args);
+		switch (predName) {
+			case "gt": return {
+				field: prop,
+				operator: ">",
+				value: parsedArgs[0]
+			};
+			case "lt": return {
+				field: prop,
+				operator: "<",
+				value: parsedArgs[0]
+			};
+			case "gte": return {
+				field: prop,
+				operator: ">=",
+				value: parsedArgs[0]
+			};
+			case "lte": return {
+				field: prop,
+				operator: "<=",
+				value: parsedArgs[0]
+			};
+			case "neq": return {
+				field: prop,
+				operator: "!=",
+				value: parsedArgs[0]
+			};
+			case "within": return {
+				field: prop,
+				operator: "in",
+				value: parsedArgs
+			};
+			case "without": return {
+				field: prop,
+				operator: "notIn",
+				value: parsedArgs
+			};
+			case "between": return {
+				field: prop,
+				operator: "between",
+				value: parsedArgs.slice(0, 2)
+			};
+			case "outside": return {
+				field: prop,
+				operator: "notBetween",
+				value: parsedArgs.slice(0, 2)
+			};
+			case "containing": return {
+				field: prop,
+				operator: "contains",
+				value: parsedArgs[0]
+			};
+			case "notContaining": return {
+				field: prop,
+				operator: "doesNotContain",
+				value: parsedArgs[0]
+			};
+			case "startingWith": return {
+				field: prop,
+				operator: "beginsWith",
+				value: parsedArgs[0]
+			};
+			case "notStartingWith": return {
+				field: prop,
+				operator: "doesNotBeginWith",
+				value: parsedArgs[0]
+			};
+			case "endingWith": return {
+				field: prop,
+				operator: "endsWith",
+				value: parsedArgs[0]
+			};
+			case "notEndingWith": return {
+				field: prop,
+				operator: "doesNotEndWith",
+				value: parsedArgs[0]
+			};
+			default: return null;
+		}
+	}
+	return {
+		field: prop,
+		operator: "=",
+		value: parseGremlinLiteral(rawValue)
+	};
+};
+/** Parses a comma-separated argument list. */
+const parseGremlinArgs = (args) => {
+	const result = [];
+	let depth = 0;
+	let current = "";
+	for (const ch of args) {
+		if (ch === "(") depth++;
+		else if (ch === ")") depth--;
+		if (ch === "," && depth === 0) {
+			result.push(parseGremlinLiteral(current.trim()));
+			current = "";
+			continue;
+		}
+		current += ch;
+	}
+	if (current.trim()) result.push(parseGremlinLiteral(current.trim()));
+	return result;
+};
+/** Parses a Gremlin literal value. */
+const parseGremlinLiteral = (raw) => {
+	if (raw.startsWith("'") && raw.endsWith("'")) return raw.slice(1, -1).replace(/\\'/g, "'");
+	if (raw === "null") return null;
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+	const num = Number(raw);
+	if (!Number.isNaN(num)) return num;
+	return raw;
+};
+//#endregion
+export { parseGremlin };
+
+//# sourceMappingURL=parseGremlin.mjs.map

package/dist/parseGremlin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseGremlin.mjs","names":[],"sources":["../src/utils/parseGremlin/parseGremlin.ts"],"sourcesContent":["import type {\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n} from '../../types';\n\n/**\n * Options for {@link parseGremlin}.\n */\nexport interface ParseGremlinOptions {\n  independentCombinators?: boolean;\n}\n\n/**\n * Parses a Gremlin traversal string into a {@link DefaultRuleGroupType}.\n *\n * Accepts a full Gremlin traversal or a chain of `.has()` steps.\n * Pattern steps (`.hasLabel()`, `.out()`, `.in()`, `.both()`, `.as()`) are\n * consumed but discarded — only `.has()` filter predicates are returned.\n *\n * @example\n * ```ts\n * // Full traversal — extracts .has() conditions only\n * parseGremlin(\"g.V().hasLabel('Person').has('age', gt(30))\");\n *\n * // Bare .has() chain\n * parseGremlin(\".has('age', gt(30)).has('name', 'Alice')\");\n * ```\n */\nexport function parseGremlin(gremlin: string): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nexport function parseGremlin(\n  gremlin: string,\n  _options?: ParseGremlinOptions\n): DefaultRuleGroupTypeAny {\n  const trimmed = gremlin.trim();\n  if (!trimmed) return { combinator: 'and', rules: [] };\n\n  const rules: (DefaultRuleType | DefaultRuleGroupType)[] = [];\n  const steps = tokenizeGremlinSteps(trimmed);\n\n  for (const step of steps) {\n    // Skip pattern steps — only extract filter predicates\n    // .hasLabel('Label') — pattern step, skip\n    if (step.startsWith('hasLabel(')) continue;\n    // .as('alias') — pattern step, skip\n    if (step.startsWith('as(')) continue;\n    // .out('edge'), .in('edge'), .both('edge') — pattern step, skip\n    if (/^(out|in|both)\\(/.test(step)) continue;\n    // .V(), .E() — traversal source, skip\n    if (/^[VE]\\(/.test(step)) continue;\n\n    // .hasNot('prop') — null check\n    const hasNotMatch = step.match(/^hasNot\\('([^']+)'\\)$/);\n    if (hasNotMatch) {\n      rules.push({ field: hasNotMatch[1], operator: 'null', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop') — property exists\n    const hasExistsMatch = step.match(/^has\\('([^']+)'\\)$/);\n    if (hasExistsMatch) {\n      rules.push({ field: hasExistsMatch[1], operator: 'notNull', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop', value) — equality or predicate\n    const hasEqMatch = step.match(/^has\\('([^']+)',\\s*(.+)\\)$/);\n    if (hasEqMatch) {\n      const [, prop, rawValue] = hasEqMatch;\n      const parsed = parseGremlinPredicate(prop, rawValue.trim());\n      if (parsed) {\n        rules.push(parsed);\n      }\n      continue;\n    }\n  }\n\n  return { combinator: 'and', rules };\n}\n\n/** Tokenizes a Gremlin traversal string into individual step strings. */\nconst tokenizeGremlinSteps = (gremlin: string): string[] => {\n  const steps: string[] = [];\n\n  // Remove leading source (e.g., \"g.V().\")\n  let str = gremlin.trim();\n  const sourceMatch = str.match(/^\\w+\\.V\\(\\)\\./);\n  if (sourceMatch) {\n    str = str.slice(sourceMatch[0].length);\n  } else if (str.startsWith('.')) {\n    // Bare step chain starting with a dot\n    str = str.slice(1);\n  }\n\n  // Split on top-level dots\n  let depth = 0;\n  let current = '';\n\n  for (let i = 0; i < str.length; i++) {\n    const ch = str[i];\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n\n    if (ch === '.' && depth === 0) {\n      if (current.trim()) steps.push(current.trim());\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) steps.push(current.trim());\n\n  return steps;\n};\n\n/** Parses a Gremlin predicate (the second argument of `.has()`). */\nconst parseGremlinPredicate = (prop: string, rawValue: string): DefaultRuleType | null => {\n  // Predicate functions: gt(), lt(), gte(), lte(), neq(), within(), without(), between(), outside()\n  const predicateMatch = rawValue.match(/^(\\w+)\\((.+)\\)$/);\n  if (predicateMatch) {\n    const [, predName, args] = predicateMatch;\n    const parsedArgs = parseGremlinArgs(args);\n\n    switch (predName) {\n      case 'gt':\n        return { field: prop, operator: '>', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lt':\n        return { field: prop, operator: '<', value: parsedArgs[0] } as DefaultRuleType;\n      case 'gte':\n        return { field: prop, operator: '>=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lte':\n        return { field: prop, operator: '<=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'neq':\n        return { field: prop, operator: '!=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'within':\n        return { field: prop, operator: 'in', value: parsedArgs } as DefaultRuleType;\n      case 'without':\n        return { field: prop, operator: 'notIn', value: parsedArgs } as DefaultRuleType;\n      case 'between':\n        return {\n          field: prop,\n          operator: 'between',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'outside':\n        return {\n          field: prop,\n          operator: 'notBetween',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'containing':\n        return { field: prop, operator: 'contains', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notContaining':\n        return { field: prop, operator: 'doesNotContain', value: parsedArgs[0] } as DefaultRuleType;\n      case 'startingWith':\n        return { field: prop, operator: 'beginsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notStartingWith':\n        return {\n          field: prop,\n          operator: 'doesNotBeginWith',\n          value: parsedArgs[0],\n        } as DefaultRuleType;\n      case 'endingWith':\n        return { field: prop, operator: 'endsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notEndingWith':\n        return { field: prop, operator: 'doesNotEndWith', value: parsedArgs[0] } as DefaultRuleType;\n      default:\n        return null;\n    }\n  }\n\n  // Plain value — equality\n  return { field: prop, operator: '=', value: parseGremlinLiteral(rawValue) } as DefaultRuleType;\n};\n\n/** Parses a comma-separated argument list. */\nconst parseGremlinArgs = (args: string): unknown[] => {\n  const result: unknown[] = [];\n  let depth = 0;\n  let current = '';\n\n  for (const ch of args) {\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n    if (ch === ',' && depth === 0) {\n      result.push(parseGremlinLiteral(current.trim()));\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) result.push(parseGremlinLiteral(current.trim()));\n  return result;\n};\n\n/** Parses a Gremlin literal value. */\nconst parseGremlinLiteral = (raw: string): unknown => {\n  if (raw.startsWith(\"'\") && raw.endsWith(\"'\")) {\n    return raw.slice(1, -1).replace(/\\\\'/g, \"'\");\n  }\n  if (raw === 'null') return null;\n  if (raw === 'true') return true;\n  if (raw === 'false') return false;\n  const num = Number(raw);\n  if (!Number.isNaN(num)) return num;\n  return raw;\n};\n"],"mappings":"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"}

package/dist/parseJSONata.d.mts

@@ -1,5 +1,5 @@
-import { E as DefaultRuleGroupType, j as Except, x as DefaultRuleGroupTypeIC } from "./index-Lht_Wq3V.mjs";
-import { t as ParserCommonOptions } from "./import-0wp72lLT.mjs";
+import { E as DefaultRuleGroupType, j as Except, x as DefaultRuleGroupTypeIC } from "./index-AAZg4Uh1.mjs";
+import { t as ParserCommonOptions } from "./import-BC_bAKQ8.mjs";
 
 //#region src/utils/parseJSONata/parseJSONata.d.ts
 /**

package/dist/parseJSONata.d.ts

@@ -1,5 +1,5 @@
-import { E as DefaultRuleGroupType, j as Except, x as DefaultRuleGroupTypeIC } from "./index-D5TXNIzF.js";
-import { t as ParserCommonOptions } from "./import-yRVJh7E1.js";
+import { E as DefaultRuleGroupType, j as Except, x as DefaultRuleGroupTypeIC } from "./index-Ds06V0zO.js";
+import { t as ParserCommonOptions } from "./import-D1KnXhkQ.js";
 
 //#region src/utils/parseJSONata/parseJSONata.d.ts
 /**

package/dist/parseJSONata.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseJSONata.js","names":["getFieldsArray","fieldIsValidUtil","isRuleGroup","prepareRuleGroup"],"sources":["../src/utils/parseJSONata/utils.ts","../src/utils/parseJSONata/parseJSONata.ts"],"sourcesContent":["import type { DefaultCombinatorName, DefaultOperatorName } from '../../types';\nimport type {\n  JSONataAnd,\n  JSONataBinaryNode,\n  JSONataBlock,\n  JSONataBoolean,\n  JSONataContains,\n  JSONataEqual,\n  JSONataExprNode,\n  JSONataGreaterThan,\n  JSONataGreaterThanOrEqual,\n  JSONataIdentifier,\n  JSONataIn,\n  JSONataLessThan,\n  JSONataLessThanOrEqual,\n  JSONataList,\n  JSONataName,\n  JSONataNot,\n  JSONataNotEqual,\n  JSONataNull,\n  JSONataNumber,\n  JSONataOr,\n  JSONataPath,\n  JSONataRegex,\n  JSONataString,\n  JSONataToMillis,\n} from './types';\n\n// oxlint-disable-next-line typescript/no-explicit-any\ntype Any = any;\n\nexport const isJSONataExprNode = (expr: Any): expr is JSONataExprNode => {\n  return expr && typeof expr === 'object' && typeof expr.type === 'string';\n};\nconst isJSONataBinaryNode = (expr: Any): expr is JSONataBinaryNode =>\n  isJSONataExprNode(expr) && expr.type === 'binary';\n\n// Identifiers\nexport const isJSONataPath = (expr: Any): expr is JSONataPath =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'path' &&\n  Array.isArray(expr.steps) &&\n  expr.steps.length > 0 &&\n  isJSONataExprNode(expr.steps[0]);\nexport const isJSONataName = (expr: Any): expr is JSONataName =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'name' &&\n  typeof expr.value === 'string' &&\n  expr.value.length > 0;\nexport const isJSONataIdentifier = (expr: Any): expr is JSONataIdentifier =>\n  isJSONataPath(expr) && expr.steps.every(v => isJSONataName(v));\n\n// Groups\nexport const isJSONataBlock = (expr: Any): expr is JSONataBlock =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'block' &&\n  Array.isArray(expr.expressions) &&\n  expr.expressions.length > 0 &&\n  isJSONataExprNode(expr.expressions[0]);\n\n// Values\nexport const isJSONataString = (expr: Any): expr is JSONataString =>\n  isJSONataExprNode(expr) && expr.type === 'string' && typeof expr.value === 'string';\nexport const isJSONataNumber = (expr: Any): expr is JSONataNumber =>\n  isJSONataExprNode(expr) && expr.type === 'number' && typeof expr.value === 'number';\nexport const isJSONataBoolean = (expr: Any): expr is JSONataBoolean =>\n  isJSONataExprNode(expr) && expr.type === 'value' && typeof expr.value === 'boolean';\nexport const isJSONataNull = (expr: Any): expr is JSONataNull =>\n  isJSONataExprNode(expr) && expr.type === 'value' && expr.value === null;\nexport const isJSONataRegex = (expr: Any): expr is JSONataRegex =>\n  isJSONataExprNode(expr) && expr.type === 'regex' && expr.value instanceof RegExp;\n\n// Combinators\nexport const isJSONataAnd = (expr: Any): expr is JSONataAnd =>\n  isJSONataBinaryNode(expr) && expr.value === 'and';\nexport const isJSONataOr = (expr: Any): expr is JSONataOr =>\n  isJSONataBinaryNode(expr) && expr.value === 'or';\n\n// Operators\nexport const isJSONataEqual = (expr: Any): expr is JSONataEqual =>\n  isJSONataBinaryNode(expr) && expr.value === '=';\nexport const isJSONataNotEqual = (expr: Any): expr is JSONataNotEqual =>\n  isJSONataBinaryNode(expr) && expr.value === '!=';\nexport const isJSONataGreaterThan = (expr: Any): expr is JSONataGreaterThan =>\n  isJSONataBinaryNode(expr) && expr.value === '>';\nexport const isJSONataGreaterThanOrEqual = (expr: Any): expr is JSONataGreaterThanOrEqual =>\n  isJSONataBinaryNode(expr) && expr.value === '>=';\nexport const isJSONataLessThan = (expr: Any): expr is JSONataLessThan =>\n  isJSONataBinaryNode(expr) && expr.value === '<';\nexport const isJSONataLessThanOrEqual = (expr: Any): expr is JSONataLessThanOrEqual =>\n  isJSONataBinaryNode(expr) && expr.value === '<=';\nexport const isJSONataIn = (expr: Any): expr is JSONataIn =>\n  isJSONataBinaryNode(expr) &&\n  expr.value === 'in' &&\n  isJSONataPath(expr.lhs) &&\n  isJSONataList(expr.rhs);\n\n// Functions\nexport const isJSONataNot = (expr: Any): expr is JSONataNot =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'function' &&\n  expr.value === '(' &&\n  Array.isArray(expr.arguments) &&\n  isJSONataExprNode(expr.arguments[0]) &&\n  isJSONataExprNode(expr.procedure) &&\n  expr.procedure.value === 'not' &&\n  expr.procedure.type === 'variable';\nexport const isJSONataContains = (expr: Any): expr is JSONataContains =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'function' &&\n  expr.value === '(' &&\n  Array.isArray(expr.arguments) &&\n  expr.arguments.length >= 2 &&\n  isJSONataExprNode(expr.arguments[0]) &&\n  isJSONataExprNode(expr.procedure) &&\n  expr.procedure.value === 'contains' &&\n  expr.procedure.type === 'variable';\nexport const isJSONataToMillis = (expr: Any): expr is JSONataToMillis =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'function' &&\n  expr.value === '(' &&\n  Array.isArray(expr.arguments) &&\n  expr.arguments.length > 0 &&\n  isJSONataString(expr.arguments[0]) &&\n  isJSONataExprNode(expr.procedure) &&\n  expr.procedure.value === 'toMillis' &&\n  expr.procedure.type === 'variable';\n\n// Miscellaneous\nexport const isJSONataList = (expr: Any): expr is JSONataList =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'unary' &&\n  expr.value === '[' &&\n  Array.isArray(expr.expressions);\nexport const isJSONataPrimitive = (expr: Any): boolean => {\n  return (\n    isJSONataString(expr) ||\n    isJSONataNumber(expr) ||\n    isJSONataBoolean(expr) ||\n    isJSONataNull(expr) ||\n    isJSONataToMillis(expr)\n  );\n};\nexport const isJSONataPrimitiveList = (expr: Any): boolean =>\n  isJSONataList(expr) && expr.expressions.every(v => isJSONataPrimitive(v));\nexport const isJSONataIdentifierList = (expr: Any): boolean =>\n  isJSONataList(expr) && expr.expressions.every(v => isJSONataIdentifier(v));\nexport const isJSONataValidValue = (expr: Any): boolean =>\n  isJSONataPrimitive(expr) ||\n  isJSONataRegex(expr) ||\n  isJSONataIdentifier(expr) ||\n  isJSONataPrimitiveList(expr) ||\n  isJSONataIdentifierList(expr) ||\n  isJSONataToMillis(expr);\nexport const isJSONataComparison = (\n  expr: Any\n): expr is\n  | JSONataEqual\n  | JSONataNotEqual\n  | JSONataGreaterThan\n  | JSONataGreaterThanOrEqual\n  | JSONataLessThan\n  | JSONataLessThanOrEqual =>\n  isJSONataEqual(expr) ||\n  isJSONataNotEqual(expr) ||\n  isJSONataGreaterThan(expr) ||\n  isJSONataGreaterThanOrEqual(expr) ||\n  isJSONataLessThan(expr) ||\n  isJSONataLessThanOrEqual(expr);\n\nexport const getValidValue = (expr: Any): Any => {\n  if (isJSONataToMillis(expr)) {\n    return getValidValue(expr.arguments[0]);\n  } else if (isJSONataIdentifier(expr)) {\n    return getFieldFromPath(expr);\n  } else if (isJSONataPrimitiveList(expr)) {\n    return expr.expressions.map((v: Any) => getValidValue(v));\n  } else if (isJSONataIdentifierList(expr)) {\n    return expr.expressions.map((v: Any) => getFieldFromPath(v));\n  }\n  return expr.value;\n};\n\nexport const getFieldFromPath = (path: JSONataPath): string =>\n  isJSONataIdentifier(path)\n    ? path.steps.map(s => s.value).join('.')\n    : /* v8 ignore next -- @preserve */ '';\n\nexport const normalizeOperator = (\n  opType: DefaultOperatorName,\n  flip?: boolean\n): DefaultOperatorName => {\n  if (flip) {\n    if (opType === '<') return '>';\n    if (opType === '<=') return '>=';\n    if (opType === '>') return '<';\n    if (opType === '>=') return '<=';\n  }\n  return opType;\n};\n\nexport const negatedLikeOperators: Record<\n  Extract<DefaultOperatorName, 'beginsWith' | 'contains' | 'endsWith'>,\n  DefaultOperatorName\n> = {\n  contains: 'doesNotContain',\n  beginsWith: 'doesNotBeginWith',\n  endsWith: 'doesNotEndWith',\n} satisfies Record<\n  Extract<DefaultOperatorName, 'beginsWith' | 'contains' | 'endsWith'>,\n  DefaultOperatorName\n>;\n\nexport const generateFlatAndOrList = (\n  expr: JSONataExprNode\n): (DefaultCombinatorName | JSONataExprNode)[] => {\n  // v8 ignore else\n  if (isJSONataAnd(expr) || isJSONataOr(expr)) {\n    const { lhs, rhs, value: combinator } = expr;\n    if (isJSONataAnd(lhs) || isJSONataOr(lhs)) {\n      return [...generateFlatAndOrList(lhs), combinator, rhs];\n    }\n    return [lhs, combinator, rhs];\n  }\n  // v8 ignore next\n  return [];\n};\n\nexport const generateMixedAndOrList = (\n  expr: JSONataAnd | JSONataOr\n): (JSONataExprNode | DefaultCombinatorName | (JSONataExprNode | 'and')[])[] => {\n  const arr = generateFlatAndOrList(expr);\n  const returnArray: (DefaultCombinatorName | JSONataExprNode | ('and' | JSONataExprNode)[])[] = [];\n  let startIndex = 0;\n  for (let i = 0; i < arr.length; i += 2) {\n    if (arr[i + 1] === 'and') {\n      startIndex = i;\n      let j = 1;\n      while (arr[startIndex + j] === 'and') {\n        i += 2;\n        j += 2;\n      }\n      const tempAndArray = arr.slice(startIndex, i + 1) as ('and' | JSONataExprNode)[];\n      returnArray.push(tempAndArray);\n      i -= 2;\n    } else if (arr[i + 1] === 'or') {\n      if (i === 0 || i === arr.length - 3) {\n        if (i === 0 || arr[i - 1] === 'or') {\n          returnArray.push(arr[i]);\n        }\n        returnArray.push(arr[i + 1]);\n        if (i === arr.length - 3) {\n          returnArray.push(arr[i + 2]);\n        }\n      } else {\n        if (arr[i - 1] === 'and') {\n          returnArray.push(arr[i + 1]);\n        } else {\n          returnArray.push(arr[i], arr[i + 1]);\n        }\n      }\n    }\n  }\n  if (returnArray.length === 1 && Array.isArray(returnArray[0])) {\n    // If length is 1, then the only element is an AND array so just return that\n    return returnArray[0];\n  }\n  return returnArray;\n};\n","import jsonata from 'jsonata';\nimport type { Except } from 'type-fest';\nimport type {\n  DefaultCombinatorName,\n  DefaultOperatorName,\n  DefaultRuleGroupArray,\n  DefaultRuleGroupICArray,\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n  ValueSource,\n} from '../../types';\nimport type { ParserCommonOptions } from '../../types/import';\nimport { isRuleGroup } from '../isRuleGroup';\nimport { fieldIsValidUtil, getFieldsArray } from '../parserUtils';\nimport { prepareRuleGroup } from '../prepareQueryObjects';\nimport type { JSONataExprNode } from './types';\nimport {\n  generateFlatAndOrList,\n  generateMixedAndOrList,\n  getFieldFromPath,\n  getValidValue,\n  isJSONataAnd,\n  isJSONataBlock,\n  isJSONataComparison,\n  isJSONataContains,\n  isJSONataIdentifier,\n  isJSONataIdentifierList,\n  isJSONataIn,\n  isJSONataNot,\n  isJSONataOr,\n  isJSONataRegex,\n  isJSONataString,\n  isJSONataValidValue,\n  negatedLikeOperators,\n  normalizeOperator,\n} from './utils';\n\n/**\n * Options object for {@link parseJSONata}.\n *\n * Note: `listsAsArrays` is ignored by `parseJSONata`; lists are _always_ arrays.\n */\nexport interface ParseJSONataOptions extends ParserCommonOptions {}\n\n/**\n * Converts a JSONata string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).\n */\nfunction parseJSONata(jsonataInput: string): DefaultRuleGroupType;\n/**\n * Converts a JSONata string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).\n */\nfunction parseJSONata(\n  jsonataInput: string,\n  options: Except<ParseJSONataOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\n/**\n * Converts a JSONata string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).\n */\nfunction parseJSONata(\n  jsonataInput: string,\n  options: Except<ParseJSONataOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nfunction parseJSONata(\n  jsonataInput: string,\n  options: ParseJSONataOptions = {}\n): DefaultRuleGroupTypeAny {\n  const { fields, independentCombinators, listsAsArrays: _laa } = options;\n  const ic = !!independentCombinators;\n  const fieldsFlat = getFieldsArray(fields);\n\n  const fieldIsValid = (\n    fieldName: string,\n    operator: DefaultOperatorName,\n    subordinateFieldName?: string\n  ) =>\n    fieldIsValidUtil({\n      fieldName,\n      fieldsFlat,\n      operator,\n      subordinateFieldName,\n      getValueSources: options?.getValueSources,\n    });\n\n  const emptyQuery: DefaultRuleGroupTypeAny = {\n    rules: [],\n    ...(ic ? {} : { combinator: 'and' }),\n  };\n\n  const parseJSONataAST = (\n    expr: JSONataExprNode,\n    processOpts: {\n      groupOnlyIfNecessary?: boolean;\n      forwardNegation?: boolean;\n    } = {}\n  ): DefaultRuleType | DefaultRuleGroupTypeAny | null => {\n    const { forwardNegation: _forwardedNegation, groupOnlyIfNecessary: _g } = processOpts;\n    if (isJSONataBlock(expr)) {\n      if (\n        isJSONataAnd(expr.expressions[0]) ||\n        isJSONataOr(expr.expressions[0]) ||\n        isJSONataBlock(expr.expressions[0])\n      ) {\n        return parseJSONataAST(expr.expressions[0]);\n      }\n      const blockOfExpr = parseJSONataAST(expr.expressions[0]);\n      // v8 ignore else\n      if (blockOfExpr) {\n        return ic\n          ? ({ rules: [blockOfExpr] } as DefaultRuleGroupTypeIC)\n          : ({\n              combinator: 'and',\n              rules: [blockOfExpr],\n            } as DefaultRuleGroupType);\n      }\n    } else if (isJSONataAnd(expr) || isJSONataOr(expr)) {\n      if (ic) {\n        const andOrList = generateFlatAndOrList(expr);\n        const rules = andOrList.map(v => {\n          if (typeof v === 'string') {\n            return v;\n          }\n          return parseJSONataAST(v);\n        });\n        // Bail out completely if any rules in the list were invalid\n        // so as not to return an incorrect and/or sequence\n        if (!rules.every(Boolean)) {\n          return null;\n        }\n\n        // Reduce this group to a single between/notBetween rule if possible\n        if (\n          ((rs: unknown[]): rs is [DefaultRuleType, DefaultCombinatorName, DefaultRuleType] =>\n            rs.length === 3 &&\n            (rs[1] === 'and' || rs[1] === 'or') &&\n            !isRuleGroup(rs[0]) &&\n            !isRuleGroup(rs[2]))(rules) &&\n          rules[0].field === rules[2].field &&\n          (rules[0].valueSource ?? 'value') === (rules[2].valueSource ?? 'value') &&\n          ((rules[1] === 'and' &&\n            ((rules[0].operator === '>=' && rules[2].operator === '<=') ||\n              (rules[0].operator === '<=' && rules[2].operator === '>='))) ||\n            (rules[1] === 'or' &&\n              ((rules[0].operator === '>' && rules[2].operator === '<') ||\n                (rules[0].operator === '<' && rules[2].operator === '>'))))\n        ) {\n          return {\n            field: rules[0].field,\n            operator: rules[1] === 'and' ? 'between' : 'notBetween',\n            value:\n              (rules[1] === 'and' && rules[0].operator === '<=') ||\n              (rules[1] === 'or' && rules[0].operator === '>')\n                ? [rules[2].value, rules[0].value]\n                : [rules[0].value, rules[2].value],\n            ...(rules[0].valueSource ? { valueSource: rules[0].valueSource } : null),\n          };\n        }\n\n        return {\n          rules: rules as DefaultRuleGroupICArray,\n        };\n      }\n      const andOrList = generateMixedAndOrList(expr);\n      const combinator = andOrList[1] as DefaultCombinatorName;\n      const filteredList = andOrList\n        .filter(v => Array.isArray(v) || (!!v && typeof v !== 'string' && 'type' in v))\n        .map(v =>\n          Array.isArray(v) ? v.filter(vf => !!v && typeof vf !== 'string' && 'type' in vf) : v\n        ) as (JSONataExprNode | JSONataExprNode[])[];\n      const rules = filteredList\n        .map((exp): DefaultRuleGroupType | DefaultRuleType | null => {\n          if (Array.isArray(exp)) {\n            return {\n              combinator: 'and',\n              rules: exp.map(e => parseJSONataAST(e)).filter(Boolean) as DefaultRuleGroupArray,\n            };\n          }\n          return parseJSONataAST(exp) as DefaultRuleType | DefaultRuleGroupType | null;\n        })\n        .filter(Boolean) as DefaultRuleGroupArray;\n\n      // Reduce this group to a single between/notBetween rule if possible\n      if (\n        ((rs: unknown[]): rs is [DefaultRuleType, DefaultRuleType] =>\n          rs.length === 2 && !isRuleGroup(rs[0]) && !isRuleGroup(rs[1]))(rules) &&\n        rules[0].field === rules[1].field &&\n        (rules[0].valueSource ?? 'value') === (rules[1].valueSource ?? 'value') &&\n        ((combinator === 'and' &&\n          ((rules[0].operator === '>=' && rules[1].operator === '<=') ||\n            (rules[0].operator === '<=' && rules[1].operator === '>='))) ||\n          (combinator === 'or' &&\n            ((rules[0].operator === '>' && rules[1].operator === '<') ||\n              (rules[0].operator === '<' && rules[1].operator === '>'))))\n      ) {\n        return {\n          field: rules[0].field,\n          operator: combinator === 'and' ? 'between' : 'notBetween',\n          value:\n            (combinator === 'and' && rules[0].operator === '<=') ||\n            (combinator === 'or' && rules[0].operator === '>')\n              ? [rules[1].value, rules[0].value]\n              : [rules[0].value, rules[1].value],\n          ...(rules[0].valueSource ? { valueSource: rules[0].valueSource } : null),\n        };\n      }\n\n      // v8 ignore else\n      if (rules.length > 0) {\n        return { combinator, rules };\n      }\n    } else if (isJSONataNot(expr)) {\n      const negatedExpr = parseJSONataAST(expr.arguments[0]);\n      // v8 ignore else\n      if (negatedExpr) {\n        if (\n          !isRuleGroup(negatedExpr) &&\n          (negatedExpr.operator === 'contains' ||\n            negatedExpr.operator === 'beginsWith' ||\n            negatedExpr.operator === 'endsWith')\n        ) {\n          return {\n            ...negatedExpr,\n            operator: negatedLikeOperators[negatedExpr.operator],\n          };\n        }\n        return ic\n          ? ({ rules: [negatedExpr], not: true } as DefaultRuleGroupTypeIC)\n          : ({\n              combinator: 'and',\n              rules: [negatedExpr],\n              not: true,\n            } as DefaultRuleGroupType);\n      }\n    } else if (isJSONataContains(expr)) {\n      const [arg1, arg2] = expr.arguments;\n      let field: string = '';\n      let regex: string | RegExp = '';\n      let valueSource: ValueSource | undefined = undefined;\n      // v8 ignore else\n      if (isJSONataIdentifier(arg1)) {\n        field = getFieldFromPath(arg1);\n        if (isJSONataIdentifier(arg2)) {\n          regex = getFieldFromPath(arg2);\n          valueSource = 'field';\n        } else {\n          // v8 ignore else\n          if (isJSONataString(arg2) || isJSONataRegex(arg2)) {\n            regex = getValidValue(arg2);\n          }\n        }\n      }\n\n      // v8 ignore else\n      if (\n        valueSource === 'field'\n          ? fieldIsValid(field, 'contains', regex as string)\n          : fieldIsValid(field, 'contains')\n      ) {\n        return {\n          field,\n          operator: 'contains',\n          value: regex,\n          ...(valueSource ? { valueSource } : {}),\n        };\n      }\n    } else if (isJSONataIn(expr)) {\n      const field = getFieldFromPath(expr.lhs);\n      let valueSource: ValueSource | undefined = undefined;\n      if (isJSONataIdentifierList(expr.rhs)) {\n        valueSource = 'field';\n      }\n      if (isJSONataValidValue(expr.rhs)) {\n        // oxlint-disable-next-line typescript/no-explicit-any\n        const value: any[] = getValidValue(expr.rhs);\n        // v8 ignore else\n        if (\n          field &&\n          value.every(v => fieldIsValid(field, 'in', valueSource === 'field' ? v : undefined))\n        ) {\n          return { field, operator: 'in', value, ...(valueSource ? { valueSource } : {}) };\n        }\n      }\n    } else if (isJSONataComparison(expr)) {\n      let field: string | null = null;\n      // oxlint-disable-next-line typescript/no-explicit-any\n      let value: any = undefined;\n      let valueSource: ValueSource | undefined = undefined;\n      let flip = false;\n      const { lhs, rhs } = expr;\n\n      if (isJSONataIdentifier(lhs) && isJSONataValidValue(rhs)) {\n        field = getFieldFromPath(lhs);\n        value = getValidValue(rhs);\n        if (isJSONataIdentifier(rhs)) {\n          valueSource = 'field';\n        }\n      } else {\n        // v8 ignore else\n        if (isJSONataIdentifier(rhs) && isJSONataValidValue(lhs)) {\n          flip = true;\n          field = getFieldFromPath(rhs);\n          value = getValidValue(lhs);\n        }\n      }\n      let operator = normalizeOperator(expr.value, flip);\n      if (value === null && (operator === '=' || operator === '!=')) {\n        operator = operator === '=' ? 'null' : 'notNull';\n      }\n      if (\n        field &&\n        fieldIsValid(field, operator, valueSource === 'field' ? value : undefined) &&\n        value !== undefined\n      ) {\n        return valueSource ? { field, operator, value, valueSource } : { field, operator, value };\n      }\n    }\n    return null;\n  };\n\n  const prepare = options.generateIDs ? prepareRuleGroup : <T>(g: T) => g;\n\n  let jsonataExpr: jsonata.Expression;\n  try {\n    jsonataExpr = jsonata(jsonataInput);\n  } catch {\n    return prepare(emptyQuery);\n  }\n  const jsonataAST = jsonataExpr.ast() as JSONataExprNode;\n\n  const result = parseJSONataAST(jsonataAST);\n  if (result) {\n    if (isRuleGroup(result)) {\n      return prepare(result);\n    }\n    return prepare({ rules: [result], ...(ic ? {} : { combinator: 'and' }) });\n  }\n\n  return prepare(emptyQuery);\n}\n\nexport { parseJSONata };\n"],"mappings":"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"}
+{"version":3,"file":"parseJSONata.js","names":["getFieldsArray","fieldIsValidUtil","isRuleGroup","prepareRuleGroup"],"sources":["../src/utils/parseJSONata/utils.ts","../src/utils/parseJSONata/parseJSONata.ts"],"sourcesContent":["import type { DefaultCombinatorName, DefaultOperatorName } from '../../types';\nimport type {\n  JSONataAnd,\n  JSONataBinaryNode,\n  JSONataBlock,\n  JSONataBoolean,\n  JSONataContains,\n  JSONataEqual,\n  JSONataExprNode,\n  JSONataGreaterThan,\n  JSONataGreaterThanOrEqual,\n  JSONataIdentifier,\n  JSONataIn,\n  JSONataLessThan,\n  JSONataLessThanOrEqual,\n  JSONataList,\n  JSONataName,\n  JSONataNot,\n  JSONataNotEqual,\n  JSONataNull,\n  JSONataNumber,\n  JSONataOr,\n  JSONataPath,\n  JSONataRegex,\n  JSONataString,\n  JSONataToMillis,\n} from './types';\n\n// oxlint-disable-next-line typescript/no-explicit-any\ntype Any = any;\n\nexport const isJSONataExprNode = (expr: Any): expr is JSONataExprNode => {\n  return expr && typeof expr === 'object' && typeof expr.type === 'string';\n};\nconst isJSONataBinaryNode = (expr: Any): expr is JSONataBinaryNode =>\n  isJSONataExprNode(expr) && expr.type === 'binary';\n\n// Identifiers\nexport const isJSONataPath = (expr: Any): expr is JSONataPath =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'path' &&\n  Array.isArray(expr.steps) &&\n  expr.steps.length > 0 &&\n  isJSONataExprNode(expr.steps[0]);\nexport const isJSONataName = (expr: Any): expr is JSONataName =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'name' &&\n  typeof expr.value === 'string' &&\n  expr.value.length > 0;\nexport const isJSONataIdentifier = (expr: Any): expr is JSONataIdentifier =>\n  isJSONataPath(expr) && expr.steps.every(v => isJSONataName(v));\n\n// Groups\nexport const isJSONataBlock = (expr: Any): expr is JSONataBlock =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'block' &&\n  Array.isArray(expr.expressions) &&\n  expr.expressions.length > 0 &&\n  isJSONataExprNode(expr.expressions[0]);\n\n// Values\nexport const isJSONataString = (expr: Any): expr is JSONataString =>\n  isJSONataExprNode(expr) && expr.type === 'string' && typeof expr.value === 'string';\nexport const isJSONataNumber = (expr: Any): expr is JSONataNumber =>\n  isJSONataExprNode(expr) && expr.type === 'number' && typeof expr.value === 'number';\nexport const isJSONataBoolean = (expr: Any): expr is JSONataBoolean =>\n  isJSONataExprNode(expr) && expr.type === 'value' && typeof expr.value === 'boolean';\nexport const isJSONataNull = (expr: Any): expr is JSONataNull =>\n  isJSONataExprNode(expr) && expr.type === 'value' && expr.value === null;\nexport const isJSONataRegex = (expr: Any): expr is JSONataRegex =>\n  isJSONataExprNode(expr) && expr.type === 'regex' && expr.value instanceof RegExp;\n\n// Combinators\nexport const isJSONataAnd = (expr: Any): expr is JSONataAnd =>\n  isJSONataBinaryNode(expr) && expr.value === 'and';\nexport const isJSONataOr = (expr: Any): expr is JSONataOr =>\n  isJSONataBinaryNode(expr) && expr.value === 'or';\n\n// Operators\nexport const isJSONataEqual = (expr: Any): expr is JSONataEqual =>\n  isJSONataBinaryNode(expr) && expr.value === '=';\nexport const isJSONataNotEqual = (expr: Any): expr is JSONataNotEqual =>\n  isJSONataBinaryNode(expr) && expr.value === '!=';\nexport const isJSONataGreaterThan = (expr: Any): expr is JSONataGreaterThan =>\n  isJSONataBinaryNode(expr) && expr.value === '>';\nexport const isJSONataGreaterThanOrEqual = (expr: Any): expr is JSONataGreaterThanOrEqual =>\n  isJSONataBinaryNode(expr) && expr.value === '>=';\nexport const isJSONataLessThan = (expr: Any): expr is JSONataLessThan =>\n  isJSONataBinaryNode(expr) && expr.value === '<';\nexport const isJSONataLessThanOrEqual = (expr: Any): expr is JSONataLessThanOrEqual =>\n  isJSONataBinaryNode(expr) && expr.value === '<=';\nexport const isJSONataIn = (expr: Any): expr is JSONataIn =>\n  isJSONataBinaryNode(expr) &&\n  expr.value === 'in' &&\n  isJSONataPath(expr.lhs) &&\n  isJSONataList(expr.rhs);\n\n// Functions\nexport const isJSONataNot = (expr: Any): expr is JSONataNot =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'function' &&\n  expr.value === '(' &&\n  Array.isArray(expr.arguments) &&\n  isJSONataExprNode(expr.arguments[0]) &&\n  isJSONataExprNode(expr.procedure) &&\n  expr.procedure.value === 'not' &&\n  expr.procedure.type === 'variable';\nexport const isJSONataContains = (expr: Any): expr is JSONataContains =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'function' &&\n  expr.value === '(' &&\n  Array.isArray(expr.arguments) &&\n  expr.arguments.length >= 2 &&\n  isJSONataExprNode(expr.arguments[0]) &&\n  isJSONataExprNode(expr.procedure) &&\n  expr.procedure.value === 'contains' &&\n  expr.procedure.type === 'variable';\nexport const isJSONataToMillis = (expr: Any): expr is JSONataToMillis =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'function' &&\n  expr.value === '(' &&\n  Array.isArray(expr.arguments) &&\n  expr.arguments.length > 0 &&\n  isJSONataString(expr.arguments[0]) &&\n  isJSONataExprNode(expr.procedure) &&\n  expr.procedure.value === 'toMillis' &&\n  expr.procedure.type === 'variable';\n\n// Miscellaneous\nexport const isJSONataList = (expr: Any): expr is JSONataList =>\n  isJSONataExprNode(expr) &&\n  expr.type === 'unary' &&\n  expr.value === '[' &&\n  Array.isArray(expr.expressions);\nexport const isJSONataPrimitive = (expr: Any): boolean => {\n  return (\n    isJSONataString(expr) ||\n    isJSONataNumber(expr) ||\n    isJSONataBoolean(expr) ||\n    isJSONataNull(expr) ||\n    isJSONataToMillis(expr)\n  );\n};\nexport const isJSONataPrimitiveList = (expr: Any): boolean =>\n  isJSONataList(expr) && expr.expressions.every(v => isJSONataPrimitive(v));\nexport const isJSONataIdentifierList = (expr: Any): boolean =>\n  isJSONataList(expr) && expr.expressions.every(v => isJSONataIdentifier(v));\nexport const isJSONataValidValue = (expr: Any): boolean =>\n  isJSONataPrimitive(expr) ||\n  isJSONataRegex(expr) ||\n  isJSONataIdentifier(expr) ||\n  isJSONataPrimitiveList(expr) ||\n  isJSONataIdentifierList(expr) ||\n  isJSONataToMillis(expr);\nexport const isJSONataComparison = (\n  expr: Any\n): expr is\n  | JSONataEqual\n  | JSONataNotEqual\n  | JSONataGreaterThan\n  | JSONataGreaterThanOrEqual\n  | JSONataLessThan\n  | JSONataLessThanOrEqual =>\n  isJSONataEqual(expr) ||\n  isJSONataNotEqual(expr) ||\n  isJSONataGreaterThan(expr) ||\n  isJSONataGreaterThanOrEqual(expr) ||\n  isJSONataLessThan(expr) ||\n  isJSONataLessThanOrEqual(expr);\n\nexport const getValidValue = (expr: Any): Any => {\n  if (isJSONataToMillis(expr)) {\n    return getValidValue(expr.arguments[0]);\n  } else if (isJSONataIdentifier(expr)) {\n    return getFieldFromPath(expr);\n  } else if (isJSONataPrimitiveList(expr)) {\n    return expr.expressions.map((v: Any) => getValidValue(v));\n  } else if (isJSONataIdentifierList(expr)) {\n    return expr.expressions.map((v: Any) => getFieldFromPath(v));\n  }\n  return expr.value;\n};\n\nexport const getFieldFromPath = (path: JSONataPath): string =>\n  isJSONataIdentifier(path)\n    ? path.steps.map(s => s.value).join('.')\n    : /* v8 ignore next -- @preserve */ '';\n\nexport const normalizeOperator = (\n  opType: DefaultOperatorName,\n  flip?: boolean\n): DefaultOperatorName => {\n  if (flip) {\n    if (opType === '<') return '>';\n    if (opType === '<=') return '>=';\n    if (opType === '>') return '<';\n    if (opType === '>=') return '<=';\n  }\n  return opType;\n};\n\nexport const negatedLikeOperators: Record<\n  Extract<DefaultOperatorName, 'beginsWith' | 'contains' | 'endsWith'>,\n  DefaultOperatorName\n> = {\n  contains: 'doesNotContain',\n  beginsWith: 'doesNotBeginWith',\n  endsWith: 'doesNotEndWith',\n} satisfies Record<\n  Extract<DefaultOperatorName, 'beginsWith' | 'contains' | 'endsWith'>,\n  DefaultOperatorName\n>;\n\nexport const generateFlatAndOrList = (\n  expr: JSONataExprNode\n): (DefaultCombinatorName | JSONataExprNode)[] => {\n  // v8 ignore else\n  if (isJSONataAnd(expr) || isJSONataOr(expr)) {\n    const { lhs, rhs, value: combinator } = expr;\n    if (isJSONataAnd(lhs) || isJSONataOr(lhs)) {\n      return [...generateFlatAndOrList(lhs), combinator, rhs];\n    }\n    return [lhs, combinator, rhs];\n  }\n  // v8 ignore next\n  return [];\n};\n\nexport const generateMixedAndOrList = (\n  expr: JSONataAnd | JSONataOr\n): (JSONataExprNode | DefaultCombinatorName | (JSONataExprNode | 'and')[])[] => {\n  const arr = generateFlatAndOrList(expr);\n  const returnArray: (DefaultCombinatorName | JSONataExprNode | ('and' | JSONataExprNode)[])[] = [];\n  let startIndex = 0;\n  for (let i = 0; i < arr.length; i += 2) {\n    if (arr[i + 1] === 'and') {\n      startIndex = i;\n      let j = 1;\n      while (arr[startIndex + j] === 'and') {\n        i += 2;\n        j += 2;\n      }\n      const tempAndArray = arr.slice(startIndex, i + 1) as ('and' | JSONataExprNode)[];\n      returnArray.push(tempAndArray);\n      i -= 2;\n    } else if (arr[i + 1] === 'or') {\n      if (i === 0 || i === arr.length - 3) {\n        if (i === 0 || arr[i - 1] === 'or') {\n          returnArray.push(arr[i]);\n        }\n        returnArray.push(arr[i + 1]);\n        if (i === arr.length - 3) {\n          returnArray.push(arr[i + 2]);\n        }\n      } else {\n        if (arr[i - 1] === 'and') {\n          returnArray.push(arr[i + 1]);\n        } else {\n          returnArray.push(arr[i], arr[i + 1]);\n        }\n      }\n    }\n  }\n  if (returnArray.length === 1 && Array.isArray(returnArray[0])) {\n    // If length is 1, then the only element is an AND array so just return that\n    return returnArray[0];\n  }\n  return returnArray;\n};\n","import jsonata from 'jsonata';\nimport type { Except } from 'type-fest';\nimport type {\n  DefaultCombinatorName,\n  DefaultOperatorName,\n  DefaultRuleGroupArray,\n  DefaultRuleGroupICArray,\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n  ValueSource,\n} from '../../types';\nimport type { ParserCommonOptions } from '../../types/import';\nimport { isRuleGroup } from '../isRuleGroup';\nimport { fieldIsValidUtil, getFieldsArray } from '../parserUtils';\nimport { prepareRuleGroup } from '../prepareQueryObjects';\nimport type { JSONataExprNode } from './types';\nimport {\n  generateFlatAndOrList,\n  generateMixedAndOrList,\n  getFieldFromPath,\n  getValidValue,\n  isJSONataAnd,\n  isJSONataBlock,\n  isJSONataComparison,\n  isJSONataContains,\n  isJSONataIdentifier,\n  isJSONataIdentifierList,\n  isJSONataIn,\n  isJSONataNot,\n  isJSONataOr,\n  isJSONataRegex,\n  isJSONataString,\n  isJSONataValidValue,\n  negatedLikeOperators,\n  normalizeOperator,\n} from './utils';\n\n/**\n * Options object for {@link parseJSONata}.\n *\n * Note: `listsAsArrays` is ignored by `parseJSONata`; lists are _always_ arrays.\n */\nexport interface ParseJSONataOptions extends ParserCommonOptions {}\n\n/**\n * Converts a JSONata string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).\n */\nfunction parseJSONata(jsonataInput: string): DefaultRuleGroupType;\n/**\n * Converts a JSONata string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).\n */\nfunction parseJSONata(\n  jsonataInput: string,\n  options: Except<ParseJSONataOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\n/**\n * Converts a JSONata string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).\n */\nfunction parseJSONata(\n  jsonataInput: string,\n  options: Except<ParseJSONataOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nfunction parseJSONata(\n  jsonataInput: string,\n  options: ParseJSONataOptions = {}\n): DefaultRuleGroupTypeAny {\n  const { fields, independentCombinators, listsAsArrays: _laa } = options;\n  const ic = !!independentCombinators;\n  const fieldsFlat = getFieldsArray(fields);\n\n  const fieldIsValid = (\n    fieldName: string,\n    operator: DefaultOperatorName,\n    subordinateFieldName?: string\n  ) =>\n    fieldIsValidUtil({\n      fieldName,\n      fieldsFlat,\n      operator,\n      subordinateFieldName,\n      getValueSources: options?.getValueSources,\n    });\n\n  const emptyQuery: DefaultRuleGroupTypeAny = {\n    rules: [],\n    ...(ic ? {} : { combinator: 'and' }),\n  };\n\n  const parseJSONataAST = (\n    expr: JSONataExprNode,\n    processOpts: {\n      groupOnlyIfNecessary?: boolean;\n      forwardNegation?: boolean;\n    } = {}\n  ): DefaultRuleType | DefaultRuleGroupTypeAny | null => {\n    const { forwardNegation: _forwardedNegation, groupOnlyIfNecessary: _g } = processOpts;\n    if (isJSONataBlock(expr)) {\n      if (\n        isJSONataAnd(expr.expressions[0]) ||\n        isJSONataOr(expr.expressions[0]) ||\n        isJSONataBlock(expr.expressions[0])\n      ) {\n        return parseJSONataAST(expr.expressions[0]);\n      }\n      const blockOfExpr = parseJSONataAST(expr.expressions[0]);\n      // v8 ignore else\n      if (blockOfExpr) {\n        return ic\n          ? ({ rules: [blockOfExpr] } as DefaultRuleGroupTypeIC)\n          : ({\n              combinator: 'and',\n              rules: [blockOfExpr],\n            } as DefaultRuleGroupType);\n      }\n    } else if (isJSONataAnd(expr) || isJSONataOr(expr)) {\n      if (ic) {\n        const andOrList = generateFlatAndOrList(expr);\n        const rules = andOrList.map(v => {\n          if (typeof v === 'string') {\n            return v;\n          }\n          return parseJSONataAST(v);\n        });\n        // Bail out completely if any rules in the list were invalid\n        // so as not to return an incorrect and/or sequence\n        if (!rules.every(Boolean)) {\n          return null;\n        }\n\n        // Reduce this group to a single between/notBetween rule if possible\n        if (\n          ((rs: unknown[]): rs is [DefaultRuleType, DefaultCombinatorName, DefaultRuleType] =>\n            rs.length === 3 &&\n            (rs[1] === 'and' || rs[1] === 'or') &&\n            !isRuleGroup(rs[0]) &&\n            !isRuleGroup(rs[2]))(rules) &&\n          rules[0].field === rules[2].field &&\n          (rules[0].valueSource ?? 'value') === (rules[2].valueSource ?? 'value') &&\n          ((rules[1] === 'and' &&\n            ((rules[0].operator === '>=' && rules[2].operator === '<=') ||\n              (rules[0].operator === '<=' && rules[2].operator === '>='))) ||\n            (rules[1] === 'or' &&\n              ((rules[0].operator === '>' && rules[2].operator === '<') ||\n                (rules[0].operator === '<' && rules[2].operator === '>'))))\n        ) {\n          return {\n            field: rules[0].field,\n            operator: rules[1] === 'and' ? 'between' : 'notBetween',\n            value:\n              (rules[1] === 'and' && rules[0].operator === '<=') ||\n              (rules[1] === 'or' && rules[0].operator === '>')\n                ? [rules[2].value, rules[0].value]\n                : [rules[0].value, rules[2].value],\n            ...(rules[0].valueSource ? { valueSource: rules[0].valueSource } : null),\n          };\n        }\n\n        return {\n          rules: rules as DefaultRuleGroupICArray,\n        };\n      }\n      const andOrList = generateMixedAndOrList(expr);\n      const combinator = andOrList[1] as DefaultCombinatorName;\n      const filteredList = andOrList\n        .filter(v => Array.isArray(v) || (!!v && typeof v !== 'string' && 'type' in v))\n        .map(v =>\n          Array.isArray(v) ? v.filter(vf => !!v && typeof vf !== 'string' && 'type' in vf) : v\n        ) as (JSONataExprNode | JSONataExprNode[])[];\n      const rules = filteredList\n        .map((exp): DefaultRuleGroupType | DefaultRuleType | null => {\n          if (Array.isArray(exp)) {\n            return {\n              combinator: 'and',\n              rules: exp.map(e => parseJSONataAST(e)).filter(Boolean) as DefaultRuleGroupArray,\n            };\n          }\n          return parseJSONataAST(exp) as DefaultRuleType | DefaultRuleGroupType | null;\n        })\n        .filter(Boolean) as DefaultRuleGroupArray;\n\n      // Reduce this group to a single between/notBetween rule if possible\n      if (\n        ((rs: unknown[]): rs is [DefaultRuleType, DefaultRuleType] =>\n          rs.length === 2 && !isRuleGroup(rs[0]) && !isRuleGroup(rs[1]))(rules) &&\n        rules[0].field === rules[1].field &&\n        (rules[0].valueSource ?? 'value') === (rules[1].valueSource ?? 'value') &&\n        ((combinator === 'and' &&\n          ((rules[0].operator === '>=' && rules[1].operator === '<=') ||\n            (rules[0].operator === '<=' && rules[1].operator === '>='))) ||\n          (combinator === 'or' &&\n            ((rules[0].operator === '>' && rules[1].operator === '<') ||\n              (rules[0].operator === '<' && rules[1].operator === '>'))))\n      ) {\n        return {\n          field: rules[0].field,\n          operator: combinator === 'and' ? 'between' : 'notBetween',\n          value:\n            (combinator === 'and' && rules[0].operator === '<=') ||\n            (combinator === 'or' && rules[0].operator === '>')\n              ? [rules[1].value, rules[0].value]\n              : [rules[0].value, rules[1].value],\n          ...(rules[0].valueSource ? { valueSource: rules[0].valueSource } : null),\n        };\n      }\n\n      // v8 ignore else\n      if (rules.length > 0) {\n        return { combinator, rules };\n      }\n    } else if (isJSONataNot(expr)) {\n      const negatedExpr = parseJSONataAST(expr.arguments[0]);\n      // v8 ignore else\n      if (negatedExpr) {\n        if (\n          !isRuleGroup(negatedExpr) &&\n          (negatedExpr.operator === 'contains' ||\n            negatedExpr.operator === 'beginsWith' ||\n            negatedExpr.operator === 'endsWith')\n        ) {\n          return {\n            ...negatedExpr,\n            operator: negatedLikeOperators[negatedExpr.operator],\n          };\n        }\n        return ic\n          ? ({ rules: [negatedExpr], not: true } as DefaultRuleGroupTypeIC)\n          : ({\n              combinator: 'and',\n              rules: [negatedExpr],\n              not: true,\n            } as DefaultRuleGroupType);\n      }\n    } else if (isJSONataContains(expr)) {\n      const [arg1, arg2] = expr.arguments;\n      let field: string = '';\n      let regex: string | RegExp = '';\n      let valueSource: ValueSource | undefined = undefined;\n      // v8 ignore else\n      if (isJSONataIdentifier(arg1)) {\n        field = getFieldFromPath(arg1);\n        if (isJSONataIdentifier(arg2)) {\n          regex = getFieldFromPath(arg2);\n          valueSource = 'field';\n        } else {\n          // v8 ignore else\n          if (isJSONataString(arg2) || isJSONataRegex(arg2)) {\n            regex = getValidValue(arg2);\n          }\n        }\n      }\n\n      // v8 ignore else\n      if (\n        valueSource === 'field'\n          ? fieldIsValid(field, 'contains', regex as string)\n          : fieldIsValid(field, 'contains')\n      ) {\n        return {\n          field,\n          operator: 'contains',\n          value: regex,\n          ...(valueSource ? { valueSource } : {}),\n        };\n      }\n    } else if (isJSONataIn(expr)) {\n      const field = getFieldFromPath(expr.lhs);\n      let valueSource: ValueSource | undefined = undefined;\n      if (isJSONataIdentifierList(expr.rhs)) {\n        valueSource = 'field';\n      }\n      if (isJSONataValidValue(expr.rhs)) {\n        // oxlint-disable-next-line typescript/no-explicit-any\n        const value: any[] = getValidValue(expr.rhs);\n        // v8 ignore else\n        if (\n          field &&\n          value.every(v => fieldIsValid(field, 'in', valueSource === 'field' ? v : undefined))\n        ) {\n          return { field, operator: 'in', value, ...(valueSource ? { valueSource } : {}) };\n        }\n      }\n    } else if (isJSONataComparison(expr)) {\n      let field: string | null = null;\n      // oxlint-disable-next-line typescript/no-explicit-any\n      let value: any = undefined;\n      let valueSource: ValueSource | undefined = undefined;\n      let flip = false;\n      const { lhs, rhs } = expr;\n\n      if (isJSONataIdentifier(lhs) && isJSONataValidValue(rhs)) {\n        field = getFieldFromPath(lhs);\n        value = getValidValue(rhs);\n        if (isJSONataIdentifier(rhs)) {\n          valueSource = 'field';\n        }\n      } else {\n        // v8 ignore else\n        if (isJSONataIdentifier(rhs) && isJSONataValidValue(lhs)) {\n          flip = true;\n          field = getFieldFromPath(rhs);\n          value = getValidValue(lhs);\n        }\n      }\n      let operator = normalizeOperator(expr.value, flip);\n      if (value === null && (operator === '=' || operator === '!=')) {\n        operator = operator === '=' ? 'null' : 'notNull';\n      }\n      if (\n        field &&\n        fieldIsValid(field, operator, valueSource === 'field' ? value : undefined) &&\n        value !== undefined\n      ) {\n        return valueSource ? { field, operator, value, valueSource } : { field, operator, value };\n      }\n    }\n    return null;\n  };\n\n  const prepare = options.generateIDs ? prepareRuleGroup : <T>(g: T) => g;\n\n  let jsonataExpr: jsonata.Expression;\n  try {\n    jsonataExpr = jsonata(jsonataInput);\n  } catch {\n    return prepare(emptyQuery);\n  }\n  const jsonataAST = jsonataExpr.ast() as JSONataExprNode;\n\n  const result = parseJSONataAST(jsonataAST);\n  if (result) {\n    if (isRuleGroup(result)) {\n      return prepare(result);\n    }\n    return prepare({ rules: [result], ...(ic ? {} : { combinator: 'and' }) });\n  }\n\n  return prepare(emptyQuery);\n}\n\nexport { parseJSONata };\n"],"mappings":"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"}