@react-querybuilder/core 8.14.4 → 8.16.0

package/dist/parseGremlin.d.ts

@@ -0,0 +1,35 @@
+import { E as DefaultRuleGroupType, x as DefaultRuleGroupTypeIC } from "./index-Cjapnb-H.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 { A as Except, T as DefaultRuleGroupType, b as DefaultRuleGroupTypeIC } from "./index-CYT4Saz-.mjs";
-import { t as ParserCommonOptions } from "./import-BwQqExpO.mjs";
+import { E as DefaultRuleGroupType, j as Except, x as DefaultRuleGroupTypeIC } from "./index-D-Iej37L.mjs";
+import { t as ParserCommonOptions } from "./import-BHlzBLM_.mjs";
 
 //#region src/utils/parseJSONata/parseJSONata.d.ts
 /**

package/dist/parseJSONata.d.ts

@@ -1,5 +1,5 @@
-import { A as Except, T as DefaultRuleGroupType, b as DefaultRuleGroupTypeIC } from "./index-DBlQeLax.js";
-import { t as ParserCommonOptions } from "./import-CrJf23Nf.js";
+import { E as DefaultRuleGroupType, j as Except, x as DefaultRuleGroupTypeIC } from "./index-Cjapnb-H.js";
+import { t as ParserCommonOptions } from "./import-C6imciDf.js";
 
 //#region src/utils/parseJSONata/parseJSONata.d.ts
 /**

package/dist/parseJSONata.js

@@ -21,8 +21,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-const require_objectUtils = require("./objectUtils-ButT0Mng.js");
-const require_prepareQueryObjects = require("./prepareQueryObjects-DO3qXriW.js");
+const require_objectUtils = require("./objectUtils-Bzug_QfX.js");
+const require_prepareQueryObjects = require("./prepareQueryObjects-BoG5Rt8z.js");
 let jsonata = require("jsonata");
 jsonata = __toESM(jsonata);
 //#region src/utils/parseJSONata/utils.ts
@@ -66,7 +66,7 @@ const getValidValue = (expr) => {
 	else if (isJSONataIdentifierList(expr)) return expr.expressions.map((v) => getFieldFromPath(v));
 	return expr.value;
 };
-const getFieldFromPath = (path) => isJSONataIdentifier(path) ? path.steps.map((s) => s.value).join(".") : "";
+const getFieldFromPath = (path) => isJSONataIdentifier(path) ? path.steps.map((s) => s.value).join(".") : /* v8 ignore next -- @preserve */ "";
 const normalizeOperator = (opType, flip) => {
 	if (flip) {
 		if (opType === "<") return ">";
@@ -82,7 +82,7 @@ const negatedLikeOperators = {
 	endsWith: "doesNotEndWith"
 };
 const generateFlatAndOrList = (expr) => {
-	// istanbul ignore else
+	// v8 ignore else
 	if (isJSONataAnd(expr) || isJSONataOr(expr)) {
 		const { lhs, rhs, value: combinator } = expr;
 		if (isJSONataAnd(lhs) || isJSONataOr(lhs)) return [
@@ -96,7 +96,7 @@ const generateFlatAndOrList = (expr) => {
 			rhs
 		];
 	}
-	// istanbul ignore next
+	// v8 ignore next
 	return [];
 };
 const generateMixedAndOrList = (expr) => {
@@ -144,7 +144,7 @@ function parseJSONata(jsonataInput, options = {}) {
 		if (isJSONataBlock(expr)) {
 			if (isJSONataAnd(expr.expressions[0]) || isJSONataOr(expr.expressions[0]) || isJSONataBlock(expr.expressions[0])) return parseJSONataAST(expr.expressions[0]);
 			const blockOfExpr = parseJSONataAST(expr.expressions[0]);
-			// istanbul ignore else
+			// v8 ignore else
 			if (blockOfExpr) return ic ? { rules: [blockOfExpr] } : {
 				combinator: "and",
 				rules: [blockOfExpr]
@@ -179,14 +179,14 @@ function parseJSONata(jsonataInput, options = {}) {
 				value: combinator === "and" && rules[0].operator === "<=" || combinator === "or" && rules[0].operator === ">" ? [rules[1].value, rules[0].value] : [rules[0].value, rules[1].value],
 				...rules[0].valueSource ? { valueSource: rules[0].valueSource } : null
 			};
-			// istanbul ignore else
+			// v8 ignore else
 			if (rules.length > 0) return {
 				combinator,
 				rules
 			};
 		} else if (isJSONataNot(expr)) {
 			const negatedExpr = parseJSONataAST(expr.arguments[0]);
-			// istanbul ignore else
+			// v8 ignore else
 			if (negatedExpr) {
 				if (!require_objectUtils.isRuleGroup(negatedExpr) && (negatedExpr.operator === "contains" || negatedExpr.operator === "beginsWith" || negatedExpr.operator === "endsWith")) return {
 					...negatedExpr,
@@ -206,7 +206,7 @@ function parseJSONata(jsonataInput, options = {}) {
 			let field = "";
 			let regex = "";
 			let valueSource = void 0;
-			// istanbul ignore else
+			// v8 ignore else
 			if (isJSONataIdentifier(arg1)) {
 				field = getFieldFromPath(arg1);
 				if (isJSONataIdentifier(arg2)) {
@@ -214,7 +214,7 @@ function parseJSONata(jsonataInput, options = {}) {
 					valueSource = "field";
 				} else if (isJSONataString(arg2) || isJSONataRegex(arg2)) regex = getValidValue(arg2);
 			}
-			// istanbul ignore else
+			// v8 ignore else
 			if (valueSource === "field" ? fieldIsValid(field, "contains", regex) : fieldIsValid(field, "contains")) return {
 				field,
 				operator: "contains",
@@ -227,7 +227,7 @@ function parseJSONata(jsonataInput, options = {}) {
 			if (isJSONataIdentifierList(expr.rhs)) valueSource = "field";
 			if (isJSONataValidValue(expr.rhs)) {
 				const value = getValidValue(expr.rhs);
-				// istanbul ignore else
+				// v8 ignore else
 				if (field && value.every((v) => fieldIsValid(field, "in", valueSource === "field" ? v : void 0))) return {
 					field,
 					operator: "in",