@react-querybuilder/core 8.21.1 → 8.22.0

package/dist/parseCypher.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseCypher.js","names":["Lexer","CstParser"],"sources":["../src/utils/parseCypher/parseCypher.ts"],"sourcesContent":["import { createToken, Lexer, CstParser, type CstNode, type IToken } from 'chevrotain';\nimport type {\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n} from '../../types';\n\n// ─── Lexer Tokens ────────────────────────────────────────────────────────────\n\nconst WhiteSpace = createToken({ name: 'WhiteSpace', pattern: /\\s+/, group: Lexer.SKIPPED });\n\n// Keywords (longer/multi-word first)\nconst OptionalMatch = createToken({\n  name: 'OptionalMatch',\n  pattern: /OPTIONAL\\s+MATCH/i,\n  longer_alt: undefined,\n});\nconst StartsWith = createToken({ name: 'StartsWith', pattern: /STARTS\\s+WITH/i });\nconst EndsWith = createToken({ name: 'EndsWith', pattern: /ENDS\\s+WITH/i });\nconst IsNotNull = createToken({ name: 'IsNotNull', pattern: /IS\\s+NOT\\s+NULL/i });\nconst IsNull = createToken({ name: 'IsNull', pattern: /IS\\s+NULL/i });\nconst NotIn = createToken({ name: 'NotIn', pattern: /NOT\\s+IN/i });\nconst Match = createToken({ name: 'Match', pattern: /MATCH/i });\nconst Where = createToken({ name: 'Where', pattern: /WHERE/i });\nconst Return = createToken({ name: 'Return', pattern: /RETURN/i });\nconst And = createToken({ name: 'And', pattern: /AND/i });\nconst Or = createToken({ name: 'Or', pattern: /OR/i });\nconst Not = createToken({ name: 'Not', pattern: /NOT/i });\nconst Contains = createToken({ name: 'Contains', pattern: /CONTAINS/i });\nconst In = createToken({ name: 'In', pattern: /IN/i });\nconst NullLit = createToken({ name: 'NullLit', pattern: /null\\b/ });\nconst TrueLit = createToken({ name: 'TrueLit', pattern: /true\\b/ });\nconst FalseLit = createToken({ name: 'FalseLit', pattern: /false\\b/ });\n\n// Literals\nconst StringLiteral = createToken({ name: 'StringLiteral', pattern: /'(?:[^'\\\\]|\\\\.)*'/ });\nconst NumberLiteral = createToken({ name: 'NumberLiteral', pattern: /-?\\d+(?:\\.\\d+)?/ });\n\n// Operators\nconst LessEqual = createToken({ name: 'LessEqual', pattern: /<=/ });\nconst GreaterEqual = createToken({ name: 'GreaterEqual', pattern: />=/ });\nconst NotEqual = createToken({ name: 'NotEqual', pattern: /<>/ });\nconst Less = createToken({ name: 'Less', pattern: /</ });\nconst Greater = createToken({ name: 'Greater', pattern: />/ });\nconst Equal = createToken({ name: 'Equal', pattern: /=/ });\n\n// Punctuation\nconst LParen = createToken({ name: 'LParen', pattern: /\\(/ });\nconst RParen = createToken({ name: 'RParen', pattern: /\\)/ });\nconst LBracket = createToken({ name: 'LBracket', pattern: /\\[/ });\nconst RBracket = createToken({ name: 'RBracket', pattern: /\\]/ });\nconst Comma = createToken({ name: 'Comma', pattern: /,/ });\nconst Colon = createToken({ name: 'Colon', pattern: /:/ });\nconst Dot = createToken({ name: 'Dot', pattern: /\\./ });\n\n// Arrow parts for relationship patterns\nconst DashArrowRight = createToken({ name: 'DashArrowRight', pattern: /->/ });\nconst ArrowLeftDash = createToken({ name: 'ArrowLeftDash', pattern: /<-/ });\nconst Dash = createToken({ name: 'Dash', pattern: /-/ });\n\n// Identifier (must come after all keywords)\nconst Identifier = createToken({ name: 'Identifier', pattern: /[a-zA-Z_]\\w*/ });\n\n// Token order matters: longer patterns and keywords before shorter ones\nconst allTokens = [\n  WhiteSpace,\n  // Multi-word keywords (must come before single-word)\n  OptionalMatch,\n  StartsWith,\n  EndsWith,\n  IsNotNull,\n  IsNull,\n  NotIn,\n  // Single-word keywords\n  Match,\n  Where,\n  Return,\n  And,\n  Or,\n  Not,\n  Contains,\n  In,\n  NullLit,\n  TrueLit,\n  FalseLit,\n  // Literals\n  StringLiteral,\n  NumberLiteral,\n  // Multi-char operators\n  LessEqual,\n  GreaterEqual,\n  NotEqual,\n  DashArrowRight,\n  ArrowLeftDash,\n  // Single-char operators\n  Less,\n  Greater,\n  Equal,\n  // Punctuation\n  LParen,\n  RParen,\n  LBracket,\n  RBracket,\n  Comma,\n  Colon,\n  Dot,\n  Dash,\n  // Identifier last\n  Identifier,\n];\n\nconst cypherLexer = new Lexer(allTokens);\n\n// ─── CST Parser ──────────────────────────────────────────────────────────────\n\nclass CypherCstParser extends CstParser {\n  constructor() {\n    super(allTokens, { recoveryEnabled: false });\n    this.performSelfAnalysis();\n  }\n\n  /** Top-level: sequence of MATCH/OPTIONAL MATCH clauses, optional WHERE, optional RETURN */\n  public cypherQuery = this.RULE('cypherQuery', () => {\n    this.MANY(() => {\n      this.OR([\n        { ALT: () => this.SUBRULE(this.optionalMatchClause) },\n        { ALT: () => this.SUBRULE(this.matchClause) },\n      ]);\n    });\n    this.OPTION(() => this.SUBRULE(this.whereClause));\n    this.OPTION1(() => this.SUBRULE(this.returnClause));\n  });\n\n  /** MATCH pattern */\n  public matchClause = this.RULE('matchClause', () => {\n    this.CONSUME(Match);\n    this.SUBRULE(this.pattern);\n  });\n\n  /** OPTIONAL MATCH pattern */\n  public optionalMatchClause = this.RULE('optionalMatchClause', () => {\n    this.CONSUME(OptionalMatch);\n    this.SUBRULE(this.pattern);\n  });\n\n  /** A graph pattern: node or node-rel-node */\n  public pattern = this.RULE('pattern', () => {\n    this.SUBRULE(this.nodePattern, { LABEL: 'lhs' });\n    this.OPTION(() => {\n      this.SUBRULE(this.relPattern);\n      this.SUBRULE1(this.nodePattern, { LABEL: 'rhs' });\n    });\n  });\n\n  /** (alias:Label) or (alias) */\n  public nodePattern = this.RULE('nodePattern', () => {\n    this.CONSUME(LParen);\n    this.CONSUME(Identifier, { LABEL: 'alias' });\n    this.OPTION(() => {\n      this.CONSUME(Colon);\n      this.CONSUME1(Identifier, { LABEL: 'label' });\n    });\n    this.CONSUME(RParen);\n  });\n\n  /** -[:TYPE]-> or <-[:TYPE]- or -[:TYPE]- */\n  public relPattern = this.RULE('relPattern', () => {\n    this.OR([\n      {\n        ALT: () => {\n          this.CONSUME(ArrowLeftDash, { LABEL: 'leftArrow' });\n          this.CONSUME(LBracket);\n          this.OPTION(() => {\n            this.CONSUME(Colon);\n            this.CONSUME(Identifier, { LABEL: 'relType' });\n          });\n          this.CONSUME(RBracket);\n          this.CONSUME(Dash, { LABEL: 'rightDash' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME1(Dash, { LABEL: 'leftDash' });\n          this.CONSUME1(LBracket);\n          this.OPTION1(() => {\n            this.CONSUME1(Colon);\n            this.CONSUME1(Identifier, { LABEL: 'relType' });\n          });\n          this.CONSUME1(RBracket);\n          this.CONSUME(DashArrowRight, { LABEL: 'rightArrow' });\n        },\n      },\n    ]);\n  });\n\n  /** WHERE expression */\n  public whereClause = this.RULE('whereClause', () => {\n    this.CONSUME(Where);\n    this.SUBRULE(this.orExpression);\n  });\n\n  /** expression OR expression */\n  public orExpression = this.RULE('orExpression', () => {\n    this.SUBRULE(this.andExpression, { LABEL: 'lhs' });\n    this.MANY(() => {\n      this.CONSUME(Or);\n      this.SUBRULE1(this.andExpression, { LABEL: 'rhs' });\n    });\n  });\n\n  /** expression AND expression */\n  public andExpression = this.RULE('andExpression', () => {\n    this.SUBRULE(this.notExpression, { LABEL: 'lhs' });\n    this.MANY(() => {\n      this.CONSUME(And);\n      this.SUBRULE1(this.notExpression, { LABEL: 'rhs' });\n    });\n  });\n\n  /** NOT expression */\n  public notExpression = this.RULE('notExpression', () => {\n    this.OPTION(() => this.CONSUME(Not));\n    this.SUBRULE(this.atomicExpression);\n  });\n\n  /** Parenthesized group or single condition */\n  public atomicExpression = this.RULE('atomicExpression', () => {\n    this.OR([\n      {\n        ALT: () => {\n          this.CONSUME(LParen);\n          this.SUBRULE(this.orExpression);\n          this.CONSUME(RParen);\n        },\n      },\n      { ALT: () => this.SUBRULE(this.condition) },\n    ]);\n  });\n\n  /** Single condition: field op value */\n  public condition = this.RULE('condition', () => {\n    this.SUBRULE(this.propertyRef, { LABEL: 'field' });\n    this.OR([\n      {\n        ALT: () => {\n          this.CONSUME(Equal);\n          this.SUBRULE(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(NotEqual);\n          this.SUBRULE1(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(Less);\n          this.SUBRULE2(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(Greater);\n          this.SUBRULE3(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(LessEqual);\n          this.SUBRULE4(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(GreaterEqual);\n          this.SUBRULE5(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(Contains);\n          this.SUBRULE6(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(StartsWith);\n          this.SUBRULE7(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(EndsWith);\n          this.SUBRULE8(this.literal, { LABEL: 'value' });\n        },\n      },\n      { ALT: () => this.CONSUME(IsNotNull) },\n      { ALT: () => this.CONSUME(IsNull) },\n      {\n        ALT: () => {\n          this.CONSUME(In);\n          this.SUBRULE(this.listLiteral, { LABEL: 'list' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(NotIn);\n          this.SUBRULE1(this.listLiteral, { LABEL: 'list' });\n        },\n      },\n    ]);\n  });\n\n  /** Dotted property reference: alias.prop or just identifier */\n  public propertyRef = this.RULE('propertyRef', () => {\n    this.CONSUME(Identifier, { LABEL: 'head' });\n    this.MANY(() => {\n      this.CONSUME(Dot);\n      this.CONSUME1(Identifier, { LABEL: 'tail' });\n    });\n  });\n\n  /** A literal value */\n  public literal = this.RULE('literal', () => {\n    this.OR([\n      { ALT: () => this.CONSUME(StringLiteral) },\n      { ALT: () => this.CONSUME(NumberLiteral) },\n      { ALT: () => this.CONSUME(NullLit) },\n      { ALT: () => this.CONSUME(TrueLit) },\n      { ALT: () => this.CONSUME(FalseLit) },\n      { ALT: () => this.CONSUME(Identifier) },\n    ]);\n  });\n\n  /** [val, val, ...] */\n  public listLiteral = this.RULE('listLiteral', () => {\n    this.CONSUME(LBracket);\n    this.OPTION(() => {\n      this.SUBRULE(this.literal, { LABEL: 'items' });\n      this.MANY(() => {\n        this.CONSUME(Comma);\n        this.SUBRULE1(this.literal, { LABEL: 'items' });\n      });\n    });\n    this.CONSUME(RBracket);\n  });\n\n  /** RETURN clause (consumed but not transformed) */\n  public returnClause = this.RULE('returnClause', () => {\n    this.CONSUME(Return);\n    this.MANY(() => {\n      this.OR([\n        { ALT: () => this.CONSUME(Identifier) },\n        { ALT: () => this.CONSUME(Comma) },\n        { ALT: () => this.CONSUME(Dot) },\n      ]);\n    });\n  });\n}\n\nconst parserInstance = new CypherCstParser();\n\n// ─── CST Visitor (CST → RuleGroupType) ──────────────────────────────────────\n\n/** Resolves a literal token to a JS value. */\nconst tokenToValue = (token: IToken): unknown => {\n  const img = token.image;\n  switch (token.tokenType) {\n    case StringLiteral:\n      return img.slice(1, -1).replace(/\\\\'/g, \"'\");\n    case NumberLiteral:\n      return Number(img);\n    case NullLit:\n      return null;\n    case TrueLit:\n      return true;\n    case FalseLit:\n      return false;\n    default:\n      return img;\n  }\n};\n\n/** Extracts a literal value from a CST 'literal' node. */\nconst extractLiteral = (literalNode: CstNode): unknown => {\n  const children = literalNode.children;\n  const token =\n    (children.StringLiteral as IToken[])?.[0] ??\n    (children.NumberLiteral as IToken[])?.[0] ??\n    (children.NullLit as IToken[])?.[0] ??\n    (children.TrueLit as IToken[])?.[0] ??\n    (children.FalseLit as IToken[])?.[0] ??\n    (children.Identifier as IToken[])?.[0];\n  return token ? tokenToValue(token) : '';\n};\n\n/** Builds a dotted property reference string from a propertyRef CST node. */\nconst extractPropertyRef = (node: CstNode): string => {\n  const head = (node.children.head as IToken[])[0].image;\n  const tails = (node.children.tail as IToken[] | undefined) ?? [];\n  if (tails.length === 0) return head;\n  return head + '.' + tails.map(t => t.image).join('.');\n};\n\n/** Extracts list items from a listLiteral CST node. */\nconst extractList = (node: CstNode): unknown[] => {\n  const items = (node.children.items as CstNode[] | undefined) ?? [];\n  return items.map(extractLiteral);\n};\n\ntype RuleOrGroup = DefaultRuleType | DefaultRuleGroupType;\n\n/** Visits an orExpression CST node. */\nconst visitOrExpression = (node: CstNode): RuleOrGroup[] => {\n  const lhsNodes = node.children.lhs as CstNode[];\n  const rhsNodes = (node.children.rhs as CstNode[] | undefined) ?? [];\n\n  if (rhsNodes.length === 0) {\n    return visitAndExpression(lhsNodes[0]);\n  }\n\n  const allParts = [lhsNodes[0], ...rhsNodes];\n  const subRules: RuleOrGroup[] = [];\n  for (const part of allParts) {\n    const partRules = visitAndExpression(part);\n    if (partRules.length === 1) {\n      subRules.push(partRules[0]);\n    } else {\n      subRules.push({ combinator: 'and', rules: partRules });\n    }\n  }\n  return [{ combinator: 'or', rules: subRules }];\n};\n\n/** Visits an andExpression CST node. */\nconst visitAndExpression = (node: CstNode): RuleOrGroup[] => {\n  const lhsNodes = node.children.lhs as CstNode[];\n  const rhsNodes = (node.children.rhs as CstNode[] | undefined) ?? [];\n  const all = [lhsNodes[0], ...rhsNodes];\n  const rules: RuleOrGroup[] = [];\n  for (const item of all) {\n    rules.push(...visitNotExpression(item));\n  }\n  return rules;\n};\n\n/** Visits a notExpression CST node. */\nconst visitNotExpression = (node: CstNode): RuleOrGroup[] => {\n  const hasNot = !!(node.children.Not as IToken[] | undefined)?.length;\n  const atomicRules = visitAtomicExpression((node.children.atomicExpression as CstNode[])[0]);\n\n  if (!hasNot) return atomicRules;\n\n  return [{ combinator: 'and', not: true, rules: atomicRules }];\n};\n\n/** Visits an atomicExpression CST node. */\nconst visitAtomicExpression = (node: CstNode): RuleOrGroup[] => {\n  if (node.children.orExpression) {\n    return visitOrExpression((node.children.orExpression as CstNode[])[0]);\n  }\n  if (node.children.condition) {\n    return [visitCondition((node.children.condition as CstNode[])[0])];\n  }\n  return [];\n};\n\n/** Visits a condition CST node and returns a DefaultRuleType (no meta). */\nconst visitCondition = (node: CstNode): DefaultRuleType => {\n  const field = extractPropertyRef((node.children.field as CstNode[])[0]);\n\n  if (node.children.IsNull) {\n    return { field, operator: 'null', value: null } as DefaultRuleType;\n  }\n  if (node.children.IsNotNull) {\n    return { field, operator: 'notNull', value: null } as DefaultRuleType;\n  }\n\n  if (node.children.In) {\n    const list = extractList((node.children.list as CstNode[])[0]);\n    return { field, operator: 'in', value: list } as DefaultRuleType;\n  }\n  if (node.children.NotIn) {\n    const list = extractList((node.children.list as CstNode[])[0]);\n    return { field, operator: 'notIn', value: list } as DefaultRuleType;\n  }\n\n  const valueNode = (node.children.value as CstNode[] | undefined)?.[0];\n  const value = valueNode ? extractLiteral(valueNode) : null;\n\n  if (node.children.Equal) return { field, operator: '=', value } as DefaultRuleType;\n  if (node.children.NotEqual) return { field, operator: '!=', value } as DefaultRuleType;\n  if (node.children.Less) return { field, operator: '<', value } as DefaultRuleType;\n  if (node.children.Greater) return { field, operator: '>', value } as DefaultRuleType;\n  if (node.children.LessEqual) return { field, operator: '<=', value } as DefaultRuleType;\n  if (node.children.GreaterEqual) return { field, operator: '>=', value } as DefaultRuleType;\n  if (node.children.Contains) return { field, operator: 'contains', value } as DefaultRuleType;\n  if (node.children.StartsWith) return { field, operator: 'beginsWith', value } as DefaultRuleType;\n  if (node.children.EndsWith) return { field, operator: 'endsWith', value } as DefaultRuleType;\n\n  return { field, operator: '=', value } as DefaultRuleType;\n};\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Options for {@link parseCypher}.\n */\nexport interface ParseCypherOptions {\n  independentCombinators?: boolean;\n}\n\n/**\n * Parses a Cypher query string into a {@link DefaultRuleGroupType}.\n *\n * Accepts a full Cypher query, a `WHERE` clause, or a bare boolean expression.\n * MATCH and RETURN clauses are consumed but discarded — only WHERE conditions\n * are returned.\n *\n * @example\n * ```ts\n * // Full query — extracts WHERE conditions only\n * parseCypher('MATCH (a:Person) WHERE a.age > 30 RETURN a');\n *\n * // WHERE clause\n * parseCypher('WHERE a.age > 30 AND a.name CONTAINS \"Alice\"');\n *\n * // Bare expression\n * parseCypher('a.age > 30 AND a.name CONTAINS \"Alice\"');\n * ```\n */\nexport function parseCypher(cypher: string): DefaultRuleGroupType;\nexport function parseCypher(\n  cypher: string,\n  options: Omit<ParseCypherOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\nexport function parseCypher(\n  cypher: string,\n  options: Omit<ParseCypherOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nexport function parseCypher(\n  cypher: string,\n  _options?: ParseCypherOptions\n): DefaultRuleGroupTypeAny {\n  const trimmed = cypher.trim();\n  if (!trimmed) return { combinator: 'and', rules: [] };\n\n  // Auto-detect input shape (like parseSQL)\n  let input = trimmed;\n  if (!/^\\s*match\\b/i.test(input) && !/^\\s*where\\b/i.test(input)) {\n    // Bare expression — prepend WHERE so the parser can handle it\n    input = `WHERE ${input}`;\n  }\n\n  const lexResult = cypherLexer.tokenize(input);\n  if (lexResult.errors.length > 0) {\n    return { combinator: 'and', rules: [] };\n  }\n\n  parserInstance.input = lexResult.tokens;\n  const cst = parserInstance.cypherQuery();\n\n  if (parserInstance.errors.length > 0) {\n    return { combinator: 'and', rules: [] };\n  }\n\n  const rules: RuleOrGroup[] = [];\n\n  // Only process WHERE clause — skip MATCH/RETURN\n  const whereClauses = (cst.children.whereClause as CstNode[] | undefined) ?? [];\n  if (whereClauses.length > 0) {\n    const whereNode = whereClauses[0];\n    const orExpr = (whereNode.children.orExpression as CstNode[])[0];\n    const whereRules = visitOrExpression(orExpr);\n\n    // If the top-level OR produced a single AND group without NOT, flatten it\n    if (\n      whereRules.length === 1 &&\n      'combinator' in whereRules[0] &&\n      whereRules[0].combinator === 'and' &&\n      !('not' in whereRules[0] && whereRules[0].not)\n    ) {\n      rules.push(...whereRules[0].rules);\n    } else {\n      rules.push(...whereRules);\n    }\n  }\n\n  return { combinator: 'and', rules };\n}\n\n/**\n * Parses a GQL query string. GQL is ~95% compatible with Cypher;\n * the parser handles the same syntax.\n */\nexport function parseGQL(gql: string): DefaultRuleGroupType;\nexport function parseGQL(\n  gql: string,\n  options: Omit<ParseCypherOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\nexport function parseGQL(\n  gql: string,\n  options: Omit<ParseCypherOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nexport function parseGQL(gql: string, options?: ParseCypherOptions): DefaultRuleGroupTypeAny {\n  // Call the implementation signature directly (not the overloads)\n  return (parseCypher as (s: string, o?: ParseCypherOptions) => DefaultRuleGroupTypeAny)(\n    gql,\n    options\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"parseCypher.js","names":["createToken","Lexer","CstParser"],"sources":["../src/utils/parseCypher/parseCypher.ts"],"sourcesContent":["import { createToken, Lexer, CstParser, type CstNode, type IToken } from 'chevrotain';\nimport type {\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n} from '../../types';\n\n// ─── Lexer Tokens ────────────────────────────────────────────────────────────\n\nconst WhiteSpace = createToken({ name: 'WhiteSpace', pattern: /\\s+/, group: Lexer.SKIPPED });\n\n// Keywords (longer/multi-word first)\nconst OptionalMatch = createToken({\n  name: 'OptionalMatch',\n  pattern: /OPTIONAL\\s+MATCH/i,\n  longer_alt: undefined,\n});\nconst StartsWith = createToken({ name: 'StartsWith', pattern: /STARTS\\s+WITH/i });\nconst EndsWith = createToken({ name: 'EndsWith', pattern: /ENDS\\s+WITH/i });\nconst IsNotNull = createToken({ name: 'IsNotNull', pattern: /IS\\s+NOT\\s+NULL/i });\nconst IsNull = createToken({ name: 'IsNull', pattern: /IS\\s+NULL/i });\nconst NotIn = createToken({ name: 'NotIn', pattern: /NOT\\s+IN/i });\nconst Match = createToken({ name: 'Match', pattern: /MATCH/i });\nconst Where = createToken({ name: 'Where', pattern: /WHERE/i });\nconst Return = createToken({ name: 'Return', pattern: /RETURN/i });\nconst And = createToken({ name: 'And', pattern: /AND/i });\nconst Or = createToken({ name: 'Or', pattern: /OR/i });\nconst Not = createToken({ name: 'Not', pattern: /NOT/i });\nconst Contains = createToken({ name: 'Contains', pattern: /CONTAINS/i });\nconst In = createToken({ name: 'In', pattern: /IN/i });\nconst NullLit = createToken({ name: 'NullLit', pattern: /null\\b/ });\nconst TrueLit = createToken({ name: 'TrueLit', pattern: /true\\b/ });\nconst FalseLit = createToken({ name: 'FalseLit', pattern: /false\\b/ });\n\n// Literals\nconst StringLiteral = createToken({ name: 'StringLiteral', pattern: /'(?:[^'\\\\]|\\\\.)*'/ });\nconst NumberLiteral = createToken({ name: 'NumberLiteral', pattern: /-?\\d+(?:\\.\\d+)?/ });\n\n// Operators\nconst LessEqual = createToken({ name: 'LessEqual', pattern: /<=/ });\nconst GreaterEqual = createToken({ name: 'GreaterEqual', pattern: />=/ });\nconst NotEqual = createToken({ name: 'NotEqual', pattern: /<>/ });\nconst Less = createToken({ name: 'Less', pattern: /</ });\nconst Greater = createToken({ name: 'Greater', pattern: />/ });\nconst Equal = createToken({ name: 'Equal', pattern: /=/ });\n\n// Punctuation\nconst LParen = createToken({ name: 'LParen', pattern: /\\(/ });\nconst RParen = createToken({ name: 'RParen', pattern: /\\)/ });\nconst LBracket = createToken({ name: 'LBracket', pattern: /\\[/ });\nconst RBracket = createToken({ name: 'RBracket', pattern: /\\]/ });\nconst Comma = createToken({ name: 'Comma', pattern: /,/ });\nconst Colon = createToken({ name: 'Colon', pattern: /:/ });\nconst Dot = createToken({ name: 'Dot', pattern: /\\./ });\n\n// Arrow parts for relationship patterns\nconst DashArrowRight = createToken({ name: 'DashArrowRight', pattern: /->/ });\nconst ArrowLeftDash = createToken({ name: 'ArrowLeftDash', pattern: /<-/ });\nconst Dash = createToken({ name: 'Dash', pattern: /-/ });\n\n// Identifier (must come after all keywords)\nconst Identifier = createToken({ name: 'Identifier', pattern: /[a-zA-Z_]\\w*/ });\n\n// Token order matters: longer patterns and keywords before shorter ones\nconst allTokens = [\n  WhiteSpace,\n  // Multi-word keywords (must come before single-word)\n  OptionalMatch,\n  StartsWith,\n  EndsWith,\n  IsNotNull,\n  IsNull,\n  NotIn,\n  // Single-word keywords\n  Match,\n  Where,\n  Return,\n  And,\n  Or,\n  Not,\n  Contains,\n  In,\n  NullLit,\n  TrueLit,\n  FalseLit,\n  // Literals\n  StringLiteral,\n  NumberLiteral,\n  // Multi-char operators\n  LessEqual,\n  GreaterEqual,\n  NotEqual,\n  DashArrowRight,\n  ArrowLeftDash,\n  // Single-char operators\n  Less,\n  Greater,\n  Equal,\n  // Punctuation\n  LParen,\n  RParen,\n  LBracket,\n  RBracket,\n  Comma,\n  Colon,\n  Dot,\n  Dash,\n  // Identifier last\n  Identifier,\n];\n\nconst cypherLexer = new Lexer(allTokens);\n\n// ─── CST Parser ──────────────────────────────────────────────────────────────\n\nclass CypherCstParser extends CstParser {\n  constructor() {\n    super(allTokens, { recoveryEnabled: false });\n    this.performSelfAnalysis();\n  }\n\n  /** Top-level: sequence of MATCH/OPTIONAL MATCH clauses, optional WHERE, optional RETURN */\n  public cypherQuery = this.RULE('cypherQuery', () => {\n    this.MANY(() => {\n      this.OR([\n        { ALT: () => this.SUBRULE(this.optionalMatchClause) },\n        { ALT: () => this.SUBRULE(this.matchClause) },\n      ]);\n    });\n    this.OPTION(() => this.SUBRULE(this.whereClause));\n    this.OPTION1(() => this.SUBRULE(this.returnClause));\n  });\n\n  /** MATCH pattern */\n  public matchClause = this.RULE('matchClause', () => {\n    this.CONSUME(Match);\n    this.SUBRULE(this.pattern);\n  });\n\n  /** OPTIONAL MATCH pattern */\n  public optionalMatchClause = this.RULE('optionalMatchClause', () => {\n    this.CONSUME(OptionalMatch);\n    this.SUBRULE(this.pattern);\n  });\n\n  /** A graph pattern: node or node-rel-node */\n  public pattern = this.RULE('pattern', () => {\n    this.SUBRULE(this.nodePattern, { LABEL: 'lhs' });\n    this.OPTION(() => {\n      this.SUBRULE(this.relPattern);\n      this.SUBRULE1(this.nodePattern, { LABEL: 'rhs' });\n    });\n  });\n\n  /** (alias:Label) or (alias) */\n  public nodePattern = this.RULE('nodePattern', () => {\n    this.CONSUME(LParen);\n    this.CONSUME(Identifier, { LABEL: 'alias' });\n    this.OPTION(() => {\n      this.CONSUME(Colon);\n      this.CONSUME1(Identifier, { LABEL: 'label' });\n    });\n    this.CONSUME(RParen);\n  });\n\n  /** -[:TYPE]-> or <-[:TYPE]- or -[:TYPE]- */\n  public relPattern = this.RULE('relPattern', () => {\n    this.OR([\n      {\n        ALT: () => {\n          this.CONSUME(ArrowLeftDash, { LABEL: 'leftArrow' });\n          this.CONSUME(LBracket);\n          this.OPTION(() => {\n            this.CONSUME(Colon);\n            this.CONSUME(Identifier, { LABEL: 'relType' });\n          });\n          this.CONSUME(RBracket);\n          this.CONSUME(Dash, { LABEL: 'rightDash' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME1(Dash, { LABEL: 'leftDash' });\n          this.CONSUME1(LBracket);\n          this.OPTION1(() => {\n            this.CONSUME1(Colon);\n            this.CONSUME1(Identifier, { LABEL: 'relType' });\n          });\n          this.CONSUME1(RBracket);\n          this.CONSUME(DashArrowRight, { LABEL: 'rightArrow' });\n        },\n      },\n    ]);\n  });\n\n  /** WHERE expression */\n  public whereClause = this.RULE('whereClause', () => {\n    this.CONSUME(Where);\n    this.SUBRULE(this.orExpression);\n  });\n\n  /** expression OR expression */\n  public orExpression = this.RULE('orExpression', () => {\n    this.SUBRULE(this.andExpression, { LABEL: 'lhs' });\n    this.MANY(() => {\n      this.CONSUME(Or);\n      this.SUBRULE1(this.andExpression, { LABEL: 'rhs' });\n    });\n  });\n\n  /** expression AND expression */\n  public andExpression = this.RULE('andExpression', () => {\n    this.SUBRULE(this.notExpression, { LABEL: 'lhs' });\n    this.MANY(() => {\n      this.CONSUME(And);\n      this.SUBRULE1(this.notExpression, { LABEL: 'rhs' });\n    });\n  });\n\n  /** NOT expression */\n  public notExpression = this.RULE('notExpression', () => {\n    this.OPTION(() => this.CONSUME(Not));\n    this.SUBRULE(this.atomicExpression);\n  });\n\n  /** Parenthesized group or single condition */\n  public atomicExpression = this.RULE('atomicExpression', () => {\n    this.OR([\n      {\n        ALT: () => {\n          this.CONSUME(LParen);\n          this.SUBRULE(this.orExpression);\n          this.CONSUME(RParen);\n        },\n      },\n      { ALT: () => this.SUBRULE(this.condition) },\n    ]);\n  });\n\n  /** Single condition: field op value */\n  public condition = this.RULE('condition', () => {\n    this.SUBRULE(this.propertyRef, { LABEL: 'field' });\n    this.OR([\n      {\n        ALT: () => {\n          this.CONSUME(Equal);\n          this.SUBRULE(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(NotEqual);\n          this.SUBRULE1(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(Less);\n          this.SUBRULE2(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(Greater);\n          this.SUBRULE3(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(LessEqual);\n          this.SUBRULE4(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(GreaterEqual);\n          this.SUBRULE5(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(Contains);\n          this.SUBRULE6(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(StartsWith);\n          this.SUBRULE7(this.literal, { LABEL: 'value' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(EndsWith);\n          this.SUBRULE8(this.literal, { LABEL: 'value' });\n        },\n      },\n      { ALT: () => this.CONSUME(IsNotNull) },\n      { ALT: () => this.CONSUME(IsNull) },\n      {\n        ALT: () => {\n          this.CONSUME(In);\n          this.SUBRULE(this.listLiteral, { LABEL: 'list' });\n        },\n      },\n      {\n        ALT: () => {\n          this.CONSUME(NotIn);\n          this.SUBRULE1(this.listLiteral, { LABEL: 'list' });\n        },\n      },\n    ]);\n  });\n\n  /** Dotted property reference: alias.prop or just identifier */\n  public propertyRef = this.RULE('propertyRef', () => {\n    this.CONSUME(Identifier, { LABEL: 'head' });\n    this.MANY(() => {\n      this.CONSUME(Dot);\n      this.CONSUME1(Identifier, { LABEL: 'tail' });\n    });\n  });\n\n  /** A literal value */\n  public literal = this.RULE('literal', () => {\n    this.OR([\n      { ALT: () => this.CONSUME(StringLiteral) },\n      { ALT: () => this.CONSUME(NumberLiteral) },\n      { ALT: () => this.CONSUME(NullLit) },\n      { ALT: () => this.CONSUME(TrueLit) },\n      { ALT: () => this.CONSUME(FalseLit) },\n      { ALT: () => this.CONSUME(Identifier) },\n    ]);\n  });\n\n  /** [val, val, ...] */\n  public listLiteral = this.RULE('listLiteral', () => {\n    this.CONSUME(LBracket);\n    this.OPTION(() => {\n      this.SUBRULE(this.literal, { LABEL: 'items' });\n      this.MANY(() => {\n        this.CONSUME(Comma);\n        this.SUBRULE1(this.literal, { LABEL: 'items' });\n      });\n    });\n    this.CONSUME(RBracket);\n  });\n\n  /** RETURN clause (consumed but not transformed) */\n  public returnClause = this.RULE('returnClause', () => {\n    this.CONSUME(Return);\n    this.MANY(() => {\n      this.OR([\n        { ALT: () => this.CONSUME(Identifier) },\n        { ALT: () => this.CONSUME(Comma) },\n        { ALT: () => this.CONSUME(Dot) },\n      ]);\n    });\n  });\n}\n\nconst parserInstance = new CypherCstParser();\n\n// ─── CST Visitor (CST → RuleGroupType) ──────────────────────────────────────\n\n/** Resolves a literal token to a JS value. */\nconst tokenToValue = (token: IToken): unknown => {\n  const img = token.image;\n  switch (token.tokenType) {\n    case StringLiteral:\n      return img.slice(1, -1).replace(/\\\\'/g, \"'\");\n    case NumberLiteral:\n      return Number(img);\n    case NullLit:\n      return null;\n    case TrueLit:\n      return true;\n    case FalseLit:\n      return false;\n    default:\n      return img;\n  }\n};\n\n/** Extracts a literal value from a CST 'literal' node. */\nconst extractLiteral = (literalNode: CstNode): unknown => {\n  const children = literalNode.children;\n  const token =\n    (children.StringLiteral as IToken[])?.[0] ??\n    (children.NumberLiteral as IToken[])?.[0] ??\n    (children.NullLit as IToken[])?.[0] ??\n    (children.TrueLit as IToken[])?.[0] ??\n    (children.FalseLit as IToken[])?.[0] ??\n    (children.Identifier as IToken[])?.[0];\n  return token ? tokenToValue(token) : '';\n};\n\n/** Builds a dotted property reference string from a propertyRef CST node. */\nconst extractPropertyRef = (node: CstNode): string => {\n  const head = (node.children.head as IToken[])[0].image;\n  const tails = (node.children.tail as IToken[] | undefined) ?? [];\n  if (tails.length === 0) return head;\n  return head + '.' + tails.map(t => t.image).join('.');\n};\n\n/** Extracts list items from a listLiteral CST node. */\nconst extractList = (node: CstNode): unknown[] => {\n  const items = (node.children.items as CstNode[] | undefined) ?? [];\n  return items.map(extractLiteral);\n};\n\ntype RuleOrGroup = DefaultRuleType | DefaultRuleGroupType;\n\n/** Visits an orExpression CST node. */\nconst visitOrExpression = (node: CstNode): RuleOrGroup[] => {\n  const lhsNodes = node.children.lhs as CstNode[];\n  const rhsNodes = (node.children.rhs as CstNode[] | undefined) ?? [];\n\n  if (rhsNodes.length === 0) {\n    return visitAndExpression(lhsNodes[0]);\n  }\n\n  const allParts = [lhsNodes[0], ...rhsNodes];\n  const subRules: RuleOrGroup[] = [];\n  for (const part of allParts) {\n    const partRules = visitAndExpression(part);\n    if (partRules.length === 1) {\n      subRules.push(partRules[0]);\n    } else {\n      subRules.push({ combinator: 'and', rules: partRules });\n    }\n  }\n  return [{ combinator: 'or', rules: subRules }];\n};\n\n/** Visits an andExpression CST node. */\nconst visitAndExpression = (node: CstNode): RuleOrGroup[] => {\n  const lhsNodes = node.children.lhs as CstNode[];\n  const rhsNodes = (node.children.rhs as CstNode[] | undefined) ?? [];\n  const all = [lhsNodes[0], ...rhsNodes];\n  const rules: RuleOrGroup[] = [];\n  for (const item of all) {\n    rules.push(...visitNotExpression(item));\n  }\n  return rules;\n};\n\n/** Visits a notExpression CST node. */\nconst visitNotExpression = (node: CstNode): RuleOrGroup[] => {\n  const hasNot = !!(node.children.Not as IToken[] | undefined)?.length;\n  const atomicRules = visitAtomicExpression((node.children.atomicExpression as CstNode[])[0]);\n\n  if (!hasNot) return atomicRules;\n\n  return [{ combinator: 'and', not: true, rules: atomicRules }];\n};\n\n/** Visits an atomicExpression CST node. */\nconst visitAtomicExpression = (node: CstNode): RuleOrGroup[] => {\n  if (node.children.orExpression) {\n    return visitOrExpression((node.children.orExpression as CstNode[])[0]);\n  }\n  if (node.children.condition) {\n    return [visitCondition((node.children.condition as CstNode[])[0])];\n  }\n  return [];\n};\n\n/** Visits a condition CST node and returns a DefaultRuleType (no meta). */\nconst visitCondition = (node: CstNode): DefaultRuleType => {\n  const field = extractPropertyRef((node.children.field as CstNode[])[0]);\n\n  if (node.children.IsNull) {\n    return { field, operator: 'null', value: null } as DefaultRuleType;\n  }\n  if (node.children.IsNotNull) {\n    return { field, operator: 'notNull', value: null } as DefaultRuleType;\n  }\n\n  if (node.children.In) {\n    const list = extractList((node.children.list as CstNode[])[0]);\n    return { field, operator: 'in', value: list } as DefaultRuleType;\n  }\n  if (node.children.NotIn) {\n    const list = extractList((node.children.list as CstNode[])[0]);\n    return { field, operator: 'notIn', value: list } as DefaultRuleType;\n  }\n\n  const valueNode = (node.children.value as CstNode[] | undefined)?.[0];\n  const value = valueNode ? extractLiteral(valueNode) : null;\n\n  if (node.children.Equal) return { field, operator: '=', value } as DefaultRuleType;\n  if (node.children.NotEqual) return { field, operator: '!=', value } as DefaultRuleType;\n  if (node.children.Less) return { field, operator: '<', value } as DefaultRuleType;\n  if (node.children.Greater) return { field, operator: '>', value } as DefaultRuleType;\n  if (node.children.LessEqual) return { field, operator: '<=', value } as DefaultRuleType;\n  if (node.children.GreaterEqual) return { field, operator: '>=', value } as DefaultRuleType;\n  if (node.children.Contains) return { field, operator: 'contains', value } as DefaultRuleType;\n  if (node.children.StartsWith) return { field, operator: 'beginsWith', value } as DefaultRuleType;\n  if (node.children.EndsWith) return { field, operator: 'endsWith', value } as DefaultRuleType;\n\n  return { field, operator: '=', value } as DefaultRuleType;\n};\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Options for {@link parseCypher}.\n */\nexport interface ParseCypherOptions {\n  independentCombinators?: boolean;\n}\n\n/**\n * Parses a Cypher query string into a {@link DefaultRuleGroupType}.\n *\n * Accepts a full Cypher query, a `WHERE` clause, or a bare boolean expression.\n * MATCH and RETURN clauses are consumed but discarded — only WHERE conditions\n * are returned.\n *\n * @example\n * ```ts\n * // Full query — extracts WHERE conditions only\n * parseCypher('MATCH (a:Person) WHERE a.age > 30 RETURN a');\n *\n * // WHERE clause\n * parseCypher('WHERE a.age > 30 AND a.name CONTAINS \"Alice\"');\n *\n * // Bare expression\n * parseCypher('a.age > 30 AND a.name CONTAINS \"Alice\"');\n * ```\n */\nexport function parseCypher(cypher: string): DefaultRuleGroupType;\nexport function parseCypher(\n  cypher: string,\n  options: Omit<ParseCypherOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\nexport function parseCypher(\n  cypher: string,\n  options: Omit<ParseCypherOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nexport function parseCypher(\n  cypher: string,\n  _options?: ParseCypherOptions\n): DefaultRuleGroupTypeAny {\n  const trimmed = cypher.trim();\n  if (!trimmed) return { combinator: 'and', rules: [] };\n\n  // Auto-detect input shape (like parseSQL)\n  let input = trimmed;\n  if (!/^\\s*match\\b/i.test(input) && !/^\\s*where\\b/i.test(input)) {\n    // Bare expression — prepend WHERE so the parser can handle it\n    input = `WHERE ${input}`;\n  }\n\n  const lexResult = cypherLexer.tokenize(input);\n  if (lexResult.errors.length > 0) {\n    return { combinator: 'and', rules: [] };\n  }\n\n  parserInstance.input = lexResult.tokens;\n  const cst = parserInstance.cypherQuery();\n\n  if (parserInstance.errors.length > 0) {\n    return { combinator: 'and', rules: [] };\n  }\n\n  const rules: RuleOrGroup[] = [];\n\n  // Only process WHERE clause — skip MATCH/RETURN\n  const whereClauses = (cst.children.whereClause as CstNode[] | undefined) ?? [];\n  if (whereClauses.length > 0) {\n    const whereNode = whereClauses[0];\n    const orExpr = (whereNode.children.orExpression as CstNode[])[0];\n    const whereRules = visitOrExpression(orExpr);\n\n    // If the top-level OR produced a single AND group without NOT, flatten it\n    if (\n      whereRules.length === 1 &&\n      'combinator' in whereRules[0] &&\n      whereRules[0].combinator === 'and' &&\n      !('not' in whereRules[0] && whereRules[0].not)\n    ) {\n      rules.push(...whereRules[0].rules);\n    } else {\n      rules.push(...whereRules);\n    }\n  }\n\n  return { combinator: 'and', rules };\n}\n\n/**\n * Parses a GQL query string. GQL is ~95% compatible with Cypher;\n * the parser handles the same syntax.\n */\nexport function parseGQL(gql: string): DefaultRuleGroupType;\nexport function parseGQL(\n  gql: string,\n  options: Omit<ParseCypherOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\nexport function parseGQL(\n  gql: string,\n  options: Omit<ParseCypherOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nexport function parseGQL(gql: string, options?: ParseCypherOptions): DefaultRuleGroupTypeAny {\n  // Call the implementation signature directly (not the overloads)\n  return (parseCypher as (s: string, o?: ParseCypherOptions) => DefaultRuleGroupTypeAny)(\n    gql,\n    options\n  );\n}\n"],"mappings":"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"}

package/dist/parseGremlin.d.mts

@@ -1,4 +1,4 @@
-import { T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-BSwFvkeI.mjs";
+import { T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-CX9mehdL.mjs";
 //#region src/utils/parseGremlin/parseGremlin.d.ts
 /**
  * Options for {@link parseGremlin}.

package/dist/parseGremlin.d.ts

@@ -1,4 +1,4 @@
-import { T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-BSwFvkeI.js";
+import { T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-CX9mehdL.js";
 //#region src/utils/parseGremlin/parseGremlin.d.ts
 /**
  * Options for {@link parseGremlin}.

package/dist/parseJSONata.d.mts

@@ -1,5 +1,5 @@
-import { L as Except, P as ExpressionNode, R as Merge, T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-BSwFvkeI.mjs";
-import { t as ParserCommonOptions } from "./import-BVdxeIBO.mjs";
+import { L as Except, P as ExpressionNode, R as Merge, T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-CX9mehdL.mjs";
+import { t as ParserCommonOptions } from "./import-DVWI7Fdh.mjs";
 //#region ../../node_modules/type-fest/source/override-properties.d.ts
 /**
 Override existing properties of the given type. Similar to `Merge`, but enforces that the original type has the properties you want to override.

package/dist/parseJSONata.d.ts

@@ -1,5 +1,5 @@
-import { L as Except, P as ExpressionNode, R as Merge, T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-BSwFvkeI.js";
-import { t as ParserCommonOptions } from "./import-Ddc3d_8q.js";
+import { L as Except, P as ExpressionNode, R as Merge, T as DefaultRuleGroupTypeIC, j as DefaultRuleGroupType } from "./index-CX9mehdL.js";
+import { t as ParserCommonOptions } from "./import-6ExjhifL.js";
 //#region ../../node_modules/type-fest/source/override-properties.d.ts
 /**
 Override existing properties of the given type. Similar to `Merge`, but enforces that the original type has the properties you want to override.

package/dist/parseJSONata.js

@@ -16,13 +16,13 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
 //#endregion
 const require_isRuleGroup = require("./isRuleGroup-0JNiQgLg.js");
-const require_prepareQueryObjects = require("./prepareQueryObjects-C2-kTZvR.js");
+const require_prepareQueryObjects = require("./prepareQueryObjects-BnGL91Tt.js");
 let jsonata = require("jsonata");
 jsonata = __toESM(jsonata);
 //#region src/utils/parseJSONata/utils.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\n// Arithmetic infix operators eligible as expression operands\nconst jsonataArithmeticOperators = new Set(['+', '-', '*', '/', '%']);\n\n/**\n * A JSONata comparison operand that is a candidate expression subtree: an arithmetic infix node\n * (`+ - * / %`) or a function-call node (excluding the `not`/`contains` predicates handled\n * elsewhere). The expr-supplied `getExpression` handler decides whether it maps to a known\n * function.\n */\nexport const isJSONataExpressionOperand = (expr: Any): expr is JSONataExprNode => {\n  if (!isJSONataExprNode(expr)) return false;\n  // Unwrap parenthesized single-expression blocks (e.g. `(cost * 2)`)\n  if (isJSONataBlock(expr) && expr.expressions.length === 1)\n    return isJSONataExpressionOperand(expr.expressions[0]);\n  if (isJSONataBinaryNode(expr) && jsonataArithmeticOperators.has(expr.value)) return true;\n  return (\n    expr.type === 'function' &&\n    expr.value === '(' &&\n    isJSONataExprNode(expr.procedure) &&\n    expr.procedure.type === 'variable' &&\n    typeof expr.procedure.value === 'string' &&\n    expr.procedure.value !== 'not' &&\n    expr.procedure.value !== 'contains'\n  );\n};\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  ExpressionNode,\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 {\n  JSONataExprNode,\n  JSONataExpressionOperand,\n  ParseJSONataExpressionContext,\n} from './types';\nimport {\n  generateFlatAndOrList,\n  generateMixedAndOrList,\n  getFieldFromPath,\n  getValidValue,\n  isJSONataAnd,\n  isJSONataBlock,\n  isJSONataComparison,\n  isJSONataContains,\n  isJSONataExpressionOperand,\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   * Handler that converts a JSONata arithmetic/function operand subtree into an\n   * {@link ExpressionNode}. Return `null` to reject (the rule is dropped). Supplied by\n   * `@react-querybuilder/expr` (`expressionParserJSONata`). When omitted, expression\n   * operands are ignored (rule dropped).\n   */\n  getExpression?: (\n    node: JSONataExpressionOperand,\n    ctx: ParseJSONataExpressionContext\n  ) => ExpressionNode | null;\n}\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, getExpression } = 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 exprCtx: ParseJSONataExpressionContext = {\n    fieldExists: fieldName => fieldsFlat.length === 0 || fieldsFlat.some(f => f.name === fieldName),\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      // Arithmetic/function expression operands (from `@react-querybuilder/expr`)\n      if (getExpression) {\n        const lhsIsExpr = isJSONataExpressionOperand(lhs);\n        const rhsIsExpr = isJSONataExpressionOperand(rhs);\n        if (lhsIsExpr && rhsIsExpr) {\n          // expression <op> expression → both sides on lhs/value\n          const l = getExpression(lhs, exprCtx);\n          const r = getExpression(rhs, exprCtx);\n          if (l && r) {\n            return {\n              field: '',\n              operator: normalizeOperator(expr.value),\n              lhs: l,\n              value: r,\n              valueSource: 'expression',\n            };\n          }\n          return null;\n        } else if (isJSONataIdentifier(lhs) && rhsIsExpr) {\n          // field <op> expression → rhs expression\n          const node = getExpression(rhs, exprCtx);\n          const f = getFieldFromPath(lhs);\n          const op = normalizeOperator(expr.value);\n          if (node && fieldIsValid(f, op)) {\n            return { field: f, operator: op, value: node, valueSource: 'expression' };\n          }\n          return null;\n        } else if (lhsIsExpr && isJSONataIdentifier(rhs)) {\n          // expression <op> field → flip to field <op> expression\n          const node = getExpression(lhs, exprCtx);\n          const f = getFieldFromPath(rhs);\n          const op = normalizeOperator(expr.value, true);\n          if (node && fieldIsValid(f, op)) {\n            return { field: f, operator: op, value: node, valueSource: 'expression' };\n          }\n          return null;\n        } else if (lhsIsExpr && isJSONataValidValue(rhs)) {\n          // expression <op> literal → lhs = expression, literal value\n          const l = getExpression(lhs, exprCtx);\n          if (l) {\n            return {\n              field: '',\n              operator: normalizeOperator(expr.value),\n              lhs: l,\n              value: getValidValue(rhs),\n            };\n          }\n          return null;\n        } else if (isJSONataValidValue(lhs) && rhsIsExpr) {\n          // literal <op> expression → lhs = expression, flip operator\n          const l = getExpression(rhs, exprCtx);\n          if (l) {\n            return {\n              field: '',\n              operator: normalizeOperator(expr.value, true),\n              lhs: l,\n              value: getValidValue(lhs),\n            };\n          }\n          return null;\n        }\n      }\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\n// Arithmetic infix operators eligible as expression operands\nconst jsonataArithmeticOperators = new Set(['+', '-', '*', '/', '%']);\n\n/**\n * A JSONata comparison operand that is a candidate expression subtree: an arithmetic infix node\n * (`+ - * / %`) or a function-call node (excluding the `not`/`contains` predicates handled\n * elsewhere). The expr-supplied `getExpression` handler decides whether it maps to a known\n * function.\n */\nexport const isJSONataExpressionOperand = (expr: Any): expr is JSONataExprNode => {\n  if (!isJSONataExprNode(expr)) return false;\n  // Unwrap parenthesized single-expression blocks (e.g. `(cost * 2)`)\n  if (isJSONataBlock(expr) && expr.expressions.length === 1)\n    return isJSONataExpressionOperand(expr.expressions[0]);\n  if (isJSONataBinaryNode(expr) && jsonataArithmeticOperators.has(expr.value)) return true;\n  return (\n    expr.type === 'function' &&\n    expr.value === '(' &&\n    isJSONataExprNode(expr.procedure) &&\n    expr.procedure.type === 'variable' &&\n    typeof expr.procedure.value === 'string' &&\n    expr.procedure.value !== 'not' &&\n    expr.procedure.value !== 'contains'\n  );\n};\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  ExpressionNode,\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 {\n  JSONataExprNode,\n  JSONataExpressionOperand,\n  ParseJSONataExpressionContext,\n} from './types';\nimport {\n  generateFlatAndOrList,\n  generateMixedAndOrList,\n  getFieldFromPath,\n  getValidValue,\n  isJSONataAnd,\n  isJSONataBlock,\n  isJSONataComparison,\n  isJSONataContains,\n  isJSONataExpressionOperand,\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   * Handler that converts a JSONata arithmetic/function operand subtree into an\n   * {@link ExpressionNode}. Return `null` to reject (the rule is dropped). Supplied by\n   * `@react-querybuilder/expr` (`expressionParserJSONata`). When omitted, expression\n   * operands are ignored (rule dropped).\n   */\n  getExpression?: (\n    node: JSONataExpressionOperand,\n    ctx: ParseJSONataExpressionContext\n  ) => ExpressionNode | null;\n}\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, getExpression } = 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 exprCtx: ParseJSONataExpressionContext = {\n    fieldExists: fieldName => fieldsFlat.length === 0 || fieldsFlat.some(f => f.name === fieldName),\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      // Arithmetic/function expression operands (from `@react-querybuilder/expr`)\n      if (getExpression) {\n        const lhsIsExpr = isJSONataExpressionOperand(lhs);\n        const rhsIsExpr = isJSONataExpressionOperand(rhs);\n        if (lhsIsExpr && rhsIsExpr) {\n          // expression <op> expression → both sides on lhs/value\n          const l = getExpression(lhs, exprCtx);\n          const r = getExpression(rhs, exprCtx);\n          if (l && r) {\n            return {\n              field: '',\n              operator: normalizeOperator(expr.value),\n              lhs: l,\n              value: r,\n              valueSource: 'expression',\n            };\n          }\n          return null;\n        } else if (isJSONataIdentifier(lhs) && rhsIsExpr) {\n          // field <op> expression → rhs expression\n          const node = getExpression(rhs, exprCtx);\n          const f = getFieldFromPath(lhs);\n          const op = normalizeOperator(expr.value);\n          if (node && fieldIsValid(f, op)) {\n            return { field: f, operator: op, value: node, valueSource: 'expression' };\n          }\n          return null;\n        } else if (lhsIsExpr && isJSONataIdentifier(rhs)) {\n          // expression <op> field → flip to field <op> expression\n          const node = getExpression(lhs, exprCtx);\n          const f = getFieldFromPath(rhs);\n          const op = normalizeOperator(expr.value, true);\n          if (node && fieldIsValid(f, op)) {\n            return { field: f, operator: op, value: node, valueSource: 'expression' };\n          }\n          return null;\n        } else if (lhsIsExpr && isJSONataValidValue(rhs)) {\n          // expression <op> literal → lhs = expression, literal value\n          const l = getExpression(lhs, exprCtx);\n          if (l) {\n            return {\n              field: '',\n              operator: normalizeOperator(expr.value),\n              lhs: l,\n              value: getValidValue(rhs),\n            };\n          }\n          return null;\n        } else if (isJSONataValidValue(lhs) && rhsIsExpr) {\n          // literal <op> expression → lhs = expression, flip operator\n          const l = getExpression(rhs, exprCtx);\n          if (l) {\n            return {\n              field: '',\n              operator: normalizeOperator(expr.value, true),\n              lhs: l,\n              value: getValidValue(lhs),\n            };\n          }\n          return null;\n        }\n      }\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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"}

package/dist/parseJSONata.mjs

@@ -1,5 +1,5 @@
 import { t as isRuleGroup } from "./isRuleGroup-CqLThsbu.mjs";
-import { n as fieldIsValidUtil, r as getFieldsArray, t as prepareRuleGroup } from "./prepareQueryObjects-Q18lHCKl.mjs";
+import { n as fieldIsValidUtil, r as getFieldsArray, t as prepareRuleGroup } from "./prepareQueryObjects-ChINDIap.mjs";
 import jsonata from "jsonata";
 //#region src/utils/parseJSONata/utils.ts
 const isJSONataExprNode = (expr) => {

package/dist/parseJsonLogic.d.mts

@@ -1,5 +1,5 @@
-import { E as RuleGroupTypeAny, L as Except, N as RuleType, P as ExpressionNode, T as DefaultRuleGroupTypeIC, g as RQBJsonLogicVar, h as RQBJsonLogic, j as DefaultRuleGroupType, n as JsonLogicLessThanOrEqual, r as JsonLogicRulesLogic, t as JsonLogicLessThan } from "./index-BSwFvkeI.mjs";
-import { t as ParserCommonOptions } from "./import-BVdxeIBO.mjs";
+import { E as RuleGroupTypeAny, L as Except, N as RuleType, P as ExpressionNode, T as DefaultRuleGroupTypeIC, g as RQBJsonLogicVar, h as RQBJsonLogic, j as DefaultRuleGroupType, n as JsonLogicLessThanOrEqual, r as JsonLogicRulesLogic, t as JsonLogicLessThan } from "./index-CX9mehdL.mjs";
+import { t as ParserCommonOptions } from "./import-DVWI7Fdh.mjs";
 //#region src/utils/parseJsonLogic/types.d.ts
 interface JsonLogicBetweenExclusive extends JsonLogicLessThan {
   "<": [JsonLogicRulesLogic, JsonLogicRulesLogic, JsonLogicRulesLogic];

package/dist/parseJsonLogic.d.ts

@@ -1,5 +1,5 @@
-import { E as RuleGroupTypeAny, L as Except, N as RuleType, P as ExpressionNode, T as DefaultRuleGroupTypeIC, g as RQBJsonLogicVar, h as RQBJsonLogic, j as DefaultRuleGroupType, n as JsonLogicLessThanOrEqual, r as JsonLogicRulesLogic, t as JsonLogicLessThan } from "./index-BSwFvkeI.js";
-import { t as ParserCommonOptions } from "./import-Ddc3d_8q.js";
+import { E as RuleGroupTypeAny, L as Except, N as RuleType, P as ExpressionNode, T as DefaultRuleGroupTypeIC, g as RQBJsonLogicVar, h as RQBJsonLogic, j as DefaultRuleGroupType, n as JsonLogicLessThanOrEqual, r as JsonLogicRulesLogic, t as JsonLogicLessThan } from "./index-CX9mehdL.js";
+import { t as ParserCommonOptions } from "./import-6ExjhifL.js";
 //#region src/utils/parseJsonLogic/types.d.ts
 interface JsonLogicBetweenExclusive extends JsonLogicLessThan {
   "<": [JsonLogicRulesLogic, JsonLogicRulesLogic, JsonLogicRulesLogic];

package/dist/parseJsonLogic.js

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_utils = require("./utils-DEwV7F6B.js");
+const require_utils = require("./utils-C79dxwZb.js");
 const require_isRuleGroup = require("./isRuleGroup-0JNiQgLg.js");
 const require_objectUtils = require("./objectUtils-Cr02aGxb.js");
 const require_convertQuery = require("./convertQuery-Cw76XFIn.js");
-const require_prepareQueryObjects = require("./prepareQueryObjects-C2-kTZvR.js");
+const require_prepareQueryObjects = require("./prepareQueryObjects-BnGL91Tt.js");
 //#region src/utils/parseJsonLogic/utils.ts
 const isJsonLogicVar = (logic) => require_isRuleGroup.isPojo(logic) && "var" in logic;
 const isRQBJsonLogicVar = (logic) => isJsonLogicVar(logic) && typeof logic.var === "string";
@@ -179,7 +179,7 @@ function parseJsonLogic(rqbJsonLogic, options = {}) {
 			field = logic["<"][1].var;
 			const values = [logic["<"][0], logic["<"][2]];
 			// v8 ignore else
-			if (values.every((v) => isRQBJsonLogicVar(v)) || values.every((el) => typeof el === "string") || values.every((el) => typeof el === "number") || values.every((el) => typeof el === "boolean")) return processLogic({ and: [{ ">": [{ var: field }, values[0]] }, { "<": [{ var: field }, values[1]] }] }) || false;
+			if (values.every((v) => isRQBJsonLogicVar(v)) || values.every((el) => typeof el === "string") || values.every((el) => typeof el === "number") || values.every((el) => typeof el === "boolean")) return processLogic({ and: [{ ">": [{ var: field }, values[0]] }, { "<": [{ var: field }, values[1]] }] }) || /* v8 ignore start -- @preserve */ false;
 		} else if (isJsonLogicBetweenInclusive(logic) && isRQBJsonLogicVar(logic["<="][1])) {
 			field = logic["<="][1].var;
 			operator = "between";