@lowgular/code-graph 0.0.1 → 0.1.1

package/{libs/cli/cypher/src → cypher}/lib/parser.js

@@ -1,26 +1,4 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var parser_exports = {};
-__export(parser_exports, {
-  Parser: () => Parser
-});
-module.exports = __toCommonJS(parser_exports);
-var import_lexer = require("./lexer");
+import { TokenType } from "./lexer.js";
 class Parser {
   constructor(tokens) {
     this.tokens = [];
@@ -57,29 +35,29 @@ class Parser {
    * Note: Cypher uses colon (:) for properties in node patterns, not equals (=)
    */
   parseProperties() {
-    this.expect(import_lexer.TokenType.LBRACE);
+    this.expect(TokenType.LBRACE);
     const properties = {};
-    if (this.current().type === import_lexer.TokenType.RBRACE) {
+    if (this.current().type === TokenType.RBRACE) {
       this.advance();
       return properties;
     }
     while (true) {
-      const key = this.expect(import_lexer.TokenType.IDENTIFIER).value;
-      this.expect(import_lexer.TokenType.LABEL);
+      const key = this.expect(TokenType.IDENTIFIER).value;
+      this.expect(TokenType.LABEL);
       let value;
-      if (this.current().type === import_lexer.TokenType.LBRACKET) {
+      if (this.current().type === TokenType.LBRACKET) {
         value = this.parseArrayLiteral();
-      } else if (this.current().type === import_lexer.TokenType.STRING) {
+      } else if (this.current().type === TokenType.STRING) {
         value = this.advance().value;
-      } else if (this.current().type === import_lexer.TokenType.NUMBER) {
+      } else if (this.current().type === TokenType.NUMBER) {
         value = parseFloat(this.advance().value);
-      } else if (this.current().type === import_lexer.TokenType.TRUE) {
+      } else if (this.current().type === TokenType.TRUE) {
         value = true;
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.FALSE) {
+      } else if (this.current().type === TokenType.FALSE) {
         value = false;
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.IDENTIFIER) {
+      } else if (this.current().type === TokenType.IDENTIFIER) {
         value = this.advance().value;
       } else {
         throw new Error(
@@ -87,11 +65,11 @@ class Parser {
         );
       }
       properties[key] = value;
-      if (this.current().type === import_lexer.TokenType.RBRACE) {
+      if (this.current().type === TokenType.RBRACE) {
         this.advance();
         break;
       }
-      this.expect(import_lexer.TokenType.COMMA);
+      this.expect(TokenType.COMMA);
     }
     return properties;
   }
@@ -99,30 +77,30 @@ class Parser {
    * Parse a node pattern: (var:Label {prop: value}) or (:Label {prop: value})
    */
   parseNodePattern() {
-    this.expect(import_lexer.TokenType.LPAREN);
+    this.expect(TokenType.LPAREN);
     const pattern = {
       type: "NodePattern",
       labels: []
     };
-    if (this.current().type === import_lexer.TokenType.IDENTIFIER) {
+    if (this.current().type === TokenType.IDENTIFIER) {
       const nextToken = this.peek();
-      if (nextToken.type === import_lexer.TokenType.LABEL || nextToken.type === import_lexer.TokenType.LBRACE || nextToken.type === import_lexer.TokenType.RPAREN) {
+      if (nextToken.type === TokenType.LABEL || nextToken.type === TokenType.LBRACE || nextToken.type === TokenType.RPAREN) {
         pattern.variable = this.advance().value;
       }
     }
-    if (this.current().type === import_lexer.TokenType.LABEL) {
+    if (this.current().type === TokenType.LABEL) {
       this.advance();
-      if (this.current().type !== import_lexer.TokenType.IDENTIFIER) {
+      if (this.current().type !== TokenType.IDENTIFIER) {
         throw new Error(
           `Expected identifier after :, got ${this.current().type}`
         );
       }
       pattern.labels.push(this.advance().value);
-      if (this.current().type === import_lexer.TokenType.LABEL) {
+      if (this.current().type === TokenType.LABEL) {
         pattern.labelOperator = "AND";
-        while (this.current().type === import_lexer.TokenType.LABEL) {
+        while (this.current().type === TokenType.LABEL) {
           this.advance();
-          if (this.current().type === import_lexer.TokenType.IDENTIFIER) {
+          if (this.current().type === TokenType.IDENTIFIER) {
             pattern.labels.push(this.advance().value);
           } else {
             throw new Error(
@@ -130,11 +108,11 @@ class Parser {
             );
           }
         }
-      } else if (this.current().type === import_lexer.TokenType.PIPE) {
+      } else if (this.current().type === TokenType.PIPE) {
         pattern.labelOperator = "OR";
-        while (this.current().type === import_lexer.TokenType.PIPE) {
+        while (this.current().type === TokenType.PIPE) {
           this.advance();
-          if (this.current().type === import_lexer.TokenType.IDENTIFIER) {
+          if (this.current().type === TokenType.IDENTIFIER) {
             pattern.labels.push(this.advance().value);
           } else {
             throw new Error(
@@ -146,10 +124,10 @@ class Parser {
         pattern.labelOperator = "AND";
       }
     }
-    if (this.current().type === import_lexer.TokenType.LBRACE) {
+    if (this.current().type === TokenType.LBRACE) {
       pattern.properties = this.parseProperties();
     }
-    this.expect(import_lexer.TokenType.RPAREN);
+    this.expect(TokenType.RPAREN);
     return pattern;
   }
   /**
@@ -160,49 +138,49 @@ class Parser {
       type: "RelationshipPattern",
       direction: "outgoing"
     };
-    if (this.current().type === import_lexer.TokenType.ARROW && this.current().value === "<-") {
+    if (this.current().type === TokenType.ARROW && this.current().value === "<-") {
       relationship.direction = "incoming";
       this.advance();
     } else {
-      this.expect(import_lexer.TokenType.DASH);
+      this.expect(TokenType.DASH);
     }
-    if (this.current().type === import_lexer.TokenType.LBRACKET) {
+    if (this.current().type === TokenType.LBRACKET) {
       this.advance();
-      if (this.current().type === import_lexer.TokenType.IDENTIFIER) {
+      if (this.current().type === TokenType.IDENTIFIER) {
         const nextToken = this.peek();
-        if (nextToken.type === import_lexer.TokenType.LABEL || nextToken.type === import_lexer.TokenType.ASTERISK) {
+        if (nextToken.type === TokenType.LABEL || nextToken.type === TokenType.ASTERISK) {
           relationship.variable = this.advance().value;
         }
       }
-      if (this.current().type === import_lexer.TokenType.ASTERISK) {
+      if (this.current().type === TokenType.ASTERISK) {
         this.advance();
         relationship.variableLength = true;
         relationship.minLength = 0;
         relationship.maxLength = void 0;
-      } else if (this.current().type === import_lexer.TokenType.LABEL) {
+      } else if (this.current().type === TokenType.LABEL) {
         this.advance();
         const edgeTypes = [];
-        edgeTypes.push(this.expect(import_lexer.TokenType.IDENTIFIER).value);
-        while (this.current().type === import_lexer.TokenType.PIPE) {
+        edgeTypes.push(this.expect(TokenType.IDENTIFIER).value);
+        while (this.current().type === TokenType.PIPE) {
           this.advance();
-          edgeTypes.push(this.expect(import_lexer.TokenType.IDENTIFIER).value);
+          edgeTypes.push(this.expect(TokenType.IDENTIFIER).value);
         }
         relationship.edgeType = edgeTypes.length === 1 ? edgeTypes[0] : edgeTypes;
-        if (this.current().type === import_lexer.TokenType.ASTERISK) {
+        if (this.current().type === TokenType.ASTERISK) {
           this.advance();
           relationship.variableLength = true;
           relationship.minLength = 0;
           relationship.maxLength = void 0;
         }
       }
-      this.expect(import_lexer.TokenType.RBRACKET);
+      this.expect(TokenType.RBRACKET);
     }
     if (relationship.direction === "incoming") {
-      this.expect(import_lexer.TokenType.DASH);
+      this.expect(TokenType.DASH);
     } else {
-      if (this.current().type === import_lexer.TokenType.ARROW && this.current().value === "->") {
+      if (this.current().type === TokenType.ARROW && this.current().value === "->") {
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.DASH) {
+      } else if (this.current().type === TokenType.DASH) {
         relationship.direction = "both";
         this.advance();
       }
@@ -213,11 +191,11 @@ class Parser {
    * Parse MATCH clause (supports OPTIONAL MATCH)
    */
   parseMatch() {
-    const isOptional = this.isKeyword(import_lexer.TokenType.OPTIONAL);
+    const isOptional = this.isKeyword(TokenType.OPTIONAL);
     if (isOptional) {
       this.advance();
     }
-    this.expect(import_lexer.TokenType.MATCH);
+    this.expect(TokenType.MATCH);
     const firstPattern = this.parsePatternChain();
     const matchClause = {
       type: "MatchClause",
@@ -225,7 +203,7 @@ class Parser {
       relationships: firstPattern.relationships,
       additionalMatches: []
     };
-    while (this.current().type === import_lexer.TokenType.COMMA) {
+    while (this.current().type === TokenType.COMMA) {
       this.advance();
       const additionalPattern = this.parsePatternChain();
       matchClause.additionalMatches.push(additionalPattern);
@@ -253,7 +231,7 @@ class Parser {
     const patterns = [];
     const relationships = [];
     patterns.push(this.parseNodePattern());
-    while (this.current().type === import_lexer.TokenType.DASH || this.current().type === import_lexer.TokenType.ARROW) {
+    while (this.current().type === TokenType.DASH || this.current().type === TokenType.ARROW) {
       relationships.push(this.parseRelationship());
       patterns.push(this.parseNodePattern());
     }
@@ -269,68 +247,68 @@ class Parser {
    * Note: Flat properties only (no nesting, like Neo4j Cypher)
    */
   parseWhere() {
-    this.expect(import_lexer.TokenType.WHERE);
+    this.expect(TokenType.WHERE);
     const conditions = [];
     let logic;
     while (true) {
-      const variable = this.expect(import_lexer.TokenType.IDENTIFIER).value;
+      const variable = this.expect(TokenType.IDENTIFIER).value;
       let property;
-      if (this.current().type === import_lexer.TokenType.DOT) {
+      if (this.current().type === TokenType.DOT) {
         this.advance();
-        property = this.expect(import_lexer.TokenType.IDENTIFIER).value;
+        property = this.expect(TokenType.IDENTIFIER).value;
       }
       let operator = "=";
-      if (this.current().type === import_lexer.TokenType.EQUALS) {
+      if (this.current().type === TokenType.EQUALS) {
         operator = "=";
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.NOT_EQUALS) {
+      } else if (this.current().type === TokenType.NOT_EQUALS) {
         operator = "!=";
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.GT) {
+      } else if (this.current().type === TokenType.GT) {
         operator = ">";
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.LT) {
+      } else if (this.current().type === TokenType.LT) {
         operator = "<";
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.GTE) {
+      } else if (this.current().type === TokenType.GTE) {
         operator = ">=";
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.LTE) {
+      } else if (this.current().type === TokenType.LTE) {
         operator = "<=";
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.NOT) {
+      } else if (this.current().type === TokenType.NOT) {
         this.advance();
-        this.expect(import_lexer.TokenType.IN);
+        this.expect(TokenType.IN);
         operator = "NOT IN";
-      } else if (this.current().type === import_lexer.TokenType.IN) {
+      } else if (this.current().type === TokenType.IN) {
         this.advance();
         operator = "IN";
-      } else if (this.current().type === import_lexer.TokenType.IS) {
+      } else if (this.current().type === TokenType.IS) {
         this.advance();
-        if (this.isKeyword(import_lexer.TokenType.NULL)) {
+        if (this.isKeyword(TokenType.NULL)) {
           this.advance();
           operator = "IS NULL";
-        } else if (this.isKeyword(import_lexer.TokenType.NOT)) {
+        } else if (this.isKeyword(TokenType.NOT)) {
           this.advance();
-          this.expect(import_lexer.TokenType.NULL);
+          this.expect(TokenType.NULL);
           operator = "IS NOT NULL";
         } else {
           throw new Error(
             `Expected NULL or NOT NULL after IS at position ${this.current().position}`
           );
         }
-      } else if (this.current().type === import_lexer.TokenType.STARTS) {
+      } else if (this.current().type === TokenType.STARTS) {
         this.advance();
-        this.expect(import_lexer.TokenType.WITH);
+        this.expect(TokenType.WITH);
         operator = "STARTS WITH";
-      } else if (this.current().type === import_lexer.TokenType.ENDS) {
+      } else if (this.current().type === TokenType.ENDS) {
         this.advance();
-        this.expect(import_lexer.TokenType.WITH);
+        this.expect(TokenType.WITH);
         operator = "ENDS WITH";
-      } else if (this.current().type === import_lexer.TokenType.CONTAINS) {
+      } else if (this.current().type === TokenType.CONTAINS) {
         operator = "CONTAINS";
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.REGEX_MATCH) {
+      } else if (this.current().type === TokenType.REGEX_MATCH) {
         operator = "=~";
         this.advance();
       } else {
@@ -341,26 +319,26 @@ class Parser {
       let value = null;
       if (operator === "IS NULL" || operator === "IS NOT NULL") {
       } else if (operator === "STARTS WITH" || operator === "ENDS WITH" || operator === "CONTAINS" || operator === "=~") {
-        if (this.current().type === import_lexer.TokenType.STRING) {
+        if (this.current().type === TokenType.STRING) {
           value = this.advance().value;
         } else {
           throw new Error(
             `String matching operators (${operator}) require a string value at position ${this.current().position}`
           );
         }
-      } else if (this.current().type === import_lexer.TokenType.LBRACKET) {
+      } else if (this.current().type === TokenType.LBRACKET) {
         value = this.parseArrayLiteral();
-      } else if (this.current().type === import_lexer.TokenType.STRING) {
+      } else if (this.current().type === TokenType.STRING) {
         value = this.advance().value;
-      } else if (this.current().type === import_lexer.TokenType.NUMBER) {
+      } else if (this.current().type === TokenType.NUMBER) {
         value = parseFloat(this.advance().value);
-      } else if (this.current().type === import_lexer.TokenType.TRUE) {
+      } else if (this.current().type === TokenType.TRUE) {
         value = true;
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.FALSE) {
+      } else if (this.current().type === TokenType.FALSE) {
         value = false;
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.IDENTIFIER) {
+      } else if (this.current().type === TokenType.IDENTIFIER) {
         value = this.advance().value;
       } else {
         throw new Error(
@@ -368,7 +346,7 @@ class Parser {
         );
       }
       conditions.push({ variable, property, operator, value });
-      if (this.isKeyword(import_lexer.TokenType.AND)) {
+      if (this.isKeyword(TokenType.AND)) {
         if (logic === void 0) {
           logic = "AND";
         } else if (logic !== "AND") {
@@ -376,7 +354,7 @@ class Parser {
         }
         this.advance();
         continue;
-      } else if (this.isKeyword(import_lexer.TokenType.OR)) {
+      } else if (this.isKeyword(TokenType.OR)) {
         if (logic === void 0) {
           logic = "OR";
         } else if (logic !== "OR") {
@@ -397,33 +375,33 @@ class Parser {
    * Parse array literal: [value1, value2, ...]
    */
   parseArrayLiteral() {
-    this.expect(import_lexer.TokenType.LBRACKET);
+    this.expect(TokenType.LBRACKET);
     const array = [];
-    if (this.current().type === import_lexer.TokenType.RBRACKET) {
+    if (this.current().type === TokenType.RBRACKET) {
       this.advance();
       return array;
     }
     while (true) {
-      if (this.current().type === import_lexer.TokenType.STRING) {
+      if (this.current().type === TokenType.STRING) {
         array.push(this.advance().value);
-      } else if (this.current().type === import_lexer.TokenType.NUMBER) {
+      } else if (this.current().type === TokenType.NUMBER) {
         array.push(parseFloat(this.advance().value));
-      } else if (this.current().type === import_lexer.TokenType.TRUE) {
+      } else if (this.current().type === TokenType.TRUE) {
         array.push(true);
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.FALSE) {
+      } else if (this.current().type === TokenType.FALSE) {
         array.push(false);
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.IDENTIFIER) {
+      } else if (this.current().type === TokenType.IDENTIFIER) {
         array.push(this.advance().value);
       } else {
         throw new Error(
           `Unexpected token type in array literal: ${this.current().type}`
         );
       }
-      if (this.current().type === import_lexer.TokenType.COMMA) {
+      if (this.current().type === TokenType.COMMA) {
         this.advance();
-      } else if (this.current().type === import_lexer.TokenType.RBRACKET) {
+      } else if (this.current().type === TokenType.RBRACKET) {
         this.advance();
         break;
       } else {
@@ -436,15 +414,20 @@ class Parser {
   }
   /**
    * Parse RETURN clause
-   * Supports: RETURN *, RETURN var1, var2, RETURN var AS alias, LIMIT n
+   * Supports: RETURN *, RETURN DISTINCT, RETURN var1, var2, RETURN var AS alias, LIMIT n
    */
   parseReturn() {
-    this.expect(import_lexer.TokenType.RETURN);
-    if (this.current().type === import_lexer.TokenType.ASTERISK) {
+    this.expect(TokenType.RETURN);
+    const distinct = this.isKeyword(TokenType.DISTINCT);
+    if (distinct) {
+      this.advance();
+    }
+    if (this.current().type === TokenType.ASTERISK) {
       this.advance();
       const limit2 = this.parseOptionalLimit();
       return {
         type: "ReturnClause",
+        distinct,
         returnAll: true,
         items: [],
         limit: limit2
@@ -452,14 +435,14 @@ class Parser {
     }
     const items = [];
     while (true) {
-      const expression = this.expect(import_lexer.TokenType.IDENTIFIER).value;
+      const expression = this.expect(TokenType.IDENTIFIER).value;
       let alias;
-      if (this.isKeyword(import_lexer.TokenType.AS)) {
+      if (this.isKeyword(TokenType.AS)) {
         this.advance();
-        alias = this.expect(import_lexer.TokenType.IDENTIFIER).value;
+        alias = this.expect(TokenType.IDENTIFIER).value;
       }
       items.push({ expression, alias });
-      if (this.current().type === import_lexer.TokenType.COMMA) {
+      if (this.current().type === TokenType.COMMA) {
         this.advance();
         continue;
       }
@@ -468,6 +451,7 @@ class Parser {
     const limit = this.parseOptionalLimit();
     return {
       type: "ReturnClause",
+      distinct,
       returnAll: false,
       items,
       limit
@@ -478,9 +462,9 @@ class Parser {
    * Returns the limit number or undefined if not present
    */
   parseOptionalLimit() {
-    if (this.isKeyword(import_lexer.TokenType.LIMIT)) {
+    if (this.isKeyword(TokenType.LIMIT)) {
       this.advance();
-      const limitToken = this.expect(import_lexer.TokenType.NUMBER);
+      const limitToken = this.expect(TokenType.NUMBER);
       return parseInt(limitToken.value, 10);
     }
     return void 0;
@@ -491,26 +475,26 @@ class Parser {
    * Also supports multiple fields: ORDER BY n.type DESC, n.name ASC
    */
   parseOrderBy() {
-    this.expect(import_lexer.TokenType.ORDER);
-    this.expect(import_lexer.TokenType.BY);
+    this.expect(TokenType.ORDER);
+    this.expect(TokenType.BY);
     const items = [];
     while (true) {
-      const variable = this.expect(import_lexer.TokenType.IDENTIFIER).value;
+      const variable = this.expect(TokenType.IDENTIFIER).value;
       let property;
-      if (this.current().type === import_lexer.TokenType.DOT) {
+      if (this.current().type === TokenType.DOT) {
         this.advance();
-        property = this.expect(import_lexer.TokenType.IDENTIFIER).value;
+        property = this.expect(TokenType.IDENTIFIER).value;
       }
       let direction = "ASC";
-      if (this.isKeyword(import_lexer.TokenType.ASC)) {
+      if (this.isKeyword(TokenType.ASC)) {
         this.advance();
         direction = "ASC";
-      } else if (this.isKeyword(import_lexer.TokenType.DESC)) {
+      } else if (this.isKeyword(TokenType.DESC)) {
         this.advance();
         direction = "DESC";
       }
       items.push({ variable, property, direction });
-      if (this.current().type === import_lexer.TokenType.COMMA) {
+      if (this.current().type === TokenType.COMMA) {
         this.advance();
         continue;
       }
@@ -524,9 +508,9 @@ class Parser {
    */
   parse() {
     const statements = [];
-    while (this.current().type !== import_lexer.TokenType.EOF) {
-      if (this.isKeyword(import_lexer.TokenType.MATCH) || this.isKeyword(import_lexer.TokenType.OPTIONAL)) {
-        const isOptional = this.isKeyword(import_lexer.TokenType.OPTIONAL);
+    while (this.current().type !== TokenType.EOF) {
+      if (this.isKeyword(TokenType.MATCH) || this.isKeyword(TokenType.OPTIONAL)) {
+        const isOptional = this.isKeyword(TokenType.OPTIONAL);
         const matchClause = this.parseMatch();
         if (matchClause.optionalMatches) {
           for (const optionalMatch of matchClause.optionalMatches) {
@@ -559,7 +543,7 @@ class Parser {
         }
         continue;
       }
-      if (this.isKeyword(import_lexer.TokenType.WHERE)) {
+      if (this.isKeyword(TokenType.WHERE)) {
         const whereClause = this.parseWhere();
         statements.push({
           type: "WhereStatement",
@@ -568,15 +552,16 @@ class Parser {
         });
         continue;
       }
-      if (this.isKeyword(import_lexer.TokenType.ORDER)) {
+      if (this.isKeyword(TokenType.ORDER)) {
         const orderByStatement = this.parseOrderBy();
         statements.push(orderByStatement);
         continue;
       }
-      if (this.isKeyword(import_lexer.TokenType.RETURN)) {
+      if (this.isKeyword(TokenType.RETURN)) {
         const returnClause = this.parseReturn();
         statements.push({
           type: "ReturnStatement",
+          distinct: returnClause.distinct,
           returnAll: returnClause.returnAll,
           items: returnClause.items,
           limit: returnClause.limit
@@ -585,7 +570,7 @@ class Parser {
       }
       break;
     }
-    if (this.current().type !== import_lexer.TokenType.EOF) {
+    if (this.current().type !== TokenType.EOF) {
       throw new Error(
         `Unexpected token: ${this.current().type} at position ${this.current().position}`
       );
@@ -596,7 +581,6 @@ class Parser {
     };
   }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   Parser
-});
+};

package/{libs/cli/cypher/src → cypher}/lib/validator/query-validator.js

@@ -1,33 +1,14 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var query_validator_exports = {};
-__export(query_validator_exports, {
-  UnsupportedFeatureError: () => UnsupportedFeatureError,
-  validateQuery: () => validateQuery,
-  validateQuerySafe: () => validateQuerySafe
-});
-module.exports = __toCommonJS(query_validator_exports);
-var import_unsupported_features = require("./unsupported-features.config");
+import {
+  FORBIDDEN_AGGREGATIONS,
+  FORBIDDEN_KEYWORDS,
+  FORBIDDEN_MODIFIERS,
+  FORBIDDEN_PATTERNS
+} from "./unsupported-features.config.js";
 const UNSUPPORTED_FEATURES = [
-  ...import_unsupported_features.FORBIDDEN_KEYWORDS,
-  ...import_unsupported_features.FORBIDDEN_AGGREGATIONS,
-  ...import_unsupported_features.FORBIDDEN_MODIFIERS,
-  ...import_unsupported_features.FORBIDDEN_PATTERNS
+  ...FORBIDDEN_KEYWORDS,
+  ...FORBIDDEN_AGGREGATIONS,
+  ...FORBIDDEN_MODIFIERS,
+  ...FORBIDDEN_PATTERNS
 ];
 class UnsupportedFeatureError extends Error {
   constructor(feature, query) {
@@ -87,9 +68,8 @@ function validateQuerySafe(query) {
     throw error;
   }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   UnsupportedFeatureError,
   validateQuery,
   validateQuerySafe
-});
+};