@coana-tech/cli 14.12.79 → 14.12.81

package/repos/coana-tech/callgraph-reachability-analyzers/packages/cli/dist/bundle/cli.mjs

@@ -1,6 +1,4 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
-const __dirname = import.meta.dirname
-const __filename = import.meta.filename
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -20911,12 +20909,10 @@ if (Number.parseInt(process.versions.node, 10) < 22) {
       next: { value: next, writable: true, configurable: true }
     });
   };
-  iteratorImpl2 = iteratorImpl;
   class It {
     [Symbol.iterator]() {
       return this;
     }
-    // Iterator.prototype.map
     map(fn) {
       const iterator = this;
       let index = 0;
@@ -20927,7 +20923,6 @@ if (Number.parseInt(process.versions.node, 10) < 22) {
         return { value: fn(result.value, index++), done: false };
       });
     }
-    // Iterator.prototype.filter
     filter(fn) {
       const iterator = this;
       let index = 0;
@@ -20941,7 +20936,6 @@ if (Number.parseInt(process.versions.node, 10) < 22) {
         }
       });
     }
-    // Iterator.prototype.take
     take(n12) {
       const iterator = this;
       let count = 0;
@@ -20952,7 +20946,6 @@ if (Number.parseInt(process.versions.node, 10) < 22) {
         return iterator.next();
       });
     }
-    // Iterator.prototype.drop
     drop(n12) {
       const iterator = this;
       let count = 0;
@@ -20966,7 +20959,6 @@ if (Number.parseInt(process.versions.node, 10) < 22) {
         return iterator.next();
       });
     }
-    // Iterator.prototype.toArray
     toArray() {
       const result = [];
       let next = this.next();
@@ -20976,13 +20968,11 @@ if (Number.parseInt(process.versions.node, 10) < 22) {
       }
       return result;
     }
-    // Iterator.prototype.forEach
     forEach(fn) {
       let index = 0;
       for (const value of this)
         fn(value, index++);
     }
-    // Iterator.prototype.some
     some(fn) {
       let index = 0;
       for (const value of this)
@@ -20990,7 +20980,6 @@ if (Number.parseInt(process.versions.node, 10) < 22) {
           return true;
       return false;
     }
-    // Iterator.prototype.every
     every(fn) {
       let index = 0;
       for (const value of this)
@@ -20998,14 +20987,12 @@ if (Number.parseInt(process.versions.node, 10) < 22) {
           return false;
       return true;
     }
-    // Iterator.prototype.find
     find(fn) {
       let index = 0;
       for (const value of this)
         if (fn(value, index++))
           return value;
     }
-    // Iterator.prototype.reduce
     reduce(fn, initialValue) {
       let accumulator = initialValue;
       let index = 0;
@@ -21020,7 +21007,6 @@ if (Number.parseInt(process.versions.node, 10) < 22) {
         throw new TypeError("Reduce of empty iterator with no initial value");
       return accumulator;
     }
-    // Iterator.prototype.flatMap
     flatMap(fn) {
       const iterator = this;
       let currentIterator;
@@ -21045,7 +21031,6 @@ if (Number.parseInt(process.versions.node, 10) < 22) {
         }
       });
     }
-    // Iterator.from
     static from(value) {
       if (value === void 0)
         throw new TypeError("Iterator.from requires a value");
@@ -21084,7 +21069,6 @@ if (Number.parseInt(process.versions.node, 10) < 22) {
     Object.setPrototypeOf(proto, It.prototype);
   }
 }
-var iteratorImpl2;
 
 // ../../node_modules/.pnpm/commander@14.0.2/node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
@@ -21277,7 +21261,7 @@ function n11(e5, t15) {
 }
 var r2 = (n12, { preserveConsecutiveUppercase: r3 = true } = {}) => t13(t14.test(n12) ? n12 : n12.toLowerCase()).map((e5, t15) => `${t15 === 0 ? e5[0].toLowerCase() : e5[0].toUpperCase()}${r3 ? e5.slice(1) : e5.slice(1).toLowerCase()}`).join(``);
 
-// ../utils/src/asserts.ts
+// ../utils/dist/asserts.js
 import { format } from "node:util";
 function assertDefined(value, msg, ...params) {
   if (value === void 0 || value === null)
@@ -21285,7 +21269,7 @@ function assertDefined(value, msg, ...params) {
   return value;
 }
 
-// ../utils/src/collections.ts
+// ../utils/dist/collections.js
 function getOrSet(m, k, v) {
   let r3 = m.get(k);
   if (r3 === void 0) {
@@ -21346,7 +21330,8 @@ var Queue = class {
   }
   pop() {
     if (this.items.length === 0) {
-      if (this.back.length === 0) throw new Error("Queue is empty");
+      if (this.back.length === 0)
+        throw new Error("Queue is empty");
       [this.items, this.back] = [this.back.reverse(), this.items];
     }
     return this.items.pop();
@@ -21362,31 +21347,25 @@ var Queue = class {
   }
 };
 
-// ../utils/src/logger.ts
+// ../utils/dist/logger.js
 var import_winston = __toESM(require_winston(), 1);
 import { tmpdir } from "node:os";
 import { sep } from "node:path";
 var logger = (0, import_winston.createLogger)({
   level: "info",
-  format: import_winston.format.combine(
-    import_winston.format.splat(),
-    import_winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss.SSS" }),
-    ...process.stdout.isTTY ? [import_winston.format.colorize()] : [],
-    // eslint-disable-next-line @typescript-eslint/no-base-to-string
-    import_winston.format.printf(({ level, message, label, timestamp }) => `${timestamp} ${label ?? "-"} ${level}: ${message}`)
-  ),
+  format: import_winston.format.combine(import_winston.format.splat(), import_winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss.SSS" }), ...process.stdout.isTTY ? [import_winston.format.colorize()] : [], import_winston.format.printf(({ level, message, label, timestamp }) => `${timestamp} ${label ?? "-"} ${level}: ${message}`)),
   transports: [new import_winston.default.transports.Console()]
 });
 function setLogLevel(level) {
   logger.level = level;
 }
 
-// ../utils/src/numbers.ts
+// ../utils/dist/numbers.js
 function percent(part, total) {
   return `${Math.round(part / (total || 1) * 1e4) / 100}%`;
 }
 
-// ../utils/src/source-locations.ts
+// ../utils/dist/source-locations.js
 function locationToString(location, { filename = true } = {}) {
   return `${filename ? `${location.filename}:` : ""}${location.start.line}:${location.start.column}:${location.end.line}:${location.end.column}`;
 }
@@ -21398,7 +21377,7 @@ function createDummyLocation(filepath) {
   };
 }
 
-// ../utils/src/tree-sitter-ast-utils.ts
+// ../utils/dist/tree-sitter-ast-utils.js
 import assert2 from "node:assert";
 var PRINT_NODES = !!process.env["PRINT_NODES"];
 function visit(rootNode, astVisitor) {
@@ -21415,13 +21394,17 @@ function visit(rootNode, astVisitor) {
         const gen = visitor(cursor.currentNode);
         if (gen !== void 0) {
           visitChildren = false;
-          for (const child of gen) visitNode(child);
+          for (const child of gen)
+            visitNode(child);
         }
       }
-      if (visitChildren && cursor.gotoFirstChild()) continue;
+      if (visitChildren && cursor.gotoFirstChild())
+        continue;
       while (true) {
-        if (cursor.gotoNextSibling()) break;
-        if (!cursor.gotoParent()) return;
+        if (cursor.gotoNextSibling())
+          break;
+        if (!cursor.gotoParent())
+          return;
       }
     }
   }
@@ -21460,7 +21443,9 @@ function nodeEq(a, b) {
 var NodeMap = class {
   map = /* @__PURE__ */ new Map();
   constructor(iterable) {
-    if (iterable !== void 0) for (const [key, value] of iterable) this.set(key, value);
+    if (iterable !== void 0)
+      for (const [key, value] of iterable)
+        this.set(key, value);
   }
   get size() {
     return this.map.size;
@@ -21515,16 +21500,19 @@ var FullNodeMap = class {
     return this.entries();
   }
   forEach(callbackfn, thisArg) {
-    for (const [key, value] of this) callbackfn.call(thisArg, value, key, this);
+    for (const [key, value] of this)
+      callbackfn.call(thisArg, value, key, this);
   }
   entries() {
     return this.map.values();
   }
   *keys() {
-    for (const [key] of this) yield key;
+    for (const [key] of this)
+      yield key;
   }
   *values() {
-    for (const [, value] of this) yield value;
+    for (const [, value] of this)
+      yield value;
   }
 };
 var NodeSet = class {
@@ -21553,25 +21541,30 @@ var NodeSet = class {
   [Symbol.toStringTag] = "NodeSet";
 };
 
-// ../analysis-engine/src/infos.ts
+// ../analysis-engine/dist/infos.js
 import { join } from "node:path";
 var PackageInfo = class {
-  // map from path relative to the package root to module info
-  // readonly directDependencies = new Set<PackageInfo>(); // the direct dependencies of this package
+  name;
+  version;
+  dir;
+  isEntry;
+  modules = /* @__PURE__ */ new Map();
   constructor(name, version, dir, isEntry) {
     this.name = name;
     this.version = version;
     this.dir = dir;
     this.isEntry = isEntry;
   }
-  modules = /* @__PURE__ */ new Map();
   toString() {
     return `${this.name}${this.version ? `@${this.version}` : ""}`;
   }
 };
 var ModuleInfo = class {
-  // top-level source location, dummy if not yet analyzed
-  // readonly hash: number;
+  relativePath;
+  packageInfo;
+  isEntry;
+  isIncluded;
+  loc;
   constructor(relativePath, packageInfo, isEntry, isIncluded) {
     this.relativePath = relativePath;
     this.packageInfo = packageInfo;
@@ -21579,29 +21572,19 @@ var ModuleInfo = class {
     this.isIncluded = isIncluded;
     this.loc = createDummyLocation(this.getPath());
   }
-  // readonly functions = new Set<FunctionInfo>(); // functions directly inside this module
-  loc;
   toString() {
     return `${this.packageInfo}:${this.relativePath}`;
   }
-  /**
-   * Returns normalized file path of the representative file (different paths may refer to the same ModuleInfo).
-   */
   getPath() {
     return join(this.packageInfo.dir, this.relativePath);
   }
-  /**
-   * Returns the official name of this module, using the package name if the module is the main module,
-   * and otherwise stripping /index.js, .js and .mjs.
-   */
-  /*
-  getOfficialName(): string {
-    if (this.relativePath === this.packageInfo.main) return this.packageInfo.name;
-    return normalizeModuleName(`${this.packageInfo.name}/${this.relativePath}`);
-  }
-  */
 };
 var FunctionInfo = class {
+  name;
+  node;
+  parent;
+  moduleInfo;
+  loc;
   constructor(name, node, parent, moduleInfo) {
     this.name = name;
     this.node = node;
@@ -21609,8 +21592,6 @@ var FunctionInfo = class {
     this.moduleInfo = moduleInfo;
     this.loc = getSourceLocation(node);
   }
-  // readonly functions = new Set<FunctionInfo>(); // functions directly inside this function
-  loc;
   get isEntry() {
     return this.moduleInfo.isEntry;
   }
@@ -21622,23 +21603,11 @@ var FunctionInfo = class {
   }
 };
 
-// ../analysis-engine/src/call-graph.ts
+// ../analysis-engine/dist/call-graph.js
 var CallGraph = class {
-  /**
-   * Map that provides for each function/module the set of functions that may be called.
-   */
   functionToFunction = /* @__PURE__ */ new Map();
-  /**
-   * Map that provides for each call-site the set of functions that may be called.
-   */
   callToFunctionOrModule = new FullNodeMap();
-  /**
-   * Map that provides for each call-site the innermost function that contains it.
-   */
   callToContainingFunction = new NodeMap();
-  /**
-   * Adds an edge in the call graph (both function->function and call->function).
-   */
   addEdge(call, from, to) {
     const fs4 = mapGetSet(this.functionToFunction, from);
     fs4.add(to);
@@ -21654,12 +21623,9 @@ var CallGraph = class {
     return this.callToFunctionOrModule.entries().flatMap(([call, tos]) => {
       const from = assertDefined(this.callToContainingFunction.get(call));
       const loc = locationToString(from.loc);
-      return tos.keys().map(
-        (to) => `${loc} ${locationToString(getSourceLocation(call), { filename: false })} -> ${locationToString(to.loc)}`
-      );
+      return tos.keys().map((to) => `${loc} ${locationToString(getSourceLocation(call), { filename: false })} -> ${locationToString(to.loc)}`);
     }).toArray();
   }
-  // Returns a parent map for all reachable functions starting from `initial`
   reachableFunctions(initial) {
     const stack = [...initial];
     const parent = new Map(stack.map((f) => [f, void 0]));
@@ -21676,7 +21642,8 @@ var CallGraph = class {
   serialize() {
     const targetIndex = /* @__PURE__ */ new Map();
     for (const f of [...this.functionToFunction.keys(), ...this.functionToFunction.values().flatMap(e3())]) {
-      if (targetIndex.has(f)) continue;
+      if (targetIndex.has(f))
+        continue;
       targetIndex.set(f, targetIndex.size);
     }
     const edgeIndex = /* @__PURE__ */ new Map();
@@ -21736,14 +21703,7 @@ function compareStaticWithDynamicCG(callGraph, moduleInfos, { targets, edges },
     staticLibReachable
   };
 }
-function comparisonReport({
-  dynamicEdges,
-  dynamicReachable,
-  dynamicLibReachable,
-  staticEdges,
-  staticReachable,
-  staticLibReachable
-}) {
+function comparisonReport({ dynamicEdges, dynamicReachable, dynamicLibReachable, staticEdges, staticReachable, staticLibReachable }) {
   const sse = new Set(staticEdges);
   const ssr = new Set(staticReachable);
   const sslr = new Set(staticLibReachable);
@@ -21764,13 +21724,13 @@ Extra: ${fmt(staticReachable.length - reachableMatches, staticReachable.length)}
 `;
 }
 
-// ../ruby-analyzer/src/ruby-analyzer.ts
+// ../ruby-analyzer/dist/ruby-analyzer.js
 import assert9 from "node:assert";
 import { createReadStream } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { basename as basename2, dirname as dirname3, resolve as resolve2 } from "node:path";
 
-// ../utils/src/files.ts
+// ../utils/dist/files.js
 import { access, readdir, stat } from "node:fs/promises";
 import { resolve } from "node:path";
 async function findFiles(dir, predicate, recurse = e2(true)) {
@@ -21780,32 +21740,33 @@ async function findFiles(dir, predicate, recurse = e2(true)) {
     for (const entry of entries) {
       const fullPath = resolve(dir2, entry.name);
       const e5 = entry.isSymbolicLink() ? await stat(fullPath) : entry;
-      if (e5.isDirectory() && recurse(fullPath)) await aux(fullPath);
-      else if (e5.isFile() && await predicate(fullPath)) files.push(fullPath);
+      if (e5.isDirectory() && recurse(fullPath))
+        await aux(fullPath);
+      else if (e5.isFile() && await predicate(fullPath))
+        files.push(fullPath);
     }
   };
   await aux(dir);
   return files;
 }
 
-// ../utils/src/timer.ts
+// ../utils/dist/timer.js
 var Timer = class {
+  timeout;
+  startTime;
   constructor(timeout) {
     this.timeout = timeout;
     this.reset();
   }
-  startTime;
   reset() {
     this.startTime = process.hrtime.bigint();
   }
-  /**
-   * Returns the elapsed time in nanoseconds since the timer was created.
-   */
   elapsed() {
     return process.hrtime.bigint() - this.startTime;
   }
   checkTimeout() {
-    if (this.timeout && this.elapsed() > BigInt(this.timeout) * 1000000000n) throw new TimeoutException();
+    if (this.timeout && this.elapsed() > BigInt(this.timeout) * 1000000000n)
+      throw new TimeoutException();
   }
 };
 var TimeoutException = class extends Error {
@@ -21817,12 +21778,14 @@ function nanoToMs(n12) {
   return `${n12 / 1000000n}ms`;
 }
 
-// ../analysis-engine/src/abstract-constraintvar.ts
+// ../analysis-engine/dist/abstract-constraintvar.js
 var ConstraintVar = class {
 };
 
-// ../ruby-analyzer/src/constraintvars.ts
+// ../ruby-analyzer/dist/constraintvars.js
 var NodeVar = class extends ConstraintVar {
+  node;
+  kind;
   constructor(node, kind) {
     super();
     this.node = node;
@@ -21833,6 +21796,8 @@ var NodeVar = class extends ConstraintVar {
   }
 };
 var MethodsVar = class extends ConstraintVar {
+  obj;
+  name;
   constructor(obj, name) {
     super();
     this.obj = obj;
@@ -21843,6 +21808,7 @@ var MethodsVar = class extends ConstraintVar {
   }
 };
 var AncestorsVar = class extends ConstraintVar {
+  obj;
   constructor(obj) {
     super();
     this.obj = obj;
@@ -21852,6 +21818,7 @@ var AncestorsVar = class extends ConstraintVar {
   }
 };
 var ConstantVar = class extends ConstraintVar {
+  constant;
   constructor(constant) {
     super();
     this.constant = constant;
@@ -21861,6 +21828,8 @@ var ConstantVar = class extends ConstraintVar {
   }
 };
 var ObjPropVar = class extends ConstraintVar {
+  obj;
+  prop;
   constructor(obj, prop) {
     super();
     this.obj = obj;
@@ -21871,7 +21840,7 @@ var ObjPropVar = class extends ConstraintVar {
   }
 };
 
-// ../ruby-analyzer/src/types/ruby-node-types.ts
+// ../ruby-analyzer/dist/types/ruby-node-types.js
 function isAliasNode(node) {
   return node?.type === "alias";
 }
@@ -21990,10 +21959,12 @@ function isStringContentNode(node) {
   return node?.type === "string_content";
 }
 
-// ../ruby-analyzer/src/ruby-ast-helpers.ts
+// ../ruby-analyzer/dist/ruby-ast-helpers.js
 function getStringContent(node) {
-  if (node.namedChildCount === 0) return "";
-  else if (node.namedChildCount === 1 && isStringContentNode(node.namedChildren[0])) return node.namedChildren[0].text;
+  if (node.namedChildCount === 0)
+    return "";
+  else if (node.namedChildCount === 1 && isStringContentNode(node.namedChildren[0]))
+    return node.namedChildren[0].text;
   const parts = [];
   for (const child of node.namedChildren)
     switch (child.type) {
@@ -22015,59 +21986,56 @@ function getStringContent(node) {
 }
 function getLastNodeInFunction(node) {
   const bodyNode = node.bodyNode;
-  if (!bodyNode) return;
+  if (!bodyNode)
+    return;
   const blockBodyNode = bodyNode.namedChildren.find((b) => b.type === "block_body");
   return (blockBodyNode ?? bodyNode).lastNamedChild;
 }
 function isCommandCall(node, bindings) {
-  if (bindings.has(node)) return false;
+  if (bindings.has(node))
+    return false;
   const { parent } = node;
-  if ((isMethodNode(parent) || isSingletonMethodNode(parent)) && parent.nameNode.id === node.id) return false;
-  if (isCallNode(parent) && parent.methodNode?.id === node.id) return false;
-  if (isAliasNode(parent) && parent.namedChildren.some((c) => c.id === node.id)) return false;
+  if ((isMethodNode(parent) || isSingletonMethodNode(parent)) && parent.nameNode.id === node.id)
+    return false;
+  if (isCallNode(parent) && parent.methodNode?.id === node.id)
+    return false;
+  if (isAliasNode(parent) && parent.namedChildren.some((c) => c.id === node.id))
+    return false;
   return true;
 }
 
-// ../ruby-analyzer/src/constraintvar-producer.ts
+// ../ruby-analyzer/dist/constraintvar-producer.js
 var ConstraintVarProducer = class {
-  /**
-   * Map from AST node to canonical NodeVar object - This ensures that we only have one constraint variable per AST node.
-   */
-  canonicalNodeVars = t7(
-    ["normal", "callee", "return", "self", "default definee", "block param"],
-    () => new NodeMap()
-  );
+  canonicalNodeVars = t7(["normal", "callee", "return", "self", "default definee", "block param"], () => new NodeMap());
   canonicalMethodsVars = /* @__PURE__ */ new Map();
   canonicalPropVars = /* @__PURE__ */ new Map();
   canonicalAncestorsVars = /* @__PURE__ */ new WeakMap();
   canonicalConstantVars = /* @__PURE__ */ new Map();
-  /**
-   * Map from constraint variable string hash to canonical ConstraintVar object.
-   */
-  // private readonly canonicalConstraintVars = new Map<string, RubyConstraintVar>();
   canonicalizeVar(v) {
-    if (v instanceof NodeVar) return getOrSet(this.canonicalNodeVars[v.kind], v.node, () => v);
+    if (v instanceof NodeVar)
+      return getOrSet(this.canonicalNodeVars[v.kind], v.node, () => v);
     else if (v instanceof MethodsVar) {
       const map = getOrSet(this.canonicalMethodsVars, v.name, () => /* @__PURE__ */ new WeakMap());
       return getOrSet(map, v.obj, () => v);
     } else if (v instanceof ConstantVar)
       return getOrSet(this.canonicalConstantVars, v.constant, () => v);
-    else if (v instanceof AncestorsVar) return getOrSet(this.canonicalAncestorsVars, v.obj, () => v);
+    else if (v instanceof AncestorsVar)
+      return getOrSet(this.canonicalAncestorsVars, v.obj, () => v);
     else if (v instanceof ObjPropVar) {
       const map = getOrSet(this.canonicalPropVars, v.prop, () => /* @__PURE__ */ new WeakMap());
       return getOrSet(map, v.obj, () => v);
-    } else v;
+    } else
+      v;
     throw new Error(`Unsupported constraint variable: ${v}`);
   }
   identVar(n12, bindings) {
-    if (isCommandCall(n12, bindings)) return this.nodeVar(n12);
+    if (isCommandCall(n12, bindings))
+      return this.nodeVar(n12);
     const def = bindings.get(n12);
-    if (!def) logger.error(`No definition found for identifier: ${n12.text}`);
+    if (!def)
+      logger.error(`No definition found for identifier: ${n12.text}`);
     return this.nodeVar(def);
   }
-  /**
-   * Finds the constraint variable representing the return values of the given function.
-   */
   returnVar(fun) {
     return this.canonicalizeVar(new NodeVar(fun, "return"));
   }
@@ -22100,18 +22068,18 @@ var ConstraintVarProducer = class {
   }
 };
 
-// ../ruby-analyzer/src/natives/native-builder.ts
+// ../ruby-analyzer/dist/natives/native-builder.js
 import assert6 from "node:assert";
 
-// ../ruby-analyzer/src/tokens.ts
+// ../ruby-analyzer/dist/tokens.js
 import assert3 from "node:assert";
 
-// ../analysis-engine/src/abstract-token.ts
+// ../analysis-engine/dist/abstract-token.js
 var TokenInterface = class {
   hash;
 };
 
-// ../utils/src/strings.ts
+// ../utils/dist/strings.js
 function strHash(s) {
   let h1 = 0;
   let h2 = 17656767856;
@@ -22127,7 +22095,7 @@ function strHash(s) {
   return 4294967296 * (2097151 & h2) + (h1 >>> 0);
 }
 
-// ../ruby-analyzer/src/tokens.ts
+// ../ruby-analyzer/dist/tokens.js
 function makeConstant(name) {
   return name;
 }
@@ -22145,25 +22113,17 @@ var TokenFactory = class {
   canonicalMethodTokens = /* @__PURE__ */ new Map();
   canonicalizeToken(token) {
     if (token instanceof MethodToken) {
-      const map = getOrSet(
-        this.canonicalMethodTokens,
-        token.methodName,
-        () => /* @__PURE__ */ new WeakMap()
-      );
+      const map = getOrSet(this.canonicalMethodTokens, token.methodName, () => /* @__PURE__ */ new WeakMap());
       return getOrSet(map, token.receiver, () => {
         token.hash = strHash(`Method;${token.receiver};${token.methodName}`);
         return token;
       });
     } else if (token instanceof ObjectToken) {
-      const { index, ...maps } = getOrSet(
-        this.canonicalObjectTokens,
-        token.klass,
-        () => ({
-          index: this.canonicalObjectTokens.size,
-          nodeInstances: new NodeMap(),
-          otherInstances: /* @__PURE__ */ new Map()
-        })
-      );
+      const { index, ...maps } = getOrSet(this.canonicalObjectTokens, token.klass, () => ({
+        index: this.canonicalObjectTokens.size,
+        nodeInstances: new NodeMap(),
+        otherInstances: /* @__PURE__ */ new Map()
+      }));
       const site = token instanceof SingletonClassToken ? token.obj : token.allocSite;
       if (typeof site === "object" && "id" in site)
         return getOrSet(maps.nodeInstances, site, () => {
@@ -22181,14 +22141,16 @@ var TokenFactory = class {
         lambda: void 0
       }));
       const t15 = canon[token.kind] ??= token;
-      if (t15 === token) t15.hash = strHash(`${token.kind};${syntaxNodeToHashStr(token.fun)}`);
+      if (t15 === token)
+        t15.hash = strHash(`${token.kind};${syntaxNodeToHashStr(token.fun)}`);
       return t15;
     } else if (token instanceof NativeFunctionToken)
       return getOrSet(this.canonicalNativeFunctionTokens, token.native, () => {
         token.hash = strHash(token.native);
         return token;
       });
-    else token;
+    else
+      token;
     throw new Error(`Unknown token type: ${token}`);
   }
   createFunctionToken(fun, kind, scope, parameters = fun.parametersNode) {
@@ -22212,7 +22174,8 @@ var TokenFactory = class {
 };
 var ObjectToken = class extends TokenInterface {
   constructor(key) {
-    if (key !== tokenFactoryKey) throw new Error("ObjectToken must be created through TokenFactory");
+    if (key !== tokenFactoryKey)
+      throw new Error("ObjectToken must be created through TokenFactory");
     super();
   }
   isClassOrModuleToken() {
@@ -22223,6 +22186,7 @@ var ObjectToken = class extends TokenInterface {
   }
 };
 var ClassToken = class extends ObjectToken {
+  allocSite;
   constructor(key, allocSite) {
     super(key);
     this.allocSite = allocSite;
@@ -22233,29 +22197,36 @@ var ClassToken = class extends ObjectToken {
 };
 var rubyClassToken = ClassToken.prototype.klass = new ClassToken(tokenFactoryKey, "::Class");
 var SingletonClassToken = class extends ObjectToken {
+  obj;
+  static {
+    this.prototype.klass = rubyClassToken;
+  }
   constructor(key, obj) {
     super(key);
     this.obj = obj;
   }
-  static {
-    this.prototype.klass = rubyClassToken;
-  }
   toString() {
     return `SingletonClass[${this.obj}]`;
   }
 };
 var InstanceToken = class extends ObjectToken {
+  klass;
+  allocSite;
   constructor(key, klass, allocSite) {
     super(key);
     this.klass = klass;
     this.allocSite = allocSite;
   }
   toString() {
-    if (this.allocSite === void 0) return `Instance[${this.klass}]`;
+    if (this.allocSite === void 0)
+      return `Instance[${this.klass}]`;
     return `Object[${typeof this.allocSite === "string" ? this.allocSite : `${this.allocSite.type}:${nodeLocationToString(this.allocSite)}`} < ${this.klass}]`;
   }
 };
 var MethodToken = class extends ObjectToken {
+  klass;
+  receiver;
+  methodName;
   constructor(key, klass, receiver, methodName) {
     super(key);
     this.klass = klass;
@@ -22267,13 +22238,18 @@ var MethodToken = class extends ObjectToken {
   }
 };
 var FunctionToken = class extends TokenInterface {
+  fun;
+  parameters;
+  kind;
+  scope;
   constructor(key, fun, parameters, kind, scope) {
     super();
     this.fun = fun;
     this.parameters = parameters;
     this.kind = kind;
     this.scope = scope;
-    if (key !== tokenFactoryKey) throw new Error("FunctionToken must be created through TokenFactory");
+    if (key !== tokenFactoryKey)
+      throw new Error("FunctionToken must be created through TokenFactory");
     assert3(kind === "method" || isBlockNode(fun) || isDoBlockNode(fun));
   }
   toString() {
@@ -22281,31 +22257,33 @@ var FunctionToken = class extends TokenInterface {
     return `${t2(this.kind)}[${repr}]`;
   }
   toKind(kind, { tokenFactory }) {
-    if (this.kind === kind) return this;
+    if (this.kind === kind)
+      return this;
     return tokenFactory.createFunctionToken(this.fun, kind, this.scope, this.parameters);
   }
 };
 var NativeFunctionToken = class extends TokenInterface {
-  // TODO: maybe this belongs in the analysis-engine package
+  native;
+  invoke;
   constructor(key, native, invoke) {
     super();
     this.native = native;
     this.invoke = invoke;
-    if (key !== tokenFactoryKey) throw new Error("NativeObjectToken must be created through TokenFactory");
+    if (key !== tokenFactoryKey)
+      throw new Error("NativeObjectToken must be created through TokenFactory");
   }
   toString() {
     return `NativeFunction[${this.native}]`;
   }
 };
 
-// ../utils/src/objects.ts
+// ../utils/dist/objects.js
 function maybeOmit(obj, key) {
   return key in obj ? n7(obj, [key]) : obj;
 }
 
-// ../ruby-analyzer/src/natives/3rd-party/jwe.ts
+// ../ruby-analyzer/dist/natives/3rd-party/jwe.js
 var jwe_default = {
-  // TODO: Check whether these work for old versions
   "JWE::Enc": {
     fake: true,
     staticMethods: {
@@ -22327,20 +22305,22 @@ var jwe_default = {
   }
 };
 
-// ../ruby-analyzer/src/natives/models/module.ts
+// ../ruby-analyzer/dist/natives/models/module.js
 import assert4 from "node:assert";
 
-// ../utils/src/cache.ts
+// ../utils/dist/cache.js
 function cache(func, map = /* @__PURE__ */ new Map()) {
   return (key, ...rest) => {
     let value = map.get(key);
-    if (value === void 0) map.set(key, value = func(key, ...rest));
+    if (value === void 0)
+      map.set(key, value = func(key, ...rest));
     return value;
   };
 }
 
-// ../ruby-analyzer/src/listeners.ts
-var TokenListener = /* @__PURE__ */ ((TokenListener2) => {
+// ../ruby-analyzer/dist/listeners.js
+var TokenListener;
+(function(TokenListener2) {
   TokenListener2[TokenListener2["Call"] = 0] = "Call";
   TokenListener2[TokenListener2["Method"] = 1] = "Method";
   TokenListener2[TokenListener2["READ_BASE"] = 2] = "READ_BASE";
@@ -22369,10 +22349,9 @@ var TokenListener = /* @__PURE__ */ ((TokenListener2) => {
   TokenListener2[TokenListener2["NATIVE_BASIC_OBJECT_INSTANCE_EXEC_PROC"] = 25] = "NATIVE_BASIC_OBJECT_INSTANCE_EXEC_PROC";
   TokenListener2[TokenListener2["RAILS_INITIALIZABLE_INITIALIZER"] = 26] = "RAILS_INITIALIZABLE_INITIALIZER";
   TokenListener2[TokenListener2["RAILS_INITIALIZABLE_INITIALIZER_PROC"] = 27] = "RAILS_INITIALIZABLE_INITIALIZER_PROC";
-  return TokenListener2;
-})(TokenListener || {});
+})(TokenListener || (TokenListener = {}));
 
-// ../ruby-analyzer/src/natives/utils.ts
+// ../ruby-analyzer/dist/natives/utils.js
 function unsupported(klass, name) {
   return ({ cd, op }) => {
     op.a.warnUnsupported(cd.callNode, `Unsupported native method '${klass}#${name}'`);
@@ -22381,10 +22360,12 @@ function unsupported(klass, name) {
   };
 }
 function literalArg(op, cd, arg, method) {
-  if (!arg) op.a.warnUnsupported(cd.callNode, `${method} called with undefined (unsupported) argument`);
+  if (!arg)
+    op.a.warnUnsupported(cd.callNode, `${method} called with undefined (unsupported) argument`);
   else if (arg instanceof ConstraintVar || arg instanceof TokenInterface)
     op.a.warnUnsupported(cd.callNode, `${method} called with non-literal argument`);
-  else return arg;
+  else
+    return arg;
 }
 function invokeBlock(block, listener, defaultDefinee, p) {
   if (block) {
@@ -22392,25 +22373,24 @@ function invokeBlock(block, listener, defaultDefinee, p) {
     const key = { t: base, n: cd.callNode };
     op.addForAllTokensConstraint(block, listener, key, (t15) => {
       if (t15 instanceof ObjectToken) {
-        if (t15.klass !== op.state.globalNatives.Proc) return;
-        op.solver.addForAllTokensConstraint(
-          op.cvp.methodsVar(op.singletonClass(t15), "call"),
-          listener + 1,
-          key,
-          (ft) => {
-            if (ft instanceof FunctionToken) {
-              op.inclusionConstraint(defaultDefinee, op.cvp.defaultDefineeVar(ft.fun));
-              op.dispatchCall(ft.toKind("method", op), base, cd);
-            } else if (ft instanceof NativeFunctionToken) ft.invoke(p);
-            else ft;
-          }
-        );
-      } else t15;
+        if (t15.klass !== op.state.globalNatives.Proc)
+          return;
+        op.solver.addForAllTokensConstraint(op.cvp.methodsVar(op.singletonClass(t15), "call"), listener + 1, key, (ft) => {
+          if (ft instanceof FunctionToken) {
+            op.inclusionConstraint(defaultDefinee, op.cvp.defaultDefineeVar(ft.fun));
+            op.dispatchCall(ft.toKind("method", op), base, cd);
+          } else if (ft instanceof NativeFunctionToken)
+            ft.invoke(p);
+          else
+            ft;
+        });
+      } else
+        t15;
     });
   }
 }
 
-// ../ruby-analyzer/src/natives/models/module.ts
+// ../ruby-analyzer/dist/natives/models/module.js
 function include(kind, { base, op, cd }) {
   if (base instanceof SingletonClassToken) {
     op.a.warnUnsupported(cd.callNode, `Module#${kind} on a singleton class`);
@@ -22420,7 +22400,8 @@ function include(kind, { base, op, cd }) {
     logger.error(`Module#${kind} is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`);
     return;
   }
-  if (cd.arguments?.pSplat) op.a.warnUnsupported(cd.callNode, `Module#${kind} called with splat arguments`);
+  if (cd.arguments?.pSplat)
+    op.a.warnUnsupported(cd.callNode, `Module#${kind} called with splat arguments`);
   const ncd = {
     ...cd,
     arguments: { positional: [base] },
@@ -22428,46 +22409,44 @@ function include(kind, { base, op, cd }) {
   };
   for (const arg of cd.arguments?.positional ?? [])
     if (arg instanceof ConstraintVar || arg instanceof ObjectToken)
-      op.addForAllTokensConstraint(
-        arg,
-        11 /* NATIVE_MODULE_INCLUDE */,
-        { t: base, s: kind, n: cd.callNode },
-        (t15) => {
-          if (t15 instanceof ObjectToken) {
-            if (t15.klass === op.state.globalNatives.Module) {
-              op.callMethod(t15, kind === "include" ? "append_features" : "prepend_features", ncd);
-              op.callMethod(t15, kind === "include" ? "included" : "prepended", ncd);
-            }
-          } else t15;
-        }
-      );
-    else arg;
+      op.addForAllTokensConstraint(arg, TokenListener.NATIVE_MODULE_INCLUDE, { t: base, s: kind, n: cd.callNode }, (t15) => {
+        if (t15 instanceof ObjectToken) {
+          if (t15.klass === op.state.globalNatives.Module) {
+            op.callMethod(t15, kind === "include" ? "append_features" : "prepend_features", ncd);
+            op.callMethod(t15, kind === "include" ? "included" : "prepended", ncd);
+          }
+        } else
+          t15;
+      });
+    else
+      arg;
 }
 function appendFeatures({ base, op, cd }) {
   assert4.strictEqual(base.klass, op.state.globalNatives.Module);
-  if (cd.arguments?.pSplat) op.a.warnUnsupported(cd.callNode, "Module#append_features called with splat arguments");
+  if (cd.arguments?.pSplat)
+    op.a.warnUnsupported(cd.callNode, "Module#append_features called with splat arguments");
   const srcAv = op.cvp.ancestorsVar(base);
   for (const arg of cd.arguments?.positional ?? [])
     if (arg instanceof ConstraintVar || arg instanceof ObjectToken)
-      op.addForAllTokensConstraint(arg, 12 /* NATIVE_MODULE_APPEND_FEATURES */, { t: base }, (t15) => {
+      op.addForAllTokensConstraint(arg, TokenListener.NATIVE_MODULE_APPEND_FEATURES, { t: base }, (t15) => {
         if (t15 instanceof ObjectToken) {
           if (t15 instanceof SingletonClassToken)
             op.a.warnUnsupported(cd.callNode, "Module#append_features called with a singleton class");
-          else if (t15.isClassOrModuleToken()) op.solver.addSubsetConstraint(srcAv, op.cvp.ancestorsVar(t15));
+          else if (t15.isClassOrModuleToken())
+            op.solver.addSubsetConstraint(srcAv, op.cvp.ancestorsVar(t15));
           else
-            throw new Error(
-              `Module#append_features is called with a non-Class or Module token ${t15} at ${nodeToString(cd.callNode)}`
-            );
-        } else t15;
+            throw new Error(`Module#append_features is called with a non-Class or Module token ${t15} at ${nodeToString(cd.callNode)}`);
+        } else
+          t15;
       });
-    else arg;
+    else
+      arg;
 }
 function attrModel(name, { base, op, cd }) {
   if (!base.isClassLikeToken())
-    throw new Error(
-      `Module#attr_${name} is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`
-    );
-  if (cd.arguments?.pSplat) op.a.warnUnsupported(cd.callNode, `Module#attr_${name} called with splat arguments`);
+    throw new Error(`Module#attr_${name} is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`);
+  if (cd.arguments?.pSplat)
+    op.a.warnUnsupported(cd.callNode, `Module#attr_${name} called with splat arguments`);
   for (const arg of cd.arguments?.positional ?? []) {
     const lArg = literalArg(op, cd, arg, `Module#attr_${name}`);
     if (lArg) {
@@ -22478,15 +22457,9 @@ function attrModel(name, { base, op, cd }) {
 }
 function attrModelImpl(op, name, base, attr) {
   if (name !== "writer")
-    op.solver.addTokenConstraint(
-      op.tokenFactory.createNativeFunctionToken(...attrReader(attr)),
-      op.cvp.methodsVar(base, attr)
-    );
+    op.solver.addTokenConstraint(op.tokenFactory.createNativeFunctionToken(...attrReader(attr)), op.cvp.methodsVar(base, attr));
   if (name !== "reader")
-    op.solver.addTokenConstraint(
-      op.tokenFactory.createNativeFunctionToken(...attrWriter(attr)),
-      op.cvp.methodsVar(base, `${attr}=`)
-    );
+    op.solver.addTokenConstraint(op.tokenFactory.createNativeFunctionToken(...attrWriter(attr)), op.cvp.methodsVar(base, `${attr}=`));
 }
 var module_default = {
   newInstance({ op, cd }) {
@@ -22499,28 +22472,24 @@ var module_default = {
     prepend: include.bind(void 0, "prepend"),
     alias_method({ op, base, cd }) {
       if (!base.isClassLikeToken())
-        throw new Error(
-          `Module#alias_method is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`
-        );
-      if (cd.arguments?.pSplat) op.a.warnUnsupported(cd.callNode, "Module#alias_method called with splat arguments");
+        throw new Error(`Module#alias_method is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`);
+      if (cd.arguments?.pSplat)
+        op.a.warnUnsupported(cd.callNode, "Module#alias_method called with splat arguments");
       const pos = cd.arguments?.positional;
       if (pos?.length !== 2) {
         op.a.warnUnsupported(cd.callNode, "Module#alias_method called with incorrect number of positional arguments");
         return;
       }
       const lArgs = pos.map((a) => literalArg(op, cd, a, "Module#alias_method"));
-      if (lArgs.includes(void 0)) return;
-      const [target, source] = lArgs.map(
-        (a) => a.type === "symbol" ? a.value.slice(1) : a.value
-      );
+      if (lArgs.includes(void 0))
+        return;
+      const [target, source] = lArgs.map((a) => a.type === "symbol" ? a.value.slice(1) : a.value);
       op.solver.addSubsetConstraint(op.cvp.methodsVar(base, source), op.cvp.methodsVar(base, target));
     },
     define_method: unsupported("Module", "define_method"),
     module_function({ op, base, cd }) {
       if (!base.isClassLikeToken())
-        throw new Error(
-          `Module#module_function is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`
-        );
+        throw new Error(`Module#module_function is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`);
       if (base.klass !== op.state.globalNatives.Module)
         return;
       if (isCallNode(cd.callNode) && cd.callNode.receiverNode && !isSelfNode(cd.callNode.receiverNode))
@@ -22528,7 +22497,8 @@ var module_default = {
       const names = [];
       if (!cd.arguments || !("pSplat" in cd.arguments || cd.arguments.positional?.length)) {
         const scope = assertDefined(cd.callNode.closest(["block", "do_block", "module", "program"]));
-        if (isModuleNode(scope)) assert4(base.allocSite.endsWith(`::${scope.nameNode.text}`));
+        if (isModuleNode(scope))
+          assert4(base.allocSite.endsWith(`::${scope.nameNode.text}`));
         const endPos = cd.callNode.endPosition;
         for (const [name, startPos] of DefinedMethodsVisitor.getNames(scope, op))
           if (startPos.row > endPos.row || startPos.row === endPos.row && startPos.column >= endPos.column)
@@ -22538,7 +22508,8 @@ var module_default = {
           op.a.warnUnsupported(cd.callNode, "Module#module_function called with splat arguments");
         for (const arg of cd.arguments.positional ?? []) {
           const lArg = literalArg(op, cd, arg, "Module#module_function");
-          if (lArg) names.push(lArg.type === "symbol" ? lArg.value.slice(1) : lArg.value);
+          if (lArg)
+            names.push(lArg.type === "symbol" ? lArg.value.slice(1) : lArg.value);
         }
       }
       const sct = op.singletonClass(base);
@@ -22552,12 +22523,11 @@ var module_default = {
         op.a.warnUnsupported(cd.callNode, "Module#const_get on a singleton class");
         return;
       } else if (!base.isClassOrModuleToken())
-        throw new Error(
-          `Module#const_get is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`
-        );
+        throw new Error(`Module#const_get is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`);
       const positional = cd.arguments?.positional;
       const lArg = literalArg(op, cd, positional?.[0], "Module#const_get");
-      if (!lArg) return;
+      if (!lArg)
+        return;
       const name = lArg.type === "symbol" ? lArg.value.slice(1) : lArg.value;
       checkConstant(name);
       if (name.startsWith("::")) {
@@ -22568,20 +22538,21 @@ var module_default = {
       const vars = [];
       if (inherit) {
         vars.push(op.cvp.ancestorsVar(base));
-        if (base.klass === op.state.globalNatives.Module) vars.push(op.cvp.ancestorsVar(op.state.globalNatives.Object));
-      } else vars.push(base);
+        if (base.klass === op.state.globalNatives.Module)
+          vars.push(op.cvp.ancestorsVar(op.state.globalNatives.Object));
+      } else
+        vars.push(base);
       for (const v of vars)
-        op.addForAllTokensConstraint(v, 17 /* NATIVE_MODULE_CONST_GET */, { n: cd.callNode }, (t15) => {
+        op.addForAllTokensConstraint(v, TokenListener.NATIVE_MODULE_CONST_GET, { n: cd.callNode }, (t15) => {
           if (t15 instanceof ObjectToken) {
             if (t15 instanceof SingletonClassToken)
               op.a.warnUnsupported(cd.callNode, "Module#const_get called with a singleton class ancestor");
             else if (t15.isClassOrModuleToken())
               op.solver.addSubsetConstraint(op.cvp.constantVar(makeConstant(`${t15.allocSite}::${name}`)), cd.result);
             else
-              throw new Error(
-                `Module#const_get is called with a non-Class or Module token ${t15} at ${nodeToString(cd.callNode)}`
-              );
-          } else t15;
+              throw new Error(`Module#const_get is called with a non-Class or Module token ${t15} at ${nodeToString(cd.callNode)}`);
+          } else
+            t15;
         });
     },
     const_set({ op, base, cd }) {
@@ -22589,19 +22560,21 @@ var module_default = {
         op.a.warnUnsupported(cd.callNode, "Module#const_set on a singleton class");
         return;
       } else if (!base.isClassOrModuleToken())
-        throw new Error(
-          `Module#const_set is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`
-        );
+        throw new Error(`Module#const_set is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`);
       const pos = cd.arguments?.positional;
       const value = pos?.[1];
-      if (!(value instanceof ConstraintVar || value instanceof TokenInterface)) return;
-      if (cd.result) op.inclusionConstraint(value, cd.result);
+      if (!(value instanceof ConstraintVar || value instanceof TokenInterface))
+        return;
+      if (cd.result)
+        op.inclusionConstraint(value, cd.result);
       const lArg = literalArg(op, cd, pos[0], "Module#const_set");
-      if (!lArg) return;
+      if (!lArg)
+        return;
       const name = lArg.type === "symbol" ? lArg.value.slice(1) : lArg.value;
       if (/^[A-Z][^:]*$/.test(name))
         op.inclusionConstraint(value, op.cvp.constantVar(makeConstant(`${base.allocSite}::${name}`)));
-      else op.a.warnUnsupported(cd.callNode, "Module#const_set with invalid constant name");
+      else
+        op.a.warnUnsupported(cd.callNode, "Module#const_set with invalid constant name");
     },
     attr: unsupported("Module", "attr"),
     attr_reader: attrModel.bind(void 0, "reader"),
@@ -22609,9 +22582,7 @@ var module_default = {
     attr_accessor: attrModel.bind(void 0, "accessor"),
     module_eval({ op, base, cd }) {
       if (!base.isClassLikeToken())
-        throw new Error(
-          `Module#module_eval is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`
-        );
+        throw new Error(`Module#module_eval is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`);
       const pos = cd.arguments?.positional;
       if (pos?.length) {
         const a = pos[0];
@@ -22619,34 +22590,21 @@ var module_default = {
           op.a.warnUnsupported(cd.callNode, "Module#module_eval with dynamically computed argument");
         else if (a.type === "string")
           op.a.warnUnsupported(cd.callNode, "Module#module_eval with statically known string argument");
-        else op.a.warnUnsupported(cd.callNode, `Module#module_eval with ${a.type} argument`);
+        else
+          op.a.warnUnsupported(cd.callNode, `Module#module_eval with ${a.type} argument`);
         return;
       }
-      invokeBlock(
-        cd.arguments?.block,
-        13 /* NATIVE_MODULE_MODULE_EVAL */,
-        // Functions defined in the block are defined on the module itself
+      invokeBlock(cd.arguments?.block, TokenListener.NATIVE_MODULE_MODULE_EVAL, base, {
+        op,
         base,
-        {
-          op,
-          base,
-          cd: { ...cd, arguments: { positional: [base] } }
-        }
-      );
+        cd: { ...cd, arguments: { positional: [base] } }
+      });
     },
     module_exec({ op, base, cd }) {
       if (!base.isClassLikeToken())
-        throw new Error(
-          `Module#module_exec is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`
-        );
+        throw new Error(`Module#module_exec is called on a non-Class or Module token ${base} at ${nodeToString(cd.callNode)}`);
       const { block, ...args } = cd.arguments ?? {};
-      invokeBlock(
-        block,
-        15 /* NATIVE_MODULE_MODULE_EXEC */,
-        // Functions defined in the block are defined on the module itself
-        base,
-        { op, base, cd: { ...cd, arguments: args } }
-      );
+      invokeBlock(block, TokenListener.NATIVE_MODULE_MODULE_EXEC, base, { op, base, cd: { ...cd, arguments: args } });
     },
     using: unsupported("Module", "using")
   },
@@ -22661,14 +22619,16 @@ var module_default = {
 var attrReader = cache((name) => [
   makeNative(`Module#attr_reader#${name}`),
   ({ op, cd, base }) => {
-    if (!(base instanceof ObjectToken)) throw new Error("attr_reader is called on a non-object");
+    if (!(base instanceof ObjectToken))
+      throw new Error("attr_reader is called on a non-object");
     op.solver.addSubsetConstraint(op.cvp.objPropVar(base, `@${name}`), cd.result);
   }
 ]);
 var attrWriter = cache((name) => [
   makeNative(`Module#attr_writer#${name}`),
   ({ op, cd, base }) => {
-    if (!(base instanceof ObjectToken)) throw new Error("attr_writer is called on a non-object");
+    if (!(base instanceof ObjectToken))
+      throw new Error("attr_writer is called on a non-object");
     const positional = cd.arguments?.positional;
     if (positional?.length !== 1) {
       op.a.warnUnsupported(cd.callNode, "attr_writer called with incorrect number of positional arguments");
@@ -22676,27 +22636,31 @@ var attrWriter = cache((name) => [
     }
     const arg = positional[0];
     const rVar = op.cvp.objPropVar(base, `@${name}`);
-    if (arg instanceof ConstraintVar) op.solver.addSubsetConstraint(arg, rVar);
-    else if (arg instanceof ObjectToken) op.solver.addTokenConstraint(arg, rVar);
-    else arg;
+    if (arg instanceof ConstraintVar)
+      op.solver.addSubsetConstraint(arg, rVar);
+    else if (arg instanceof ObjectToken)
+      op.solver.addTokenConstraint(arg, rVar);
+    else
+      arg;
   }
 ]);
 var DefinedMethodsVisitor = class _DefinedMethodsVisitor {
+  op;
+  static getNames = cache((scope, op) => {
+    const visitor = new _DefinedMethodsVisitor(op);
+    const v = visitor;
+    if (isBlockNode(scope) || isDoBlockNode(scope) || isModuleNode(scope)) {
+      if (scope.bodyNode)
+        visit(scope.bodyNode, v);
+    } else
+      for (const node of scope.namedChildren)
+        visit(node, v);
+    return visitor.names;
+  }, new NodeMap());
+  names = new Array();
   constructor(op) {
     this.op = op;
   }
-  static getNames = cache(
-    (scope, op) => {
-      const visitor = new _DefinedMethodsVisitor(op);
-      const v = visitor;
-      if (isBlockNode(scope) || isDoBlockNode(scope) || isModuleNode(scope)) {
-        if (scope.bodyNode) visit(scope.bodyNode, v);
-      } else for (const node of scope.namedChildren) visit(node, v);
-      return visitor.names;
-    },
-    new NodeMap()
-  );
-  names = new Array();
   *method(node) {
     this.names.push([node.nameNode.text, node.startPosition]);
   }
@@ -22710,8 +22674,6 @@ var DefinedMethodsVisitor = class _DefinedMethodsVisitor {
       }
     }
   }
-  // Stop visitor from going into nested scopes
-  /* eslint-disable @typescript-eslint/no-empty-function */
   *singleton_method() {
   }
   *block() {
@@ -22724,10 +22686,9 @@ var DefinedMethodsVisitor = class _DefinedMethodsVisitor {
   }
   *singleton_class() {
   }
-  /* eslint-enable @typescript-eslint/no-empty-function */
 };
 
-// ../ruby-analyzer/src/natives/3rd-party/nokogiri.ts
+// ../ruby-analyzer/dist/natives/3rd-party/nokogiri.js
 var nokogiri_default = {
   "Nokogiri::XML::Node": {
     fake: true
@@ -22736,11 +22697,7 @@ var nokogiri_default = {
     fake: true,
     methods: {
       initialize({ base, op }) {
-        op.solver.addTokenConstraint(
-          // eslint-disable-next-line unicorn/no-useless-undefined
-          op.tokenFactory.createInstanceToken(op.state.globalNatives["Nokogiri::XML::Node"], void 0),
-          op.cvp.objPropVar(base, "@root")
-        );
+        op.solver.addTokenConstraint(op.tokenFactory.createInstanceToken(op.state.globalNatives["Nokogiri::XML::Node"], void 0), op.cvp.objPropVar(base, "@root"));
       }
     },
     setup(t15, op) {
@@ -22749,32 +22706,27 @@ var nokogiri_default = {
   }
 };
 
-// ../ruby-analyzer/src/natives/3rd-party/rails.ts
+// ../ruby-analyzer/dist/natives/3rd-party/rails.js
 var rails_default = {
   "Rails::Initializable::ClassMethods": {
     fake: true,
     methods: {
       initializer({ base, op, cd }) {
         const blk = cd.arguments?.block;
-        if (!blk) return;
+        if (!blk)
+          return;
         if (!(base instanceof ClassToken)) {
           op.a.warnUnsupported(cd.callNode, "Rails::Initializable::ClassMethods#initializer called on non-Class");
           return;
         }
         const it = op.tokenFactory.createInstanceToken(base, void 0);
-        invokeBlock(
-          blk,
-          26 /* RAILS_INITIALIZABLE_INITIALIZER */,
-          // uses instance_exec under the hood
-          op.singletonClass(it),
-          { op, base: it, cd: n7(cd, ["arguments"]) }
-        );
+        invokeBlock(blk, TokenListener.RAILS_INITIALIZABLE_INITIALIZER, op.singletonClass(it), { op, base: it, cd: n7(cd, ["arguments"]) });
       }
     }
   }
 };
 
-// ../ruby-analyzer/src/natives/models/basic-object.ts
+// ../ruby-analyzer/dist/natives/models/basic-object.js
 var basic_object_default = {
   methods: {
     instance_eval({ op, base, cd }) {
@@ -22785,10 +22737,11 @@ var basic_object_default = {
           op.a.warnUnsupported(cd.callNode, "BasicObject#instance_eval with dynamically computed argument");
         else if (a.type === "string")
           op.a.warnUnsupported(cd.callNode, "BasicObject#instance_eval with statically known string argument");
-        else op.a.warnUnsupported(cd.callNode, `BasicObject#instance_eval with ${a.type} argument`);
+        else
+          op.a.warnUnsupported(cd.callNode, `BasicObject#instance_eval with ${a.type} argument`);
         return;
       }
-      invokeBlock(cd.arguments?.block, 22 /* NATIVE_BASIC_OBJECT_INSTANCE_EVAL */, op.singletonClass(base), {
+      invokeBlock(cd.arguments?.block, TokenListener.NATIVE_BASIC_OBJECT_INSTANCE_EVAL, op.singletonClass(base), {
         op,
         base,
         cd: { ...cd, arguments: { positional: [base] } }
@@ -22796,7 +22749,7 @@ var basic_object_default = {
     },
     instance_exec({ op, base, cd }) {
       const { block, ...args } = cd.arguments ?? {};
-      invokeBlock(block, 24 /* NATIVE_BASIC_OBJECT_INSTANCE_EXEC */, op.singletonClass(base), {
+      invokeBlock(block, TokenListener.NATIVE_BASIC_OBJECT_INSTANCE_EXEC, op.singletonClass(base), {
         op,
         base,
         cd: { ...cd, arguments: args }
@@ -22805,7 +22758,7 @@ var basic_object_default = {
   }
 };
 
-// ../ruby-analyzer/src/natives/models/kernel.ts
+// ../ruby-analyzer/dist/natives/models/kernel.js
 import assert5 from "node:assert";
 import fs from "node:fs";
 import { dirname, extname, isAbsolute, join as join2 } from "node:path";
@@ -22816,13 +22769,15 @@ function callProcNew(p) {
 function simpleResolver(root) {
   return (candidate) => {
     const fullPath = join2(root, candidate);
-    if (fs.existsSync(fullPath)) return fullPath;
+    if (fs.existsSync(fullPath))
+      return fullPath;
   };
 }
 var cachedResolver = cache((root) => {
   const paths = new Set(globSync2(`**/*.{${requireExtensions.map((ext2) => ext2.slice(1)).join(",")}}`, { cwd: root }));
   return (c) => {
-    if (paths.has(c.startsWith("./") ? c.slice(2) : c)) return join2(root, c);
+    if (paths.has(c.startsWith("./") ? c.slice(2) : c))
+      return join2(root, c);
   };
 });
 function loadModule(method, required, roots, candidates, op, cd) {
@@ -22850,12 +22805,7 @@ function requireImpl(method, { op, cd }) {
   const positional = cd.arguments?.positional;
   const arg = positional?.[expectedArgs - 1];
   if (positional?.length !== expectedArgs) {
-    logger.error(
-      "Kernel#%s called with wrong number of arguments (%d, expected %d)",
-      method,
-      positional?.length ?? 0,
-      expectedArgs
-    );
+    logger.error("Kernel#%s called with wrong number of arguments (%d, expected %d)", method, positional?.length ?? 0, expectedArgs);
     return;
   } else if (!arg || arg instanceof ConstraintVar || arg instanceof TokenInterface || arg.type !== "string") {
     op.a.warnUnsupported(cd.callNode, `Kernel#${method} called with non-constant string argument`);
@@ -22871,19 +22821,19 @@ function requireImpl(method, { op, cd }) {
     if (isAbsolute(required)) {
       op.a.warnUnsupported(cd.callNode, `Kernel#${method} called with absolute path: '${required}'`);
       return;
-    } else if (explicitlyRelative(required)) requireFrom = [simpleResolver(op.a.rootDir)];
-    else requireFrom = op.state.loadPath.map(cachedResolver);
+    } else if (explicitlyRelative(required))
+      requireFrom = [simpleResolver(op.a.rootDir)];
+    else
+      requireFrom = op.state.loadPath.map(cachedResolver);
   }
   loadModule(method, required, requireFrom, candidates, op, cd);
 }
 var globalKernelMethods = {
   eval: unsupported("Kernel", "eval"),
   proc: callProcNew,
-  // FIXME: Tag the resulting Proc as a lambda
   lambda: callProcNew,
   require_relative: requireImpl.bind(void 0, "require_relative"),
   require: requireImpl.bind(void 0, "require"),
-  // Treat `autoload` is an immediate require, which is sound but (possibly) imprecise
   autoload: requireImpl.bind(void 0, "autoload"),
   load: ({ op, cd }) => {
     const positional = cd.arguments?.positional;
@@ -22898,16 +22848,10 @@ var globalKernelMethods = {
     if (positional.length >= 2 || cd.arguments?.keyword?.some(([name]) => name === "wrap"))
       op.a.warnUnsupported(cd.callNode, "Kernel#load called with 'wrap' argument");
     const required = arg.value;
-    if (isAbsolute(required)) op.a.warnUnsupported(cd.callNode, `Kernel#load called with absolute path: '${required}'`);
+    if (isAbsolute(required))
+      op.a.warnUnsupported(cd.callNode, `Kernel#load called with absolute path: '${required}'`);
     else
-      loadModule(
-        "load",
-        required,
-        [...explicitlyRelative(required) ? [] : op.state.loadPath.map(cachedResolver), simpleResolver(op.a.rootDir)],
-        [required],
-        op,
-        cd
-      );
+      loadModule("load", required, [...explicitlyRelative(required) ? [] : op.state.loadPath.map(cachedResolver), simpleResolver(op.a.rootDir)], [required], op, cd);
   }
 };
 var kernel_default = {
@@ -22919,9 +22863,11 @@ var kernel_default = {
     define_singleton_method({ base, op, cd }) {
       let [nameArg, methodArg] = cd.arguments?.positional ?? [];
       const lNameArg = literalArg(op, cd, nameArg, "Kernel#define_singleton_method");
-      if (!lNameArg) return;
+      if (!lNameArg)
+        return;
       if (cd.arguments.positional.length === 1) {
-        if ("block" in cd.arguments) methodArg = cd.arguments.block;
+        if ("block" in cd.arguments)
+          methodArg = cd.arguments.block;
         else {
           op.a.warnUnsupported(cd.callNode, "Kernel#define_singleton_method called with wrong number of arguments");
           return;
@@ -22931,109 +22877,104 @@ var kernel_default = {
         op.a.warnUnsupported(cd.callNode, "Kernel#define_singleton_method called with non-object method argument");
         return;
       }
-      const mVar = op.cvp.methodsVar(
-        op.singletonClass(base),
-        lNameArg.type === "symbol" ? lNameArg.value.slice(1) : lNameArg.value
-      );
-      op.addForAllTokensConstraint(
-        methodArg,
-        19 /* NATIVE_KERNEL_DEFINE_SINGLETON_METHOD */,
-        { t: base, s: mVar.name },
-        (mt) => {
-          if (mt instanceof ObjectToken) {
-            if (mt instanceof MethodToken)
-              op.solver.addForAllTokensConstraint(
-                op.cvp.ancestorsVar(op.singletonClass(mt.receiver)),
-                21 /* NATIVE_KERNEL_DEFINE_SINGLETON_METHOD_METHOD */,
-                { t: base, s: mVar.name },
-                (t15) => {
-                  if (t15 instanceof ObjectToken) {
-                    if (!t15.isClassLikeToken()) assert5.fail(`Expected class or module token, got ${t15}`);
-                    op.solver.addSubsetConstraint(op.cvp.methodsVar(t15, mt.methodName), mVar);
-                  } else t15;
-                }
-              );
-            else if (mt.klass === op.state.globalNatives.Proc)
-              op.solver.addForAllTokensConstraint(
-                op.cvp.methodsVar(op.singletonClass(mt), "call"),
-                20 /* NATIVE_KERNEL_DEFINE_SINGLETON_METHOD_PROC */,
-                { t: base, s: mVar.name },
-                (ft) => {
-                  if (ft instanceof FunctionToken) {
-                    assert5(ft.kind !== "method");
-                    op.solver.addTokenConstraint(ft.toKind("method", op), mVar);
-                  } else if (ft instanceof NativeFunctionToken) op.solver.addTokenConstraint(ft, mVar);
-                  else ft;
-                }
-              );
-            else op.a.warnUnsupported(cd.callNode, "Kernel#define_singleton_method got non-Proc/Method token");
-          } else {
-            mt;
-            op.a.warnUnsupported(cd.callNode, "Kernel#define_singleton_method got non-object method token");
-          }
+      const mVar = op.cvp.methodsVar(op.singletonClass(base), lNameArg.type === "symbol" ? lNameArg.value.slice(1) : lNameArg.value);
+      op.addForAllTokensConstraint(methodArg, TokenListener.NATIVE_KERNEL_DEFINE_SINGLETON_METHOD, { t: base, s: mVar.name }, (mt) => {
+        if (mt instanceof ObjectToken) {
+          if (mt instanceof MethodToken)
+            op.solver.addForAllTokensConstraint(op.cvp.ancestorsVar(op.singletonClass(mt.receiver)), TokenListener.NATIVE_KERNEL_DEFINE_SINGLETON_METHOD_METHOD, { t: base, s: mVar.name }, (t15) => {
+              if (t15 instanceof ObjectToken) {
+                if (!t15.isClassLikeToken())
+                  assert5.fail(`Expected class or module token, got ${t15}`);
+                op.solver.addSubsetConstraint(op.cvp.methodsVar(t15, mt.methodName), mVar);
+              } else
+                t15;
+            });
+          else if (mt.klass === op.state.globalNatives.Proc)
+            op.solver.addForAllTokensConstraint(op.cvp.methodsVar(op.singletonClass(mt), "call"), TokenListener.NATIVE_KERNEL_DEFINE_SINGLETON_METHOD_PROC, { t: base, s: mVar.name }, (ft) => {
+              if (ft instanceof FunctionToken) {
+                assert5(ft.kind !== "method");
+                op.solver.addTokenConstraint(ft.toKind("method", op), mVar);
+              } else if (ft instanceof NativeFunctionToken)
+                op.solver.addTokenConstraint(ft, mVar);
+              else
+                ft;
+            });
+          else
+            op.a.warnUnsupported(cd.callNode, "Kernel#define_singleton_method got non-Proc/Method token");
+        } else {
+          mt;
+          op.a.warnUnsupported(cd.callNode, "Kernel#define_singleton_method got non-object method token");
         }
-      );
+      });
     },
     method({ base, op, cd }) {
       const lNameArg = literalArg(op, cd, cd.arguments?.positional?.[0], "Kernel#method");
-      if (!lNameArg) return;
+      if (!lNameArg)
+        return;
       const name = lNameArg.type === "symbol" ? lNameArg.value.slice(1) : lNameArg.value;
-      op.solver.addTokenConstraint(
-        op.tokenFactory.createMethodToken(op.state.globalNatives.Method, base, name),
-        cd.result
-      );
+      op.solver.addTokenConstraint(op.tokenFactory.createMethodToken(op.state.globalNatives.Method, base, name), cd.result);
     },
     instance_variable_get({ base, op, cd }) {
       const lNameArg = literalArg(op, cd, cd.arguments?.positional?.[0], "Kernel#instance_variable_get");
-      if (!lNameArg) return;
+      if (!lNameArg)
+        return;
       const name = lNameArg.type === "symbol" ? lNameArg.value.slice(1) : lNameArg.value;
-      if (name.startsWith("@")) op.solver.addSubsetConstraint(op.cvp.objPropVar(base, name), cd.result);
-      else op.a.warnUnsupported(cd.callNode, "Kernel#instance_variable_get called with invalid ivar name");
+      if (name.startsWith("@"))
+        op.solver.addSubsetConstraint(op.cvp.objPropVar(base, name), cd.result);
+      else
+        op.a.warnUnsupported(cd.callNode, "Kernel#instance_variable_get called with invalid ivar name");
     },
     instance_variable_set({ base, op, cd }) {
       const valueArg = cd.arguments?.positional?.[1];
-      if (!(valueArg instanceof ConstraintVar || valueArg instanceof TokenInterface)) return;
-      if (cd.result) op.inclusionConstraint(valueArg, cd.result);
+      if (!(valueArg instanceof ConstraintVar || valueArg instanceof TokenInterface))
+        return;
+      if (cd.result)
+        op.inclusionConstraint(valueArg, cd.result);
       const lNameArg = literalArg(op, cd, cd.arguments?.positional?.[0], "Kernel#instance_variable_set");
-      if (!lNameArg) return;
+      if (!lNameArg)
+        return;
       const name = lNameArg.type === "symbol" ? lNameArg.value.slice(1) : lNameArg.value;
-      if (name.startsWith("@")) op.inclusionConstraint(valueArg, op.cvp.objPropVar(base, name));
-      else op.a.warnUnsupported(cd.callNode, "Kernel#instance_variable_set called with invalid ivar name");
+      if (name.startsWith("@"))
+        op.inclusionConstraint(valueArg, op.cvp.objPropVar(base, name));
+      else
+        op.a.warnUnsupported(cd.callNode, "Kernel#instance_variable_set called with invalid ivar name");
     }
   },
-  // TODO: Remove this?
   staticMethods: globalKernelMethods
 };
 
-// ../ruby-analyzer/src/natives/models/object.ts
+// ../ruby-analyzer/dist/natives/models/object.js
 var object_default = {
   superclass: "BasicObject",
   includes: ["Kernel"],
   methods: {
-    // TODO: This is actually defined on Kernel
     extend: ({ base, op, cd }) => {
-      if (cd.arguments?.pSplat) op.a.warnUnsupported(cd.callNode, "Object#extend called with splat arguments");
+      if (cd.arguments?.pSplat)
+        op.a.warnUnsupported(cd.callNode, "Object#extend called with splat arguments");
       const av = op.cvp.ancestorsVar(op.singletonClass(base));
       for (const arg of cd.arguments?.positional ?? [])
         if (arg instanceof ConstraintVar || arg instanceof ObjectToken)
-          op.addForAllTokensConstraint(arg, 18 /* NATIVE_OBJECT_EXTEND */, { t: base }, (t15) => {
+          op.addForAllTokensConstraint(arg, TokenListener.NATIVE_OBJECT_EXTEND, { t: base }, (t15) => {
             if (t15 instanceof ObjectToken) {
               if (t15.klass === op.state.globalNatives.Module)
                 op.solver.addSubsetConstraint(op.cvp.ancestorsVar(t15), av);
-            } else t15;
+            } else
+              t15;
           });
-        else arg;
+        else
+          arg;
     }
   }
 };
 
-// ../ruby-analyzer/src/natives/models/singleton.ts
+// ../ruby-analyzer/dist/natives/models/singleton.js
 var singleton_default = {
   Singleton: {
     staticMethods: {
       included({ op, cd }) {
         const klass = cd.arguments?.positional?.[0];
-        if (!(klass instanceof ConstraintVar || klass instanceof TokenInterface)) return;
+        if (!(klass instanceof ConstraintVar || klass instanceof TokenInterface))
+          return;
         op.callMethod(klass, "extend", {
           ...cd,
           arguments: {
@@ -23054,7 +22995,7 @@ var singleton_default = {
   }
 };
 
-// ../ruby-analyzer/src/natives/ruby-model.ts
+// ../ruby-analyzer/dist/natives/ruby-model.js
 var rubyModel = {
   name: "Ruby",
   modules: {
@@ -23081,7 +23022,8 @@ var rubyModel = {
           }))(p);
           if (it) {
             op.solver.addTokenConstraint(it, cd.result);
-            if (!isNative) op.state.classInstantiations.push([base.allocSite, cd.callNode, cd.caller]);
+            if (!isNative)
+              op.state.classInstantiations.push([base.allocSite, cd.callNode, cd.caller]);
             op.callMethod(it, "initialize", {
               ...cd,
               result: void 0
@@ -23094,32 +23036,25 @@ var rubyModel = {
     Module: module_default,
     Object: object_default,
     BasicObject: basic_object_default,
-    // Proc objects are modelled by sticking a FunctionToken into the "call" method
-    // of the Proc instance's singleton class.
     Proc: {
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
       newInstance: () => {
       },
       staticMethods: {
         new: ({ op, cd }) => {
-          if (cd.result) op.inclusionConstraint(cd.arguments?.block, cd.result);
+          if (cd.result)
+            op.inclusionConstraint(cd.arguments?.block, cd.result);
         }
       }
     },
-    // We cannot model Method objects as neatly as Proc objects, as we need to pass on the bound
-    // receiver of the Method instead of the Method object itself when the Method is called.
-    // Method objects are modelled by the creation of a MethodToken in Kernel#method.
     Method: {
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
       newInstance() {
       }
-      // TODO: Add a "call" method that passes on the call to the underlying method with the bound receiver
     },
     ...nokogiri_default
   }
 };
 
-// ../ruby-analyzer/src/natives/native-builder.ts
+// ../ruby-analyzer/dist/natives/native-builder.js
 function makeNative(name) {
   return `%${name}`;
 }
@@ -23135,7 +23070,8 @@ function buildNatives(solver, tokenFactory, cvp) {
       if (name === "Class") {
         ct = rubyClassToken;
         assert6.strictEqual(tokenFactory.canonicalizeToken(ct), ct);
-      } else if (objKlass === "Class") ct = tokenFactory.createClassToken(n12);
+      } else if (objKlass === "Class")
+        ct = tokenFactory.createClassToken(n12);
       else {
         objKlass;
         ct = tokenFactory.createInstanceToken(assertDefined(created.Module), n12);
@@ -23145,18 +23081,12 @@ function buildNatives(solver, tokenFactory, cvp) {
       for (const v of [cvp.ancestorsVar(ct), cvp.constantVar(makeConstant(`::${name}`))])
         solver.addTokenConstraint(ct, v);
       for (const [mname, invoke] of "methods" in klass ? Object.entries(klass.methods) : []) {
-        solver.addTokenConstraint(
-          tokenFactory.createNativeFunctionToken(makeNative(`${name}#${mname}`), invoke),
-          cvp.methodsVar(ct, mname)
-        );
+        solver.addTokenConstraint(tokenFactory.createNativeFunctionToken(makeNative(`${name}#${mname}`), invoke), cvp.methodsVar(ct, mname));
       }
       if ("staticMethods" in klass) {
         const sct = tokenFactory.createSingletonClassToken(ct);
         for (const [mname, invoke] of Object.entries(klass.staticMethods))
-          solver.addTokenConstraint(
-            tokenFactory.createNativeFunctionToken(makeNative(`${name}$${mname}`), invoke),
-            cvp.methodsVar(sct, mname)
-          );
+          solver.addTokenConstraint(tokenFactory.createNativeFunctionToken(makeNative(`${name}$${mname}`), invoke), cvp.methodsVar(sct, mname));
       }
     }
   const finished = created;
@@ -23165,10 +23095,7 @@ function buildNatives(solver, tokenFactory, cvp) {
       const ct = finished[name];
       const superCt = finished["superclass" in klass ? klass.superclass : "Object"];
       solver.addSubsetConstraint(cvp.ancestorsVar(superCt), cvp.ancestorsVar(ct));
-      solver.addSubsetConstraint(
-        cvp.ancestorsVar(tokenFactory.createSingletonClassToken(superCt)),
-        cvp.ancestorsVar(tokenFactory.createSingletonClassToken(ct))
-      );
+      solver.addSubsetConstraint(cvp.ancestorsVar(tokenFactory.createSingletonClassToken(superCt)), cvp.ancestorsVar(tokenFactory.createSingletonClassToken(ct)));
     }
   const op = { solver, tokenFactory, cvp };
   for (const [name, klass] of [...t5(rubyModel.modules), ...t5(rubyModel.classes)]) {
@@ -23180,17 +23107,22 @@ function buildNatives(solver, tokenFactory, cvp) {
         solver.addSubsetConstraint(cvp.ancestorsVar(incCt), av);
       }
     }
-    if ("setup" in klass) klass.setup(finished[name], op);
+    if ("setup" in klass)
+      klass.setup(finished[name], op);
   }
   return finished;
 }
 
-// ../ruby-analyzer/src/operations.ts
+// ../ruby-analyzer/dist/operations.js
 import assert7 from "node:assert";
 import fs2 from "node:fs";
 import { basename, dirname as dirname2, relative } from "node:path";
 var gemDirRegex = /^(?<name>[\w-_]+)-(?<version>\d+[^-]*)/;
 var Operations = class {
+  solver;
+  state;
+  constraintVarProducer;
+  tokenFactory;
   constructor(solver, state, constraintVarProducer, tokenFactory) {
     this.solver = solver;
     this.state = state;
@@ -23217,52 +23149,39 @@ var Operations = class {
     const { solver, cvp } = this;
     const onAncestorToken = (baseToken, klass) => {
       if (logger.isDebugEnabled())
-        logger.debug(
-          `Processing call to method '${methodName}' on ancestor ${klass} of base token ${baseToken} at ${nodeLocationToString(cd.callNode)}`
-        );
-      solver.addForAllTokensConstraint(
-        cvp.methodsVar(klass, methodName),
-        0 /* Call */,
-        { n: cd.callNode, s: methodName, t: baseToken },
-        (t15) => handleCall.call(this, cd, baseToken, t15)
-      );
+        logger.debug(`Processing call to method '${methodName}' on ancestor ${klass} of base token ${baseToken} at ${nodeLocationToString(cd.callNode)}`);
+      solver.addForAllTokensConstraint(cvp.methodsVar(klass, methodName), TokenListener.Call, { n: cd.callNode, s: methodName, t: baseToken }, (t15) => handleCall.call(this, cd, baseToken, t15));
     };
     const onBaseToken = (baseToken) => {
       if (logger.isDebugEnabled())
-        logger.debug(
-          `Processing call to method '${methodName}' on base token ${baseToken} at ${nodeLocationToString(cd.callNode)}`
-        );
-      solver.addForAllTokensConstraint(
-        cvp.ancestorsVar(this.singletonClass(baseToken)),
-        4 /* CALL_ANCESTORS */,
-        { n: cd.callNode, s: methodName, t: baseToken },
-        (t15) => {
-          if (t15 instanceof ObjectToken) {
-            if (!t15.isClassLikeToken()) assert7.fail(`Expected class or module token, got ${t15}`);
-            onAncestorToken(baseToken, t15);
-          } else {
-            t15;
-            logger.error(`Unexpected token type in call ancestors: ${t15} at ${nodeLocationToString(cd.callNode)}`);
-          }
+        logger.debug(`Processing call to method '${methodName}' on base token ${baseToken} at ${nodeLocationToString(cd.callNode)}`);
+      solver.addForAllTokensConstraint(cvp.ancestorsVar(this.singletonClass(baseToken)), TokenListener.CALL_ANCESTORS, { n: cd.callNode, s: methodName, t: baseToken }, (t15) => {
+        if (t15 instanceof ObjectToken) {
+          if (!t15.isClassLikeToken())
+            assert7.fail(`Expected class or module token, got ${t15}`);
+          onAncestorToken(baseToken, t15);
+        } else {
+          t15;
+          logger.error(`Unexpected token type in call ancestors: ${t15} at ${nodeLocationToString(cd.callNode)}`);
         }
-      );
+      });
     };
     if (receiver instanceof ConstraintVar)
-      solver.addForAllTokensConstraint(
-        receiver,
-        3 /* CALL_BASE */,
-        { n: cd.callNode, s: methodName },
-        (baseToken) => {
-          if (baseToken instanceof ObjectToken) onBaseToken(baseToken);
-          else baseToken;
-        }
-      );
-    else onBaseToken(receiver);
+      solver.addForAllTokensConstraint(receiver, TokenListener.CALL_BASE, { n: cd.callNode, s: methodName }, (baseToken) => {
+        if (baseToken instanceof ObjectToken)
+          onBaseToken(baseToken);
+        else
+          baseToken;
+      });
+    else
+      onBaseToken(receiver);
     function handleCall(cd2, base, t15) {
       if (logger.isVerboseEnabled())
         logger.verbose(`Call to ${base}.${methodName} at ${nodeLocationToString(cd2.callNode)} resolved to ${t15}`);
-      if (t15 instanceof FunctionToken) this.dispatchCall(t15, base, cd2);
-      else if (t15 instanceof NativeFunctionToken) t15.invoke({ base, op: this, cd: cd2 });
+      if (t15 instanceof FunctionToken)
+        this.dispatchCall(t15, base, cd2);
+      else if (t15 instanceof NativeFunctionToken)
+        t15.invoke({ base, op: this, cd: cd2 });
       else {
         t15;
         logger.error(`Unexpected token type in call: ${t15} at ${nodeLocationToString(cd2.callNode)}`);
@@ -23271,12 +23190,7 @@ var Operations = class {
   }
   dispatchCall(t15, base, cd) {
     const { cvp, solver, a } = this;
-    solver.callGraph.addEdge(
-      cd.callNode,
-      cd.caller,
-      assertDefined(a.functionInfos.get(t15.fun))
-      // kind
-    );
+    solver.callGraph.addEdge(cd.callNode, cd.caller, assertDefined(a.functionInfos.get(t15.fun)));
     const args = cd.arguments;
     if (args) {
       const params = t15.parameters?.namedChildren ?? [];
@@ -23284,9 +23198,11 @@ var Operations = class {
         if ((arg instanceof ConstraintVar || arg instanceof TokenInterface) && params[i])
           this.inclusionConstraint(arg, cvp.nodeVar(params[i]));
       }
-      if (args.block) this.inclusionConstraint(args.block, cvp.blockParamVar(t15.fun));
+      if (args.block)
+        this.inclusionConstraint(args.block, cvp.blockParamVar(t15.fun));
     }
-    if (t15.kind === "method") solver.addTokenConstraint(base, cvp.selfVar(t15.fun));
+    if (t15.kind === "method")
+      solver.addTokenConstraint(base, cvp.selfVar(t15.fun));
     else {
       t15.kind;
       solver.addSubsetConstraint(cvp.selfVar(t15.scope), cvp.selfVar(t15.fun));
@@ -23295,14 +23211,20 @@ var Operations = class {
     solver.addSubsetConstraint(cvp.returnVar(t15.fun), cd.result);
   }
   inclusionConstraint(from, to) {
-    if (from === void 0) return;
-    if (from instanceof ConstraintVar) this.solver.addSubsetConstraint(from, to);
-    else this.solver.addTokenConstraint(from, to);
+    if (from === void 0)
+      return;
+    if (from instanceof ConstraintVar)
+      this.solver.addSubsetConstraint(from, to);
+    else
+      this.solver.addTokenConstraint(from, to);
   }
   addForAllTokensConstraint(v, key, opts, listener) {
-    if (v === void 0) return;
-    if (v instanceof ConstraintVar) this.solver.addForAllTokensConstraint(v, key, opts, listener);
-    else listener(v);
+    if (v === void 0)
+      return;
+    if (v instanceof ConstraintVar)
+      this.solver.addForAllTokensConstraint(v, key, opts, listener);
+    else
+      listener(v);
   }
   evalArg(arg, fallback) {
     if (isStringNode(arg)) {
@@ -23314,57 +23236,51 @@ var Operations = class {
       return { type: "symbol", value: s };
     } else if (isBareSymbolNode(arg) || isDelimitedSymbolNode(arg))
       this.a.warnUnsupported(arg, `${arg.type} arguments in calls`);
-    else if (isMethodNode(arg) || isSingletonMethodNode(arg)) return { type: "symbol", value: `:${arg.nameNode.text}` };
-    else return fallback?.();
-  }
-  getContainingGem = cache(
-    (dirPath, isEntry) => {
-      const dirName = basename(dirPath);
-      const entries = fs2.readdirSync(dirPath, { withFileTypes: true });
-      const entry = entries.find(
-        (entry2) => entry2.isFile() && (entry2.name === "Rakefile" || entry2.name.endsWith(".gemspec")) || // TODO: Check if the directory is on the load path?
-        entry2.isDirectory() && entry2.name === "lib"
-      );
-      if (entry) {
-        let name;
-        let version;
-        const match2 = gemDirRegex.exec(dirName);
-        if (match2) ({ name, version } = match2.groups);
-        else {
-          const e5 = entry.name.endsWith(".gemspec") ? entry : entries.find((e6) => e6.name.endsWith(".gemspec"));
-          name = e5?.name.replace(/\.gemspec$/, "");
-        }
-        if (name !== void 0) return new PackageInfo(name, version, relative(this.a.rootDir, dirPath), isEntry);
-      }
-      const parent = dirname2(dirPath);
-      if (parent === dirPath || dirPath === this.a.rootDir)
-        return new PackageInfo(
-          "<main>",
-          void 0,
-          parent === dirPath ? "" : relative(this.a.rootDir, dirPath),
-          isEntry
-        );
-      return this.getContainingGem(parent, isEntry);
+    else if (isMethodNode(arg) || isSingletonMethodNode(arg))
+      return { type: "symbol", value: `:${arg.nameNode.text}` };
+    else
+      return fallback?.();
+  }
+  getContainingGem = cache((dirPath, isEntry) => {
+    const dirName = basename(dirPath);
+    const entries = fs2.readdirSync(dirPath, { withFileTypes: true });
+    const entry = entries.find((entry2) => entry2.isFile() && (entry2.name === "Rakefile" || entry2.name.endsWith(".gemspec")) || entry2.isDirectory() && entry2.name === "lib");
+    if (entry) {
+      let name;
+      let version;
+      const match2 = gemDirRegex.exec(dirName);
+      if (match2)
+        ({ name, version } = match2.groups);
+      else {
+        const e5 = entry.name.endsWith(".gemspec") ? entry : entries.find((e6) => e6.name.endsWith(".gemspec"));
+        name = e5?.name.replace(/\.gemspec$/, "");
+      }
+      if (name !== void 0)
+        return new PackageInfo(name, version, relative(this.a.rootDir, dirPath), isEntry);
     }
-  );
+    const parent = dirname2(dirPath);
+    if (parent === dirPath || dirPath === this.a.rootDir)
+      return new PackageInfo("<main>", void 0, parent === dirPath ? "" : relative(this.a.rootDir, dirPath), isEntry);
+    return this.getContainingGem(parent, isEntry);
+  });
 };
 
-// ../ruby-analyzer/src/parser.ts
+// ../ruby-analyzer/dist/parser.js
 import Parser from "tree-sitter";
 import Ruby from "tree-sitter-ruby";
 var parser = new Parser();
 parser.setLanguage(Ruby);
 
-// ../ruby-analyzer/src/ruby-ast-visitor.ts
+// ../ruby-analyzer/dist/ruby-ast-visitor.js
 import assert8 from "node:assert";
 
-// ../ruby-analyzer/src/ruby-vulnerabilities.ts
+// ../ruby-analyzer/dist/ruby-vulnerabilities.js
 var reFQN = /^(?:(?:<<\w*|\w+)(?:::(?:<<\w*|\w+))*)?#(?:(?:\w+|\?)\.)?[^\t\n .]+$/;
 function validateVulnerabilityID(id) {
   return reFQN.test(id);
 }
 
-// ../ruby-analyzer/src/types/ruby-ast-helper-types.ts
+// ../ruby-analyzer/dist/types/ruby-ast-helper-types.js
 var functionTypes = ["method", "singleton_method", "block", "do_block"];
 var functionTypeSet = new Set(functionTypes);
 function isFunctionNode(node) {
@@ -23373,20 +23289,23 @@ function isFunctionNode(node) {
 var scopeTypes = [...functionTypes, "class", "singleton_class", "module", "program"];
 var scopeTypeSet = new Set(scopeTypes);
 
-// ../ruby-analyzer/src/ruby-ast-visitor.ts
+// ../ruby-analyzer/dist/ruby-ast-visitor.js
 function isFullyQualifiedConstant(s) {
   return s.startsWith("::");
 }
 var RubyAstVisitor = class {
+  op;
+  moduleInfo;
+  bindings;
+  done = false;
+  constantNesting = [];
+  scopes = [];
+  handledConstants = new NodeSet();
   constructor(op, moduleInfo, bindings) {
     this.op = op;
     this.moduleInfo = moduleInfo;
     this.bindings = bindings;
   }
-  done = false;
-  constantNesting = [];
-  scopes = [];
-  handledConstants = new NodeSet();
   getSurroundingScope() {
     return assertDefined(this.scopes.at(-1));
   }
@@ -23398,20 +23317,17 @@ var RubyAstVisitor = class {
     const i = nesting.findLastIndex((c) => c.startsWith("::"));
     return i === -1 ? makeConstant(`::${nesting.join("::")}`) : makeConstant(nesting.slice(i).join("::"));
   }
-  /* Helper to set up constraints for constants and scope resolution nodes. */
   expVar(n12) {
     assert8(!this.done, "expVar called after visitor is done");
-    const {
-      op: { solver, cvp },
-      constantNesting,
-      handledConstants
-    } = this;
-    if (isIdentifierNode(n12)) return cvp.identVar(n12, this.bindings);
+    const { op: { solver, cvp }, constantNesting, handledConstants } = this;
+    if (isIdentifierNode(n12))
+      return cvp.identVar(n12, this.bindings);
     else if (isScopeResolutionNode(n12) || isConstantNode(n12)) {
       const nvar = cvp.nodeVar(n12);
       if (!handledConstants.has(n12)) {
         const c = n12.text;
-        if (isFullyQualifiedConstant(c)) solver.addSubsetConstraint(cvp.constantVar(makeConstant(c)), nvar);
+        if (isFullyQualifiedConstant(c))
+          solver.addSubsetConstraint(cvp.constantVar(makeConstant(c)), nvar);
         else {
           for (let i = 0; i <= constantNesting.length; i++) {
             const fq = this.fqConstant([...constantNesting.slice(0, i), c]);
@@ -23421,42 +23337,31 @@ var RubyAstVisitor = class {
             const classOrModule = assertDefined(this.scopes.findLast((s) => isClassNode(s) || isModuleNode(s)));
             assert8.strictEqual(classOrModule.nameNode.text, constantNesting.at(-1));
             const ct = this.classOrModuleToken(this.fqConstant(), classOrModule);
-            solver.addForAllTokensConstraint(
-              cvp.ancestorsVar(ct),
-              8 /* CONSTANTS_ANCESTORS */,
-              { n: n12 },
-              (t15) => {
-                if (t15 instanceof ObjectToken) {
-                  if (!t15.isClassOrModuleToken()) assert8.fail(`Expected class or module token, got ${t15}`);
-                  const fq = makeConstant(`${t15.allocSite}::${c}`);
-                  solver.addSubsetConstraint(cvp.constantVar(fq), nvar);
-                } else t15;
-              }
-            );
+            solver.addForAllTokensConstraint(cvp.ancestorsVar(ct), TokenListener.CONSTANTS_ANCESTORS, { n: n12 }, (t15) => {
+              if (t15 instanceof ObjectToken) {
+                if (!t15.isClassOrModuleToken())
+                  assert8.fail(`Expected class or module token, got ${t15}`);
+                const fq = makeConstant(`${t15.allocSite}::${c}`);
+                solver.addSubsetConstraint(cvp.constantVar(fq), nvar);
+              } else
+                t15;
+            });
           }
         }
         handledConstants.add(n12);
       }
       return nvar;
-    } else if (isSelfNode(n12)) return cvp.selfVar(this.getSurroundingScope());
-    else if (isParenthesizedStatementsNode(n12)) return n12.lastNamedChild ? this.expVar(n12.lastNamedChild) : void 0;
-    else if (isIfModifierNode(n12) || isUnlessModifierNode(n12)) return this.expVar(n12.bodyNode);
+    } else if (isSelfNode(n12))
+      return cvp.selfVar(this.getSurroundingScope());
+    else if (isParenthesizedStatementsNode(n12))
+      return n12.lastNamedChild ? this.expVar(n12.lastNamedChild) : void 0;
+    else if (isIfModifierNode(n12) || isUnlessModifierNode(n12))
+      return this.expVar(n12.bodyNode);
     return cvp.nodeVar(n12);
   }
   *program(node) {
-    const {
-      op: {
-        solver,
-        cvp,
-        tokenFactory,
-        state: { globalNatives }
-      },
-      scopes
-    } = this;
-    solver.addTokenConstraint(
-      tokenFactory.createInstanceToken(globalNatives.Object, makeNative("main")),
-      cvp.selfVar(node)
-    );
+    const { op: { solver, cvp, tokenFactory, state: { globalNatives } }, scopes } = this;
+    solver.addTokenConstraint(tokenFactory.createInstanceToken(globalNatives.Object, makeNative("main")), cvp.selfVar(node));
     solver.addTokenConstraint(globalNatives.Object, cvp.defaultDefineeVar(node));
     scopes.push(node);
     yield* node.namedChildren;
@@ -23490,14 +23395,8 @@ var RubyAstVisitor = class {
     this.handleCall(node, this.op.cvp.blockParamVar(meth), "call", this.parseArgumentList(node.firstNamedChild));
   }
   call(node) {
-    const methodName = node.methodNode?.text ?? // E.() is syntactic sugar for E.call()
-    (assert8.strictEqual(node.operatorNode?.text, "."), "call");
-    this.handleCall(
-      node,
-      node.receiverNode ? assertDefined(this.expVar(node.receiverNode)) : this.op.cvp.selfVar(this.getSurroundingScope()),
-      methodName,
-      this.parseArgumentList(node.argumentsNode, this.blockToProc(node))
-    );
+    const methodName = node.methodNode?.text ?? (assert8.strictEqual(node.operatorNode?.text, "."), "call");
+    this.handleCall(node, node.receiverNode ? assertDefined(this.expVar(node.receiverNode)) : this.op.cvp.selfVar(this.getSurroundingScope()), methodName, this.parseArgumentList(node.argumentsNode, this.blockToProc(node)));
   }
   blockToProc(node) {
     const { op } = this;
@@ -23505,7 +23404,8 @@ var RubyAstVisitor = class {
     let blockNode;
     let kind = "proc";
     if (isCallNode(node)) {
-      if (!node.blockNode) return;
+      if (!node.blockNode)
+        return;
       blockNode = node.blockNode;
     } else {
       node.type;
@@ -23515,10 +23415,7 @@ var RubyAstVisitor = class {
     }
     const procToken = op.tokenFactory.createInstanceToken(op.state.globalNatives.Proc, node);
     const sct = op.tokenFactory.createSingletonClassToken(procToken);
-    op.solver.addTokenConstraint(
-      op.tokenFactory.createFunctionToken(blockNode, kind, this.getSurroundingScope(), parametersNode),
-      op.cvp.methodsVar(sct, "call")
-    );
+    op.solver.addTokenConstraint(op.tokenFactory.createFunctionToken(blockNode, kind, this.getSurroundingScope(), parametersNode), op.cvp.methodsVar(sct, "call"));
     return procToken;
   }
   handleCall(node, receiver, methodName, args) {
@@ -23544,31 +23441,33 @@ var RubyAstVisitor = class {
     this.registerFunctionInfo(name, node);
     const scopeDefinee = cvp.defaultDefineeVar(scope);
     solver.addSubsetEdge(scopeDefinee, cvp.defaultDefineeVar(node));
-    solver.addForAllTokensConstraint(
-      // TODO: Warn if definee var is empty
-      node.type === "method" ? scopeDefinee : this.expVar(node.objectNode),
-      1 /* Method */,
-      { n: node },
-      (t15) => {
-        if (t15 instanceof ObjectToken) {
-          if (node.type === "singleton_method") t15 = op.singletonClass(t15);
-          if (t15.isClassLikeToken()) solver.addTokenConstraint(functionToken, cvp.methodsVar(t15, name));
-          else logger.error(`Unexpected class of default definee: ${t15.klass} for method ${name}`);
-        } else t15;
-      }
-    );
-    if (node.type === "singleton_method") yield node.objectNode;
+    solver.addForAllTokensConstraint(node.type === "method" ? scopeDefinee : this.expVar(node.objectNode), TokenListener.Method, { n: node }, (t15) => {
+      if (t15 instanceof ObjectToken) {
+        if (node.type === "singleton_method")
+          t15 = op.singletonClass(t15);
+        if (t15.isClassLikeToken())
+          solver.addTokenConstraint(functionToken, cvp.methodsVar(t15, name));
+        else
+          logger.error(`Unexpected class of default definee: ${t15.klass} for method ${name}`);
+      } else
+        t15;
+    });
+    if (node.type === "singleton_method")
+      yield node.objectNode;
     scopes.push(node);
     this.addLastNodeToReturnVarConstraint(node);
-    if (node.bodyNode) yield node.bodyNode;
-    if (node.parametersNode) yield node.parametersNode;
+    if (node.bodyNode)
+      yield node.bodyNode;
+    if (node.parametersNode)
+      yield node.parametersNode;
     scopes.pop();
   }
   block_parameter(node) {
     const { solver, cvp } = this.op;
     const scope = this.getSurroundingScope();
     assert8(isFunctionNode(scope), "Block parameter not in function scope");
-    if (node.nameNode) solver.addSubsetConstraint(cvp.blockParamVar(scope), cvp.identVar(node.nameNode, this.bindings));
+    if (node.nameNode)
+      solver.addSubsetConstraint(cvp.blockParamVar(scope), cvp.identVar(node.nameNode, this.bindings));
   }
   lambda(node) {
     const { op } = this;
@@ -23597,7 +23496,8 @@ var RubyAstVisitor = class {
   *handleAssignment(node, operator) {
     const { solver, cvp, a } = this.op;
     yield node.rightNode;
-    if (!["=", "&&=", "||="].includes(operator)) return;
+    if (!["=", "&&=", "||="].includes(operator))
+      return;
     const nVar = cvp.nodeVar(node);
     const eVar = this.expVar(node.rightNode);
     const isLogical = operator !== "=";
@@ -23605,15 +23505,18 @@ var RubyAstVisitor = class {
     if (isIdentifierNode(node.leftNode)) {
       const lVar = cvp.identVar(node.leftNode, this.bindings);
       solver.addSubsetConstraint(eVar, lVar);
-      if (isLogical) solver.addSubsetConstraint(lVar, nVar);
+      if (isLogical)
+        solver.addSubsetConstraint(lVar, nVar);
     } else if (isInstanceVariableNode(node.leftNode)) {
       const selfVar = cvp.selfVar(this.getSurroundingScope());
-      solver.addForAllTokensConstraint(selfVar, 10 /* ASSIGN_INSTANCE_VAR */, { n: node }, (t15) => {
+      solver.addForAllTokensConstraint(selfVar, TokenListener.ASSIGN_INSTANCE_VAR, { n: node }, (t15) => {
         if (t15 instanceof ObjectToken) {
           const oVar = cvp.objPropVar(t15, node.leftNode.text);
           solver.addSubsetConstraint(eVar, oVar);
-          if (isLogical) solver.addSubsetConstraint(oVar, nVar);
-        } else t15;
+          if (isLogical)
+            solver.addSubsetConstraint(oVar, nVar);
+        } else
+          t15;
       });
     } else if (isCallNode(node.leftNode)) {
       const call = node.leftNode;
@@ -23634,7 +23537,6 @@ var RubyAstVisitor = class {
         callNode: node,
         arguments: { positional: [eVar] },
         result: void 0
-        // the result of an assignment is the value assigned, not the result of the setter method
       });
     } else if (isConstantNode(node.leftNode) || isScopeResolutionNode(node.leftNode)) {
       checkConstant(node.leftNode.text);
@@ -23642,15 +23544,18 @@ var RubyAstVisitor = class {
       solver.addSubsetConstraint(eVar, cvp.constantVar(name));
       if (isLogical)
         solver.addSubsetConstraint(this.expVar(node.leftNode), nVar);
-    } else a.warnUnsupported(node, `${node.leftNode.type} left-hand side in assignment`);
+    } else
+      a.warnUnsupported(node, `${node.leftNode.type} left-hand side in assignment`);
   }
   instance_variable(node) {
     const { solver, cvp } = this.op;
     const selfVar = cvp.selfVar(this.getSurroundingScope());
     const resVar = cvp.nodeVar(node);
-    solver.addForAllTokensConstraint(selfVar, 9 /* READ_INSTANCE_VAR */, { n: node }, (t15) => {
-      if (t15 instanceof ObjectToken) solver.addSubsetConstraint(cvp.objPropVar(t15, node.text), resVar);
-      else t15;
+    solver.addForAllTokensConstraint(selfVar, TokenListener.READ_INSTANCE_VAR, { n: node }, (t15) => {
+      if (t15 instanceof ObjectToken)
+        solver.addSubsetConstraint(cvp.objPropVar(t15, node.text), resVar);
+      else
+        t15;
     });
   }
   class_variable(node) {
@@ -23661,16 +23566,20 @@ var RubyAstVisitor = class {
   }
   return(node) {
     const { solver, cvp } = this.op;
-    if (node.namedChildCount === 0) return;
+    if (node.namedChildCount === 0)
+      return;
     const argumentsListOfReturnNode = node.firstNamedChild;
     const valueToReturnNode = assertDefined(argumentsListOfReturnNode.firstNamedChild);
     const resultVar = this.expVar(valueToReturnNode);
     const enclosingFunction = this.scopes.findLast((n12) => {
-      if (isMethodNode(n12) || isSingletonMethodNode(n12)) return true;
+      if (isMethodNode(n12) || isSingletonMethodNode(n12))
+        return true;
       return (isBlockNode(n12) || isDoBlockNode(n12)) && isLambdaNode(n12.parent) && n12.parent.bodyNode.id === n12.id;
     });
-    if (enclosingFunction) solver.addSubsetConstraint(resultVar, cvp.returnVar(enclosingFunction));
-    else logger.warn(`Return at ${nodeLocationToString(node)} not enclosed in a function`);
+    if (enclosingFunction)
+      solver.addSubsetConstraint(resultVar, cvp.returnVar(enclosingFunction));
+    else
+      logger.warn(`Return at ${nodeLocationToString(node)} not enclosed in a function`);
   }
   module(node) {
     return this.handleClassOrModule(node);
@@ -23679,16 +23588,7 @@ var RubyAstVisitor = class {
     return this.handleClassOrModule(node);
   }
   *handleClassOrModule(node) {
-    const {
-      op: {
-        solver,
-        cvp,
-        state: { globalNatives, constantsToNodes },
-        tokenFactory
-      },
-      scopes,
-      constantNesting
-    } = this;
+    const { op: { solver, cvp, state: { globalNatives, constantsToNodes }, tokenFactory }, scopes, constantNesting } = this;
     const n12 = node.nameNode.text;
     checkConstant(n12);
     constantNesting.push(n12);
@@ -23706,20 +23606,17 @@ var RubyAstVisitor = class {
         const sctAv = cvp.ancestorsVar(tokenFactory.createSingletonClassToken(ct));
         constantNesting.pop();
         assert8.strictEqual(node.superclassNode.namedChildCount, 1);
-        solver.addForAllTokensConstraint(
-          this.expVar(node.superclassNode.firstNamedChild),
-          5 /* SUPERCLASSES */,
-          { n: node },
-          (t15) => {
-            if (t15 instanceof ClassToken) {
-              solver.addSubsetConstraint(cvp.ancestorsVar(t15), av);
-              solver.addSubsetConstraint(cvp.ancestorsVar(tokenFactory.createSingletonClassToken(t15)), sctAv);
-            } else t15;
-          }
-        );
+        solver.addForAllTokensConstraint(this.expVar(node.superclassNode.firstNamedChild), TokenListener.SUPERCLASSES, { n: node }, (t15) => {
+          if (t15 instanceof ClassToken) {
+            solver.addSubsetConstraint(cvp.ancestorsVar(t15), av);
+            solver.addSubsetConstraint(cvp.ancestorsVar(tokenFactory.createSingletonClassToken(t15)), sctAv);
+          } else
+            t15;
+        });
         yield node.superclassNode;
         constantNesting.push(n12);
-      } else solver.addSubsetConstraint(cvp.ancestorsVar(globalNatives.Object), av);
+      } else
+        solver.addSubsetConstraint(cvp.ancestorsVar(globalNatives.Object), av);
       this.op.callMethod(av, "inherited", {
         callNode: node,
         caller: this.caller(node),
@@ -23735,23 +23632,17 @@ var RubyAstVisitor = class {
     constantNesting.pop();
   }
   *singleton_class(node) {
-    const {
-      op: { solver, cvp },
-      scopes
-    } = this;
+    const { op: { solver, cvp }, scopes } = this;
     const defaultDefineeVar = cvp.defaultDefineeVar(node);
     const selfVar = cvp.selfVar(node);
-    solver.addForAllTokensConstraint(
-      this.expVar(node.valueNode),
-      7 /* SINGLETON_CLASS */,
-      { n: node },
-      (t15) => {
-        if (t15 instanceof ObjectToken) {
-          const sct = this.op.singletonClass(t15);
-          for (const v of [defaultDefineeVar, selfVar]) solver.addTokenConstraint(sct, v);
-        } else t15;
-      }
-    );
+    solver.addForAllTokensConstraint(this.expVar(node.valueNode), TokenListener.SINGLETON_CLASS, { n: node }, (t15) => {
+      if (t15 instanceof ObjectToken) {
+        const sct = this.op.singletonClass(t15);
+        for (const v of [defaultDefineeVar, selfVar])
+          solver.addTokenConstraint(sct, v);
+      } else
+        t15;
+    });
     yield node.valueNode;
     if (node.bodyNode) {
       scopes.push(node);
@@ -23762,7 +23653,8 @@ var RubyAstVisitor = class {
   rescue_modifier(node) {
     const { cvp, solver } = this.op;
     const nVar = cvp.nodeVar(node);
-    for (const n12 of [node.bodyNode, node.handlerNode]) solver.addSubsetConstraint(this.expVar(n12), nVar);
+    for (const n12 of [node.bodyNode, node.handlerNode])
+      solver.addSubsetConstraint(this.expVar(n12), nVar);
   }
   alias(node) {
     this.op.a.warnUnsupported(node, "alias");
@@ -23784,15 +23676,16 @@ var RubyAstVisitor = class {
   if(node) {
     const nVar = this.op.cvp.nodeVar(node);
     for (const n12 of [node.consequenceNode, node.alternativeNode])
-      if (n12) this.op.solver.addSubsetConstraint(this.expVar(n12), nVar);
+      if (n12)
+        this.op.solver.addSubsetConstraint(this.expVar(n12), nVar);
   }
   elsif(node) {
     this.if(node);
   }
-  // eslint-disable-next-line unicorn/no-thenable
   then(node) {
     const val = node.lastNamedChild;
-    if (val) this.op.solver.addSubsetConstraint(this.expVar(val), this.op.cvp.nodeVar(node));
+    if (val)
+      this.op.solver.addSubsetConstraint(this.expVar(val), this.op.cvp.nodeVar(node));
   }
   else(node) {
     this.then(node);
@@ -23800,12 +23693,14 @@ var RubyAstVisitor = class {
   addLastNodeToReturnVarConstraint(node) {
     const { solver, cvp } = this.op;
     const lastNode = getLastNodeInFunction(node);
-    if (!lastNode) return;
+    if (!lastNode)
+      return;
     solver.addSubsetConstraint(this.expVar(lastNode), cvp.returnVar(node));
   }
   caller(node) {
     const enclosingFunction = this.scopes.findLast((node2) => isFunctionNode(node2));
-    if (!enclosingFunction) return this.moduleInfo;
+    if (!enclosingFunction)
+      return this.moduleInfo;
     const caller = this.op.a.functionInfos.get(enclosingFunction);
     if (!caller)
       throw new Error(`Missing function info for ${nodeToString(enclosingFunction)} at ${nodeToString(node)}`);
@@ -23819,7 +23714,8 @@ var RubyAstVisitor = class {
     const { a, state } = this.op;
     const info = new FunctionInfo(name, node, this.caller(node), this.moduleInfo);
     a.functionInfos.set(node, info);
-    if (isBlockNode(node) || isDoBlockNode(node)) return;
+    if (isBlockNode(node) || isDoBlockNode(node))
+      return;
     const scopes = [];
     for (let i = this.scopes.length - 1; i >= 0; i--) {
       const s = this.scopes[i];
@@ -23830,39 +23726,46 @@ var RubyAstVisitor = class {
           name2 = name2.slice(2);
           i = 0;
         }
-      } else if (isSingletonClassNode(s)) name2 = `<<${fqNodeText(s.valueNode) ?? ""}`;
-      if (name2) scopes.push(name2);
+      } else if (isSingletonClassNode(s))
+        name2 = `<<${fqNodeText(s.valueNode) ?? ""}`;
+      if (name2)
+        scopes.push(name2);
     }
     let fqName = name;
-    if (isClassNode(node)) fqName = "<constructor>";
-    else if (isSingletonMethodNode(node)) fqName = `${fqNodeText(node.objectNode) ?? "?"}.${node.nameNode.text}`;
-    else fqName = node.nameNode.text;
+    if (isClassNode(node))
+      fqName = "<constructor>";
+    else if (isSingletonMethodNode(node))
+      fqName = `${fqNodeText(node.objectNode) ?? "?"}.${node.nameNode.text}`;
+    else
+      fqName = node.nameNode.text;
     state.fullyQualifiedNames.set(info, fqName = `${scopes.reverse().join("::")}#${fqName}`);
     if (!validateVulnerabilityID(fqName))
       assert8.fail(`Invalid fully qualified name for vulnerability matching: ${fqName}`);
   }
 };
 function fqNodeText(n12) {
-  if (isIdentifierNode(n12) || isConstantNode(n12) || isScopeResolutionNode(n12) || isSelfNode(n12)) return n12.text;
+  if (isIdentifierNode(n12) || isConstantNode(n12) || isScopeResolutionNode(n12) || isSelfNode(n12))
+    return n12.text;
 }
 
-// ../ruby-analyzer/src/ruby-state.ts
+// ../ruby-analyzer/dist/ruby-state.js
 var RubyState = class {
+  globalNatives;
+  loadPath;
+  constantsToNodes = /* @__PURE__ */ new Map();
+  classInstantiations = new Array();
+  fullyQualifiedNames = /* @__PURE__ */ new Map();
   constructor(globalNatives, loadPath) {
     this.globalNatives = globalNatives;
     this.loadPath = loadPath;
   }
-  // Maps class constants to the syntax nodes where they are defined.
-  // (Classes and modules can be defined and re-opened in multiple places, e.g. in different files.)
-  constantsToNodes = /* @__PURE__ */ new Map();
-  // Keeps track of instantiations of classes.
-  // Used to add call edges after the analysis is done.
-  classInstantiations = new Array();
-  fullyQualifiedNames = /* @__PURE__ */ new Map();
 };
 
-// ../ruby-analyzer/src/ruby-analyzer.ts
+// ../ruby-analyzer/dist/ruby-analyzer.js
 var RubyAnalyzer = class {
+  solver;
+  state;
+  op;
   constructor(solver, loadPath) {
     this.solver = solver;
     const constraintVarProducer = new ConstraintVarProducer();
@@ -23870,34 +23773,29 @@ var RubyAnalyzer = class {
     this.state = new RubyState(buildNatives(solver, tokenFactory, constraintVarProducer), loadPath);
     this.op = new Operations(solver, this.state, constraintVarProducer, tokenFactory);
   }
-  state;
-  op;
   async findFilesToAnalyze() {
     const { rootDir } = this.solver.globalState;
     const vendorDir = resolve2(rootDir, "vendor");
-    return (await findFiles(
-      rootDir,
-      async (file) => {
-        if (basename2(file) === "config.ru" || file.endsWith(".rb")) return true;
-        if (/\bbin\/[^./]+$/.test(file)) {
-          const head = Buffer.concat(await Array.fromAsync(createReadStream(file, { start: 0, end: 127 }))).toString(
-            "utf8"
-          );
-          return /^#!.*\bruby\b/.test(head);
-        }
-        return false;
-      },
-      (dir) => dir !== vendorDir
-    )).map((file) => [this.op.getContainingGem(dirname3(file), true), file]);
+    return (await findFiles(rootDir, async (file) => {
+      if (basename2(file) === "config.ru" || file.endsWith(".rb"))
+        return true;
+      if (/\bbin\/[^./]+$/.test(file)) {
+        const head = Buffer.concat(await Array.fromAsync(createReadStream(file, { start: 0, end: 127 }))).toString("utf8");
+        return /^#!.*\bruby\b/.test(head);
+      }
+      return false;
+    }, (dir) => dir !== vendorDir)).map((file) => [this.op.getContainingGem(dirname3(file), true), file]);
   }
   async parse(filePath) {
     const tree = parser.parse(await readFile(filePath, "utf8"));
     if (tree.rootNode.isError) {
       if (/<%.*%>/s.test(tree.rootNode.text))
         logger.warn(`File '${filePath}' appears to be an ERB template. Skipping analysis.`);
-      else logger.error(`Failed to parse Ruby file '${filePath}'!`);
+      else
+        logger.error(`Failed to parse Ruby file '${filePath}'!`);
       return;
-    } else if (tree.rootNode.hasError) logger.warn(`Parsed Ruby file '${filePath}' with syntax errors!`);
+    } else if (tree.rootNode.hasError)
+      logger.warn(`Parsed Ruby file '${filePath}' with syntax errors!`);
     return tree;
   }
   visit(moduleInfo, tree) {
@@ -23913,7 +23811,9 @@ var RubyAnalyzer = class {
   patch() {
     const { functionInfos } = this.op.a;
     const calledFunctions = new Set(this.solver.callGraph.functionToFunction.values().flatMap((f) => f.values()));
-    for (const moduleInfo of this.op.a.moduleInfos.values()) if (moduleInfo.isEntry) calledFunctions.add(moduleInfo);
+    for (const moduleInfo of this.op.a.moduleInfos.values())
+      if (moduleInfo.isEntry)
+        calledFunctions.add(moduleInfo);
     const patched = /* @__PURE__ */ new Set();
     for (const t15 of this.op.a.allTokens())
       if (t15 instanceof FunctionToken && t15.kind !== "method" && (isBlockNode(t15.fun) || isDoBlockNode(t15.fun))) {
@@ -23939,7 +23839,8 @@ var RubyAnalyzer = class {
     const vs = this.solver.globalState.options.vulnerabilities;
     assert9(vs?.length);
     const vulnTargets = new Map(vs.map((v) => [v, []]));
-    for (const [fun, fqn] of this.state.fullyQualifiedNames) vulnTargets.get(fqn)?.push(fun);
+    for (const [fun, fqn] of this.state.fullyQualifiedNames)
+      vulnTargets.get(fqn)?.push(fun);
     return vulnTargets;
   }
 };
@@ -23949,15 +23850,20 @@ function scopeAnalysis(tree) {
   analyzeScope(tree.rootNode);
   return bindings;
   function analyzeScope(node, scope = {}) {
-    if (!node) return;
+    if (!node)
+      return;
     if (isLambdaNode(node) || isBlockNode(node) || isDoBlockNode(node)) {
       scope = { ...scope };
       bindParameters(node.parametersNode, scope);
     } else if (isMethodNode(node) || isSingletonMethodNode(node) || isClassNode(node) || isSingletonClassNode(node) || isModuleNode(node)) {
-      if (isSingletonMethodNode(node)) analyzeScope(node.objectNode, scope);
-      else if (isSingletonClassNode(node)) analyzeScope(node.valueNode, scope);
-      else if (isClassNode(node)) analyzeScope(node.superclassNode, scope);
-      if ("nameNode" in node) analyzeScope(node.nameNode, scope);
+      if (isSingletonMethodNode(node))
+        analyzeScope(node.objectNode, scope);
+      else if (isSingletonClassNode(node))
+        analyzeScope(node.valueNode, scope);
+      else if (isClassNode(node))
+        analyzeScope(node.superclassNode, scope);
+      if ("nameNode" in node)
+        analyzeScope(node.nameNode, scope);
       const newScope = {};
       if ("parametersNode" in node) {
         bindParameters(node.parametersNode, newScope);
@@ -23970,7 +23876,8 @@ function scopeAnalysis(tree) {
         if (isIdentifierNode(node2))
           scope[node2.text] ??= node2;
         else if (isLeftAssignmentListNode(node2) || isRestAssignmentNode(node2) || isDestructuredLeftAssignmentNode(node2))
-          for (const child of node2.namedChildren) aux(child);
+          for (const child of node2.namedChildren)
+            aux(child);
       };
       aux(node.leftNode);
     } else if (isRescueNode(node) && node.variableNode) {
@@ -23993,34 +23900,37 @@ function scopeAnalysis(tree) {
       scope[node.nameNode.text] ??= node.nameNode;
     else if (isIdentifierNode(node)) {
       const dnode = scope[node.text];
-      if (dnode) bindings.set(node, dnode);
+      if (dnode)
+        bindings.set(node, dnode);
     }
-    for (const child of node.namedChildren) analyzeScope(child, scope);
+    for (const child of node.namedChildren)
+      analyzeScope(child, scope);
   }
   function bindParameters(parameters, newScope) {
-    if (!parameters) return;
+    if (!parameters)
+      return;
     for (const param of parameters.namedChildren) {
       let id;
-      if (isIdentifierNode(param)) id = param;
-      else if (isOptionalParameterNode(param)) id = param.nameNode;
-      else if (isKeywordParameterNode(param)) id = param.nameNode;
-      else if (isBlockParameterNode(param)) id = param.nameNode;
-      else if (isDestructuredParameterNode(param)) bindParameters(param, newScope);
-      if (id) newScope[id.text] = id;
+      if (isIdentifierNode(param))
+        id = param;
+      else if (isOptionalParameterNode(param))
+        id = param.nameNode;
+      else if (isKeywordParameterNode(param))
+        id = param.nameNode;
+      else if (isBlockParameterNode(param))
+        id = param.nameNode;
+      else if (isDestructuredParameterNode(param))
+        bindParameters(param, newScope);
+      if (id)
+        newScope[id.text] = id;
     }
   }
 }
 
-// ../analysis-engine/src/solver.ts
+// ../analysis-engine/dist/solver.js
 import assert10 from "node:assert";
 var Solver = class {
-  constructor(globalState) {
-    this.globalState = globalState;
-    this.diagnostics = globalState.diagnostics;
-  }
-  /**
-   * Map from listener ID to listener key. Only used for checking hash collisions on listeners.
-   */
+  globalState;
   listeners = /* @__PURE__ */ new Map();
   callGraph = new CallGraph();
   listenersProcessed = /* @__PURE__ */ new Map();
@@ -24028,19 +23938,17 @@ var Solver = class {
   diagnostics;
   nodesWithNewEdges = /* @__PURE__ */ new Set();
   postponedListenersProcessed = 0;
-  /**
-   * Adds a single token constraint.
-   */
+  constructor(globalState) {
+    this.globalState = globalState;
+    this.diagnostics = globalState.diagnostics;
+  }
   addTokenConstraint(t15, to) {
-    if (to === void 0) return;
+    if (to === void 0)
+      return;
     if (logger.isDebugEnabled())
       logger.debug(`Adding constraint ${t15} \u2208 ${to}`);
     this.addToken(t15, to);
   }
-  /**
-   * Adds a single token if not already present.
-   * Also enqueues notification of listeners and registers object properties and array entries from the constraint variable.
-   */
   addToken(t15, toRep) {
     const state = this.globalState;
     if (state.addToken(t15, toRep)) {
@@ -24050,80 +23958,69 @@ var Solver = class {
     }
     return false;
   }
-  /**
-   * Adds a set of tokens if not already present.
-   * Also adds to worklist and notifies listeners.
-   */
   addTokens(ts, to) {
     const state = this.globalState;
     state.vars.add(to);
     if (ts instanceof TokenInterface) {
-      if (state.addToken(ts, to)) this.tokenAdded(to, ts);
+      if (state.addToken(ts, to))
+        this.tokenAdded(to, ts);
     } else {
       let ws;
-      for (const t15 of state.addTokens(ts, to)) ws = this.tokenAdded(to, t15, ws);
+      for (const t15 of state.addTokens(ts, to))
+        ws = this.tokenAdded(to, t15, ws);
     }
   }
   tokenAdded(toRep, t15, ws) {
     ws ??= this.varsToUnprocessedTokens.get(toRep);
     ws = pushArraySingle(this.varsToUnprocessedTokens, toRep, t15, ws);
     this.diagnostics.unprocessedTokensSize++;
-    if (this.diagnostics.unprocessedTokensSize % 100 === 0) this.printDiagnostics();
+    if (this.diagnostics.unprocessedTokensSize % 100 === 0)
+      this.printDiagnostics();
     return ws;
   }
-  /**
-   * Adds a universally quantified constraint for a constraint variable.
-   * The listener key must uniquely determine the function (including its free variables).
-   */
   addForAllTokensConstraint(v, key, opts, listener) {
-    if (v === void 0) return;
+    if (v === void 0)
+      return;
     const lkey = { l: key, ...opts };
     if (logger.isDebugEnabled())
-      logger.debug(
-        `Adding universally quantified constraint to ${v}: [${t5(t6(lkey, { n: nodeLocationToString, l: (l) => this.listenerName(l) })).map(([k, v2]) => `${k}: ${v2}`).join(", ")}]}`
-      );
+      logger.debug(`Adding universally quantified constraint to ${v}: [${t5(t6(lkey, { n: nodeLocationToString, l: (l) => this.listenerName(l) })).map(([k, v2]) => `${k}: ${v2}`).join(", ")}]}`);
     this.addForAllTokensConstraintPrivate(v, this.getListenerID(lkey), listener);
   }
   addForAllTokensConstraintPrivate(v, id, listener) {
     const m = mapGetMap(this.globalState.tokenListeners, v);
     if (!m.has(id)) {
-      for (const t15 of this.globalState.getTokens(v)) this.callTokenListener(id, listener, t15);
+      for (const t15 of this.globalState.getTokens(v))
+        this.callTokenListener(id, listener, t15);
       m.set(id, listener);
       this.globalState.vars.add(v);
       return true;
     }
     return false;
   }
-  /**
-   * Enqueues a call to a token listener if it hasn't been done before.
-   */
   callTokenListener(id, listener, t15, now = false) {
     const s = mapGetSet(this.listenersProcessed, id);
     if (setAdd(s, t15)) {
-      if (now) listener(t15);
+      if (now)
+        listener(t15);
       else {
         this.enqueueListenerCall([listener, t15]);
         this.diagnostics.tokenListenerNotifications++;
       }
     }
   }
-  /**
-   * Enqueues a listener call consisting of a listener and its argument(s).
-   */
   enqueueListenerCall(la) {
     this.globalState.postponedListenerCalls.push(la);
   }
-  /**
-   * Provides a unique'ish ID for the given ListenerKey.
-   */
   getListenerID(key) {
     let id = 0n;
     if (key.t) {
       assert10(key.t.hash !== void 0);
       id += BigInt(key.t.hash);
     }
-    if (key.n) id += BigInt(strHash(nodeLocationToString(key.n)));
-    if (key.s) id ^= BigInt(strHash(key.s));
+    if (key.n)
+      id += BigInt(strHash(nodeLocationToString(key.n)));
+    if (key.s)
+      id ^= BigInt(strHash(key.s));
     id = id << 16n | BigInt(key.l);
     this.checkListenerIDCollision(id, key);
     return id;
@@ -24134,14 +24031,14 @@ var Solver = class {
       if (x.l !== key.l || !nodeEq(x.n, key.n) || x.t !== key.t || x.s !== key.s) {
         throw new Error("Hash collision in getListenerID");
       }
-    } else this.listeners.set(id, key);
+    } else
+      this.listeners.set(id, key);
   }
-  /**
-   * Adds a subset constraint.
-   */
   addSubsetConstraint(from, to) {
-    if (from === void 0 || to === void 0) return;
-    if (logger.isDebugEnabled()) logger.debug(`Adding constraint ${from} \u2286 ${to}`);
+    if (from === void 0 || to === void 0)
+      return;
+    if (logger.isDebugEnabled())
+      logger.debug(`Adding constraint ${from} \u2286 ${to}`);
     this.addSubsetEdge(from, to);
   }
   addSubsetEdge(from, to) {
@@ -24156,9 +24053,7 @@ var Solver = class {
         const [size, ts] = state.getTokensSize(from);
         if (size > 0) {
           if (logger.isDebugEnabled())
-            logger.debug(
-              `Worklist size: ${this.diagnostics.unprocessedTokensSize}, propagating ${size} token${size === 1 ? "" : "s"} from ${from}`
-            );
+            logger.debug(`Worklist size: ${this.diagnostics.unprocessedTokensSize}, propagating ${size} token${size === 1 ? "" : "s"} from ${from}`);
           this.addTokens(ts, to);
           this.incrementPropagations();
         }
@@ -24166,23 +24061,6 @@ var Solver = class {
       }
     }
   }
-  /**
-   * Adds an object property and notifies listeners.
-  addObjectProperty(objVar: CV, prop: string) {
-    const state = this.globalState;
-    const ps = mapGetSet(state.objectProperties, objVar);
-    if (!ps.has(prop)) {
-      if (logger.isDebugEnabled()) logger.debug(`Adding object property ${objVar}.${prop}`);
-      ps.add(prop);
-      const ts = state.objectPropertyListeners.get(objVar);
-      if (ts)
-        for (const listener of ts.values()) {
-          this.enqueueListenerCall([listener, prop]);
-          this.diagnostics.objectPropertiesListenerNotifications++;
-        }
-    }
-  }
-   */
   incrementPropagations() {
     this.diagnostics.propagations++;
     if (this.diagnostics.propagations % 100 === 0) {
@@ -24192,17 +24070,13 @@ var Solver = class {
   }
   printDiagnostics() {
   }
-  // eslint-disable-line @typescript-eslint/no-empty-function
-  /**
-   * Processes all items in the worklist until a fixpoint is reached.
-   * This notifies listeners and propagates tokens along subset edges.
-   */
   async propagate() {
     const timer = new Timer();
     const { globalState: state, diagnostics: d } = this;
     while (this.varsToUnprocessedTokens.size > 0 || this.nodesWithNewEdges.size > 0) {
       this.nodesWithNewEdges.clear();
-      for (const v of this.varsToUnprocessedTokens.keys()) this.processTokens(v);
+      for (const v of this.varsToUnprocessedTokens.keys())
+        this.processTokens(v);
       if (state.postponedListenerCalls.length > 0) {
         if (logger.isVerboseEnabled())
           logger.verbose(`Processing listener calls: ${state.postponedListenerCalls.length}`);
@@ -24221,31 +24095,31 @@ var Solver = class {
     }
     d.timings.propagation += timer.elapsed();
   }
-  /**
-   * Processes the items in the token worklist for the given constraint variable.
-   */
   processTokens(v) {
     const ts = this.varsToUnprocessedTokens.get(v);
     if (ts !== void 0) {
       this.varsToUnprocessedTokens.delete(v);
       const size = Array.isArray(ts) ? ts.length : 1;
       if (logger.isDebugEnabled())
-        logger.debug(
-          `Worklist size: ${this.diagnostics.unprocessedTokensSize}, propagating ${size} token${size === 1 ? "" : "s"} from ${v}`
-        );
+        logger.debug(`Worklist size: ${this.diagnostics.unprocessedTokensSize}, propagating ${size} token${size === 1 ? "" : "s"} from ${v}`);
       this.diagnostics.unprocessedTokensSize -= size;
       const state = this.globalState;
       assert10(state.vars.has(v));
       const s = state.subsetEdges.get(v);
       if (s) {
-        for (const to of s) this.addTokens(Array.isArray(ts) ? ts : [ts], to);
+        for (const to of s)
+          this.addTokens(Array.isArray(ts) ? ts : [ts], to);
         this.incrementPropagations();
       }
       const tr = state.tokenListeners.get(v);
       if (tr)
         if (Array.isArray(ts))
-          for (const t15 of ts) for (const [id, listener] of tr) this.callTokenListener(id, listener, t15);
-        else for (const [id, listener] of tr) this.callTokenListener(id, listener, ts);
+          for (const t15 of ts)
+            for (const [id, listener] of tr)
+              this.callTokenListener(id, listener, t15);
+        else
+          for (const [id, listener] of tr)
+            this.callTokenListener(id, listener, ts);
     }
   }
   listenersProcessedByTokenListener() {
@@ -24258,7 +24132,7 @@ var Solver = class {
   }
 };
 
-// ../ruby-analyzer/src/types/ruby-solver.ts
+// ../ruby-analyzer/dist/types/ruby-solver.js
 var RubySolver = class extends Solver {
   listenerName(l) {
     return TokenListener[l];
@@ -24269,11 +24143,11 @@ var RubySolver = class extends Solver {
 import assert12 from "node:assert";
 import { resolve as resolve3 } from "node:path";
 
-// ../analysis-engine/src/global-state.ts
+// ../analysis-engine/dist/global-state.js
 import assert11 from "node:assert";
 import { join as join3, relative as relative2 } from "node:path";
 
-// ../analysis-engine/src/diagnostics.ts
+// ../analysis-engine/dist/diagnostics.js
 import { inspect } from "node:util";
 var AnalysisDiagnostics = class {
   timedOut = false;
@@ -24284,37 +24158,25 @@ var AnalysisDiagnostics = class {
   listenerNotificationRounds = 0;
   objectPropertiesListenerNotifications = 0;
   timings = {
-    ...t7(
-      [
-        "listenerCall",
-        "preAnalysis",
-        "parsing",
-        "constraintSetup",
-        "propagation",
-        "vulnAnalysis",
-        "vulnPaths"
-      ],
-      () => 0n
-    ),
+    ...t7([
+      "listenerCall",
+      "preAnalysis",
+      "parsing",
+      "constraintSetup",
+      "propagation",
+      "vulnAnalysis",
+      "vulnPaths"
+    ], () => 0n),
     [inspect.custom](_depth, options, f) {
       return f(t9(this, nanoToMs), options);
     }
   };
 };
 
-// ../analysis-engine/src/global-state.ts
+// ../analysis-engine/dist/global-state.js
 var GlobalState = class _GlobalState {
-  // readonly objectProperties = new Map<CV, Set<string>>();
-  //
-  // objectPropertyListeners = new Map<CV, Map<ListenerID, (prop: string) => void>>();
-  constructor(rootDir, options) {
-    this.rootDir = rootDir;
-    this.options = options;
-    this.timeoutTimer = new Timer(options.timeout);
-  }
-  /**
-   * Map from absolute paths to ModuleInfo.
-   */
+  rootDir;
+  options;
   moduleInfos = /* @__PURE__ */ new Map();
   packageInfos = /* @__PURE__ */ new Set();
   _moduleWorklist = new Queue();
@@ -24322,7 +24184,6 @@ var GlobalState = class _GlobalState {
   functionInfos = new NodeMap();
   diagnostics = new AnalysisDiagnostics();
   warningsUnsupported = new NodeMap();
-  // TODO: Move these fields to the solver?
   vars = /* @__PURE__ */ new Set();
   tokens = /* @__PURE__ */ new Map();
   tokenListeners = /* @__PURE__ */ new Map();
@@ -24331,16 +24192,19 @@ var GlobalState = class _GlobalState {
   reverseSubsetEdges = /* @__PURE__ */ new Map();
   numberOfSubsetEdges = 0;
   static EMPTY_TOKENS_SIZE = [0, []];
-  /**
-   * Timeout timer.
-   */
   timeoutTimer;
   postponedListenerCalls = [];
+  constructor(rootDir, options) {
+    this.rootDir = rootDir;
+    this.options = options;
+    this.timeoutTimer = new Timer(options.timeout);
+  }
   discoverFile(packageInfo, filePath, isEntry = false) {
     let moduleInfo = this.moduleInfos.get(filePath);
     if (moduleInfo) {
       assert11.strictEqual(packageInfo, moduleInfo.packageInfo);
-      if (isEntry) assert11(moduleInfo.isEntry);
+      if (isEntry)
+        assert11(moduleInfo.isEntry);
       return [moduleInfo, false];
     }
     moduleInfo = new ModuleInfo(relative2(join3(this.rootDir, packageInfo.dir), filePath), packageInfo, isEntry, true);
@@ -24356,70 +24220,58 @@ var GlobalState = class _GlobalState {
     if (setAdd(warnings, message) && logger.isWarnEnabled())
       logger.warn(`Unsupported: ${message} at ${nodeToString(node)}`);
   }
-  /**
-   * Returns the tokens in the solution for the given constraint variable
-   * (or empty if v is undefined).
-   */
   getTokens(v) {
     if (v) {
       const ts = this.tokens.get(v);
       if (ts) {
-        if (ts instanceof TokenInterface) return [ts];
+        if (ts instanceof TokenInterface)
+          return [ts];
         return ts;
       }
     }
     return [];
   }
-  /**
-   * Returns a generator over all tokens in the solution.
-   */
   *allTokens() {
     for (const ts of this.tokens.values()) {
-      if (ts instanceof TokenInterface) yield ts;
-      else yield* ts;
+      if (ts instanceof TokenInterface)
+        yield ts;
+      else
+        yield* ts;
     }
   }
-  /**
-   * Returns the number of tokens in the solution for the given constraint variable, and the tokens.
-   */
   getTokensSize(v) {
     if (v) {
       const ts = this.tokens.get(v);
       if (ts) {
-        if (ts instanceof TokenInterface) return [1, [ts]];
+        if (ts instanceof TokenInterface)
+          return [1, [ts]];
         return [ts.size, ts];
       }
     }
     return _GlobalState.EMPTY_TOKENS_SIZE;
   }
-  /**
-   * Checks whether a constraint variable has a token.
-   */
   hasToken(v, t15) {
     const ts = this.tokens.get(v);
-    if (!ts) return false;
-    else if (ts instanceof TokenInterface) return ts === t15;
-    else return ts.has(t15);
-  }
-  /**
-   * Adds the given token to the solution for the given constraint variable.
-   * @return true if not already there, false if already there
-   */
+    if (!ts)
+      return false;
+    else if (ts instanceof TokenInterface)
+      return ts === t15;
+    else
+      return ts.has(t15);
+  }
   addToken(t15, v) {
     const ts = this.tokens.get(v);
-    if (!ts) this.tokens.set(v, t15);
+    if (!ts)
+      this.tokens.set(v, t15);
     else if (ts instanceof TokenInterface) {
-      if (ts === t15) return false;
+      if (ts === t15)
+        return false;
       this.tokens.set(v, /* @__PURE__ */ new Set([ts, t15]));
-    } else if (!setAdd(ts, t15)) return false;
+    } else if (!setAdd(ts, t15))
+      return false;
     this.numberOfTokens++;
     return true;
   }
-  /**
-   * Adds the given tokens to the solution for the given constraint variable.
-   * It is assumed that the given set does not contain any duplicates.
-   * @return the tokens that have been added, excluding those already there
-   */
   addTokens(ts, v) {
     const added = [];
     let vs = this.tokens.get(v);
@@ -24435,49 +24287,46 @@ var GlobalState = class _GlobalState {
           this.tokens.set(v, vs);
           add = true;
         }
-      } else add = setAdd(vs, t15);
-      if (add) added.push(t15);
+      } else
+        add = setAdd(vs, t15);
+      if (add)
+        added.push(t15);
     }
     this.numberOfTokens += added.length;
     return added;
   }
 };
 
-// ../analysis-engine/src/vulnerabilities.ts
+// ../analysis-engine/dist/vulnerabilities.js
 function analyzeVulnerabilities(d, callGraph, targets) {
   const timer = new Timer();
-  const parents = callGraph.reachableFunctions(
-    callGraph.functionToFunction.keys().filter((f) => f.isEntry).toArray()
-  );
+  const parents = callGraph.reachableFunctions(callGraph.functionToFunction.keys().filter((f) => f.isEntry).toArray());
   d.timings.vulnAnalysis = timer.elapsed();
   timer.reset();
-  const results = Object.fromEntries(
-    targets.entries().map(([vuln, funcs]) => {
-      if (!funcs.length) return [vuln, { reachable: false, reason: "Function not found" }];
-      const reachableFuncs = funcs.filter((f) => parents.has(f));
-      if (!reachableFuncs.length)
-        return [vuln, { reachable: false, reason: "Function not reachable from application code" }];
-      return [
-        vuln,
-        {
-          reachable: true,
-          // TODO: More sophisticated call path generation
-          // TODO: Nodes should correspond to calls, not to functions
-          stacks: reachableFuncs.map((f) => {
-            const stack = [];
-            for (; f; f = parents.get(f))
-              stack.push({
-                package: f.packageInfo.toString(),
-                caller: f,
-                sourceLocation: f.loc,
-                confidence: 1
-              });
-            return stack.reverse();
-          })
-        }
-      ];
-    })
-  );
+  const results = Object.fromEntries(targets.entries().map(([vuln, funcs]) => {
+    if (!funcs.length)
+      return [vuln, { reachable: false, reason: "Function not found" }];
+    const reachableFuncs = funcs.filter((f) => parents.has(f));
+    if (!reachableFuncs.length)
+      return [vuln, { reachable: false, reason: "Function not reachable from application code" }];
+    return [
+      vuln,
+      {
+        reachable: true,
+        stacks: reachableFuncs.map((f) => {
+          const stack = [];
+          for (; f; f = parents.get(f))
+            stack.push({
+              package: f.packageInfo.toString(),
+              caller: f,
+              sourceLocation: f.loc,
+              confidence: 1
+            });
+          return stack.reverse();
+        })
+      }
+    ];
+  }));
   d.timings.vulnPaths += timer.elapsed();
   return results;
 }
@@ -24619,7 +24468,7 @@ ${inspect2(globalState.diagnostics, { depth: Infinity })}`);
 import assert14 from "node:assert";
 import fs3 from "node:fs/promises";
 
-// ../utils/src/graph.ts
+// ../utils/dist/graph.js
 function transitiveClosure(adj, ...initial) {
   const result = new Set(initial);
   while (initial.length) {