@react-querybuilder/core 8.16.0 → 8.16.2

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":";;;;AAUA,MAAM,cAAA,GAAA,WAAA,aAAyB;CAAE,MAAM;CAAc,SAAS;CAAO,OAAOA,WAAAA,MAAM;CAAS,CAAC;AAG5F,MAAM,iBAAA,GAAA,WAAA,aAA4B;CAChC,MAAM;CACN,SAAS;CACT,YAAY,KAAA;CACb,CAAC;AACF,MAAM,cAAA,GAAA,WAAA,aAAyB;CAAE,MAAM;CAAc,SAAS;CAAkB,CAAC;AACjF,MAAM,YAAA,GAAA,WAAA,aAAuB;CAAE,MAAM;CAAY,SAAS;CAAgB,CAAC;AAC3E,MAAM,aAAA,GAAA,WAAA,aAAwB;CAAE,MAAM;CAAa,SAAS;CAAoB,CAAC;AACjF,MAAM,UAAA,GAAA,WAAA,aAAqB;CAAE,MAAM;CAAU,SAAS;CAAc,CAAC;AACrE,MAAM,SAAA,GAAA,WAAA,aAAoB;CAAE,MAAM;CAAS,SAAS;CAAa,CAAC;AAClE,MAAM,SAAA,GAAA,WAAA,aAAoB;CAAE,MAAM;CAAS,SAAS;CAAU,CAAC;AAC/D,MAAM,SAAA,GAAA,WAAA,aAAoB;CAAE,MAAM;CAAS,SAAS;CAAU,CAAC;AAC/D,MAAM,UAAA,GAAA,WAAA,aAAqB;CAAE,MAAM;CAAU,SAAS;CAAW,CAAC;AAClE,MAAM,OAAA,GAAA,WAAA,aAAkB;CAAE,MAAM;CAAO,SAAS;CAAQ,CAAC;AACzD,MAAM,MAAA,GAAA,WAAA,aAAiB;CAAE,MAAM;CAAM,SAAS;CAAO,CAAC;AACtD,MAAM,OAAA,GAAA,WAAA,aAAkB;CAAE,MAAM;CAAO,SAAS;CAAQ,CAAC;AACzD,MAAM,YAAA,GAAA,WAAA,aAAuB;CAAE,MAAM;CAAY,SAAS;CAAa,CAAC;AACxE,MAAM,MAAA,GAAA,WAAA,aAAiB;CAAE,MAAM;CAAM,SAAS;CAAO,CAAC;AACtD,MAAM,WAAA,GAAA,WAAA,aAAsB;CAAE,MAAM;CAAW,SAAS;CAAU,CAAC;AACnE,MAAM,WAAA,GAAA,WAAA,aAAsB;CAAE,MAAM;CAAW,SAAS;CAAU,CAAC;AACnE,MAAM,YAAA,GAAA,WAAA,aAAuB;CAAE,MAAM;CAAY,SAAS;CAAW,CAAC;AAGtE,MAAM,iBAAA,GAAA,WAAA,aAA4B;CAAE,MAAM;CAAiB,SAAS;CAAqB,CAAC;AAC1F,MAAM,iBAAA,GAAA,WAAA,aAA4B;CAAE,MAAM;CAAiB,SAAS;CAAmB,CAAC;AAGxF,MAAM,aAAA,GAAA,WAAA,aAAwB;CAAE,MAAM;CAAa,SAAS;CAAM,CAAC;AACnE,MAAM,gBAAA,GAAA,WAAA,aAA2B;CAAE,MAAM;CAAgB,SAAS;CAAM,CAAC;AACzE,MAAM,YAAA,GAAA,WAAA,aAAuB;CAAE,MAAM;CAAY,SAAS;CAAM,CAAC;AACjE,MAAM,QAAA,GAAA,WAAA,aAAmB;CAAE,MAAM;CAAQ,SAAS;CAAK,CAAC;AACxD,MAAM,WAAA,GAAA,WAAA,aAAsB;CAAE,MAAM;CAAW,SAAS;CAAK,CAAC;AAC9D,MAAM,SAAA,GAAA,WAAA,aAAoB;CAAE,MAAM;CAAS,SAAS;CAAK,CAAC;AAG1D,MAAM,UAAA,GAAA,WAAA,aAAqB;CAAE,MAAM;CAAU,SAAS;CAAM,CAAC;AAC7D,MAAM,UAAA,GAAA,WAAA,aAAqB;CAAE,MAAM;CAAU,SAAS;CAAM,CAAC;AAC7D,MAAM,YAAA,GAAA,WAAA,aAAuB;CAAE,MAAM;CAAY,SAAS;CAAM,CAAC;AACjE,MAAM,YAAA,GAAA,WAAA,aAAuB;CAAE,MAAM;CAAY,SAAS;CAAM,CAAC;AACjE,MAAM,SAAA,GAAA,WAAA,aAAoB;CAAE,MAAM;CAAS,SAAS;CAAK,CAAC;AAC1D,MAAM,SAAA,GAAA,WAAA,aAAoB;CAAE,MAAM;CAAS,SAAS;CAAK,CAAC;AAC1D,MAAM,OAAA,GAAA,WAAA,aAAkB;CAAE,MAAM;CAAO,SAAS;CAAM,CAAC;AAGvD,MAAM,kBAAA,GAAA,WAAA,aAA6B;CAAE,MAAM;CAAkB,SAAS;CAAM,CAAC;AAC7E,MAAM,iBAAA,GAAA,WAAA,aAA4B;CAAE,MAAM;CAAiB,SAAS;CAAM,CAAC;AAC3E,MAAM,QAAA,GAAA,WAAA,aAAmB;CAAE,MAAM;CAAQ,SAAS;CAAK,CAAC;AAGxD,MAAM,cAAA,GAAA,WAAA,aAAyB;CAAE,MAAM;CAAc,SAAS;CAAgB,CAAC;AAG/E,MAAM,YAAY;CAChB;CAEA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CAEA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACD;AAED,MAAM,cAAc,IAAIA,WAAAA,MAAM,UAAU;AAIxC,IAAM,kBAAN,cAA8BC,WAAAA,UAAU;CACtC,cAAc;AACZ,QAAM,WAAW,EAAE,iBAAiB,OAAO,CAAC;AAC5C,OAAK,qBAAqB;;;CAI5B,cAAqB,KAAK,KAAK,qBAAqB;AAClD,OAAK,WAAW;AACd,QAAK,GAAG,CACN,EAAE,WAAW,KAAK,QAAQ,KAAK,oBAAoB,EAAE,EACrD,EAAE,WAAW,KAAK,QAAQ,KAAK,YAAY,EAAE,CAC9C,CAAC;IACF;AACF,OAAK,aAAa,KAAK,QAAQ,KAAK,YAAY,CAAC;AACjD,OAAK,cAAc,KAAK,QAAQ,KAAK,aAAa,CAAC;GACnD;;CAGF,cAAqB,KAAK,KAAK,qBAAqB;AAClD,OAAK,QAAQ,MAAM;AACnB,OAAK,QAAQ,KAAK,QAAQ;GAC1B;;CAGF,sBAA6B,KAAK,KAAK,6BAA6B;AAClE,OAAK,QAAQ,cAAc;AAC3B,OAAK,QAAQ,KAAK,QAAQ;GAC1B;;CAGF,UAAiB,KAAK,KAAK,iBAAiB;AAC1C,OAAK,QAAQ,KAAK,aAAa,EAAE,OAAO,OAAO,CAAC;AAChD,OAAK,aAAa;AAChB,QAAK,QAAQ,KAAK,WAAW;AAC7B,QAAK,SAAS,KAAK,aAAa,EAAE,OAAO,OAAO,CAAC;IACjD;GACF;;CAGF,cAAqB,KAAK,KAAK,qBAAqB;AAClD,OAAK,QAAQ,OAAO;AACpB,OAAK,QAAQ,YAAY,EAAE,OAAO,SAAS,CAAC;AAC5C,OAAK,aAAa;AAChB,QAAK,QAAQ,MAAM;AACnB,QAAK,SAAS,YAAY,EAAE,OAAO,SAAS,CAAC;IAC7C;AACF,OAAK,QAAQ,OAAO;GACpB;;CAGF,aAAoB,KAAK,KAAK,oBAAoB;AAChD,OAAK,GAAG,CACN,EACE,WAAW;AACT,QAAK,QAAQ,eAAe,EAAE,OAAO,aAAa,CAAC;AACnD,QAAK,QAAQ,SAAS;AACtB,QAAK,aAAa;AAChB,SAAK,QAAQ,MAAM;AACnB,SAAK,QAAQ,YAAY,EAAE,OAAO,WAAW,CAAC;KAC9C;AACF,QAAK,QAAQ,SAAS;AACtB,QAAK,QAAQ,MAAM,EAAE,OAAO,aAAa,CAAC;KAE7C,EACD,EACE,WAAW;AACT,QAAK,SAAS,MAAM,EAAE,OAAO,YAAY,CAAC;AAC1C,QAAK,SAAS,SAAS;AACvB,QAAK,cAAc;AACjB,SAAK,SAAS,MAAM;AACpB,SAAK,SAAS,YAAY,EAAE,OAAO,WAAW,CAAC;KAC/C;AACF,QAAK,SAAS,SAAS;AACvB,QAAK,QAAQ,gBAAgB,EAAE,OAAO,cAAc,CAAC;KAExD,CACF,CAAC;GACF;;CAGF,cAAqB,KAAK,KAAK,qBAAqB;AAClD,OAAK,QAAQ,MAAM;AACnB,OAAK,QAAQ,KAAK,aAAa;GAC/B;;CAGF,eAAsB,KAAK,KAAK,sBAAsB;AACpD,OAAK,QAAQ,KAAK,eAAe,EAAE,OAAO,OAAO,CAAC;AAClD,OAAK,WAAW;AACd,QAAK,QAAQ,GAAG;AAChB,QAAK,SAAS,KAAK,eAAe,EAAE,OAAO,OAAO,CAAC;IACnD;GACF;;CAGF,gBAAuB,KAAK,KAAK,uBAAuB;AACtD,OAAK,QAAQ,KAAK,eAAe,EAAE,OAAO,OAAO,CAAC;AAClD,OAAK,WAAW;AACd,QAAK,QAAQ,IAAI;AACjB,QAAK,SAAS,KAAK,eAAe,EAAE,OAAO,OAAO,CAAC;IACnD;GACF;;CAGF,gBAAuB,KAAK,KAAK,uBAAuB;AACtD,OAAK,aAAa,KAAK,QAAQ,IAAI,CAAC;AACpC,OAAK,QAAQ,KAAK,iBAAiB;GACnC;;CAGF,mBAA0B,KAAK,KAAK,0BAA0B;AAC5D,OAAK,GAAG,CACN,EACE,WAAW;AACT,QAAK,QAAQ,OAAO;AACpB,QAAK,QAAQ,KAAK,aAAa;AAC/B,QAAK,QAAQ,OAAO;KAEvB,EACD,EAAE,WAAW,KAAK,QAAQ,KAAK,UAAU,EAAE,CAC5C,CAAC;GACF;;CAGF,YAAmB,KAAK,KAAK,mBAAmB;AAC9C,OAAK,QAAQ,KAAK,aAAa,EAAE,OAAO,SAAS,CAAC;AAClD,OAAK,GAAG;GACN,EACE,WAAW;AACT,SAAK,QAAQ,MAAM;AACnB,SAAK,QAAQ,KAAK,SAAS,EAAE,OAAO,SAAS,CAAC;MAEjD;GACD,EACE,WAAW;AACT,SAAK,QAAQ,SAAS;AACtB,SAAK,SAAS,KAAK,SAAS,EAAE,OAAO,SAAS,CAAC;MAElD;GACD,EACE,WAAW;AACT,SAAK,QAAQ,KAAK;AAClB,SAAK,SAAS,KAAK,SAAS,EAAE,OAAO,SAAS,CAAC;MAElD;GACD,EACE,WAAW;AACT,SAAK,QAAQ,QAAQ;AACrB,SAAK,SAAS,KAAK,SAAS,EAAE,OAAO,SAAS,CAAC;MAElD;GACD,EACE,WAAW;AACT,SAAK,QAAQ,UAAU;AACvB,SAAK,SAAS,KAAK,SAAS,EAAE,OAAO,SAAS,CAAC;MAElD;GACD,EACE,WAAW;AACT,SAAK,QAAQ,aAAa;AAC1B,SAAK,SAAS,KAAK,SAAS,EAAE,OAAO,SAAS,CAAC;MAElD;GACD,EACE,WAAW;AACT,SAAK,QAAQ,SAAS;AACtB,SAAK,SAAS,KAAK,SAAS,EAAE,OAAO,SAAS,CAAC;MAElD;GACD,EACE,WAAW;AACT,SAAK,QAAQ,WAAW;AACxB,SAAK,SAAS,KAAK,SAAS,EAAE,OAAO,SAAS,CAAC;MAElD;GACD,EACE,WAAW;AACT,SAAK,QAAQ,SAAS;AACtB,SAAK,SAAS,KAAK,SAAS,EAAE,OAAO,SAAS,CAAC;MAElD;GACD,EAAE,WAAW,KAAK,QAAQ,UAAU,EAAE;GACtC,EAAE,WAAW,KAAK,QAAQ,OAAO,EAAE;GACnC,EACE,WAAW;AACT,SAAK,QAAQ,GAAG;AAChB,SAAK,QAAQ,KAAK,aAAa,EAAE,OAAO,QAAQ,CAAC;MAEpD;GACD,EACE,WAAW;AACT,SAAK,QAAQ,MAAM;AACnB,SAAK,SAAS,KAAK,aAAa,EAAE,OAAO,QAAQ,CAAC;MAErD;GACF,CAAC;GACF;;CAGF,cAAqB,KAAK,KAAK,qBAAqB;AAClD,OAAK,QAAQ,YAAY,EAAE,OAAO,QAAQ,CAAC;AAC3C,OAAK,WAAW;AACd,QAAK,QAAQ,IAAI;AACjB,QAAK,SAAS,YAAY,EAAE,OAAO,QAAQ,CAAC;IAC5C;GACF;;CAGF,UAAiB,KAAK,KAAK,iBAAiB;AAC1C,OAAK,GAAG;GACN,EAAE,WAAW,KAAK,QAAQ,cAAc,EAAE;GAC1C,EAAE,WAAW,KAAK,QAAQ,cAAc,EAAE;GAC1C,EAAE,WAAW,KAAK,QAAQ,QAAQ,EAAE;GACpC,EAAE,WAAW,KAAK,QAAQ,QAAQ,EAAE;GACpC,EAAE,WAAW,KAAK,QAAQ,SAAS,EAAE;GACrC,EAAE,WAAW,KAAK,QAAQ,WAAW,EAAE;GACxC,CAAC;GACF;;CAGF,cAAqB,KAAK,KAAK,qBAAqB;AAClD,OAAK,QAAQ,SAAS;AACtB,OAAK,aAAa;AAChB,QAAK,QAAQ,KAAK,SAAS,EAAE,OAAO,SAAS,CAAC;AAC9C,QAAK,WAAW;AACd,SAAK,QAAQ,MAAM;AACnB,SAAK,SAAS,KAAK,SAAS,EAAE,OAAO,SAAS,CAAC;KAC/C;IACF;AACF,OAAK,QAAQ,SAAS;GACtB;;CAGF,eAAsB,KAAK,KAAK,sBAAsB;AACpD,OAAK,QAAQ,OAAO;AACpB,OAAK,WAAW;AACd,QAAK,GAAG;IACN,EAAE,WAAW,KAAK,QAAQ,WAAW,EAAE;IACvC,EAAE,WAAW,KAAK,QAAQ,MAAM,EAAE;IAClC,EAAE,WAAW,KAAK,QAAQ,IAAI,EAAE;IACjC,CAAC;IACF;GACF;;AAGJ,MAAM,iBAAiB,IAAI,iBAAiB;;AAK5C,MAAM,gBAAgB,UAA2B;CAC/C,MAAM,MAAM,MAAM;AAClB,SAAQ,MAAM,WAAd;EACE,KAAK,cACH,QAAO,IAAI,MAAM,GAAG,GAAG,CAAC,QAAQ,QAAQ,IAAI;EAC9C,KAAK,cACH,QAAO,OAAO,IAAI;EACpB,KAAK,QACH,QAAO;EACT,KAAK,QACH,QAAO;EACT,KAAK,SACH,QAAO;EACT,QACE,QAAO;;;;AAKb,MAAM,kBAAkB,gBAAkC;CACxD,MAAM,WAAW,YAAY;CAC7B,MAAM,QACH,SAAS,gBAA6B,MACtC,SAAS,gBAA6B,MACtC,SAAS,UAAuB,MAChC,SAAS,UAAuB,MAChC,SAAS,WAAwB,MACjC,SAAS,aAA0B;AACtC,QAAO,QAAQ,aAAa,MAAM,GAAG;;;AAIvC,MAAM,sBAAsB,SAA0B;CACpD,MAAM,OAAQ,KAAK,SAAS,KAAkB,GAAG;CACjD,MAAM,QAAS,KAAK,SAAS,QAAiC,EAAE;AAChE,KAAI,MAAM,WAAW,EAAG,QAAO;AAC/B,QAAO,OAAO,MAAM,MAAM,KAAI,MAAK,EAAE,MAAM,CAAC,KAAK,IAAI;;;AAIvD,MAAM,eAAe,SAA6B;AAEhD,SADe,KAAK,SAAS,SAAmC,EAAE,EACrD,IAAI,eAAe;;;AAMlC,MAAM,qBAAqB,SAAiC;CAC1D,MAAM,WAAW,KAAK,SAAS;CAC/B,MAAM,WAAY,KAAK,SAAS,OAAiC,EAAE;AAEnE,KAAI,SAAS,WAAW,EACtB,QAAO,mBAAmB,SAAS,GAAG;CAGxC,MAAM,WAAW,CAAC,SAAS,IAAI,GAAG,SAAS;CAC3C,MAAM,WAA0B,EAAE;AAClC,MAAK,MAAM,QAAQ,UAAU;EAC3B,MAAM,YAAY,mBAAmB,KAAK;AAC1C,MAAI,UAAU,WAAW,EACvB,UAAS,KAAK,UAAU,GAAG;MAE3B,UAAS,KAAK;GAAE,YAAY;GAAO,OAAO;GAAW,CAAC;;AAG1D,QAAO,CAAC;EAAE,YAAY;EAAM,OAAO;EAAU,CAAC;;;AAIhD,MAAM,sBAAsB,SAAiC;CAC3D,MAAM,WAAW,KAAK,SAAS;CAC/B,MAAM,WAAY,KAAK,SAAS,OAAiC,EAAE;CACnE,MAAM,MAAM,CAAC,SAAS,IAAI,GAAG,SAAS;CACtC,MAAM,QAAuB,EAAE;AAC/B,MAAK,MAAM,QAAQ,IACjB,OAAM,KAAK,GAAG,mBAAmB,KAAK,CAAC;AAEzC,QAAO;;;AAIT,MAAM,sBAAsB,SAAiC;CAC3D,MAAM,SAAS,CAAC,CAAE,KAAK,SAAS,KAA8B;CAC9D,MAAM,cAAc,sBAAuB,KAAK,SAAS,iBAA+B,GAAG;AAE3F,KAAI,CAAC,OAAQ,QAAO;AAEpB,QAAO,CAAC;EAAE,YAAY;EAAO,KAAK;EAAM,OAAO;EAAa,CAAC;;;AAI/D,MAAM,yBAAyB,SAAiC;AAC9D,KAAI,KAAK,SAAS,aAChB,QAAO,kBAAmB,KAAK,SAAS,aAA2B,GAAG;AAExE,KAAI,KAAK,SAAS,UAChB,QAAO,CAAC,eAAgB,KAAK,SAAS,UAAwB,GAAG,CAAC;AAEpE,QAAO,EAAE;;;AAIX,MAAM,kBAAkB,SAAmC;CACzD,MAAM,QAAQ,mBAAoB,KAAK,SAAS,MAAoB,GAAG;AAEvE,KAAI,KAAK,SAAS,OAChB,QAAO;EAAE;EAAO,UAAU;EAAQ,OAAO;EAAM;AAEjD,KAAI,KAAK,SAAS,UAChB,QAAO;EAAE;EAAO,UAAU;EAAW,OAAO;EAAM;AAGpD,KAAI,KAAK,SAAS,GAEhB,QAAO;EAAE;EAAO,UAAU;EAAM,OADnB,YAAa,KAAK,SAAS,KAAmB,GAChB;EAAE;AAE/C,KAAI,KAAK,SAAS,MAEhB,QAAO;EAAE;EAAO,UAAU;EAAS,OADtB,YAAa,KAAK,SAAS,KAAmB,GACb;EAAE;CAGlD,MAAM,YAAa,KAAK,SAAS,QAAkC;CACnE,MAAM,QAAQ,YAAY,eAAe,UAAU,GAAG;AAEtD,KAAI,KAAK,SAAS,MAAO,QAAO;EAAE;EAAO,UAAU;EAAK;EAAO;AAC/D,KAAI,KAAK,SAAS,SAAU,QAAO;EAAE;EAAO,UAAU;EAAM;EAAO;AACnE,KAAI,KAAK,SAAS,KAAM,QAAO;EAAE;EAAO,UAAU;EAAK;EAAO;AAC9D,KAAI,KAAK,SAAS,QAAS,QAAO;EAAE;EAAO,UAAU;EAAK;EAAO;AACjE,KAAI,KAAK,SAAS,UAAW,QAAO;EAAE;EAAO,UAAU;EAAM;EAAO;AACpE,KAAI,KAAK,SAAS,aAAc,QAAO;EAAE;EAAO,UAAU;EAAM;EAAO;AACvE,KAAI,KAAK,SAAS,SAAU,QAAO;EAAE;EAAO,UAAU;EAAY;EAAO;AACzE,KAAI,KAAK,SAAS,WAAY,QAAO;EAAE;EAAO,UAAU;EAAc;EAAO;AAC7E,KAAI,KAAK,SAAS,SAAU,QAAO;EAAE;EAAO,UAAU;EAAY;EAAO;AAEzE,QAAO;EAAE;EAAO,UAAU;EAAK;EAAO;;AA4CxC,SAAgB,YACd,QACA,UACyB;CACzB,MAAM,UAAU,OAAO,MAAM;AAC7B,KAAI,CAAC,QAAS,QAAO;EAAE,YAAY;EAAO,OAAO,EAAE;EAAE;CAGrD,IAAI,QAAQ;AACZ,KAAI,CAAC,eAAe,KAAK,MAAM,IAAI,CAAC,eAAe,KAAK,MAAM,CAE5D,SAAQ,SAAS;CAGnB,MAAM,YAAY,YAAY,SAAS,MAAM;AAC7C,KAAI,UAAU,OAAO,SAAS,EAC5B,QAAO;EAAE,YAAY;EAAO,OAAO,EAAE;EAAE;AAGzC,gBAAe,QAAQ,UAAU;CACjC,MAAM,MAAM,eAAe,aAAa;AAExC,KAAI,eAAe,OAAO,SAAS,EACjC,QAAO;EAAE,YAAY;EAAO,OAAO,EAAE;EAAE;CAGzC,MAAM,QAAuB,EAAE;CAG/B,MAAM,eAAgB,IAAI,SAAS,eAAyC,EAAE;AAC9E,KAAI,aAAa,SAAS,GAAG;EAE3B,MAAM,SADY,aAAa,GACL,SAAS,aAA2B;EAC9D,MAAM,aAAa,kBAAkB,OAAO;AAG5C,MACE,WAAW,WAAW,KACtB,gBAAgB,WAAW,MAC3B,WAAW,GAAG,eAAe,SAC7B,EAAE,SAAS,WAAW,MAAM,WAAW,GAAG,KAE1C,OAAM,KAAK,GAAG,WAAW,GAAG,MAAM;MAElC,OAAM,KAAK,GAAG,WAAW;;AAI7B,QAAO;EAAE,YAAY;EAAO;EAAO;;AAoBrC,SAAgB,SAAS,KAAa,SAAuD;AAE3F,QAAQ,YACN,KACA,QACD"}
+{"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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"}

package/dist/parseCypher.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseCypher.mjs","names":[],"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.mjs","names":[],"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 { E as DefaultRuleGroupType, x as DefaultRuleGroupTypeIC } from "./index-D-Iej37L.mjs";
+import { E as DefaultRuleGroupType, x as DefaultRuleGroupTypeIC } from "./index-CR-tk4Ci.mjs";
 
 //#region src/utils/parseGremlin/parseGremlin.d.ts
 /**

package/dist/parseGremlin.d.ts

@@ -1,4 +1,4 @@
-import { E as DefaultRuleGroupType, x as DefaultRuleGroupTypeIC } from "./index-Cjapnb-H.js";
+import { E as DefaultRuleGroupType, x as DefaultRuleGroupTypeIC } from "./index-NSVgGj45.js";
 
 //#region src/utils/parseGremlin/parseGremlin.d.ts
 /**

package/dist/parseGremlin.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseGremlin.js","names":[],"sources":["../src/utils/parseGremlin/parseGremlin.ts"],"sourcesContent":["import type {\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n} from '../../types';\n\n/**\n * Options for {@link parseGremlin}.\n */\nexport interface ParseGremlinOptions {\n  independentCombinators?: boolean;\n}\n\n/**\n * Parses a Gremlin traversal string into a {@link DefaultRuleGroupType}.\n *\n * Accepts a full Gremlin traversal or a chain of `.has()` steps.\n * Pattern steps (`.hasLabel()`, `.out()`, `.in()`, `.both()`, `.as()`) are\n * consumed but discarded — only `.has()` filter predicates are returned.\n *\n * @example\n * ```ts\n * // Full traversal — extracts .has() conditions only\n * parseGremlin(\"g.V().hasLabel('Person').has('age', gt(30))\");\n *\n * // Bare .has() chain\n * parseGremlin(\".has('age', gt(30)).has('name', 'Alice')\");\n * ```\n */\nexport function parseGremlin(gremlin: string): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nexport function parseGremlin(\n  gremlin: string,\n  _options?: ParseGremlinOptions\n): DefaultRuleGroupTypeAny {\n  const trimmed = gremlin.trim();\n  if (!trimmed) return { combinator: 'and', rules: [] };\n\n  const rules: (DefaultRuleType | DefaultRuleGroupType)[] = [];\n  const steps = tokenizeGremlinSteps(trimmed);\n\n  for (const step of steps) {\n    // Skip pattern steps — only extract filter predicates\n    // .hasLabel('Label') — pattern step, skip\n    if (step.startsWith('hasLabel(')) continue;\n    // .as('alias') — pattern step, skip\n    if (step.startsWith('as(')) continue;\n    // .out('edge'), .in('edge'), .both('edge') — pattern step, skip\n    if (/^(out|in|both)\\(/.test(step)) continue;\n    // .V(), .E() — traversal source, skip\n    if (/^[VE]\\(/.test(step)) continue;\n\n    // .hasNot('prop') — null check\n    const hasNotMatch = step.match(/^hasNot\\('([^']+)'\\)$/);\n    if (hasNotMatch) {\n      rules.push({ field: hasNotMatch[1], operator: 'null', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop') — property exists\n    const hasExistsMatch = step.match(/^has\\('([^']+)'\\)$/);\n    if (hasExistsMatch) {\n      rules.push({ field: hasExistsMatch[1], operator: 'notNull', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop', value) — equality or predicate\n    const hasEqMatch = step.match(/^has\\('([^']+)',\\s*(.+)\\)$/);\n    if (hasEqMatch) {\n      const [, prop, rawValue] = hasEqMatch;\n      const parsed = parseGremlinPredicate(prop, rawValue.trim());\n      if (parsed) {\n        rules.push(parsed);\n      }\n      continue;\n    }\n  }\n\n  return { combinator: 'and', rules };\n}\n\n/** Tokenizes a Gremlin traversal string into individual step strings. */\nconst tokenizeGremlinSteps = (gremlin: string): string[] => {\n  const steps: string[] = [];\n\n  // Remove leading source (e.g., \"g.V().\")\n  let str = gremlin.trim();\n  const sourceMatch = str.match(/^\\w+\\.V\\(\\)\\./);\n  if (sourceMatch) {\n    str = str.slice(sourceMatch[0].length);\n  } else if (str.startsWith('.')) {\n    // Bare step chain starting with a dot\n    str = str.slice(1);\n  }\n\n  // Split on top-level dots\n  let depth = 0;\n  let current = '';\n\n  for (let i = 0; i < str.length; i++) {\n    const ch = str[i];\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n\n    if (ch === '.' && depth === 0) {\n      if (current.trim()) steps.push(current.trim());\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) steps.push(current.trim());\n\n  return steps;\n};\n\n/** Parses a Gremlin predicate (the second argument of `.has()`). */\nconst parseGremlinPredicate = (prop: string, rawValue: string): DefaultRuleType | null => {\n  // Predicate functions: gt(), lt(), gte(), lte(), neq(), within(), without(), between(), outside()\n  const predicateMatch = rawValue.match(/^(\\w+)\\((.+)\\)$/);\n  if (predicateMatch) {\n    const [, predName, args] = predicateMatch;\n    const parsedArgs = parseGremlinArgs(args);\n\n    switch (predName) {\n      case 'gt':\n        return { field: prop, operator: '>', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lt':\n        return { field: prop, operator: '<', value: parsedArgs[0] } as DefaultRuleType;\n      case 'gte':\n        return { field: prop, operator: '>=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lte':\n        return { field: prop, operator: '<=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'neq':\n        return { field: prop, operator: '!=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'within':\n        return { field: prop, operator: 'in', value: parsedArgs } as DefaultRuleType;\n      case 'without':\n        return { field: prop, operator: 'notIn', value: parsedArgs } as DefaultRuleType;\n      case 'between':\n        return {\n          field: prop,\n          operator: 'between',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'outside':\n        return {\n          field: prop,\n          operator: 'notBetween',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'containing':\n        return { field: prop, operator: 'contains', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notContaining':\n        return { field: prop, operator: 'doesNotContain', value: parsedArgs[0] } as DefaultRuleType;\n      case 'startingWith':\n        return { field: prop, operator: 'beginsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notStartingWith':\n        return {\n          field: prop,\n          operator: 'doesNotBeginWith',\n          value: parsedArgs[0],\n        } as DefaultRuleType;\n      case 'endingWith':\n        return { field: prop, operator: 'endsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notEndingWith':\n        return { field: prop, operator: 'doesNotEndWith', value: parsedArgs[0] } as DefaultRuleType;\n      default:\n        return null;\n    }\n  }\n\n  // Plain value — equality\n  return { field: prop, operator: '=', value: parseGremlinLiteral(rawValue) } as DefaultRuleType;\n};\n\n/** Parses a comma-separated argument list. */\nconst parseGremlinArgs = (args: string): unknown[] => {\n  const result: unknown[] = [];\n  let depth = 0;\n  let current = '';\n\n  for (const ch of args) {\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n    if (ch === ',' && depth === 0) {\n      result.push(parseGremlinLiteral(current.trim()));\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) result.push(parseGremlinLiteral(current.trim()));\n  return result;\n};\n\n/** Parses a Gremlin literal value. */\nconst parseGremlinLiteral = (raw: string): unknown => {\n  if (raw.startsWith(\"'\") && raw.endsWith(\"'\")) {\n    return raw.slice(1, -1).replace(/\\\\'/g, \"'\");\n  }\n  if (raw === 'null') return null;\n  if (raw === 'true') return true;\n  if (raw === 'false') return false;\n  const num = Number(raw);\n  if (!Number.isNaN(num)) return num;\n  return raw;\n};\n"],"mappings":"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"}
+{"version":3,"file":"parseGremlin.js","names":[],"sources":["../src/utils/parseGremlin/parseGremlin.ts"],"sourcesContent":["import type {\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n} from '../../types';\n\n/**\n * Options for {@link parseGremlin}.\n */\nexport interface ParseGremlinOptions {\n  independentCombinators?: boolean;\n}\n\n/**\n * Parses a Gremlin traversal string into a {@link DefaultRuleGroupType}.\n *\n * Accepts a full Gremlin traversal or a chain of `.has()` steps.\n * Pattern steps (`.hasLabel()`, `.out()`, `.in()`, `.both()`, `.as()`) are\n * consumed but discarded — only `.has()` filter predicates are returned.\n *\n * @example\n * ```ts\n * // Full traversal — extracts .has() conditions only\n * parseGremlin(\"g.V().hasLabel('Person').has('age', gt(30))\");\n *\n * // Bare .has() chain\n * parseGremlin(\".has('age', gt(30)).has('name', 'Alice')\");\n * ```\n */\nexport function parseGremlin(gremlin: string): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nexport function parseGremlin(\n  gremlin: string,\n  _options?: ParseGremlinOptions\n): DefaultRuleGroupTypeAny {\n  const trimmed = gremlin.trim();\n  if (!trimmed) return { combinator: 'and', rules: [] };\n\n  const rules: (DefaultRuleType | DefaultRuleGroupType)[] = [];\n  const steps = tokenizeGremlinSteps(trimmed);\n\n  for (const step of steps) {\n    // Skip pattern steps — only extract filter predicates\n    // .hasLabel('Label') — pattern step, skip\n    if (step.startsWith('hasLabel(')) continue;\n    // .as('alias') — pattern step, skip\n    if (step.startsWith('as(')) continue;\n    // .out('edge'), .in('edge'), .both('edge') — pattern step, skip\n    if (/^(out|in|both)\\(/.test(step)) continue;\n    // .V(), .E() — traversal source, skip\n    if (/^[VE]\\(/.test(step)) continue;\n\n    // .hasNot('prop') — null check\n    const hasNotMatch = step.match(/^hasNot\\('([^']+)'\\)$/);\n    if (hasNotMatch) {\n      rules.push({ field: hasNotMatch[1], operator: 'null', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop') — property exists\n    const hasExistsMatch = step.match(/^has\\('([^']+)'\\)$/);\n    if (hasExistsMatch) {\n      rules.push({ field: hasExistsMatch[1], operator: 'notNull', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop', value) — equality or predicate\n    const hasEqMatch = step.match(/^has\\('([^']+)',\\s*(.+)\\)$/);\n    if (hasEqMatch) {\n      const [, prop, rawValue] = hasEqMatch;\n      const parsed = parseGremlinPredicate(prop, rawValue.trim());\n      if (parsed) {\n        rules.push(parsed);\n      }\n      continue;\n    }\n  }\n\n  return { combinator: 'and', rules };\n}\n\n/** Tokenizes a Gremlin traversal string into individual step strings. */\nconst tokenizeGremlinSteps = (gremlin: string): string[] => {\n  const steps: string[] = [];\n\n  // Remove leading source (e.g., \"g.V().\")\n  let str = gremlin.trim();\n  const sourceMatch = str.match(/^\\w+\\.V\\(\\)\\./);\n  if (sourceMatch) {\n    str = str.slice(sourceMatch[0].length);\n  } else if (str.startsWith('.')) {\n    // Bare step chain starting with a dot\n    str = str.slice(1);\n  }\n\n  // Split on top-level dots\n  let depth = 0;\n  let current = '';\n\n  for (let i = 0; i < str.length; i++) {\n    const ch = str[i];\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n\n    if (ch === '.' && depth === 0) {\n      if (current.trim()) steps.push(current.trim());\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) steps.push(current.trim());\n\n  return steps;\n};\n\n/** Parses a Gremlin predicate (the second argument of `.has()`). */\nconst parseGremlinPredicate = (prop: string, rawValue: string): DefaultRuleType | null => {\n  // Predicate functions: gt(), lt(), gte(), lte(), neq(), within(), without(), between(), outside()\n  const predicateMatch = rawValue.match(/^(\\w+)\\((.+)\\)$/);\n  if (predicateMatch) {\n    const [, predName, args] = predicateMatch;\n    const parsedArgs = parseGremlinArgs(args);\n\n    switch (predName) {\n      case 'gt':\n        return { field: prop, operator: '>', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lt':\n        return { field: prop, operator: '<', value: parsedArgs[0] } as DefaultRuleType;\n      case 'gte':\n        return { field: prop, operator: '>=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lte':\n        return { field: prop, operator: '<=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'neq':\n        return { field: prop, operator: '!=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'within':\n        return { field: prop, operator: 'in', value: parsedArgs } as DefaultRuleType;\n      case 'without':\n        return { field: prop, operator: 'notIn', value: parsedArgs } as DefaultRuleType;\n      case 'between':\n        return {\n          field: prop,\n          operator: 'between',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'outside':\n        return {\n          field: prop,\n          operator: 'notBetween',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'containing':\n        return { field: prop, operator: 'contains', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notContaining':\n        return { field: prop, operator: 'doesNotContain', value: parsedArgs[0] } as DefaultRuleType;\n      case 'startingWith':\n        return { field: prop, operator: 'beginsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notStartingWith':\n        return {\n          field: prop,\n          operator: 'doesNotBeginWith',\n          value: parsedArgs[0],\n        } as DefaultRuleType;\n      case 'endingWith':\n        return { field: prop, operator: 'endsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notEndingWith':\n        return { field: prop, operator: 'doesNotEndWith', value: parsedArgs[0] } as DefaultRuleType;\n      default:\n        return null;\n    }\n  }\n\n  // Plain value — equality\n  return { field: prop, operator: '=', value: parseGremlinLiteral(rawValue) } as DefaultRuleType;\n};\n\n/** Parses a comma-separated argument list. */\nconst parseGremlinArgs = (args: string): unknown[] => {\n  const result: unknown[] = [];\n  let depth = 0;\n  let current = '';\n\n  for (const ch of args) {\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n    if (ch === ',' && depth === 0) {\n      result.push(parseGremlinLiteral(current.trim()));\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) result.push(parseGremlinLiteral(current.trim()));\n  return result;\n};\n\n/** Parses a Gremlin literal value. */\nconst parseGremlinLiteral = (raw: string): unknown => {\n  if (raw.startsWith(\"'\") && raw.endsWith(\"'\")) {\n    return raw.slice(1, -1).replace(/\\\\'/g, \"'\");\n  }\n  if (raw === 'null') return null;\n  if (raw === 'true') return true;\n  if (raw === 'false') return false;\n  const num = Number(raw);\n  if (!Number.isNaN(num)) return num;\n  return raw;\n};\n"],"mappings":";;AA2CA,SAAgB,aACd,SACA,UACyB;CACzB,MAAM,UAAU,QAAQ,KAAK;CAC7B,IAAI,CAAC,SAAS,OAAO;EAAE,YAAY;EAAO,OAAO,CAAC;CAAE;CAEpD,MAAM,QAAoD,CAAC;CAC3D,MAAM,QAAQ,qBAAqB,OAAO;CAE1C,KAAK,MAAM,QAAQ,OAAO;EAGxB,IAAI,KAAK,WAAW,WAAW,GAAG;EAElC,IAAI,KAAK,WAAW,KAAK,GAAG;EAE5B,IAAI,mBAAmB,KAAK,IAAI,GAAG;EAEnC,IAAI,UAAU,KAAK,IAAI,GAAG;EAG1B,MAAM,cAAc,KAAK,MAAM,uBAAuB;EACtD,IAAI,aAAa;GACf,MAAM,KAAK;IAAE,OAAO,YAAY;IAAI,UAAU;IAAQ,OAAO;GAAK,CAAoB;GACtF;EACF;EAGA,MAAM,iBAAiB,KAAK,MAAM,oBAAoB;EACtD,IAAI,gBAAgB;GAClB,MAAM,KAAK;IAAE,OAAO,eAAe;IAAI,UAAU;IAAW,OAAO;GAAK,CAAoB;GAC5F;EACF;EAGA,MAAM,aAAa,KAAK,MAAM,4BAA4B;EAC1D,IAAI,YAAY;GACd,MAAM,GAAG,MAAM,YAAY;GAC3B,MAAM,SAAS,sBAAsB,MAAM,SAAS,KAAK,CAAC;GAC1D,IAAI,QACF,MAAM,KAAK,MAAM;GAEnB;EACF;CACF;CAEA,OAAO;EAAE,YAAY;EAAO;CAAM;AACpC;;AAGA,MAAM,wBAAwB,YAA8B;CAC1D,MAAM,QAAkB,CAAC;CAGzB,IAAI,MAAM,QAAQ,KAAK;CACvB,MAAM,cAAc,IAAI,MAAM,eAAe;CAC7C,IAAI,aACF,MAAM,IAAI,MAAM,YAAY,GAAG,MAAM;MAChC,IAAI,IAAI,WAAW,GAAG,GAE3B,MAAM,IAAI,MAAM,CAAC;CAInB,IAAI,QAAQ;CACZ,IAAI,UAAU;CAEd,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACnC,MAAM,KAAK,IAAI;EACf,IAAI,OAAO,KAAK;OACX,IAAI,OAAO,KAAK;EAErB,IAAI,OAAO,OAAO,UAAU,GAAG;GAC7B,IAAI,QAAQ,KAAK,GAAG,MAAM,KAAK,QAAQ,KAAK,CAAC;GAC7C,UAAU;GACV;EACF;EACA,WAAW;CACb;CACA,IAAI,QAAQ,KAAK,GAAG,MAAM,KAAK,QAAQ,KAAK,CAAC;CAE7C,OAAO;AACT;;AAGA,MAAM,yBAAyB,MAAc,aAA6C;CAExF,MAAM,iBAAiB,SAAS,MAAM,iBAAiB;CACvD,IAAI,gBAAgB;EAClB,MAAM,GAAG,UAAU,QAAQ;EAC3B,MAAM,aAAa,iBAAiB,IAAI;EAExC,QAAQ,UAAR;GACE,KAAK,MACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAK,OAAO,WAAW;GAAG;GAC5D,KAAK,MACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAK,OAAO,WAAW;GAAG;GAC5D,KAAK,OACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAM,OAAO,WAAW;GAAG;GAC7D,KAAK,OACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAM,OAAO,WAAW;GAAG;GAC7D,KAAK,OACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAM,OAAO,WAAW;GAAG;GAC7D,KAAK,UACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAM,OAAO;GAAW;GAC1D,KAAK,WACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAS,OAAO;GAAW;GAC7D,KAAK,WACH,OAAO;IACL,OAAO;IACP,UAAU;IACV,OAAO,WAAW,MAAM,GAAG,CAAC;GAC9B;GACF,KAAK,WACH,OAAO;IACL,OAAO;IACP,UAAU;IACV,OAAO,WAAW,MAAM,GAAG,CAAC;GAC9B;GACF,KAAK,cACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAY,OAAO,WAAW;GAAG;GACnE,KAAK,iBACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAkB,OAAO,WAAW;GAAG;GACzE,KAAK,gBACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAc,OAAO,WAAW;GAAG;GACrE,KAAK,mBACH,OAAO;IACL,OAAO;IACP,UAAU;IACV,OAAO,WAAW;GACpB;GACF,KAAK,cACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAY,OAAO,WAAW;GAAG;GACnE,KAAK,iBACH,OAAO;IAAE,OAAO;IAAM,UAAU;IAAkB,OAAO,WAAW;GAAG;GACzE,SACE,OAAO;EACX;CACF;CAGA,OAAO;EAAE,OAAO;EAAM,UAAU;EAAK,OAAO,oBAAoB,QAAQ;CAAE;AAC5E;;AAGA,MAAM,oBAAoB,SAA4B;CACpD,MAAM,SAAoB,CAAC;CAC3B,IAAI,QAAQ;CACZ,IAAI,UAAU;CAEd,KAAK,MAAM,MAAM,MAAM;EACrB,IAAI,OAAO,KAAK;OACX,IAAI,OAAO,KAAK;EACrB,IAAI,OAAO,OAAO,UAAU,GAAG;GAC7B,OAAO,KAAK,oBAAoB,QAAQ,KAAK,CAAC,CAAC;GAC/C,UAAU;GACV;EACF;EACA,WAAW;CACb;CACA,IAAI,QAAQ,KAAK,GAAG,OAAO,KAAK,oBAAoB,QAAQ,KAAK,CAAC,CAAC;CACnE,OAAO;AACT;;AAGA,MAAM,uBAAuB,QAAyB;CACpD,IAAI,IAAI,WAAW,GAAG,KAAK,IAAI,SAAS,GAAG,GACzC,OAAO,IAAI,MAAM,GAAG,EAAE,EAAE,QAAQ,QAAQ,GAAG;CAE7C,IAAI,QAAQ,QAAQ,OAAO;CAC3B,IAAI,QAAQ,QAAQ,OAAO;CAC3B,IAAI,QAAQ,SAAS,OAAO;CAC5B,MAAM,MAAM,OAAO,GAAG;CACtB,IAAI,CAAC,OAAO,MAAM,GAAG,GAAG,OAAO;CAC/B,OAAO;AACT"}

package/dist/parseGremlin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseGremlin.mjs","names":[],"sources":["../src/utils/parseGremlin/parseGremlin.ts"],"sourcesContent":["import type {\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n} from '../../types';\n\n/**\n * Options for {@link parseGremlin}.\n */\nexport interface ParseGremlinOptions {\n  independentCombinators?: boolean;\n}\n\n/**\n * Parses a Gremlin traversal string into a {@link DefaultRuleGroupType}.\n *\n * Accepts a full Gremlin traversal or a chain of `.has()` steps.\n * Pattern steps (`.hasLabel()`, `.out()`, `.in()`, `.both()`, `.as()`) are\n * consumed but discarded — only `.has()` filter predicates are returned.\n *\n * @example\n * ```ts\n * // Full traversal — extracts .has() conditions only\n * parseGremlin(\"g.V().hasLabel('Person').has('age', gt(30))\");\n *\n * // Bare .has() chain\n * parseGremlin(\".has('age', gt(30)).has('name', 'Alice')\");\n * ```\n */\nexport function parseGremlin(gremlin: string): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nexport function parseGremlin(\n  gremlin: string,\n  _options?: ParseGremlinOptions\n): DefaultRuleGroupTypeAny {\n  const trimmed = gremlin.trim();\n  if (!trimmed) return { combinator: 'and', rules: [] };\n\n  const rules: (DefaultRuleType | DefaultRuleGroupType)[] = [];\n  const steps = tokenizeGremlinSteps(trimmed);\n\n  for (const step of steps) {\n    // Skip pattern steps — only extract filter predicates\n    // .hasLabel('Label') — pattern step, skip\n    if (step.startsWith('hasLabel(')) continue;\n    // .as('alias') — pattern step, skip\n    if (step.startsWith('as(')) continue;\n    // .out('edge'), .in('edge'), .both('edge') — pattern step, skip\n    if (/^(out|in|both)\\(/.test(step)) continue;\n    // .V(), .E() — traversal source, skip\n    if (/^[VE]\\(/.test(step)) continue;\n\n    // .hasNot('prop') — null check\n    const hasNotMatch = step.match(/^hasNot\\('([^']+)'\\)$/);\n    if (hasNotMatch) {\n      rules.push({ field: hasNotMatch[1], operator: 'null', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop') — property exists\n    const hasExistsMatch = step.match(/^has\\('([^']+)'\\)$/);\n    if (hasExistsMatch) {\n      rules.push({ field: hasExistsMatch[1], operator: 'notNull', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop', value) — equality or predicate\n    const hasEqMatch = step.match(/^has\\('([^']+)',\\s*(.+)\\)$/);\n    if (hasEqMatch) {\n      const [, prop, rawValue] = hasEqMatch;\n      const parsed = parseGremlinPredicate(prop, rawValue.trim());\n      if (parsed) {\n        rules.push(parsed);\n      }\n      continue;\n    }\n  }\n\n  return { combinator: 'and', rules };\n}\n\n/** Tokenizes a Gremlin traversal string into individual step strings. */\nconst tokenizeGremlinSteps = (gremlin: string): string[] => {\n  const steps: string[] = [];\n\n  // Remove leading source (e.g., \"g.V().\")\n  let str = gremlin.trim();\n  const sourceMatch = str.match(/^\\w+\\.V\\(\\)\\./);\n  if (sourceMatch) {\n    str = str.slice(sourceMatch[0].length);\n  } else if (str.startsWith('.')) {\n    // Bare step chain starting with a dot\n    str = str.slice(1);\n  }\n\n  // Split on top-level dots\n  let depth = 0;\n  let current = '';\n\n  for (let i = 0; i < str.length; i++) {\n    const ch = str[i];\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n\n    if (ch === '.' && depth === 0) {\n      if (current.trim()) steps.push(current.trim());\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) steps.push(current.trim());\n\n  return steps;\n};\n\n/** Parses a Gremlin predicate (the second argument of `.has()`). */\nconst parseGremlinPredicate = (prop: string, rawValue: string): DefaultRuleType | null => {\n  // Predicate functions: gt(), lt(), gte(), lte(), neq(), within(), without(), between(), outside()\n  const predicateMatch = rawValue.match(/^(\\w+)\\((.+)\\)$/);\n  if (predicateMatch) {\n    const [, predName, args] = predicateMatch;\n    const parsedArgs = parseGremlinArgs(args);\n\n    switch (predName) {\n      case 'gt':\n        return { field: prop, operator: '>', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lt':\n        return { field: prop, operator: '<', value: parsedArgs[0] } as DefaultRuleType;\n      case 'gte':\n        return { field: prop, operator: '>=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lte':\n        return { field: prop, operator: '<=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'neq':\n        return { field: prop, operator: '!=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'within':\n        return { field: prop, operator: 'in', value: parsedArgs } as DefaultRuleType;\n      case 'without':\n        return { field: prop, operator: 'notIn', value: parsedArgs } as DefaultRuleType;\n      case 'between':\n        return {\n          field: prop,\n          operator: 'between',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'outside':\n        return {\n          field: prop,\n          operator: 'notBetween',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'containing':\n        return { field: prop, operator: 'contains', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notContaining':\n        return { field: prop, operator: 'doesNotContain', value: parsedArgs[0] } as DefaultRuleType;\n      case 'startingWith':\n        return { field: prop, operator: 'beginsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notStartingWith':\n        return {\n          field: prop,\n          operator: 'doesNotBeginWith',\n          value: parsedArgs[0],\n        } as DefaultRuleType;\n      case 'endingWith':\n        return { field: prop, operator: 'endsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notEndingWith':\n        return { field: prop, operator: 'doesNotEndWith', value: parsedArgs[0] } as DefaultRuleType;\n      default:\n        return null;\n    }\n  }\n\n  // Plain value — equality\n  return { field: prop, operator: '=', value: parseGremlinLiteral(rawValue) } as DefaultRuleType;\n};\n\n/** Parses a comma-separated argument list. */\nconst parseGremlinArgs = (args: string): unknown[] => {\n  const result: unknown[] = [];\n  let depth = 0;\n  let current = '';\n\n  for (const ch of args) {\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n    if (ch === ',' && depth === 0) {\n      result.push(parseGremlinLiteral(current.trim()));\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) result.push(parseGremlinLiteral(current.trim()));\n  return result;\n};\n\n/** Parses a Gremlin literal value. */\nconst parseGremlinLiteral = (raw: string): unknown => {\n  if (raw.startsWith(\"'\") && raw.endsWith(\"'\")) {\n    return raw.slice(1, -1).replace(/\\\\'/g, \"'\");\n  }\n  if (raw === 'null') return null;\n  if (raw === 'true') return true;\n  if (raw === 'false') return false;\n  const num = Number(raw);\n  if (!Number.isNaN(num)) return num;\n  return raw;\n};\n"],"mappings":";AA2CA,SAAgB,aACd,SACA,UACyB;CACzB,MAAM,UAAU,QAAQ,MAAM;AAC9B,KAAI,CAAC,QAAS,QAAO;EAAE,YAAY;EAAO,OAAO,EAAE;EAAE;CAErD,MAAM,QAAoD,EAAE;CAC5D,MAAM,QAAQ,qBAAqB,QAAQ;AAE3C,MAAK,MAAM,QAAQ,OAAO;AAGxB,MAAI,KAAK,WAAW,YAAY,CAAE;AAElC,MAAI,KAAK,WAAW,MAAM,CAAE;AAE5B,MAAI,mBAAmB,KAAK,KAAK,CAAE;AAEnC,MAAI,UAAU,KAAK,KAAK,CAAE;EAG1B,MAAM,cAAc,KAAK,MAAM,wBAAwB;AACvD,MAAI,aAAa;AACf,SAAM,KAAK;IAAE,OAAO,YAAY;IAAI,UAAU;IAAQ,OAAO;IAAM,CAAoB;AACvF;;EAIF,MAAM,iBAAiB,KAAK,MAAM,qBAAqB;AACvD,MAAI,gBAAgB;AAClB,SAAM,KAAK;IAAE,OAAO,eAAe;IAAI,UAAU;IAAW,OAAO;IAAM,CAAoB;AAC7F;;EAIF,MAAM,aAAa,KAAK,MAAM,6BAA6B;AAC3D,MAAI,YAAY;GACd,MAAM,GAAG,MAAM,YAAY;GAC3B,MAAM,SAAS,sBAAsB,MAAM,SAAS,MAAM,CAAC;AAC3D,OAAI,OACF,OAAM,KAAK,OAAO;AAEpB;;;AAIJ,QAAO;EAAE,YAAY;EAAO;EAAO;;;AAIrC,MAAM,wBAAwB,YAA8B;CAC1D,MAAM,QAAkB,EAAE;CAG1B,IAAI,MAAM,QAAQ,MAAM;CACxB,MAAM,cAAc,IAAI,MAAM,gBAAgB;AAC9C,KAAI,YACF,OAAM,IAAI,MAAM,YAAY,GAAG,OAAO;UAC7B,IAAI,WAAW,IAAI,CAE5B,OAAM,IAAI,MAAM,EAAE;CAIpB,IAAI,QAAQ;CACZ,IAAI,UAAU;AAEd,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACnC,MAAM,KAAK,IAAI;AACf,MAAI,OAAO,IAAK;WACP,OAAO,IAAK;AAErB,MAAI,OAAO,OAAO,UAAU,GAAG;AAC7B,OAAI,QAAQ,MAAM,CAAE,OAAM,KAAK,QAAQ,MAAM,CAAC;AAC9C,aAAU;AACV;;AAEF,aAAW;;AAEb,KAAI,QAAQ,MAAM,CAAE,OAAM,KAAK,QAAQ,MAAM,CAAC;AAE9C,QAAO;;;AAIT,MAAM,yBAAyB,MAAc,aAA6C;CAExF,MAAM,iBAAiB,SAAS,MAAM,kBAAkB;AACxD,KAAI,gBAAgB;EAClB,MAAM,GAAG,UAAU,QAAQ;EAC3B,MAAM,aAAa,iBAAiB,KAAK;AAEzC,UAAQ,UAAR;GACE,KAAK,KACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAK,OAAO,WAAW;IAAI;GAC7D,KAAK,KACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAK,OAAO,WAAW;IAAI;GAC7D,KAAK,MACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAM,OAAO,WAAW;IAAI;GAC9D,KAAK,MACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAM,OAAO,WAAW;IAAI;GAC9D,KAAK,MACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAM,OAAO,WAAW;IAAI;GAC9D,KAAK,SACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAM,OAAO;IAAY;GAC3D,KAAK,UACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAS,OAAO;IAAY;GAC9D,KAAK,UACH,QAAO;IACL,OAAO;IACP,UAAU;IACV,OAAO,WAAW,MAAM,GAAG,EAAE;IAC9B;GACH,KAAK,UACH,QAAO;IACL,OAAO;IACP,UAAU;IACV,OAAO,WAAW,MAAM,GAAG,EAAE;IAC9B;GACH,KAAK,aACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAY,OAAO,WAAW;IAAI;GACpE,KAAK,gBACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAkB,OAAO,WAAW;IAAI;GAC1E,KAAK,eACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAc,OAAO,WAAW;IAAI;GACtE,KAAK,kBACH,QAAO;IACL,OAAO;IACP,UAAU;IACV,OAAO,WAAW;IACnB;GACH,KAAK,aACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAY,OAAO,WAAW;IAAI;GACpE,KAAK,gBACH,QAAO;IAAE,OAAO;IAAM,UAAU;IAAkB,OAAO,WAAW;IAAI;GAC1E,QACE,QAAO;;;AAKb,QAAO;EAAE,OAAO;EAAM,UAAU;EAAK,OAAO,oBAAoB,SAAS;EAAE;;;AAI7E,MAAM,oBAAoB,SAA4B;CACpD,MAAM,SAAoB,EAAE;CAC5B,IAAI,QAAQ;CACZ,IAAI,UAAU;AAEd,MAAK,MAAM,MAAM,MAAM;AACrB,MAAI,OAAO,IAAK;WACP,OAAO,IAAK;AACrB,MAAI,OAAO,OAAO,UAAU,GAAG;AAC7B,UAAO,KAAK,oBAAoB,QAAQ,MAAM,CAAC,CAAC;AAChD,aAAU;AACV;;AAEF,aAAW;;AAEb,KAAI,QAAQ,MAAM,CAAE,QAAO,KAAK,oBAAoB,QAAQ,MAAM,CAAC,CAAC;AACpE,QAAO;;;AAIT,MAAM,uBAAuB,QAAyB;AACpD,KAAI,IAAI,WAAW,IAAI,IAAI,IAAI,SAAS,IAAI,CAC1C,QAAO,IAAI,MAAM,GAAG,GAAG,CAAC,QAAQ,QAAQ,IAAI;AAE9C,KAAI,QAAQ,OAAQ,QAAO;AAC3B,KAAI,QAAQ,OAAQ,QAAO;AAC3B,KAAI,QAAQ,QAAS,QAAO;CAC5B,MAAM,MAAM,OAAO,IAAI;AACvB,KAAI,CAAC,OAAO,MAAM,IAAI,CAAE,QAAO;AAC/B,QAAO"}
+{"version":3,"file":"parseGremlin.mjs","names":[],"sources":["../src/utils/parseGremlin/parseGremlin.ts"],"sourcesContent":["import type {\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n} from '../../types';\n\n/**\n * Options for {@link parseGremlin}.\n */\nexport interface ParseGremlinOptions {\n  independentCombinators?: boolean;\n}\n\n/**\n * Parses a Gremlin traversal string into a {@link DefaultRuleGroupType}.\n *\n * Accepts a full Gremlin traversal or a chain of `.has()` steps.\n * Pattern steps (`.hasLabel()`, `.out()`, `.in()`, `.both()`, `.as()`) are\n * consumed but discarded — only `.has()` filter predicates are returned.\n *\n * @example\n * ```ts\n * // Full traversal — extracts .has() conditions only\n * parseGremlin(\"g.V().hasLabel('Person').has('age', gt(30))\");\n *\n * // Bare .has() chain\n * parseGremlin(\".has('age', gt(30)).has('name', 'Alice')\");\n * ```\n */\nexport function parseGremlin(gremlin: string): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\nexport function parseGremlin(\n  gremlin: string,\n  options: Omit<ParseGremlinOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nexport function parseGremlin(\n  gremlin: string,\n  _options?: ParseGremlinOptions\n): DefaultRuleGroupTypeAny {\n  const trimmed = gremlin.trim();\n  if (!trimmed) return { combinator: 'and', rules: [] };\n\n  const rules: (DefaultRuleType | DefaultRuleGroupType)[] = [];\n  const steps = tokenizeGremlinSteps(trimmed);\n\n  for (const step of steps) {\n    // Skip pattern steps — only extract filter predicates\n    // .hasLabel('Label') — pattern step, skip\n    if (step.startsWith('hasLabel(')) continue;\n    // .as('alias') — pattern step, skip\n    if (step.startsWith('as(')) continue;\n    // .out('edge'), .in('edge'), .both('edge') — pattern step, skip\n    if (/^(out|in|both)\\(/.test(step)) continue;\n    // .V(), .E() — traversal source, skip\n    if (/^[VE]\\(/.test(step)) continue;\n\n    // .hasNot('prop') — null check\n    const hasNotMatch = step.match(/^hasNot\\('([^']+)'\\)$/);\n    if (hasNotMatch) {\n      rules.push({ field: hasNotMatch[1], operator: 'null', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop') — property exists\n    const hasExistsMatch = step.match(/^has\\('([^']+)'\\)$/);\n    if (hasExistsMatch) {\n      rules.push({ field: hasExistsMatch[1], operator: 'notNull', value: null } as DefaultRuleType);\n      continue;\n    }\n\n    // .has('prop', value) — equality or predicate\n    const hasEqMatch = step.match(/^has\\('([^']+)',\\s*(.+)\\)$/);\n    if (hasEqMatch) {\n      const [, prop, rawValue] = hasEqMatch;\n      const parsed = parseGremlinPredicate(prop, rawValue.trim());\n      if (parsed) {\n        rules.push(parsed);\n      }\n      continue;\n    }\n  }\n\n  return { combinator: 'and', rules };\n}\n\n/** Tokenizes a Gremlin traversal string into individual step strings. */\nconst tokenizeGremlinSteps = (gremlin: string): string[] => {\n  const steps: string[] = [];\n\n  // Remove leading source (e.g., \"g.V().\")\n  let str = gremlin.trim();\n  const sourceMatch = str.match(/^\\w+\\.V\\(\\)\\./);\n  if (sourceMatch) {\n    str = str.slice(sourceMatch[0].length);\n  } else if (str.startsWith('.')) {\n    // Bare step chain starting with a dot\n    str = str.slice(1);\n  }\n\n  // Split on top-level dots\n  let depth = 0;\n  let current = '';\n\n  for (let i = 0; i < str.length; i++) {\n    const ch = str[i];\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n\n    if (ch === '.' && depth === 0) {\n      if (current.trim()) steps.push(current.trim());\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) steps.push(current.trim());\n\n  return steps;\n};\n\n/** Parses a Gremlin predicate (the second argument of `.has()`). */\nconst parseGremlinPredicate = (prop: string, rawValue: string): DefaultRuleType | null => {\n  // Predicate functions: gt(), lt(), gte(), lte(), neq(), within(), without(), between(), outside()\n  const predicateMatch = rawValue.match(/^(\\w+)\\((.+)\\)$/);\n  if (predicateMatch) {\n    const [, predName, args] = predicateMatch;\n    const parsedArgs = parseGremlinArgs(args);\n\n    switch (predName) {\n      case 'gt':\n        return { field: prop, operator: '>', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lt':\n        return { field: prop, operator: '<', value: parsedArgs[0] } as DefaultRuleType;\n      case 'gte':\n        return { field: prop, operator: '>=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'lte':\n        return { field: prop, operator: '<=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'neq':\n        return { field: prop, operator: '!=', value: parsedArgs[0] } as DefaultRuleType;\n      case 'within':\n        return { field: prop, operator: 'in', value: parsedArgs } as DefaultRuleType;\n      case 'without':\n        return { field: prop, operator: 'notIn', value: parsedArgs } as DefaultRuleType;\n      case 'between':\n        return {\n          field: prop,\n          operator: 'between',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'outside':\n        return {\n          field: prop,\n          operator: 'notBetween',\n          value: parsedArgs.slice(0, 2),\n        } as DefaultRuleType;\n      case 'containing':\n        return { field: prop, operator: 'contains', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notContaining':\n        return { field: prop, operator: 'doesNotContain', value: parsedArgs[0] } as DefaultRuleType;\n      case 'startingWith':\n        return { field: prop, operator: 'beginsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notStartingWith':\n        return {\n          field: prop,\n          operator: 'doesNotBeginWith',\n          value: parsedArgs[0],\n        } as DefaultRuleType;\n      case 'endingWith':\n        return { field: prop, operator: 'endsWith', value: parsedArgs[0] } as DefaultRuleType;\n      case 'notEndingWith':\n        return { field: prop, operator: 'doesNotEndWith', value: parsedArgs[0] } as DefaultRuleType;\n      default:\n        return null;\n    }\n  }\n\n  // Plain value — equality\n  return { field: prop, operator: '=', value: parseGremlinLiteral(rawValue) } as DefaultRuleType;\n};\n\n/** Parses a comma-separated argument list. */\nconst parseGremlinArgs = (args: string): unknown[] => {\n  const result: unknown[] = [];\n  let depth = 0;\n  let current = '';\n\n  for (const ch of args) {\n    if (ch === '(') depth++;\n    else if (ch === ')') depth--;\n    if (ch === ',' && depth === 0) {\n      result.push(parseGremlinLiteral(current.trim()));\n      current = '';\n      continue;\n    }\n    current += ch;\n  }\n  if (current.trim()) result.push(parseGremlinLiteral(current.trim()));\n  return result;\n};\n\n/** Parses a Gremlin literal value. */\nconst parseGremlinLiteral = (raw: string): unknown => {\n  if (raw.startsWith(\"'\") && raw.endsWith(\"'\")) {\n    return raw.slice(1, -1).replace(/\\\\'/g, \"'\");\n  }\n  if (raw === 'null') return null;\n  if (raw === 'true') return true;\n  if (raw === 'false') return false;\n  const num = Number(raw);\n  if (!Number.isNaN(num)) return num;\n  return raw;\n};\n"],"mappings":"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"}

package/dist/parseJSONata.d.mts

@@ -1,5 +1,5 @@
-import { E as DefaultRuleGroupType, j as Except, x as DefaultRuleGroupTypeIC } from "./index-D-Iej37L.mjs";
-import { t as ParserCommonOptions } from "./import-BHlzBLM_.mjs";
+import { E as DefaultRuleGroupType, j as Except, x as DefaultRuleGroupTypeIC } from "./index-CR-tk4Ci.mjs";
+import { t as ParserCommonOptions } from "./import-BXXgiPlr.mjs";
 
 //#region src/utils/parseJSONata/parseJSONata.d.ts
 /**

package/dist/parseJSONata.d.ts

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