@lowgular/code-graph 0.0.1 → 0.1.2

package/libs/cli/cypher/src/lib/docs/specs.js

@@ -1,181 +0,0 @@
-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 specs_exports = {};
-__export(specs_exports, {
-  CYPHER_CONSTRAINTS: () => CYPHER_CONSTRAINTS,
-  CYPHER_FORBIDDEN_FEATURES: () => CYPHER_FORBIDDEN_FEATURES,
-  MATCH_BASICS: () => MATCH_BASICS,
-  RELATIONSHIP_ADVANCED: () => RELATIONSHIP_ADVANCED,
-  RELATIONSHIP_BASICS: () => RELATIONSHIP_BASICS,
-  WHERE_BASICS: () => WHERE_BASICS,
-  mb: () => mb
-});
-module.exports = __toCommonJS(specs_exports);
-var import_supported_features = require("../validator/supported-features.config");
-var import_unsupported_features = require("../validator/unsupported-features.config");
-var import_features = require("./features");
-var import_basic_optional_match = require("./features/basic-optional-match.feature");
-var import_return_statement = require("./features/return-statement.feature");
-const mb = (content, type) => `\`\`\`${type}
-${content}
-\`\`\``;
-function generateFeatureList(depth, features) {
-  return features.map((feature) => {
-    const lines = [];
-    lines.push(`${mh(depth)} ${feature.name}`);
-    lines.push(feature.description);
-    if (feature.queries) {
-      lines.push(`Allowed queries:`);
-      feature.queries.forEach((query) => {
-        lines.push(mb(query.join("\n"), "cypher"));
-      });
-    }
-    return lines.join("\n\n");
-  }).join("\n");
-}
-function generateConstraintList(constraints) {
-  return constraints.map((constraint) => `- ${constraint.description}`).join("\n");
-}
-function generateForbiddenFeaturesList(data) {
-  return data.map((feature) => {
-    let line = `- **${feature.name}** - ${feature.errorMessage}`;
-    if (feature.alternative) {
-      line += ` ${feature.alternative}`;
-    }
-    return line;
-  }).join("\n");
-}
-const mh = (depth) => `${"#".repeat(depth)}`;
-const MATCH_BASICS = (depth) => `
-${mh(depth)} MATCH Nodes
-
-${generateFeatureList(depth + 1, import_features.MATCH_NODES_FEATURES)}
-
-${mh(depth)} MATCH Nodes by Properties
-
-${generateFeatureList(depth + 1, import_features.PROPERTY_MATCHING_FEATURES)}
-
-${mh(depth)} Optional Match
-
-${generateFeatureList(depth + 1, import_basic_optional_match.BASIC_OPTIONAL_MATCH_FEATURES)}
-
-${mh(depth)} Return Statement
-
-${generateFeatureList(depth + 1, import_return_statement.RETURN_STATEMENT_FEATURES)}
-
-${mh(depth)} LIMIT Clause
-
-${generateFeatureList(depth + 1, import_features.LIMIT_FEATURES)}
-
-${mh(depth)} ORDER BY Clause
-
-Without ORDER BY, results are returned in graph insertion order:
-- Files: Order from TypeScript's program.getSourceFiles() (typically alphabetical by file path based on tsconfig include patterns)
-- Within files: Top-to-bottom AST traversal order (position in SourceFile)
-
-${generateFeatureList(depth + 1, import_features.ORDER_BY_FEATURES)}
-`;
-const WHERE_BASICS = (depth) => `
-${mh(depth)} Filtering Nodes
-
-${generateFeatureList(depth + 1, import_features.BASIC_FILTERING_FEATURES)}
-
-${mh(depth)} WHERE Clause Operators
-
-${generateFeatureList(depth + 1, import_features.WHERE_OPERATORS_FEATURES)}
-
-${mh(depth)} WHERE Conditional Logic
-
-${generateFeatureList(depth + 1, import_features.WHERE_CONDITIONAL_LOGIC_FEATURES)}
-
-${mh(depth)} Advanced Optional Match
-
-${generateFeatureList(depth + 1, import_features.ADVANCED_OPTIONAL_MATCH_FEATURES)}
-`;
-const RELATIONSHIP_BASICS = (depth) => `
-${mh(depth)} Basic Relationships
-
-${generateFeatureList(depth + 1, import_features.BASIC_RELATIONSHIP_FEATURES)}
-
-${mh(depth)} Undirected Relationships
-
-${generateFeatureList(depth + 1, import_features.UNDIRECTED_RELATIONSHIP_FEATURES)}
-
-${mh(depth)} Multiple Relationship Types
-
-${generateFeatureList(depth + 1, import_features.MULTIPLE_RELATIONSHIP_TYPES_FEATURES)}
-
-${mh(depth)} Anonymous Relationships
-
-${generateFeatureList(depth + 1, import_features.ANONYMOUS_RELATIONSHIP_FEATURES)}
-
-${mh(depth)} Relationship Without Variable
-
-${generateFeatureList(depth + 1, import_features.RELATIONSHIP_WITHOUT_VARIABLE_FEATURES)}
-`;
-const RELATIONSHIP_ADVANCED = (depth) => `
-${mh(depth)} Variable-Length Paths
-
-${generateFeatureList(depth + 1, import_features.VARIABLE_LENGTH_PATH_FEATURES)}
-
-${mh(depth)} Anonymous Variable-Length Paths
-
-${generateFeatureList(depth + 1, import_features.ANONYMOUS_VARIABLE_LENGTH_FEATURES)}
-`;
-const CYPHER_CONSTRAINTS = (depth) => `${mh(depth)} Node Constraints
-
-${generateConstraintList(import_supported_features.NODE_CONSTRAINTS)}
-
-${mh(depth)} Relationship Constraints
-
-${generateConstraintList(import_supported_features.RELATIONSHIP_CONSTRAINTS)}
-
-${mh(depth)} Query Constraints
-
-${generateConstraintList(import_supported_features.QUERY_CONSTRAINTS)}
-
-${mh(depth)} Pattern Constraints
-
-${generateConstraintList(import_supported_features.PATTERN_CONSTRAINTS)}`;
-const CYPHER_FORBIDDEN_FEATURES = (depth) => `${mh(depth)} Forbidden Keywords
-
-${generateForbiddenFeaturesList(import_unsupported_features.FORBIDDEN_KEYWORDS)}
-
-${mh(depth)} Forbidden Aggregations
-
-${generateForbiddenFeaturesList(import_unsupported_features.FORBIDDEN_AGGREGATIONS)}
-
-${mh(depth)} Forbidden Modifiers
-
-${generateForbiddenFeaturesList(import_unsupported_features.FORBIDDEN_MODIFIERS)}
-
-${mh(depth)} Forbidden Patterns
-
-${generateForbiddenFeaturesList(import_unsupported_features.FORBIDDEN_PATTERNS)}
-
-`;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CYPHER_CONSTRAINTS,
-  CYPHER_FORBIDDEN_FEATURES,
-  MATCH_BASICS,
-  RELATIONSHIP_ADVANCED,
-  RELATIONSHIP_BASICS,
-  WHERE_BASICS,
-  mb
-});

package/libs/cli/cypher/src/lib/executor/condition-evaluator.js

@@ -1,158 +0,0 @@
-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 condition_evaluator_exports = {};
-__export(condition_evaluator_exports, {
-  ConditionEvaluator: () => ConditionEvaluator
-});
-module.exports = __toCommonJS(condition_evaluator_exports);
-class ConditionEvaluator {
-  // @TODO: apply where at match level
-  /**
-   * Apply WHERE clause filtering to matches
-   */
-  applyWhereClauseIfNeeded(matches, where) {
-    return matches.filter((match) => {
-      const conditionResults = where.conditions.map(
-        (condition) => this.evaluateCondition(match, condition)
-      );
-      const logic = where.logic || "AND";
-      if (logic === "AND") {
-        return conditionResults.every((result) => result === true);
-      } else {
-        return conditionResults.some((result) => result === true);
-      }
-    });
-  }
-  // @fixme move to utils
-  /**
-   * Escape special regex characters in a string
-   */
-  escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  /**
-   * Evaluate a single WHERE condition
-   * Supports flat properties only (no nesting, like Neo4j Cypher)
-   * Handles null values from optional matches (null values fail the condition)
-   */
-  evaluateCondition(match, condition) {
-    const value = match[condition.variable];
-    if ((condition.operator === "IS NULL" || condition.operator === "IS NOT NULL") && !condition.property) {
-      const isNull = value === null || value === void 0;
-      return condition.operator === "IS NULL" ? isNull : !isNull;
-    }
-    if (!value || value === null) {
-      return false;
-    }
-    let baseObject;
-    if ("id" in value) {
-      baseObject = value;
-    } else if ("type" in value && "source" in value) {
-      baseObject = value;
-    } else {
-      return false;
-    }
-    let actualValue;
-    if (!condition.property) {
-      actualValue = baseObject;
-    } else {
-      actualValue = baseObject[condition.property];
-      if (actualValue === void 0) {
-        if (condition.operator === "IS NULL" || condition.operator === "IS NOT NULL") {
-          actualValue = void 0;
-        } else {
-          return false;
-        }
-      }
-    }
-    const conditionValue = condition.value;
-    switch (condition.operator) {
-      case "=":
-        return actualValue === conditionValue;
-      case "!=":
-        return actualValue !== conditionValue;
-      case ">":
-        return actualValue > conditionValue;
-      case "<":
-        return actualValue < conditionValue;
-      case ">=":
-        return actualValue >= conditionValue;
-      case "<=":
-        return actualValue <= conditionValue;
-      case "IS NULL":
-        return actualValue === null || actualValue === void 0;
-      case "IS NOT NULL":
-        return actualValue !== null && actualValue !== void 0;
-      case "IN":
-        if (Array.isArray(conditionValue)) {
-          if (conditionValue.length > 0 && typeof conditionValue[0] === "object" && conditionValue[0] !== null) {
-            const extractedValues = conditionValue.map((item) => item?.name).filter((name) => name !== void 0);
-            return extractedValues.includes(actualValue);
-          }
-          return conditionValue.includes(actualValue);
-        }
-        return false;
-      case "NOT IN":
-        if (Array.isArray(conditionValue)) {
-          if (conditionValue.length > 0 && typeof conditionValue[0] === "object" && conditionValue[0] !== null) {
-            const extractedValues = conditionValue.map((item) => item?.name).filter((name) => name !== void 0);
-            return !extractedValues.includes(actualValue);
-          }
-          return !conditionValue.includes(actualValue);
-        }
-        return true;
-      case "STARTS WITH":
-        return this.testRegex(
-          new RegExp(`^${this.escapeRegex(conditionValue)}`),
-          actualValue
-        );
-      case "ENDS WITH":
-        return this.testRegex(
-          new RegExp(`${this.escapeRegex(conditionValue)}$`),
-          actualValue
-        );
-      case "CONTAINS":
-        return this.testRegex(
-          new RegExp(this.escapeRegex(conditionValue)),
-          actualValue
-        );
-      case "=~":
-        return this.testRegex(new RegExp(conditionValue), actualValue);
-      default:
-        throw new Error(`Unsupported operator: ${condition.operator}`);
-    }
-  }
-  testRegex(regexp, actualValue) {
-    if (actualValue === null || actualValue === void 0) {
-      return false;
-    }
-    if (typeof actualValue !== "string" && typeof actualValue !== "number" && typeof actualValue !== "boolean") {
-      return false;
-    }
-    const regexStr = typeof actualValue === "string" ? actualValue : String(actualValue);
-    try {
-      return regexp.test(regexStr);
-    } catch {
-      return false;
-    }
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ConditionEvaluator
-});

package/libs/cli/cypher/src/lib/executor/executor.js

@@ -1,83 +0,0 @@
-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 executor_exports = {};
-__export(executor_exports, {
-  CypherExecutor: () => CypherExecutor
-});
-module.exports = __toCommonJS(executor_exports);
-var import_condition_evaluator = require("./condition-evaluator");
-var import_match_engine = require("./match-engine");
-var import_pattern_matcher = require("./pattern-matcher");
-var import_relationship_navigator = require("./relationship-navigator");
-var import_result_formatter = require("./result-formatter");
-var import_traverse_engine = require("./traverse-engine");
-class CypherExecutor {
-  constructor(graph) {
-    this.graph = graph;
-    this.conditionEvaluator = new import_condition_evaluator.ConditionEvaluator();
-    const patternMatcher = new import_pattern_matcher.PatternMatcher();
-    const relationshipNavigator = new import_relationship_navigator.RelationshipNavigator(patternMatcher);
-    const traverseEngine = new import_traverse_engine.TraverseEngine(
-      patternMatcher,
-      relationshipNavigator
-    );
-    this.matchEngine = new import_match_engine.MatchEngine(patternMatcher, traverseEngine);
-    this.resultFormatter = new import_result_formatter.ResultFormatter();
-  }
-  /**
-   * Execute a parsed Cypher query
-   * @param extractData - If true (default), returns node.data. If false, returns full GraphNode objects.
-   * For edges, always returns the full GraphEdge object (edges have no data property).
-   * Returns results where keys are variable names and values are either node data or edge objects
-   */
-  execute(query) {
-    if (query.statements.length === 0) {
-      throw new Error("Query must have at least one statement");
-    }
-    if (query.statements[query.statements.length - 1].type !== "ReturnStatement") {
-      throw new Error("MATCH Query must have a RETURN statement");
-    }
-    let results = [];
-    for (const statement of query.statements) {
-      if (statement.type === "MatchStatement") {
-        results = this.matchEngine.processMatchStatement(
-          this.graph,
-          statement,
-          results
-        );
-      } else if (statement.type === "WhereStatement") {
-        results = this.conditionEvaluator.applyWhereClauseIfNeeded(
-          results,
-          statement
-        );
-      } else if (statement.type === "OrderByStatement") {
-        results = this.resultFormatter.sortResults(results, statement);
-      }
-    }
-    const returnStatement = query.statements[query.statements.length - 1];
-    let formattedResults = this.resultFormatter.formatResults(
-      results,
-      returnStatement
-    );
-    return formattedResults;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CypherExecutor
-});

package/libs/cli/cypher/src/lib/executor/graph.js

@@ -1,15 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 graph_exports = {};
-module.exports = __toCommonJS(graph_exports);

package/libs/cli/cypher/src/lib/executor/match-engine.js

@@ -1,153 +0,0 @@
-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 match_engine_exports = {};
-__export(match_engine_exports, {
-  MatchEngine: () => MatchEngine
-});
-module.exports = __toCommonJS(match_engine_exports);
-var import_utils = require("./utils");
-class MatchEngine {
-  constructor(patternMatcher, traverseEngine) {
-    this.patternMatcher = patternMatcher;
-    this.traverseEngine = traverseEngine;
-    this.annonymizer = new import_utils.Annonymizer();
-  }
-  processMatchStatement(graph, match, existingResults = []) {
-    if (match.patterns.length === 0)
-      return existingResults;
-    const starting = match.patterns[0];
-    const allResults = [];
-    this.patternMatcher.filterMatchingNodes(graph, starting).forEach((node) => {
-      const matches = this.traverseEngine.traverseRelationships(
-        graph,
-        node,
-        starting.variable || this.annonymizer.generate(node),
-        match.patterns.slice(1),
-        match.relationships
-      );
-      allResults.push(...matches);
-    });
-    if (existingResults.length > 0) {
-      if (match.optional) {
-        return this.mergeOptionalResults(existingResults, allResults, match);
-      } else {
-        return this.mergeResults(existingResults, allResults);
-      }
-    }
-    return allResults;
-  }
-  mergeResults(existingResults, newResults) {
-    if (existingResults.length === 0) {
-      return newResults;
-    }
-    const mergedResults = [];
-    for (const existingResult of existingResults) {
-      for (const newResult of newResults) {
-        if (this.canMergeResult(existingResult, newResult)) {
-          mergedResults.push({ ...existingResult, ...newResult });
-        }
-      }
-    }
-    return mergedResults;
-  }
-  /**
-   * Merge optional match results with existing results (left outer join)
-   * - Keeps all existing results
-   * - Merges optional results where variables overlap
-   * - Adds nulls for optional variables when no match is found
-   */
-  mergeOptionalResults(existingResults, optionalResults, match) {
-    if (existingResults.length === 0) {
-      return optionalResults;
-    }
-    const optionalVarNames = /* @__PURE__ */ new Set();
-    for (const pattern of match.patterns) {
-      if (pattern.variable) {
-        optionalVarNames.add(pattern.variable);
-      }
-    }
-    if (match.relationships) {
-      for (const rel of match.relationships) {
-        if (rel.variable) {
-          optionalVarNames.add(rel.variable);
-        }
-      }
-    }
-    if (optionalResults.length === 0) {
-      return existingResults.map((result) => {
-        const resultWithNulls = { ...result };
-        for (const varName of optionalVarNames) {
-          if (!(varName in resultWithNulls)) {
-            resultWithNulls[varName] = null;
-          }
-        }
-        return resultWithNulls;
-      });
-    }
-    for (const optionalResult of optionalResults) {
-      for (const key in optionalResult) {
-        optionalVarNames.add(key);
-      }
-    }
-    const mergedResults = [];
-    for (const existingResult of existingResults) {
-      let hasMatch = false;
-      for (const optionalResult of optionalResults) {
-        if (this.canMergeResult(existingResult, optionalResult)) {
-          mergedResults.push({ ...existingResult, ...optionalResult });
-          hasMatch = true;
-        }
-      }
-      if (!hasMatch) {
-        const resultWithNulls = { ...existingResult };
-        for (const varName of optionalVarNames) {
-          if (!(varName in resultWithNulls)) {
-            resultWithNulls[varName] = null;
-          }
-        }
-        mergedResults.push(resultWithNulls);
-      }
-    }
-    return mergedResults;
-  }
-  /**
-   * Check if additionalResult can be merged with existingResult
-   * Returns true if shared variables match (same node/edge) or if there are no conflicts
-   * Does NOT mutate any parameters
-   */
-  canMergeResult(additionalResult, existingResult) {
-    for (const key in additionalResult) {
-      if (key in existingResult) {
-        const existing = existingResult[key];
-        const additional = additionalResult[key];
-        if (existing !== null && additional !== null) {
-          if ("id" in existing && "id" in additional && existing.id !== additional.id) {
-            return false;
-          }
-        } else if (existing !== additional) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MatchEngine
-});

package/libs/cli/cypher/src/lib/executor/pattern-matcher.js

@@ -1,109 +0,0 @@
-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 pattern_matcher_exports = {};
-__export(pattern_matcher_exports, {
-  PatternMatcher: () => PatternMatcher
-});
-module.exports = __toCommonJS(pattern_matcher_exports);
-class PatternMatcher {
-  /**
-   * Check if an edge type matches the relationship pattern's edge type(s)
-   * Supports both single edge type (string) and multiple edge types (array)
-   */
-  matchesEdgeType(edgeType, patternEdgeType) {
-    if (!patternEdgeType) {
-      return true;
-    }
-    if (typeof patternEdgeType === "string") {
-      return edgeType === patternEdgeType;
-    }
-    return patternEdgeType.includes(edgeType);
-  }
-  /**
-   * Deep equality check for arrays
-   */
-  arraysEqual(a, b) {
-    if (a.length !== b.length) {
-      return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (Array.isArray(a[i]) && Array.isArray(b[i])) {
-        if (!this.arraysEqual(a[i], b[i])) {
-          return false;
-        }
-      } else if (a[i] !== b[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Check if two values are equal (handles arrays with deep equality)
-   */
-  valuesEqual(expected, actual) {
-    if (Array.isArray(expected) && Array.isArray(actual)) {
-      return this.arraysEqual(expected, actual);
-    }
-    return expected === actual;
-  }
-  /**
-   * Check if a node matches a pattern (labels and properties)
-   */
-  doesNodeMatchPattern(node, pattern) {
-    if (pattern.labels.length > 0) {
-      const labelOperator = pattern.labelOperator || "AND";
-      if (labelOperator === "AND") {
-        if (!pattern.labels.every((label) => node.labels.includes(label))) {
-          return false;
-        }
-      } else {
-        if (!pattern.labels.some((label) => node.labels.includes(label))) {
-          return false;
-        }
-      }
-    }
-    if (pattern.properties) {
-      const notFound = Object.entries(pattern.properties).find(
-        ([key, expectedValue]) => !this.valuesEqual(expectedValue, node[key])
-      ) !== void 0;
-      if (notFound) {
-        return false;
-      }
-    }
-    return true;
-  }
-  findMatchingNodes(graph, pattern) {
-    return Object.values(graph.nodesById).find(
-      (node) => this.doesNodeMatchPattern(node, pattern)
-    );
-  }
-  /**
-   * Match a single node pattern
-   * Finds all nodes in the graph that match the given pattern
-   * Reuses matchesPattern to avoid code duplication
-   */
-  filterMatchingNodes(graph, pattern) {
-    return Object.values(graph.nodesById).filter(
-      (node) => this.doesNodeMatchPattern(node, pattern)
-    );
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PatternMatcher
-});