dslop 1.6.1 → 1.7.1

package/dist/index.cjs

@@ -29710,11 +29710,11 @@ var require_visitors = __commonJS({
       }
       visitor._verified = true;
     }
-    function validateVisitorMethods(path5, val) {
+    function validateVisitorMethods(path6, val) {
       const fns = [].concat(val);
       for (const fn of fns) {
         if (typeof fn !== "function") {
-          throw new TypeError(`Non-function found defined in ${path5} with type ${typeof fn}`);
+          throw new TypeError(`Non-function found defined in ${path6} with type ${typeof fn}`);
         }
       }
     }
@@ -29759,8 +29759,8 @@ var require_visitors = __commonJS({
         fns = fns.map(function(fn) {
           let newFn = fn;
           if (state) {
-            newFn = function(path5) {
-              fn.call(state, path5, state);
+            newFn = function(path6) {
+              fn.call(state, path6, state);
             };
           }
           if (wrapper) {
@@ -29793,8 +29793,8 @@ var require_visitors = __commonJS({
     function wrapCheck(nodeType, fn) {
       const fnKey = `is${nodeType}`;
       const validator = virtualTypesValidators[fnKey];
-      const newFn = function(path5) {
-        if (validator.call(path5)) {
+      const newFn = function(path6) {
+        if (validator.call(path6)) {
           return fn.apply(this, arguments);
         }
       };
@@ -29821,24 +29821,24 @@ var require_visitors = __commonJS({
       }
     }
     var _environmentVisitor = {
-      FunctionParent(path5) {
-        if (path5.isArrowFunctionExpression()) return;
-        path5.skip();
-        if (path5.isMethod()) {
-          if (!path5.requeueComputedKeyAndDecorators) {
-            _context.requeueComputedKeyAndDecorators.call(path5);
+      FunctionParent(path6) {
+        if (path6.isArrowFunctionExpression()) return;
+        path6.skip();
+        if (path6.isMethod()) {
+          if (!path6.requeueComputedKeyAndDecorators) {
+            _context.requeueComputedKeyAndDecorators.call(path6);
           } else {
-            path5.requeueComputedKeyAndDecorators();
+            path6.requeueComputedKeyAndDecorators();
           }
         }
       },
-      Property(path5) {
-        if (path5.isObjectProperty()) return;
-        path5.skip();
-        if (!path5.requeueComputedKeyAndDecorators) {
-          _context.requeueComputedKeyAndDecorators.call(path5);
+      Property(path6) {
+        if (path6.isObjectProperty()) return;
+        path6.skip();
+        if (!path6.requeueComputedKeyAndDecorators) {
+          _context.requeueComputedKeyAndDecorators.call(path6);
         } else {
-          path5.requeueComputedKeyAndDecorators();
+          path6.requeueComputedKeyAndDecorators();
         }
       }
     };
@@ -29872,14 +29872,14 @@ var require_renamer = __commonJS({
           node.name = state.newName;
         }
       },
-      Scope(path5, state) {
-        if (!path5.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
-          path5.skip();
-          if (path5.isMethod()) {
-            if (!path5.requeueComputedKeyAndDecorators) {
-              _context.requeueComputedKeyAndDecorators.call(path5);
+      Scope(path6, state) {
+        if (!path6.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
+          path6.skip();
+          if (path6.isMethod()) {
+            if (!path6.requeueComputedKeyAndDecorators) {
+              _context.requeueComputedKeyAndDecorators.call(path6);
             } else {
-              path5.requeueComputedKeyAndDecorators();
+              path6.requeueComputedKeyAndDecorators();
             }
           }
         }
@@ -29899,9 +29899,9 @@ var require_renamer = __commonJS({
           }
         }
       },
-      "AssignmentExpression|Declaration|VariableDeclarator"(path5, state) {
-        if (path5.isVariableDeclaration()) return;
-        const ids = path5.isAssignmentExpression() ? getAssignmentIdentifiers(path5.node) : path5.getOuterBindingIdentifiers();
+      "AssignmentExpression|Declaration|VariableDeclarator"(path6, state) {
+        if (path6.isVariableDeclaration()) return;
+        const ids = path6.isAssignmentExpression() ? getAssignmentIdentifiers(path6.node) : path6.getOuterBindingIdentifiers();
         for (const name in ids) {
           if (name === state.oldName) ids[name].name = state.newName;
         }
@@ -29931,11 +29931,11 @@ var require_renamer = __commonJS({
         }
         maybeExportDeclar.splitExportDeclaration();
       }
-      maybeConvertFromClassFunctionDeclaration(path5) {
-        return path5;
+      maybeConvertFromClassFunctionDeclaration(path6) {
+        return path6;
       }
-      maybeConvertFromClassFunctionExpression(path5) {
-        return path5;
+      maybeConvertFromClassFunctionExpression(path6) {
+        return path6;
       }
       rename() {
         const {
@@ -29945,9 +29945,9 @@ var require_renamer = __commonJS({
         } = this;
         const {
           scope,
-          path: path5
+          path: path6
         } = binding;
-        const parentDeclar = path5.find((path6) => path6.isDeclaration() || path6.isFunctionExpression() || path6.isClassExpression());
+        const parentDeclar = path6.find((path7) => path7.isDeclaration() || path7.isFunctionExpression() || path7.isClassExpression());
         if (parentDeclar) {
           const bindingIds = parentDeclar.getOuterBindingIdentifiers();
           if (bindingIds[oldName] === binding.identifier) {
@@ -29973,8 +29973,8 @@ var require_renamer = __commonJS({
           this.binding.identifier.name = newName;
         }
         if (parentDeclar) {
-          this.maybeConvertFromClassFunctionDeclaration(path5);
-          this.maybeConvertFromClassFunctionExpression(path5);
+          this.maybeConvertFromClassFunctionDeclaration(path6);
+          this.maybeConvertFromClassFunctionExpression(path6);
         }
       }
     };
@@ -29997,17 +29997,17 @@ var require_traverseForScope = __commonJS({
     var {
       VISITOR_KEYS
     } = _t;
-    function traverseForScope(path5, visitors, state) {
+    function traverseForScope(path6, visitors, state) {
       const exploded = (0, _visitors.explode)(visitors);
       if (exploded.enter || exploded.exit) {
         throw new Error("Should not be used with enter/exit visitors.");
       }
-      _traverse2(path5.parentPath, path5.parent, path5.node, path5.container, path5.key, path5.listKey, path5.hub, path5);
+      _traverse2(path6.parentPath, path6.parent, path6.node, path6.container, path6.key, path6.listKey, path6.hub, path6);
       function _traverse2(parentPath, parent, node, container, key, listKey, hub, inPath) {
         if (!node) {
           return;
         }
-        const path6 = inPath || _index.NodePath.get({
+        const path7 = inPath || _index.NodePath.get({
           hub,
           parentPath,
           parent,
@@ -30015,21 +30015,21 @@ var require_traverseForScope = __commonJS({
           listKey,
           key
         });
-        _context.setScope.call(path6);
+        _context.setScope.call(path7);
         const visitor = exploded[node.type];
         if (visitor) {
           if (visitor.enter) {
             for (const visit of visitor.enter) {
-              visit.call(state, path6, state);
+              visit.call(state, path7, state);
             }
           }
           if (visitor.exit) {
             for (const visit of visitor.exit) {
-              visit.call(state, path6, state);
+              visit.call(state, path7, state);
             }
           }
         }
-        if (path6.shouldSkip) {
+        if (path7.shouldSkip) {
           return;
         }
         const keys = VISITOR_KEYS[node.type];
@@ -30042,10 +30042,10 @@ var require_traverseForScope = __commonJS({
           if (Array.isArray(prop)) {
             for (let i = 0; i < prop.length; i++) {
               const value = prop[i];
-              _traverse2(path6, node, value, prop, i, key2);
+              _traverse2(path7, node, value, prop, i, key2);
             }
           } else {
-            _traverse2(path6, node, prop, node, key2, null);
+            _traverse2(path7, node, prop, node, key2, null);
           }
         }
       }
@@ -30065,7 +30065,7 @@ var require_binding = __commonJS({
       constructor({
         identifier,
         scope,
-        path: path5,
+        path: path6,
         kind
       }) {
         this.identifier = void 0;
@@ -30079,10 +30079,10 @@ var require_binding = __commonJS({
         this.references = 0;
         this.identifier = identifier;
         this.scope = scope;
-        this.path = path5;
+        this.path = path6;
         this.kind = kind;
-        if ((kind === "var" || kind === "hoisted") && isInitInLoop(path5)) {
-          this.reassign(path5);
+        if ((kind === "var" || kind === "hoisted") && isInitInLoop(path6)) {
+          this.reassign(path6);
         }
         this.clearValue();
       }
@@ -30100,20 +30100,20 @@ var require_binding = __commonJS({
         this.hasValue = false;
         this.value = null;
       }
-      reassign(path5) {
+      reassign(path6) {
         this.constant = false;
-        if (this.constantViolations.includes(path5)) {
+        if (this.constantViolations.includes(path6)) {
           return;
         }
-        this.constantViolations.push(path5);
+        this.constantViolations.push(path6);
       }
-      reference(path5) {
-        if (this.referencePaths.includes(path5)) {
+      reference(path6) {
+        if (this.referencePaths.includes(path6)) {
           return;
         }
         this.referenced = true;
         this.references++;
-        this.referencePaths.push(path5);
+        this.referencePaths.push(path6);
       }
       dereference() {
         this.references--;
@@ -30121,12 +30121,12 @@ var require_binding = __commonJS({
       }
     };
     exports2.default = Binding;
-    function isInitInLoop(path5) {
-      const isFunctionDeclarationOrHasInit = !path5.isVariableDeclarator() || path5.node.init;
+    function isInitInLoop(path6) {
+      const isFunctionDeclarationOrHasInit = !path6.isVariableDeclarator() || path6.node.init;
       for (let {
         parentPath,
         key
-      } = path5; parentPath; {
+      } = path6; parentPath; {
         parentPath,
         key
       } = parentPath) {
@@ -30165,11 +30165,11 @@ var require_cache = __commonJS({
     function clearScope() {
       exports2.scope = scope = /* @__PURE__ */ new WeakMap();
     }
-    function getCachedPaths(path5) {
+    function getCachedPaths(path6) {
       const {
         parent,
         parentPath
-      } = path5;
+      } = path6;
       return pathsCache.get(parent);
     }
     function getOrCreateCachedPaths(node, parentPath) {
@@ -30450,131 +30450,131 @@ var require_scope = __commonJS({
       scope.bindings = /* @__PURE__ */ Object.create(null);
       scope.globals = /* @__PURE__ */ Object.create(null);
     }
-    function isAnonymousFunctionExpression(path5) {
-      return path5.isFunctionExpression() && !path5.node.id || path5.isArrowFunctionExpression();
+    function isAnonymousFunctionExpression(path6) {
+      return path6.isFunctionExpression() && !path6.node.id || path6.isArrowFunctionExpression();
     }
     {
       NOT_LOCAL_BINDING = /* @__PURE__ */ Symbol.for("should not be considered a local binding");
     }
     var NOT_LOCAL_BINDING;
     var collectorVisitor = {
-      ForStatement(path5) {
-        const declar = path5.get("init");
+      ForStatement(path6) {
+        const declar = path6.get("init");
         if (declar.isVar()) {
           const {
             scope
-          } = path5;
+          } = path6;
           const parentScope = scope.getFunctionParent() || scope.getProgramParent();
           parentScope.registerBinding("var", declar);
         }
       },
-      Declaration(path5) {
-        if (path5.isBlockScoped()) return;
-        if (path5.isImportDeclaration()) return;
-        if (path5.isExportDeclaration()) return;
-        const parent = path5.scope.getFunctionParent() || path5.scope.getProgramParent();
-        parent.registerDeclaration(path5);
+      Declaration(path6) {
+        if (path6.isBlockScoped()) return;
+        if (path6.isImportDeclaration()) return;
+        if (path6.isExportDeclaration()) return;
+        const parent = path6.scope.getFunctionParent() || path6.scope.getProgramParent();
+        parent.registerDeclaration(path6);
       },
-      ImportDeclaration(path5) {
-        const parent = path5.scope.getBlockParent();
-        parent.registerDeclaration(path5);
+      ImportDeclaration(path6) {
+        const parent = path6.scope.getBlockParent();
+        parent.registerDeclaration(path6);
       },
-      TSImportEqualsDeclaration(path5) {
-        const parent = path5.scope.getBlockParent();
-        parent.registerDeclaration(path5);
+      TSImportEqualsDeclaration(path6) {
+        const parent = path6.scope.getBlockParent();
+        parent.registerDeclaration(path6);
       },
-      ReferencedIdentifier(path5, state) {
-        if (t2.isTSQualifiedName(path5.parent) && path5.parent.right === path5.node) {
+      ReferencedIdentifier(path6, state) {
+        if (t2.isTSQualifiedName(path6.parent) && path6.parent.right === path6.node) {
           return;
         }
-        if (path5.parentPath.isTSImportEqualsDeclaration()) return;
-        state.references.push(path5);
+        if (path6.parentPath.isTSImportEqualsDeclaration()) return;
+        state.references.push(path6);
       },
-      ForXStatement(path5, state) {
-        const left = path5.get("left");
+      ForXStatement(path6, state) {
+        const left = path6.get("left");
         if (left.isPattern() || left.isIdentifier()) {
-          state.constantViolations.push(path5);
+          state.constantViolations.push(path6);
         } else if (left.isVar()) {
           const {
             scope
-          } = path5;
+          } = path6;
           const parentScope = scope.getFunctionParent() || scope.getProgramParent();
           parentScope.registerBinding("var", left);
         }
       },
       ExportDeclaration: {
-        exit(path5) {
+        exit(path6) {
           const {
             node,
             scope
-          } = path5;
+          } = path6;
           if (isExportAllDeclaration(node)) return;
           const declar = node.declaration;
           if (isClassDeclaration2(declar) || isFunctionDeclaration2(declar)) {
             const id = declar.id;
             if (!id) return;
             const binding = scope.getBinding(id.name);
-            binding == null || binding.reference(path5);
+            binding == null || binding.reference(path6);
           } else if (isVariableDeclaration2(declar)) {
             for (const decl of declar.declarations) {
               for (const name of Object.keys(getBindingIdentifiers(decl))) {
                 const binding = scope.getBinding(name);
-                binding == null || binding.reference(path5);
+                binding == null || binding.reference(path6);
               }
             }
           }
         }
       },
-      LabeledStatement(path5) {
-        path5.scope.getBlockParent().registerDeclaration(path5);
+      LabeledStatement(path6) {
+        path6.scope.getBlockParent().registerDeclaration(path6);
       },
-      AssignmentExpression(path5, state) {
-        state.assignments.push(path5);
+      AssignmentExpression(path6, state) {
+        state.assignments.push(path6);
       },
-      UpdateExpression(path5, state) {
-        state.constantViolations.push(path5);
+      UpdateExpression(path6, state) {
+        state.constantViolations.push(path6);
       },
-      UnaryExpression(path5, state) {
-        if (path5.node.operator === "delete") {
-          state.constantViolations.push(path5);
+      UnaryExpression(path6, state) {
+        if (path6.node.operator === "delete") {
+          state.constantViolations.push(path6);
         }
       },
-      BlockScoped(path5) {
-        let scope = path5.scope;
-        if (scope.path === path5) scope = scope.parent;
+      BlockScoped(path6) {
+        let scope = path6.scope;
+        if (scope.path === path6) scope = scope.parent;
         const parent = scope.getBlockParent();
-        parent.registerDeclaration(path5);
-        if (path5.isClassDeclaration() && path5.node.id) {
-          const id = path5.node.id;
+        parent.registerDeclaration(path6);
+        if (path6.isClassDeclaration() && path6.node.id) {
+          const id = path6.node.id;
           const name = id.name;
-          path5.scope.bindings[name] = path5.scope.parent.getBinding(name);
+          path6.scope.bindings[name] = path6.scope.parent.getBinding(name);
         }
       },
-      CatchClause(path5) {
-        path5.scope.registerBinding("let", path5);
+      CatchClause(path6) {
+        path6.scope.registerBinding("let", path6);
       },
-      Function(path5) {
-        const params = path5.get("params");
+      Function(path6) {
+        const params = path6.get("params");
         for (const param of params) {
-          path5.scope.registerBinding("param", param);
+          path6.scope.registerBinding("param", param);
         }
-        if (path5.isFunctionExpression() && path5.node.id && !path5.node.id[NOT_LOCAL_BINDING]) {
-          path5.scope.registerBinding("local", path5.get("id"), path5);
+        if (path6.isFunctionExpression() && path6.node.id && !path6.node.id[NOT_LOCAL_BINDING]) {
+          path6.scope.registerBinding("local", path6.get("id"), path6);
         }
       },
-      ClassExpression(path5) {
-        if (path5.node.id && !path5.node.id[NOT_LOCAL_BINDING]) {
-          path5.scope.registerBinding("local", path5.get("id"), path5);
+      ClassExpression(path6) {
+        if (path6.node.id && !path6.node.id[NOT_LOCAL_BINDING]) {
+          path6.scope.registerBinding("local", path6.get("id"), path6);
         }
       },
-      TSTypeAnnotation(path5) {
-        path5.skip();
+      TSTypeAnnotation(path6) {
+        path6.skip();
       }
     };
     var scopeVisitor;
     var uid = 0;
     var Scope = class _Scope {
-      constructor(path5) {
+      constructor(path6) {
         this.uid = void 0;
         this.path = void 0;
         this.block = void 0;
@@ -30588,15 +30588,15 @@ var require_scope = __commonJS({
         this.crawling = void 0;
         const {
           node
-        } = path5;
+        } = path6;
         const cached = _cache.scope.get(node);
-        if ((cached == null ? void 0 : cached.path) === path5) {
+        if ((cached == null ? void 0 : cached.path) === path6) {
           return cached;
         }
         _cache.scope.set(node, this);
         this.uid = uid++;
         this.block = node;
-        this.path = path5;
+        this.path = path6;
         this.labels = /* @__PURE__ */ new Map();
         this.inited = false;
         {
@@ -30618,14 +30618,14 @@ var require_scope = __commonJS({
       }
       get parent() {
         var _parent;
-        let parent, path5 = this.path;
+        let parent, path6 = this.path;
         do {
           var _path;
-          const shouldSkip = path5.key === "key" || path5.listKey === "decorators";
-          path5 = path5.parentPath;
-          if (shouldSkip && path5.isMethod()) path5 = path5.parentPath;
-          if ((_path = path5) != null && _path.isScope()) parent = path5;
-        } while (path5 && !parent);
+          const shouldSkip = path6.key === "key" || path6.listKey === "decorators";
+          path6 = path6.parentPath;
+          if (shouldSkip && path6.isMethod()) path6 = path6.parentPath;
+          if ((_path = path6) != null && _path.isScope()) parent = path6;
+        } while (path6 && !parent);
         return (_parent = parent) == null ? void 0 : _parent.scope;
       }
       get references() {
@@ -30742,62 +30742,62 @@ var require_scope = __commonJS({
       getLabel(name) {
         return this.labels.get(name);
       }
-      registerLabel(path5) {
-        this.labels.set(path5.node.label.name, path5);
+      registerLabel(path6) {
+        this.labels.set(path6.node.label.name, path6);
       }
-      registerDeclaration(path5) {
-        if (path5.isLabeledStatement()) {
-          this.registerLabel(path5);
-        } else if (path5.isFunctionDeclaration()) {
-          this.registerBinding("hoisted", path5.get("id"), path5);
-        } else if (path5.isVariableDeclaration()) {
-          const declarations = path5.get("declarations");
+      registerDeclaration(path6) {
+        if (path6.isLabeledStatement()) {
+          this.registerLabel(path6);
+        } else if (path6.isFunctionDeclaration()) {
+          this.registerBinding("hoisted", path6.get("id"), path6);
+        } else if (path6.isVariableDeclaration()) {
+          const declarations = path6.get("declarations");
           const {
             kind
-          } = path5.node;
+          } = path6.node;
           for (const declar of declarations) {
             this.registerBinding(kind === "using" || kind === "await using" ? "const" : kind, declar);
           }
-        } else if (path5.isClassDeclaration()) {
-          if (path5.node.declare) return;
-          this.registerBinding("let", path5);
-        } else if (path5.isImportDeclaration()) {
-          const isTypeDeclaration = path5.node.importKind === "type" || path5.node.importKind === "typeof";
-          const specifiers = path5.get("specifiers");
+        } else if (path6.isClassDeclaration()) {
+          if (path6.node.declare) return;
+          this.registerBinding("let", path6);
+        } else if (path6.isImportDeclaration()) {
+          const isTypeDeclaration = path6.node.importKind === "type" || path6.node.importKind === "typeof";
+          const specifiers = path6.get("specifiers");
           for (const specifier of specifiers) {
             const isTypeSpecifier = isTypeDeclaration || specifier.isImportSpecifier() && (specifier.node.importKind === "type" || specifier.node.importKind === "typeof");
             this.registerBinding(isTypeSpecifier ? "unknown" : "module", specifier);
           }
-        } else if (path5.isExportDeclaration()) {
-          const declar = path5.get("declaration");
+        } else if (path6.isExportDeclaration()) {
+          const declar = path6.get("declaration");
           if (declar.isClassDeclaration() || declar.isFunctionDeclaration() || declar.isVariableDeclaration()) {
             this.registerDeclaration(declar);
           }
         } else {
-          this.registerBinding("unknown", path5);
+          this.registerBinding("unknown", path6);
         }
       }
       buildUndefinedNode() {
         return buildUndefinedNode();
       }
-      registerConstantViolation(path5) {
-        const ids = path5.getAssignmentIdentifiers();
+      registerConstantViolation(path6) {
+        const ids = path6.getAssignmentIdentifiers();
         for (const name of Object.keys(ids)) {
           var _this$getBinding;
-          (_this$getBinding = this.getBinding(name)) == null || _this$getBinding.reassign(path5);
+          (_this$getBinding = this.getBinding(name)) == null || _this$getBinding.reassign(path6);
         }
       }
-      registerBinding(kind, path5, bindingPath = path5) {
+      registerBinding(kind, path6, bindingPath = path6) {
         if (!kind) throw new ReferenceError("no `kind`");
-        if (path5.isVariableDeclaration()) {
-          const declarators = path5.get("declarations");
+        if (path6.isVariableDeclaration()) {
+          const declarators = path6.get("declarations");
           for (const declar of declarators) {
             this.registerBinding(kind, declar);
           }
           return;
         }
         const parent = this.getProgramParent();
-        const ids = path5.getOuterBindingIdentifiers(true);
+        const ids = path6.getOuterBindingIdentifiers(true);
         for (const name of Object.keys(ids)) {
           {
             parent.references[name] = true;
@@ -30945,7 +30945,7 @@ var require_scope = __commonJS({
         }
       }
       crawl() {
-        const path5 = this.path;
+        const path6 = this.path;
         ;
         resetScope(this);
         this.data = /* @__PURE__ */ Object.create(null);
@@ -30964,29 +30964,29 @@ var require_scope = __commonJS({
         };
         this.crawling = true;
         scopeVisitor || (scopeVisitor = _index.default.visitors.merge([{
-          Scope(path6) {
-            resetScope(path6.scope);
+          Scope(path7) {
+            resetScope(path7.scope);
           }
         }, collectorVisitor]));
-        if (path5.type !== "Program") {
-          const typeVisitors = scopeVisitor[path5.type];
+        if (path6.type !== "Program") {
+          const typeVisitors = scopeVisitor[path6.type];
           if (typeVisitors) {
             for (const visit of typeVisitors.enter) {
-              visit.call(state, path5, state);
+              visit.call(state, path6, state);
             }
           }
         }
         {
-          path5.traverse(scopeVisitor, state);
+          path6.traverse(scopeVisitor, state);
         }
         this.crawling = false;
-        for (const path6 of state.assignments) {
-          const ids = path6.getAssignmentIdentifiers();
+        for (const path7 of state.assignments) {
+          const ids = path7.getAssignmentIdentifiers();
           for (const name of Object.keys(ids)) {
-            if (path6.scope.getBinding(name)) continue;
+            if (path7.scope.getBinding(name)) continue;
             programParent.addGlobal(ids[name]);
           }
-          path6.scope.registerConstantViolation(path6);
+          path7.scope.registerConstantViolation(path7);
         }
         for (const ref of state.references) {
           const binding = ref.scope.getBinding(ref.node.name);
@@ -30996,19 +30996,19 @@ var require_scope = __commonJS({
             programParent.addGlobal(ref.node);
           }
         }
-        for (const path6 of state.constantViolations) {
-          path6.scope.registerConstantViolation(path6);
+        for (const path7 of state.constantViolations) {
+          path7.scope.registerConstantViolation(path7);
         }
       }
       push(opts) {
-        let path5 = this.path;
-        if (path5.isPattern()) {
-          path5 = this.getPatternParent().path;
-        } else if (!path5.isBlockStatement() && !path5.isProgram()) {
-          path5 = this.getBlockParent().path;
+        let path6 = this.path;
+        if (path6.isPattern()) {
+          path6 = this.getPatternParent().path;
+        } else if (!path6.isBlockStatement() && !path6.isProgram()) {
+          path6 = this.getBlockParent().path;
         }
-        if (path5.isSwitchStatement()) {
-          path5 = (this.getFunctionParent() || this.getProgramParent()).path;
+        if (path6.isSwitchStatement()) {
+          path6 = (this.getFunctionParent() || this.getProgramParent()).path;
         }
         const {
           init,
@@ -31016,29 +31016,29 @@ var require_scope = __commonJS({
           kind = "var",
           id
         } = opts;
-        if (!init && !unique && (kind === "var" || kind === "let") && isAnonymousFunctionExpression(path5) && isCallExpression2(path5.parent, {
-          callee: path5.node
-        }) && path5.parent.arguments.length <= path5.node.params.length && isIdentifier2(id)) {
-          path5.pushContainer("params", id);
-          path5.scope.registerBinding("param", path5.get("params")[path5.node.params.length - 1]);
+        if (!init && !unique && (kind === "var" || kind === "let") && isAnonymousFunctionExpression(path6) && isCallExpression2(path6.parent, {
+          callee: path6.node
+        }) && path6.parent.arguments.length <= path6.node.params.length && isIdentifier2(id)) {
+          path6.pushContainer("params", id);
+          path6.scope.registerBinding("param", path6.get("params")[path6.node.params.length - 1]);
           return;
         }
-        if (path5.isLoop() || path5.isCatchClause() || path5.isFunction()) {
-          path5.ensureBlock();
-          path5 = path5.get("body");
+        if (path6.isLoop() || path6.isCatchClause() || path6.isFunction()) {
+          path6.ensureBlock();
+          path6 = path6.get("body");
         }
         const blockHoist = opts._blockHoist == null ? 2 : opts._blockHoist;
         const dataKey = `declaration:${kind}:${blockHoist}`;
-        let declarPath = !unique && path5.getData(dataKey);
+        let declarPath = !unique && path6.getData(dataKey);
         if (!declarPath) {
           const declar = variableDeclaration(kind, []);
           declar._blockHoist = blockHoist;
-          [declarPath] = path5.unshiftContainer("body", [declar]);
-          if (!unique) path5.setData(dataKey, declarPath);
+          [declarPath] = path6.unshiftContainer("body", [declar]);
+          if (!unique) path6.setData(dataKey, declarPath);
         }
         const declarator = variableDeclarator(id, init);
         const len = declarPath.node.declarations.push(declarator);
-        path5.scope.registerBinding(kind, declarPath.get("declarations")[len - 1]);
+        path6.scope.registerBinding(kind, declarPath.get("declarations")[len - 1]);
       }
       getProgramParent() {
         let scope = this;
@@ -31185,15 +31185,15 @@ var require_scope = __commonJS({
           const binding = this.bindings[name];
           if (!binding) continue;
           const {
-            path: path5
+            path: path6
           } = binding;
-          if (!path5.isVariableDeclarator()) continue;
+          if (!path6.isVariableDeclarator()) continue;
           const {
             parent,
             parentPath
-          } = path5;
+          } = path6;
           if (parent.kind !== "var" || seen.has(parent)) continue;
-          seen.add(path5.parent);
+          seen.add(path6.parent);
           let firstId;
           const init = [];
           for (const decl of parent.declarations) {
@@ -31800,16 +31800,16 @@ var require_resolve_uri_umd = __commonJS({
       }
       function parseFileUrl(input) {
         const match2 = fileRegex.exec(input);
-        const path5 = match2[2];
-        return makeUrl("file:", "", match2[1] || "", "", isAbsolutePath(path5) ? path5 : "/" + path5, match2[3] || "", match2[4] || "");
+        const path6 = match2[2];
+        return makeUrl("file:", "", match2[1] || "", "", isAbsolutePath(path6) ? path6 : "/" + path6, match2[3] || "", match2[4] || "");
       }
-      function makeUrl(scheme, user, host, port, path5, query, hash) {
+      function makeUrl(scheme, user, host, port, path6, query, hash) {
         return {
           scheme,
           user,
           host,
           port,
-          path: path5,
+          path: path6,
           query,
           hash,
           type: 7
@@ -31839,11 +31839,11 @@ var require_resolve_uri_umd = __commonJS({
         url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
         return url;
       }
-      function stripPathFilename(path5) {
-        if (path5.endsWith("/.."))
-          return path5;
-        const index = path5.lastIndexOf("/");
-        return path5.slice(0, index + 1);
+      function stripPathFilename(path6) {
+        if (path6.endsWith("/.."))
+          return path6;
+        const index = path6.lastIndexOf("/");
+        return path6.slice(0, index + 1);
       }
       function mergePaths(url, base) {
         normalizePath(base, base.type);
@@ -31881,14 +31881,14 @@ var require_resolve_uri_umd = __commonJS({
           pieces[pointer++] = piece;
           positive++;
         }
-        let path5 = "";
+        let path6 = "";
         for (let i = 1; i < pointer; i++) {
-          path5 += "/" + pieces[i];
+          path6 += "/" + pieces[i];
         }
-        if (!path5 || addTrailingSlash && !path5.endsWith("/..")) {
-          path5 += "/";
+        if (!path6 || addTrailingSlash && !path6.endsWith("/..")) {
+          path6 += "/";
         }
-        url.path = path5;
+        url.path = path6;
       }
       function resolve(input, base) {
         if (!input && !base)
@@ -31929,13 +31929,13 @@ var require_resolve_uri_umd = __commonJS({
           case 3:
             return queryHash;
           case 4: {
-            const path5 = url.path.slice(1);
-            if (!path5)
+            const path6 = url.path.slice(1);
+            if (!path6)
               return queryHash || ".";
-            if (isRelative(base || input) && !isRelative(path5)) {
-              return "./" + path5 + queryHash;
+            if (isRelative(base || input) && !isRelative(path6)) {
+              return "./" + path6 + queryHash;
             }
-            return path5 + queryHash;
+            return path6 + queryHash;
           }
           case 5:
             return url.path + queryHash;
@@ -32034,10 +32034,10 @@ var require_trace_mapping_umd = __commonJS({
       module3.exports = __toCommonJS(trace_mapping_exports);
       var import_sourcemap_codec = __toESM2(require_sourcemap_codec());
       var import_resolve_uri = __toESM2(require_resolve_uri());
-      function stripFilename(path5) {
-        if (!path5) return "";
-        const index = path5.lastIndexOf("/");
-        return path5.slice(0, index + 1);
+      function stripFilename(path6) {
+        if (!path6) return "";
+        const index = path6.lastIndexOf("/");
+        return path6.slice(0, index + 1);
       }
       function resolver(mapUrl, sourceRoot) {
         const from = stripFilename(mapUrl);
@@ -38533,56 +38533,56 @@ var require_ancestry = __commonJS({
       VISITOR_KEYS
     } = _t;
     function findParent(callback) {
-      let path5 = this;
-      while (path5 = path5.parentPath) {
-        if (callback(path5)) return path5;
+      let path6 = this;
+      while (path6 = path6.parentPath) {
+        if (callback(path6)) return path6;
       }
       return null;
     }
     function find(callback) {
-      let path5 = this;
+      let path6 = this;
       do {
-        if (callback(path5)) return path5;
-      } while (path5 = path5.parentPath);
+        if (callback(path6)) return path6;
+      } while (path6 = path6.parentPath);
       return null;
     }
     function getFunctionParent() {
       return this.findParent((p) => p.isFunction());
     }
     function getStatementParent() {
-      let path5 = this;
+      let path6 = this;
       do {
-        if (!path5.parentPath || Array.isArray(path5.container) && path5.isStatement()) {
+        if (!path6.parentPath || Array.isArray(path6.container) && path6.isStatement()) {
           break;
         } else {
-          path5 = path5.parentPath;
+          path6 = path6.parentPath;
         }
-      } while (path5);
-      if (path5 && (path5.isProgram() || path5.isFile())) {
+      } while (path6);
+      if (path6 && (path6.isProgram() || path6.isFile())) {
         throw new Error("File/Program node, we can't possibly find a statement parent to this");
       }
-      return path5;
+      return path6;
     }
     function getEarliestCommonAncestorFrom(paths) {
       return this.getDeepestCommonAncestorFrom(paths, function(deepest, i, ancestries) {
         let earliest;
         const keys = VISITOR_KEYS[deepest.type];
         for (const ancestry of ancestries) {
-          const path5 = ancestry[i + 1];
+          const path6 = ancestry[i + 1];
           if (!earliest) {
-            earliest = path5;
+            earliest = path6;
             continue;
           }
-          if (path5.listKey && earliest.listKey === path5.listKey) {
-            if (path5.key < earliest.key) {
-              earliest = path5;
+          if (path6.listKey && earliest.listKey === path6.listKey) {
+            if (path6.key < earliest.key) {
+              earliest = path6;
               continue;
             }
           }
           const earliestKeyIndex = keys.indexOf(earliest.parentKey);
-          const currentKeyIndex = keys.indexOf(path5.parentKey);
+          const currentKeyIndex = keys.indexOf(path6.parentKey);
           if (earliestKeyIndex > currentKeyIndex) {
-            earliest = path5;
+            earliest = path6;
           }
         }
         return earliest;
@@ -38597,11 +38597,11 @@ var require_ancestry = __commonJS({
       }
       let minDepth = Infinity;
       let lastCommonIndex, lastCommon;
-      const ancestries = paths.map((path5) => {
+      const ancestries = paths.map((path6) => {
         const ancestry = [];
         do {
-          ancestry.unshift(path5);
-        } while ((path5 = path5.parentPath) && path5 !== this);
+          ancestry.unshift(path6);
+        } while ((path6 = path6.parentPath) && path6 !== this);
         if (ancestry.length < minDepth) {
           minDepth = ancestry.length;
         }
@@ -38629,11 +38629,11 @@ var require_ancestry = __commonJS({
       }
     }
     function getAncestry() {
-      let path5 = this;
+      let path6 = this;
       const paths = [];
       do {
-        paths.push(path5);
-      } while (path5 = path5.parentPath);
+        paths.push(path6);
+      } while (path6 = path6.parentPath);
       return paths;
     }
     function isAncestor(maybeDescendant) {
@@ -38643,10 +38643,10 @@ var require_ancestry = __commonJS({
       return !!this.findParent((parent) => parent === maybeAncestor);
     }
     function inType(...candidateTypes) {
-      let path5 = this;
-      while (path5) {
-        if (candidateTypes.includes(path5.node.type)) return true;
-        path5 = path5.parentPath;
+      let path6 = this;
+      while (path6) {
+        if (candidateTypes.includes(path6.node.type)) return true;
+        path6 = path6.parentPath;
       }
       return false;
     }
@@ -38719,14 +38719,14 @@ var require_inferer_reference = __commonJS({
       } else if (node.name === "arguments") {
       }
     }
-    function getTypeAnnotationBindingConstantViolations(binding, path5, name) {
+    function getTypeAnnotationBindingConstantViolations(binding, path6, name) {
       const types2 = [];
       const functionConstantViolations = [];
-      let constantViolations = getConstantViolationsBefore(binding, path5, functionConstantViolations);
-      const testType = getConditionalAnnotation(binding, path5, name);
+      let constantViolations = getConstantViolationsBefore(binding, path6, functionConstantViolations);
+      const testType = getConditionalAnnotation(binding, path6, name);
       if (testType) {
         const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
-        constantViolations = constantViolations.filter((path6) => !testConstantViolations.includes(path6));
+        constantViolations = constantViolations.filter((path7) => !testConstantViolations.includes(path7));
         types2.push(testType.typeAnnotation);
       }
       if (constantViolations.length) {
@@ -38740,20 +38740,20 @@ var require_inferer_reference = __commonJS({
       }
       return (0, _util.createUnionType)(types2);
     }
-    function getConstantViolationsBefore(binding, path5, functions) {
+    function getConstantViolationsBefore(binding, path6, functions) {
       const violations = binding.constantViolations.slice();
       violations.unshift(binding.path);
       return violations.filter((violation) => {
         violation = violation.resolve();
-        const status = violation._guessExecutionStatusRelativeTo(path5);
+        const status = violation._guessExecutionStatusRelativeTo(path6);
         if (functions && status === "unknown") functions.push(violation);
         return status === "before";
       });
     }
-    function inferAnnotationFromBinaryExpression(name, path5) {
-      const operator = path5.node.operator;
-      const right = path5.get("right").resolve();
-      const left = path5.get("left").resolve();
+    function inferAnnotationFromBinaryExpression(name, path6) {
+      const operator = path6.node.operator;
+      const right = path6.get("right").resolve();
+      const left = path6.get("left").resolve();
       let target;
       if (left.isIdentifier({
         name
@@ -38797,11 +38797,11 @@ var require_inferer_reference = __commonJS({
       if (typeof typeValue !== "string") return;
       return createTypeAnnotationBasedOnTypeof(typeValue);
     }
-    function getParentConditionalPath(binding, path5, name) {
+    function getParentConditionalPath(binding, path6, name) {
       let parentPath;
-      while (parentPath = path5.parentPath) {
+      while (parentPath = path6.parentPath) {
         if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
-          if (path5.key === "test") {
+          if (path6.key === "test") {
             return;
           }
           return parentPath;
@@ -38809,24 +38809,24 @@ var require_inferer_reference = __commonJS({
         if (parentPath.isFunction()) {
           if (name == null || parentPath.parentPath.scope.getBinding(name) !== binding) return;
         }
-        path5 = parentPath;
+        path6 = parentPath;
       }
     }
-    function getConditionalAnnotation(binding, path5, name) {
-      const ifStatement = getParentConditionalPath(binding, path5, name);
+    function getConditionalAnnotation(binding, path6, name) {
+      const ifStatement = getParentConditionalPath(binding, path6, name);
       if (!ifStatement) return;
       const test = ifStatement.get("test");
       const paths = [test];
       const types2 = [];
       for (let i = 0; i < paths.length; i++) {
-        const path6 = paths[i];
-        if (path6.isLogicalExpression()) {
-          if (path6.node.operator === "&&") {
-            paths.push(path6.get("left"));
-            paths.push(path6.get("right"));
-          }
-        } else if (path6.isBinaryExpression()) {
-          const type = inferAnnotationFromBinaryExpression(name, path6);
+        const path7 = paths[i];
+        if (path7.isLogicalExpression()) {
+          if (path7.node.operator === "&&") {
+            paths.push(path7.get("left"));
+            paths.push(path7.get("right"));
+          }
+        } else if (path7.isBinaryExpression()) {
+          const type = inferAnnotationFromBinaryExpression(name, path7);
           if (type) types2.push(type);
         }
       }
@@ -39644,12 +39644,12 @@ var require_hoister = __commonJS({
       variableDeclarator
     } = _t2;
     var referenceVisitor = {
-      ReferencedIdentifier(path5, state) {
-        if (path5.isJSXIdentifier() && react.isCompatTag(path5.node.name) && !path5.parentPath.isJSXMemberExpression()) {
+      ReferencedIdentifier(path6, state) {
+        if (path6.isJSXIdentifier() && react.isCompatTag(path6.node.name) && !path6.parentPath.isJSXMemberExpression()) {
           return;
         }
-        if (path5.node.name === "this") {
-          let scope = path5.scope;
+        if (path6.node.name === "this") {
+          let scope = path6.scope;
           do {
             if (scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) {
               break;
@@ -39657,21 +39657,21 @@ var require_hoister = __commonJS({
           } while (scope = scope.parent);
           if (scope) state.breakOnScopePaths.push(scope.path);
         }
-        const binding = path5.scope.getBinding(path5.node.name);
+        const binding = path6.scope.getBinding(path6.node.name);
         if (!binding) return;
         for (const violation of binding.constantViolations) {
           if (violation.scope !== binding.path.scope) {
             state.mutableBinding = true;
-            path5.stop();
+            path6.stop();
             return;
           }
         }
-        if (binding !== state.scope.getBinding(path5.node.name)) return;
-        state.bindings[path5.node.name] = binding;
+        if (binding !== state.scope.getBinding(path6.node.name)) return;
+        state.bindings[path6.node.name] = binding;
       }
     };
     var PathHoister = class {
-      constructor(path5, scope) {
+      constructor(path6, scope) {
         this.breakOnScopePaths = void 0;
         this.bindings = void 0;
         this.mutableBinding = void 0;
@@ -39684,7 +39684,7 @@ var require_hoister = __commonJS({
         this.mutableBinding = false;
         this.scopes = [];
         this.scope = scope;
-        this.path = path5;
+        this.path = path6;
         this.attachAfter = false;
       }
       isCompatibleScope(scope) {
@@ -39710,11 +39710,11 @@ var require_hoister = __commonJS({
         } while (scope = scope.parent);
       }
       getAttachmentPath() {
-        let path5 = this._getAttachmentPath();
-        if (!path5) return;
-        let targetScope = path5.scope;
-        if (targetScope.path === path5) {
-          targetScope = path5.scope.parent;
+        let path6 = this._getAttachmentPath();
+        if (!path6) return;
+        let targetScope = path6.scope;
+        if (targetScope.path === path6) {
+          targetScope = path6.scope.parent;
         }
         if (targetScope.path.isProgram() || targetScope.path.isFunction()) {
           for (const name of Object.keys(this.bindings)) {
@@ -39724,18 +39724,18 @@ var require_hoister = __commonJS({
               continue;
             }
             const bindingParentPath = this.getAttachmentParentForPath(binding.path);
-            if (bindingParentPath.key >= path5.key) {
+            if (bindingParentPath.key >= path6.key) {
               this.attachAfter = true;
-              path5 = binding.path;
+              path6 = binding.path;
               for (const violationPath of binding.constantViolations) {
-                if (this.getAttachmentParentForPath(violationPath).key > path5.key) {
-                  path5 = violationPath;
+                if (this.getAttachmentParentForPath(violationPath).key > path6.key) {
+                  path6 = violationPath;
                 }
               }
             }
           }
         }
-        return path5;
+        return path6;
       }
       _getAttachmentPath() {
         const scopes = this.scopes;
@@ -39760,13 +39760,13 @@ var require_hoister = __commonJS({
         const scope = this.scopes.pop();
         if (scope) return this.getAttachmentParentForPath(scope.path);
       }
-      getAttachmentParentForPath(path5) {
+      getAttachmentParentForPath(path6) {
         do {
-          if (!path5.parentPath || Array.isArray(path5.container) && path5.isStatement()) {
-            return path5;
+          if (!path6.parentPath || Array.isArray(path6.container) && path6.isStatement()) {
+            return path6;
           }
-        } while (path5 = path5.parentPath);
-        return path5;
+        } while (path6 = path6.parentPath);
+        return path6;
       }
       hasOwnParamBindings(scope) {
         for (const name of Object.keys(this.bindings)) {
@@ -39868,18 +39868,18 @@ var require_modification = __commonJS({
       for (let i = 0; i < nodes.length; i++) {
         var _this$context;
         const to = from + i;
-        const path5 = this.getSibling(to);
-        paths.push(path5);
+        const path6 = this.getSibling(to);
+        paths.push(path6);
         if ((_this$context = this.context) != null && _this$context.queue) {
-          _context.pushContext.call(path5, this.context);
+          _context.pushContext.call(path6, this.context);
         }
       }
       const contexts = _context._getQueueContexts.call(this);
-      for (const path5 of paths) {
-        _context.setScope.call(path5);
-        path5.debug("Inserted.");
+      for (const path6 of paths) {
+        _context.setScope.call(path6);
+        path6.debug("Inserted.");
         for (const context of contexts) {
-          context.maybeQueue(path5, true);
+          context.maybeQueue(path6, true);
         }
       }
       return paths;
@@ -39891,8 +39891,8 @@ var require_modification = __commonJS({
       return _containerInsert.call(this, this.key + 1, nodes);
     }
     var last = (arr) => arr[arr.length - 1];
-    function isHiddenInSequenceExpression(path5) {
-      return isSequenceExpression(path5.parent) && (last(path5.parent.expressions) !== path5.node || isHiddenInSequenceExpression(path5.parentPath));
+    function isHiddenInSequenceExpression(path6) {
+      return isSequenceExpression(path6.parent) && (last(path6.parent.expressions) !== path6.node || isHiddenInSequenceExpression(path6.parentPath));
     }
     function isAlmostConstantAssignment(node, scope) {
       if (!isAssignmentExpression2(node) || !isIdentifier2(node.left)) {
@@ -39966,9 +39966,9 @@ var require_modification = __commonJS({
       if (!this.parent) return;
       const paths = (0, _cache.getCachedPaths)(this);
       if (!paths) return;
-      for (const [, path5] of paths) {
-        if (typeof path5.key === "number" && path5.container === this.container && path5.key >= fromIndex) {
-          path5.key += incrementBy;
+      for (const [, path6] of paths) {
+        if (typeof path6.key === "number" && path6.container === this.container && path6.key >= fromIndex) {
+          path6.key += incrementBy;
         }
       }
     }
@@ -40002,27 +40002,27 @@ var require_modification = __commonJS({
       _removal._assertUnremoved.call(this);
       const verifiedNodes = _verifyNodeList.call(this, nodes);
       const container = this.node[listKey];
-      const path5 = _index.default.get({
+      const path6 = _index.default.get({
         parentPath: this,
         parent: this.node,
         container,
         listKey,
         key: 0
       }).setContext(this.context);
-      return _containerInsertBefore.call(path5, verifiedNodes);
+      return _containerInsertBefore.call(path6, verifiedNodes);
     }
     function pushContainer(listKey, nodes) {
       _removal._assertUnremoved.call(this);
       const verifiedNodes = _verifyNodeList.call(this, nodes);
       const container = this.node[listKey];
-      const path5 = _index.default.get({
+      const path6 = _index.default.get({
         parentPath: this,
         parent: this.node,
         container,
         listKey,
         key: container.length
       }).setContext(this.context);
-      return path5.replaceWithMultiple(verifiedNodes);
+      return path6.replaceWithMultiple(verifiedNodes);
     }
     {
       exports2.hoist = function hoist(scope = this.scope) {
@@ -40202,9 +40202,9 @@ var require_replacement = __commonJS({
         id
       }));
       const completionRecords = callee.getCompletionRecords();
-      for (const path5 of completionRecords) {
-        if (!path5.isExpressionStatement()) continue;
-        const loop = path5.findParent((path6) => path6.isLoop());
+      for (const path6 of completionRecords) {
+        if (!path6.isExpressionStatement()) continue;
+        const loop = path6.findParent((path7) => path7.isLoop());
         if (loop) {
           let uid = loop.getData("expressionReplacementReturnUid");
           if (!uid) {
@@ -40214,9 +40214,9 @@ var require_replacement = __commonJS({
           } else {
             uid = identifier(uid.name);
           }
-          path5.get("expression").replaceWith(assignmentExpression("=", cloneNode(uid), path5.node.expression));
+          path6.get("expression").replaceWith(assignmentExpression("=", cloneNode(uid), path6.node.expression));
         } else {
-          path5.replaceWith(returnStatement(path5.node.expression));
+          path6.replaceWith(returnStatement(path6.node.expression));
         }
       }
       callee.arrowFunctionToExpression();
@@ -40325,16 +40325,16 @@ var require_evaluation = __commonJS({
       const res = this.evaluate();
       if (res.confident) return !!res.value;
     }
-    function deopt(path5, state) {
+    function deopt(path6, state) {
       if (!state.confident) return;
-      state.deoptPath = path5;
+      state.deoptPath = path6;
       state.confident = false;
     }
     var Globals = /* @__PURE__ */ new Map([["undefined", void 0], ["Infinity", Infinity], ["NaN", NaN]]);
-    function evaluateCached(path5, state) {
+    function evaluateCached(path6, state) {
       const {
         node
-      } = path5;
+      } = path6;
       const {
         seen
       } = state;
@@ -40343,7 +40343,7 @@ var require_evaluation = __commonJS({
         if (existing.resolved) {
           return existing.value;
         } else {
-          deopt(path5, state);
+          deopt(path6, state);
           return;
         }
       } else {
@@ -40351,7 +40351,7 @@ var require_evaluation = __commonJS({
           resolved: false
         };
         seen.set(node, item);
-        const val = _evaluate(path5, state);
+        const val = _evaluate(path6, state);
         if (state.confident) {
           item.resolved = true;
           item.value = val;
@@ -40359,55 +40359,55 @@ var require_evaluation = __commonJS({
         return val;
       }
     }
-    function _evaluate(path5, state) {
+    function _evaluate(path6, state) {
       if (!state.confident) return;
-      if (path5.isSequenceExpression()) {
-        const exprs = path5.get("expressions");
+      if (path6.isSequenceExpression()) {
+        const exprs = path6.get("expressions");
         return evaluateCached(exprs[exprs.length - 1], state);
       }
-      if (path5.isStringLiteral() || path5.isNumericLiteral() || path5.isBooleanLiteral()) {
-        return path5.node.value;
+      if (path6.isStringLiteral() || path6.isNumericLiteral() || path6.isBooleanLiteral()) {
+        return path6.node.value;
       }
-      if (path5.isNullLiteral()) {
+      if (path6.isNullLiteral()) {
         return null;
       }
-      if (path5.isTemplateLiteral()) {
-        return evaluateQuasis(path5, path5.node.quasis, state);
+      if (path6.isTemplateLiteral()) {
+        return evaluateQuasis(path6, path6.node.quasis, state);
       }
-      if (path5.isTaggedTemplateExpression() && path5.get("tag").isMemberExpression()) {
-        const object = path5.get("tag.object");
+      if (path6.isTaggedTemplateExpression() && path6.get("tag").isMemberExpression()) {
+        const object = path6.get("tag.object");
         const {
           node: {
             name
           }
         } = object;
-        const property = path5.get("tag.property");
-        if (object.isIdentifier() && name === "String" && !path5.scope.getBinding(name) && property.isIdentifier() && property.node.name === "raw") {
-          return evaluateQuasis(path5, path5.node.quasi.quasis, state, true);
+        const property = path6.get("tag.property");
+        if (object.isIdentifier() && name === "String" && !path6.scope.getBinding(name) && property.isIdentifier() && property.node.name === "raw") {
+          return evaluateQuasis(path6, path6.node.quasi.quasis, state, true);
         }
       }
-      if (path5.isConditionalExpression()) {
-        const testResult = evaluateCached(path5.get("test"), state);
+      if (path6.isConditionalExpression()) {
+        const testResult = evaluateCached(path6.get("test"), state);
         if (!state.confident) return;
         if (testResult) {
-          return evaluateCached(path5.get("consequent"), state);
+          return evaluateCached(path6.get("consequent"), state);
         } else {
-          return evaluateCached(path5.get("alternate"), state);
+          return evaluateCached(path6.get("alternate"), state);
         }
       }
-      if (path5.isExpressionWrapper()) {
-        return evaluateCached(path5.get("expression"), state);
+      if (path6.isExpressionWrapper()) {
+        return evaluateCached(path6.get("expression"), state);
       }
-      if (path5.isMemberExpression() && !path5.parentPath.isCallExpression({
-        callee: path5.node
+      if (path6.isMemberExpression() && !path6.parentPath.isCallExpression({
+        callee: path6.node
       })) {
-        const property = path5.get("property");
-        const object = path5.get("object");
+        const property = path6.get("property");
+        const object = path6.get("object");
         if (object.isLiteral()) {
           const value = object.node.value;
           const type = typeof value;
           let key = null;
-          if (path5.node.computed) {
+          if (path6.node.computed) {
             key = evaluateCached(property, state);
             if (!state.confident) return;
           } else if (property.isIdentifier()) {
@@ -40418,10 +40418,10 @@ var require_evaluation = __commonJS({
           }
         }
       }
-      if (path5.isReferencedIdentifier()) {
-        const binding = path5.scope.getBinding(path5.node.name);
+      if (path6.isReferencedIdentifier()) {
+        const binding = path6.scope.getBinding(path6.node.name);
         if (binding) {
-          if (binding.constantViolations.length > 0 || path5.node.start < binding.path.node.end) {
+          if (binding.constantViolations.length > 0 || path6.node.start < binding.path.node.end) {
             deopt(binding.path, state);
             return;
           }
@@ -40430,7 +40430,7 @@ var require_evaluation = __commonJS({
             let hasUnsafeBlock = !bindingPathScope.path.parentPath.isBlockStatement();
             for (let scope = bindingPathScope.parent; scope; scope = scope.parent) {
               var _scope$path$parentPat;
-              if (scope === path5.scope) {
+              if (scope === path6.scope) {
                 if (hasUnsafeBlock) {
                   deopt(binding.path, state);
                   return;
@@ -40446,7 +40446,7 @@ var require_evaluation = __commonJS({
             return binding.value;
           }
         }
-        const name = path5.node.name;
+        const name = path6.node.name;
         if (Globals.has(name)) {
           if (!binding) {
             return Globals.get(name);
@@ -40454,9 +40454,9 @@ var require_evaluation = __commonJS({
           deopt(binding.path, state);
           return;
         }
-        const resolved = path5.resolve();
-        if (resolved === path5) {
-          deopt(path5, state);
+        const resolved = path6.resolve();
+        if (resolved === path6) {
+          deopt(path6, state);
           return;
         }
         const value = evaluateCached(resolved, state);
@@ -40466,19 +40466,19 @@ var require_evaluation = __commonJS({
         }
         return value;
       }
-      if (path5.isUnaryExpression({
+      if (path6.isUnaryExpression({
         prefix: true
       })) {
-        if (path5.node.operator === "void") {
+        if (path6.node.operator === "void") {
           return void 0;
         }
-        const argument = path5.get("argument");
-        if (path5.node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
+        const argument = path6.get("argument");
+        if (path6.node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
           return "function";
         }
         const arg = evaluateCached(argument, state);
         if (!state.confident) return;
-        switch (path5.node.operator) {
+        switch (path6.node.operator) {
           case "!":
             return !arg;
           case "+":
@@ -40491,9 +40491,9 @@ var require_evaluation = __commonJS({
             return typeof arg;
         }
       }
-      if (path5.isArrayExpression()) {
+      if (path6.isArrayExpression()) {
         const arr = [];
-        const elems = path5.get("elements");
+        const elems = path6.get("elements");
         for (const elem of elems) {
           const elemValue = elem.evaluate();
           if (elemValue.confident) {
@@ -40505,9 +40505,9 @@ var require_evaluation = __commonJS({
         }
         return arr;
       }
-      if (path5.isObjectExpression()) {
+      if (path6.isObjectExpression()) {
         const obj = {};
-        const props = path5.get("properties");
+        const props = path6.get("properties");
         for (const prop of props) {
           if (prop.isObjectMethod() || prop.isSpreadElement()) {
             deopt(prop, state);
@@ -40538,14 +40538,14 @@ var require_evaluation = __commonJS({
         }
         return obj;
       }
-      if (path5.isLogicalExpression()) {
+      if (path6.isLogicalExpression()) {
         const wasConfident = state.confident;
-        const left = evaluateCached(path5.get("left"), state);
+        const left = evaluateCached(path6.get("left"), state);
         const leftConfident = state.confident;
         state.confident = wasConfident;
-        const right = evaluateCached(path5.get("right"), state);
+        const right = evaluateCached(path6.get("right"), state);
         const rightConfident = state.confident;
-        switch (path5.node.operator) {
+        switch (path6.node.operator) {
           case "||":
             state.confident = leftConfident && (!!left || rightConfident);
             if (!state.confident) return;
@@ -40560,12 +40560,12 @@ var require_evaluation = __commonJS({
             return left != null ? left : right;
         }
       }
-      if (path5.isBinaryExpression()) {
-        const left = evaluateCached(path5.get("left"), state);
+      if (path6.isBinaryExpression()) {
+        const left = evaluateCached(path6.get("left"), state);
         if (!state.confident) return;
-        const right = evaluateCached(path5.get("right"), state);
+        const right = evaluateCached(path6.get("right"), state);
         if (!state.confident) return;
-        switch (path5.node.operator) {
+        switch (path6.node.operator) {
           case "-":
             return left - right;
           case "+":
@@ -40608,11 +40608,11 @@ var require_evaluation = __commonJS({
             return left >>> right;
         }
       }
-      if (path5.isCallExpression()) {
-        const callee = path5.get("callee");
+      if (path6.isCallExpression()) {
+        const callee = path6.get("callee");
         let context;
         let func;
-        if (callee.isIdentifier() && !path5.scope.getBinding(callee.node.name) && (isValidObjectCallee(callee.node.name) || isValidIdentifierCallee(callee.node.name))) {
+        if (callee.isIdentifier() && !path6.scope.getBinding(callee.node.name) && (isValidObjectCallee(callee.node.name) || isValidIdentifierCallee(callee.node.name))) {
           func = global[callee.node.name];
         }
         if (callee.isMemberExpression()) {
@@ -40634,17 +40634,17 @@ var require_evaluation = __commonJS({
           }
         }
         if (func) {
-          const args = path5.get("arguments").map((arg) => evaluateCached(arg, state));
+          const args = path6.get("arguments").map((arg) => evaluateCached(arg, state));
           if (!state.confident) return;
           return func.apply(context, args);
         }
       }
-      deopt(path5, state);
+      deopt(path6, state);
     }
-    function evaluateQuasis(path5, quasis, state, raw = false) {
+    function evaluateQuasis(path6, quasis, state, raw = false) {
       let str = "";
       let i = 0;
-      const exprs = path5.isTemplateLiteral() ? path5.get("expressions") : path5.get("quasi.expressions");
+      const exprs = path6.isTemplateLiteral() ? path6.get("expressions") : path6.get("quasi.expressions");
       for (const elem of quasis) {
         if (!state.confident) break;
         str += raw ? elem.value.raw : elem.value.cooked;
@@ -41440,8 +41440,8 @@ var require_conversion = __commonJS({
       }
       hoistFunctionEnvironment(this);
     }
-    function setType(path5, type) {
-      path5.node.type = type;
+    function setType(path6, type) {
+      path6.node.type = type;
     }
     function arrowFunctionToExpression({
       allowInsertArrow = true,
@@ -41856,14 +41856,14 @@ var require_conversion = __commonJS({
       return this;
     }
     var refersOuterBindingVisitor = {
-      "ReferencedIdentifier|BindingIdentifier"(path5, state) {
-        if (path5.node.name !== state.name) return;
+      "ReferencedIdentifier|BindingIdentifier"(path6, state) {
+        if (path6.node.name !== state.name) return;
         state.needsRename = true;
-        path5.stop();
+        path6.stop();
       },
-      Scope(path5, state) {
-        if (path5.scope.hasOwnBinding(state.name)) {
-          path5.skip();
+      Scope(path6, state) {
+        if (path6.scope.hasOwnBinding(state.name)) {
+          path6.skip();
         }
       }
     };
@@ -42020,21 +42020,21 @@ var require_introspection = __commonJS({
       return false;
     }
     function isCompletionRecord(allowInsideFunction) {
-      let path5 = this;
+      let path6 = this;
       let first = true;
       do {
         const {
           type,
           container
-        } = path5;
-        if (!first && (path5.isFunction() || type === "StaticBlock")) {
+        } = path6;
+        if (!first && (path6.isFunction() || type === "StaticBlock")) {
           return !!allowInsideFunction;
         }
         first = false;
-        if (Array.isArray(container) && path5.key !== container.length - 1) {
+        if (Array.isArray(container) && path6.key !== container.length - 1) {
           return false;
         }
-      } while ((path5 = path5.parentPath) && !path5.isProgram() && !path5.isDoExpression());
+      } while ((path6 = path6.parentPath) && !path6.isProgram() && !path6.isDoExpression());
       return true;
     }
     function isStatementOrBlock() {
@@ -42056,21 +42056,21 @@ var require_introspection = __commonJS({
       }
       const binding = this.scope.getBinding(this.node.name);
       if (!binding || binding.kind !== "module") return false;
-      const path5 = binding.path;
-      const parent = path5.parentPath;
+      const path6 = binding.path;
+      const parent = path6.parentPath;
       if (!parent.isImportDeclaration()) return false;
       if (parent.node.source.value === moduleSource) {
         if (!importName) return true;
       } else {
         return false;
       }
-      if (path5.isImportDefaultSpecifier() && importName === "default") {
+      if (path6.isImportDefaultSpecifier() && importName === "default") {
         return true;
       }
-      if (path5.isImportNamespaceSpecifier() && importName === "*") {
+      if (path6.isImportNamespaceSpecifier() && importName === "*") {
         return true;
       }
-      if (path5.isImportSpecifier() && isIdentifier2(path5.node.imported, {
+      if (path6.isImportSpecifier() && isIdentifier2(path6.node.imported, {
         name: importName
       })) {
         return true;
@@ -42088,8 +42088,8 @@ var require_introspection = __commonJS({
     function willIMaybeExecuteBefore(target) {
       return this._guessExecutionStatusRelativeTo(target) !== "after";
     }
-    function getOuterFunction(path5) {
-      return path5.isProgram() ? path5 : (path5.parentPath.scope.getFunctionParent() || path5.parentPath.scope.getProgramParent()).path;
+    function getOuterFunction(path6) {
+      return path6.isProgram() ? path6 : (path6.parentPath.scope.getFunctionParent() || path6.parentPath.scope.getProgramParent()).path;
     }
     function isExecutionUncertain(type, key) {
       switch (type) {
@@ -42121,8 +42121,8 @@ var require_introspection = __commonJS({
     }
     function isExecutionUncertainInList(paths, maxIndex) {
       for (let i = 0; i < maxIndex; i++) {
-        const path5 = paths[i];
-        if (isExecutionUncertain(path5.parent.type, path5.parentKey)) {
+        const path6 = paths[i];
+        if (isExecutionUncertain(path6.parent.type, path6.parentKey)) {
           return true;
         }
       }
@@ -42152,10 +42152,10 @@ var require_introspection = __commonJS({
         this: 0
       };
       while (!commonPath && commonIndex.this < paths.this.length) {
-        const path5 = paths.this[commonIndex.this];
-        commonIndex.target = paths.target.indexOf(path5);
+        const path6 = paths.this[commonIndex.this];
+        commonIndex.target = paths.target.indexOf(path6);
         if (commonIndex.target >= 0) {
-          commonPath = path5;
+          commonPath = path6;
         } else {
           commonIndex.this++;
         }
@@ -42193,13 +42193,13 @@ var require_introspection = __commonJS({
       if (!binding.references) return "before";
       const referencePaths = binding.referencePaths;
       let allStatus;
-      for (const path5 of referencePaths) {
-        const childOfFunction = !!path5.find((path6) => path6.node === target.node);
+      for (const path6 of referencePaths) {
+        const childOfFunction = !!path6.find((path7) => path7.node === target.node);
         if (childOfFunction) continue;
-        if (path5.key !== "callee" || !path5.parentPath.isCallExpression()) {
+        if (path6.key !== "callee" || !path6.parentPath.isCallExpression()) {
           return "unknown";
         }
-        const status = _guessExecutionStatusRelativeToCached(base, path5, cache);
+        const status = _guessExecutionStatusRelativeToCached(base, path6, cache);
         if (allStatus && allStatus !== status) {
           return "unknown";
         } else {
@@ -42317,19 +42317,19 @@ var require_introspection = __commonJS({
     }
     function isInStrictMode() {
       const start = this.isProgram() ? this : this.parentPath;
-      const strictParent = start.find((path5) => {
-        if (path5.isProgram({
+      const strictParent = start.find((path6) => {
+        if (path6.isProgram({
           sourceType: "module"
         })) return true;
-        if (path5.isClass()) return true;
-        if (path5.isArrowFunctionExpression() && !path5.get("body").isBlockStatement()) {
+        if (path6.isClass()) return true;
+        if (path6.isArrowFunctionExpression() && !path6.get("body").isBlockStatement()) {
           return false;
         }
         let body;
-        if (path5.isFunction()) {
-          body = path5.node.body;
-        } else if (path5.isProgram()) {
-          body = path5.node;
+        if (path6.isFunction()) {
+          body = path6.node.body;
+        } else if (path6.isProgram()) {
+          body = path6.node;
         } else {
           return false;
         }
@@ -42378,16 +42378,16 @@ var require_family = __commonJS({
     } = _t;
     var NORMAL_COMPLETION = 0;
     var BREAK_COMPLETION = 1;
-    function NormalCompletion(path5) {
+    function NormalCompletion(path6) {
       return {
         type: NORMAL_COMPLETION,
-        path: path5
+        path: path6
       };
     }
-    function BreakCompletion(path5) {
+    function BreakCompletion(path6) {
       return {
         type: BREAK_COMPLETION,
-        path: path5
+        path: path6
       };
     }
     function getOpposite() {
@@ -42398,9 +42398,9 @@ var require_family = __commonJS({
       }
       return null;
     }
-    function addCompletionRecords(path5, records, context) {
-      if (path5) {
-        records.push(..._getCompletionRecords(path5, context));
+    function addCompletionRecords(path6, records, context) {
+      if (path6) {
+        records.push(..._getCompletionRecords(path6, context));
       }
       return records;
     }
@@ -42450,16 +42450,16 @@ var require_family = __commonJS({
       if (context.canHaveBreak) {
         let lastNormalCompletions = [];
         for (let i = 0; i < paths.length; i++) {
-          const path5 = paths[i];
+          const path6 = paths[i];
           const newContext = Object.assign({}, context, {
             inCaseClause: false
           });
-          if (path5.isBlockStatement() && (context.inCaseClause || context.shouldPopulateBreak)) {
+          if (path6.isBlockStatement() && (context.inCaseClause || context.shouldPopulateBreak)) {
             newContext.shouldPopulateBreak = true;
           } else {
             newContext.shouldPopulateBreak = false;
           }
-          const statementCompletions = _getCompletionRecords(path5, newContext);
+          const statementCompletions = _getCompletionRecords(path6, newContext);
           if (statementCompletions.length > 0 && statementCompletions.every((c) => c.type === BREAK_COMPLETION)) {
             if (lastNormalCompletions.length > 0 && statementCompletions.every((c) => c.path.isBreakStatement({
               label: null
@@ -42509,35 +42509,35 @@ var require_family = __commonJS({
       }
       return completions;
     }
-    function _getCompletionRecords(path5, context) {
+    function _getCompletionRecords(path6, context) {
       let records = [];
-      if (path5.isIfStatement()) {
-        records = addCompletionRecords(path5.get("consequent"), records, context);
-        records = addCompletionRecords(path5.get("alternate"), records, context);
-      } else if (path5.isDoExpression() || path5.isFor() || path5.isWhile() || path5.isLabeledStatement()) {
-        return addCompletionRecords(path5.get("body"), records, context);
-      } else if (path5.isProgram() || path5.isBlockStatement()) {
-        return getStatementListCompletion(path5.get("body"), context);
-      } else if (path5.isFunction()) {
-        return _getCompletionRecords(path5.get("body"), context);
-      } else if (path5.isTryStatement()) {
-        records = addCompletionRecords(path5.get("block"), records, context);
-        records = addCompletionRecords(path5.get("handler"), records, context);
-      } else if (path5.isCatchClause()) {
-        return addCompletionRecords(path5.get("body"), records, context);
-      } else if (path5.isSwitchStatement()) {
-        return completionRecordForSwitch(path5.get("cases"), records, context);
-      } else if (path5.isSwitchCase()) {
-        return getStatementListCompletion(path5.get("consequent"), {
+      if (path6.isIfStatement()) {
+        records = addCompletionRecords(path6.get("consequent"), records, context);
+        records = addCompletionRecords(path6.get("alternate"), records, context);
+      } else if (path6.isDoExpression() || path6.isFor() || path6.isWhile() || path6.isLabeledStatement()) {
+        return addCompletionRecords(path6.get("body"), records, context);
+      } else if (path6.isProgram() || path6.isBlockStatement()) {
+        return getStatementListCompletion(path6.get("body"), context);
+      } else if (path6.isFunction()) {
+        return _getCompletionRecords(path6.get("body"), context);
+      } else if (path6.isTryStatement()) {
+        records = addCompletionRecords(path6.get("block"), records, context);
+        records = addCompletionRecords(path6.get("handler"), records, context);
+      } else if (path6.isCatchClause()) {
+        return addCompletionRecords(path6.get("body"), records, context);
+      } else if (path6.isSwitchStatement()) {
+        return completionRecordForSwitch(path6.get("cases"), records, context);
+      } else if (path6.isSwitchCase()) {
+        return getStatementListCompletion(path6.get("consequent"), {
           canHaveBreak: true,
           shouldPopulateBreak: false,
           inCaseClause: true,
           shouldPreserveBreak: context.shouldPreserveBreak
         });
-      } else if (path5.isBreakStatement()) {
-        records.push(BreakCompletion(path5));
+      } else if (path6.isBreakStatement()) {
+        records.push(BreakCompletion(path6));
       } else {
-        records.push(NormalCompletion(path5));
+        records.push(NormalCompletion(path6));
       }
       return records;
     }
@@ -42617,19 +42617,19 @@ var require_family = __commonJS({
       }
     }
     function _getPattern(parts, context) {
-      let path5 = this;
+      let path6 = this;
       for (const part of parts) {
         if (part === ".") {
-          path5 = path5.parentPath;
+          path6 = path6.parentPath;
         } else {
-          if (Array.isArray(path5)) {
-            path5 = path5[part];
+          if (Array.isArray(path6)) {
+            path6 = path6[part];
           } else {
-            path5 = path5.get(part, context);
+            path6 = path6.get(part, context);
           }
         }
       }
-      return path5;
+      return path6;
     }
     function getAssignmentIdentifiers() {
       return _getAssignmentIdentifiers(this.node);
@@ -42641,8 +42641,8 @@ var require_family = __commonJS({
       return _getOuterBindingIdentifiers(this.node, duplicates);
     }
     function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
-      const path5 = this;
-      const search = [path5];
+      const path6 = this;
+      const search = [path6];
       const ids = /* @__PURE__ */ Object.create(null);
       while (search.length) {
         const id = search.shift();
@@ -42841,13 +42841,13 @@ var require_path = __commonJS({
         }
         const targetNode = container[key];
         const paths = cache.getOrCreateCachedPaths(parent, parentPath);
-        let path5 = paths.get(targetNode);
-        if (!path5) {
-          path5 = new NodePath(hub, parent);
-          if (targetNode) paths.set(targetNode, path5);
+        let path6 = paths.get(targetNode);
+        if (!path6) {
+          path6 = new NodePath(hub, parent);
+          if (targetNode) paths.set(targetNode, path6);
         }
-        _context.setup.call(path5, parentPath, container, listKey, key);
-        return path5;
+        _context.setup.call(path6, parentPath, container, listKey, key);
+        return path6;
       }
       getScope(scope) {
         return this.isScope() ? new _index2.default(this) : scope;
@@ -42881,12 +42881,12 @@ var require_path = __commonJS({
       }
       getPathLocation() {
         const parts = [];
-        let path5 = this;
+        let path6 = this;
         do {
-          let key = path5.key;
-          if (path5.inList) key = `${path5.listKey}[${key}]`;
+          let key = path6.key;
+          if (path6.inList) key = `${path6.listKey}[${key}]`;
           parts.unshift(key);
-        } while (path5 = path5.parentPath);
+        } while (path6 = path6.parentPath);
         return parts.join(".");
       }
       debug(message) {
@@ -43092,12 +43092,12 @@ var require_context = __commonJS({
           listKey
         });
       }
-      maybeQueue(path5, notPriority) {
+      maybeQueue(path6, notPriority) {
         if (this.queue) {
           if (notPriority) {
-            this.queue.push(path5);
+            this.queue.push(path6);
           } else {
-            this.priorityQueue.push(path5);
+            this.priorityQueue.push(path6);
           }
         }
       }
@@ -43126,20 +43126,20 @@ var require_context = __commonJS({
         let stop = false;
         let visitIndex = 0;
         for (; visitIndex < queue.length; ) {
-          const path5 = queue[visitIndex];
+          const path6 = queue[visitIndex];
           visitIndex++;
-          _context.resync.call(path5);
+          _context.resync.call(path6);
           ;
-          if (path5.contexts.length === 0 || path5.contexts[path5.contexts.length - 1] !== this) {
-            _context.pushContext.call(path5, this);
+          if (path6.contexts.length === 0 || path6.contexts[path6.contexts.length - 1] !== this) {
+            _context.pushContext.call(path6, this);
           }
-          if (path5.key === null) continue;
+          if (path6.key === null) continue;
           const {
             node
-          } = path5;
+          } = path6;
           if (visited.has(node)) continue;
           if (node) visited.add(node);
-          if (path5.visit()) {
+          if (path6.visit()) {
             stop = true;
             break;
           }
@@ -43186,14 +43186,14 @@ var require_traverse_node = __commonJS({
     var {
       VISITOR_KEYS
     } = _t;
-    function traverseNode(node, opts, scope, state, path5, skipKeys, visitSelf) {
+    function traverseNode(node, opts, scope, state, path6, skipKeys, visitSelf) {
       ;
       const keys = VISITOR_KEYS[node.type];
       if (!keys) return false;
-      const context = new _context.default(scope, opts, state, path5);
+      const context = new _context.default(scope, opts, state, path6);
       if (visitSelf) {
-        if (skipKeys != null && skipKeys[path5.parentKey]) return false;
-        return context.visitQueue([path5]);
+        if (skipKeys != null && skipKeys[path6.parentKey]) return false;
+        return context.visitQueue([path6]);
       }
       for (const key of keys) {
         if (skipKeys != null && skipKeys[key]) continue;
@@ -43276,11 +43276,11 @@ var require_context2 = __commonJS({
     {
       exports2.isBlacklisted = isDenylisted;
     }
-    function restoreContext(path5, context) {
-      if (path5.context !== context) {
-        path5.context = context;
-        path5.state = context.state;
-        path5.opts = context.opts;
+    function restoreContext(path6, context) {
+      if (path6.context !== context) {
+        path6.context = context;
+        path6.state = context.state;
+        path6.opts = context.opts;
       }
     }
     function visit() {
@@ -43321,16 +43321,16 @@ var require_context2 = __commonJS({
     function setScope() {
       var _this$opts2, _this$scope;
       if ((_this$opts2 = this.opts) != null && _this$opts2.noScope) return;
-      let path5 = this.parentPath;
-      if ((this.key === "key" || this.listKey === "decorators") && path5.isMethod() || this.key === "discriminant" && path5.isSwitchStatement()) {
-        path5 = path5.parentPath;
+      let path6 = this.parentPath;
+      if ((this.key === "key" || this.listKey === "decorators") && path6.isMethod() || this.key === "discriminant" && path6.isSwitchStatement()) {
+        path6 = path6.parentPath;
       }
       let target;
-      while (path5 && !target) {
+      while (path6 && !target) {
         var _path$opts;
-        if ((_path$opts = path5.opts) != null && _path$opts.noScope) return;
-        target = path5.scope;
-        path5 = path5.parentPath;
+        if ((_path$opts = path6.opts) != null && _path$opts.noScope) return;
+        target = path6.scope;
+        path6 = path6.parentPath;
       }
       this.scope = this.getScope(target);
       (_this$scope = this.scope) == null || _this$scope.init();
@@ -43439,12 +43439,12 @@ var require_context2 = __commonJS({
       }
     }
     function _getQueueContexts() {
-      let path5 = this;
+      let path6 = this;
       let contexts = this.contexts;
       while (!contexts.length) {
-        path5 = path5.parentPath;
-        if (!path5) break;
-        contexts = path5.contexts;
+        path6 = path6.parentPath;
+        if (!path6) break;
+        contexts = path6.contexts;
       }
       return contexts;
     }
@@ -43539,8 +43539,8 @@ var require_lib8 = __commonJS({
       traverseFast(node, enter);
       return;
     };
-    traverse2.node = function(node, opts, scope, state, path5, skipKeys) {
-      (0, _traverseNode.traverseNode)(node, opts, scope, state, path5, skipKeys);
+    traverse2.node = function(node, opts, scope, state, path6, skipKeys) {
+      (0, _traverseNode.traverseNode)(node, opts, scope, state, path6, skipKeys);
     };
     traverse2.clearNode = function(node, opts) {
       removeProperties(node, opts);
@@ -43567,799 +43567,15 @@ var require_lib8 = __commonJS({
 
 // index.ts
 var import_node_child_process = require("node:child_process");
-var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
 var import_node_util = require("node:util");
 
-// src/constants.ts
-var DEFAULT_MIN_LINES = 4;
-var DEFAULT_SIMILARITY = 0.7;
-var DEFAULT_EXTENSIONS = ["ts", "tsx", "js", "jsx"];
-var DEFAULT_IGNORE_PATTERNS = [
-  "node_modules",
-  "dist",
-  ".git",
-  "build",
-  ".next",
-  "coverage",
-  ".turbo",
-  ".cache",
-  // Generated/data files that often have intentional repetition
-  "drizzle/migrations",
-  "migrations",
-  "assets/data",
-  "__generated__",
-  ".generated",
-  "generated"
-];
-var MAX_BLOCK_SIZE = 100;
-var BLOCK_SIZE_MULTIPLIER = 1.5;
-var MIN_MEANINGFUL_LINE_RATIO = 0.6;
-var SLIDING_WINDOW_STEP_DIVISOR = 2;
-var SKIP_LINE_PREFIXES = [
-  "//",
-  // Single-line comments
-  "/*",
-  // Multi-line comment start
-  "*",
-  // Multi-line comment continuation
-  "import ",
-  // Import statements
-  "export {"
-  // Re-exports
-];
-var SIZE_BUCKET_DIVISOR = 5;
-var MAX_SIMILARITY_SAMPLES = 5;
-var MIN_OCCURRENCES = 2;
-var GROUP_OVERLAP_THRESHOLD = 0.5;
-var STRING_PLACEHOLDER = "<STRING>";
-var TEMPLATE_PLACEHOLDER = "<TEMPLATE>";
-var NUMBER_PLACEHOLDER = "<NUMBER>";
-var COLOR_PLACEHOLDER = "<COLOR>";
-var MAX_PATH_DISPLAY_LENGTH = 60;
-var CODE_PREVIEW_CONTEXT_LINES = 3;
-var MAX_MATCHES_IN_SUMMARY = 5;
-var MAX_GROUPS_DETAILED = 20;
-var SECTION_SEPARATOR = "\u2500".repeat(80);
-var COLORS = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  magenta: "\x1B[35m",
-  cyan: "\x1B[36m",
-  white: "\x1B[37m",
-  gray: "\x1B[90m"
-};
-var MAX_FILE_SIZE = 1024 * 1024;
-var MAX_BLOCKS_FOR_SIMILARITY = 1e4;
-
-// src/normalizer.ts
-function normalizeCode(code) {
-  let normalized = code;
-  normalized = normalized.replace(/"(?:[^"\\]|\\.)*"/g, `"${STRING_PLACEHOLDER}"`);
-  normalized = normalized.replace(/'(?:[^'\\]|\\.)*'/g, `'${STRING_PLACEHOLDER}'`);
-  normalized = normalized.replace(/`(?:[^`\\]|\\.)*`/g, `\`${TEMPLATE_PLACEHOLDER}\``);
-  normalized = normalized.replace(/\b\d+\.?\d*\b/g, NUMBER_PLACEHOLDER);
-  normalized = normalized.replace(/#[0-9a-fA-F]{3,8}\b/g, COLOR_PLACEHOLDER);
-  normalized = normalized.replace(/[ \t]+/g, " ");
-  normalized = normalized.split("\n").map((line) => line.trimEnd()).join("\n");
-  normalized = normalized.replace(/\n\s*\n/g, "\n");
-  return normalized;
-}
-
-// src/declarations.ts
-function simpleHash(str) {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return hash.toString(36);
-}
-var DECLARATION_PATTERNS = [
-  // Type aliases: type X = ... or export type X = ...
-  { type: "type", regex: /^(export\s+)?type\s+([A-Z]\w*)\s*(?:<[^>]*>)?\s*=/m, nameGroup: 2 },
-  // Interfaces: interface X { or export interface X {
-  { type: "interface", regex: /^(export\s+)?interface\s+([A-Z]\w*)\s*(?:<[^>]*>)?\s*(?:extends\s+[^{]+)?\{/m, nameGroup: 2 },
-  // Classes: class X { or export class X {
-  { type: "class", regex: /^(export\s+)?(?:abstract\s+)?class\s+([A-Z]\w*)\s*(?:<[^>]*>)?\s*(?:extends\s+\w+)?\s*(?:implements\s+[^{]+)?\{/m, nameGroup: 2 },
-  // Enums: enum X { or export enum X {
-  { type: "enum", regex: /^(export\s+)?(?:const\s+)?enum\s+([A-Z]\w*)\s*\{/m, nameGroup: 2 },
-  // Named functions: function x( or export function x( or export async function x(
-  { type: "function", regex: /^(export\s+)?(?:async\s+)?function\s+([a-zA-Z]\w*)\s*(?:<[^>]*>)?\s*\(/m, nameGroup: 2 },
-  // Arrow functions: const x = ( or export const x = async (
-  { type: "function", regex: /^(export\s+)?const\s+([a-zA-Z]\w*)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s*)?\(/m, nameGroup: 2 },
-  // Arrow functions with generics: const x = <T>(
-  { type: "function", regex: /^(export\s+)?const\s+([a-zA-Z]\w*)\s*=\s*<[^>]+>\s*\(/m, nameGroup: 2 },
-  // Constants (non-function): export const X = "..." or const X = {...}
-  { type: "const", regex: /^(export\s+)?const\s+([A-Z][A-Z_0-9]*)\s*(?::\s*[^=]+)?\s*=/m, nameGroup: 2 }
-];
-function findMatchingBrace(content, startIndex) {
-  let depth = 0;
-  let inString = false;
-  let stringChar = "";
-  let inTemplate = false;
-  for (let i = startIndex; i < content.length; i++) {
-    const char = content[i];
-    const prevChar = content[i - 1];
-    if (inString) {
-      if (char === stringChar && prevChar !== "\\") {
-        inString = false;
-      }
-      continue;
-    }
-    if (inTemplate) {
-      if (char === "`" && prevChar !== "\\") {
-        inTemplate = false;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      inString = true;
-      stringChar = char;
-      continue;
-    }
-    if (char === "`") {
-      inTemplate = true;
-      continue;
-    }
-    if (char === "{") depth++;
-    if (char === "}") {
-      depth--;
-      if (depth === 0) return i;
-    }
-  }
-  return -1;
-}
-function findStatementEnd(content, startIndex) {
-  let depth = 0;
-  let inString = false;
-  let stringChar = "";
-  for (let i = startIndex; i < content.length; i++) {
-    const char = content[i];
-    const prevChar = content[i - 1];
-    if (inString) {
-      if (char === stringChar && prevChar !== "\\") {
-        inString = false;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      inString = true;
-      stringChar = char;
-      continue;
-    }
-    if (char === "(" || char === "{" || char === "[") depth++;
-    if (char === ")" || char === "}" || char === "]") depth--;
-    if (depth === 0 && (char === ";" || char === "\n")) {
-      const remaining = content.slice(i + 1).trimStart();
-      if (!remaining.startsWith("|") && !remaining.startsWith("&")) {
-        return i;
-      }
-    }
-  }
-  return content.length - 1;
-}
-var QUICK_CHECK = /^(export\s+)?(type|interface|class|enum|const|function|async\s+function)\s+/;
-function extractDeclarations(content, filePath) {
-  const declarations = [];
-  const lines = content.split("\n");
-  let lineStart = 0;
-  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
-    const line = lines[lineIndex];
-    if (!line) continue;
-    const trimmed = line.trimStart();
-    if (!QUICK_CHECK.test(trimmed)) {
-      lineStart += line.length + 1;
-      continue;
-    }
-    const remainingContent = content.slice(lineStart);
-    for (const pattern of DECLARATION_PATTERNS) {
-      const match2 = remainingContent.match(pattern.regex);
-      if (match2 && match2.index === 0) {
-        const name = match2[pattern.nameGroup];
-        if (!name) continue;
-        const exported = !!match2[1];
-        let endIndex;
-        if (pattern.type === "interface" || pattern.type === "class" || pattern.type === "enum") {
-          const braceStart = remainingContent.indexOf("{");
-          if (braceStart === -1) continue;
-          endIndex = findMatchingBrace(remainingContent, braceStart);
-          if (endIndex === -1) endIndex = remainingContent.indexOf("\n", braceStart + 1);
-        } else if (pattern.type === "type") {
-          endIndex = findStatementEnd(remainingContent, match2[0].length);
-        } else {
-          const hasArrow = remainingContent.slice(match2[0].length, match2[0].length + 100).includes("=>");
-          if (hasArrow) {
-            const arrowIndex = remainingContent.indexOf("=>", match2[0].length);
-            const afterArrow = remainingContent.slice(arrowIndex + 2).trimStart();
-            if (afterArrow.startsWith("{")) {
-              const braceStart = arrowIndex + 2 + (remainingContent.slice(arrowIndex + 2).length - afterArrow.length);
-              endIndex = findMatchingBrace(remainingContent, braceStart);
-            } else {
-              endIndex = findStatementEnd(remainingContent, arrowIndex + 2);
-            }
-          } else {
-            const braceIndex = remainingContent.indexOf("{", match2[0].length);
-            const newlineIndex = remainingContent.indexOf("\n", match2[0].length);
-            if (braceIndex !== -1 && (newlineIndex === -1 || braceIndex < newlineIndex)) {
-              endIndex = findMatchingBrace(remainingContent, braceIndex);
-            } else {
-              endIndex = findStatementEnd(remainingContent, match2[0].length);
-            }
-          }
-        }
-        if (endIndex === -1) endIndex = remainingContent.indexOf("\n\n");
-        if (endIndex === -1) endIndex = Math.min(remainingContent.length - 1, 500);
-        const declarationContent = remainingContent.slice(0, endIndex + 1).trim();
-        const endLineIndex = lineIndex + declarationContent.split("\n").length - 1;
-        const normalized = normalizeCode(declarationContent);
-        declarations.push({
-          type: pattern.type,
-          name,
-          content: declarationContent,
-          normalized,
-          hash: simpleHash(normalized),
-          filePath,
-          startLine: lineIndex + 1,
-          endLine: endLineIndex + 1,
-          exported
-        });
-        break;
-      }
-    }
-    lineStart += line.length + 1;
-  }
-  return declarations;
-}
-function calculateNameSimilarity(a, b) {
-  if (a === b) return 1;
-  const aLower = a.toLowerCase();
-  const bLower = b.toLowerCase();
-  if (aLower === bLower) return 0.95;
-  if (aLower.includes(bLower) || bLower.includes(aLower)) return 0.8;
-  const aWords = splitCamelCase(a);
-  const bWords = splitCamelCase(b);
-  const aSet = new Set(aWords.map((w) => w.toLowerCase()));
-  const bSet = new Set(bWords.map((w) => w.toLowerCase()));
-  let intersection = 0;
-  for (const word of aSet) {
-    if (bSet.has(word)) intersection++;
-  }
-  const union = aSet.size + bSet.size - intersection;
-  const wordSimilarity = union > 0 ? intersection / union : 0;
-  if (wordSimilarity > 0.5) return wordSimilarity * 0.9;
-  const distance = levenshteinDistance(aLower, bLower);
-  const maxLen = Math.max(aLower.length, bLower.length);
-  return Math.max(0, 1 - distance / maxLen) * 0.7;
-}
-function splitCamelCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_-]/g, " ").split(/\s+/).filter((w) => w.length > 0);
-}
-function levenshteinDistance(a, b) {
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-  const matrix = Array.from(
-    { length: b.length + 1 },
-    (_, i) => Array.from({ length: a.length + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
-  );
-  for (let i = 1; i <= b.length; i++) {
-    for (let j = 1; j <= a.length; j++) {
-      const prevRow = matrix[i - 1];
-      const currRow = matrix[i];
-      if (!prevRow || !currRow) continue;
-      if (b[i - 1] === a[j - 1]) {
-        currRow[j] = prevRow[j - 1] ?? 0;
-      } else {
-        currRow[j] = Math.min(
-          (prevRow[j - 1] ?? 0) + 1,
-          (currRow[j - 1] ?? 0) + 1,
-          (prevRow[j] ?? 0) + 1
-        );
-      }
-    }
-  }
-  return matrix[b.length]?.[a.length] ?? Math.max(a.length, b.length);
-}
-
-// src/detector.ts
-function calculateSimilarityFast(a, b) {
-  if (a === b) return 1;
-  if (a.length === 0 || b.length === 0) return 0;
-  const linesA = a.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
-  const linesB = b.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
-  if (linesA.length === 0 || linesB.length === 0) return 0;
-  const lenRatio = Math.min(linesA.length, linesB.length) / Math.max(linesA.length, linesB.length);
-  if (lenRatio < 0.5) return lenRatio * 0.5;
-  const setA = new Set(linesA);
-  const setB = new Set(linesB);
-  let intersection = 0;
-  for (const line of setA) {
-    if (setB.has(line)) {
-      intersection++;
-    }
-  }
-  const union = setA.size + setB.size - intersection;
-  return union > 0 ? intersection / union : 0;
-}
-function getFingerprint(normalized) {
-  const lines = normalized.split("\n");
-  if (lines.length < 3) return normalized.slice(0, 100);
-  const first = lines.slice(0, 2).join("");
-  const mid = lines[Math.floor(lines.length / 2)] ?? "";
-  const last = lines.slice(-2).join("");
-  return (first + mid + last).slice(0, 200);
-}
-var UnionFind = class {
-  parent = /* @__PURE__ */ new Map();
-  rank = /* @__PURE__ */ new Map();
-  find(x) {
-    if (!this.parent.has(x)) {
-      this.parent.set(x, x);
-      this.rank.set(x, 0);
-    }
-    const parentVal = this.parent.get(x);
-    if (parentVal !== void 0 && parentVal !== x) {
-      const root = this.find(parentVal);
-      this.parent.set(x, root);
-      return root;
-    }
-    return this.parent.get(x) ?? x;
-  }
-  union(x, y) {
-    const rootX = this.find(x);
-    const rootY = this.find(y);
-    if (rootX === rootY) return;
-    const rankX = this.rank.get(rootX) ?? 0;
-    const rankY = this.rank.get(rootY) ?? 0;
-    if (rankX < rankY) {
-      this.parent.set(rootX, rootY);
-    } else if (rankX > rankY) {
-      this.parent.set(rootY, rootX);
-    } else {
-      this.parent.set(rootY, rootX);
-      this.rank.set(rootX, rankX + 1);
-    }
-  }
-};
-function findDuplicates(blocks, minSimilarity, basePath) {
-  const hashGroups = /* @__PURE__ */ new Map();
-  for (const block of blocks) {
-    const existing = hashGroups.get(block.hash) ?? [];
-    existing.push(block);
-    hashGroups.set(block.hash, existing);
-  }
-  const exactDuplicates = [];
-  let groupId = 0;
-  for (const [, groupBlocks] of hashGroups) {
-    const uniqueLocations = filterOverlappingBlocks(groupBlocks);
-    if (uniqueLocations.length >= MIN_OCCURRENCES) {
-      exactDuplicates.push({
-        id: groupId++,
-        similarity: 1,
-        lineCount: uniqueLocations[0]?.lineCount ?? 0,
-        occurrences: uniqueLocations.length,
-        matches: uniqueLocations.map((b) => ({
-          filePath: b.filePath,
-          startLine: b.startLine,
-          endLine: b.endLine,
-          content: b.content
-        })),
-        pattern: uniqueLocations[0]?.normalized ?? ""
-      });
-    }
-  }
-  const similarDuplicates = [];
-  const uniqueHashCount = hashGroups.size;
-  if (minSimilarity < 1 && uniqueHashCount <= MAX_BLOCKS_FOR_SIMILARITY) {
-    const uniqueBlocks = [];
-    const seenHashes = /* @__PURE__ */ new Set();
-    for (const block of blocks) {
-      if (!seenHashes.has(block.hash)) {
-        seenHashes.add(block.hash);
-        uniqueBlocks.push(block);
-      }
-    }
-    const sizeGroups = /* @__PURE__ */ new Map();
-    for (const block of uniqueBlocks) {
-      const sizeKey = Math.floor(block.lineCount / SIZE_BUCKET_DIVISOR);
-      const existing = sizeGroups.get(sizeKey) ?? [];
-      existing.push(block);
-      sizeGroups.set(sizeKey, existing);
-    }
-    const fingerprints = /* @__PURE__ */ new Map();
-    for (const block of uniqueBlocks) {
-      fingerprints.set(block, getFingerprint(block.normalized));
-    }
-    const uf = new UnionFind();
-    const blockIndexMap = /* @__PURE__ */ new Map();
-    for (let i = 0; i < uniqueBlocks.length; i++) {
-      const block = uniqueBlocks[i];
-      if (block) blockIndexMap.set(block, i);
-    }
-    for (const [sizeKey, sizeGroup] of sizeGroups) {
-      const adjacentGroups = [
-        sizeGroups.get(sizeKey - 1) ?? [],
-        sizeGroup,
-        sizeGroups.get(sizeKey + 1) ?? []
-      ].flat();
-      const maxComparisons = 1e3;
-      let comparisons = 0;
-      for (let i = 0; i < sizeGroup.length && comparisons < maxComparisons; i++) {
-        const blockA = sizeGroup[i];
-        if (!blockA) continue;
-        const fpA = fingerprints.get(blockA) ?? "";
-        for (let j = 0; j < adjacentGroups.length && comparisons < maxComparisons; j++) {
-          const blockB = adjacentGroups[j];
-          if (!blockB) continue;
-          if (blockA === blockB) continue;
-          if (blockA.hash === blockB.hash) continue;
-          const fpB = fingerprints.get(blockB) ?? "";
-          const fpSimilarity = calculateSimilarityFast(fpA, fpB);
-          if (fpSimilarity < minSimilarity * 0.5) continue;
-          comparisons++;
-          const similarity = calculateSimilarityFast(blockA.normalized, blockB.normalized);
-          if (similarity >= minSimilarity) {
-            const idxA = blockIndexMap.get(blockA);
-            const idxB = blockIndexMap.get(blockB);
-            if (idxA !== void 0 && idxB !== void 0) {
-              uf.union(idxA, idxB);
-            }
-          }
-        }
-      }
-    }
-    const groupMap = /* @__PURE__ */ new Map();
-    for (const block of uniqueBlocks) {
-      const idx = blockIndexMap.get(block);
-      if (idx === void 0) continue;
-      const root = uf.find(idx);
-      const existing = groupMap.get(root) ?? [];
-      existing.push(block);
-      groupMap.set(root, existing);
-    }
-    for (const [, groupBlocks] of groupMap) {
-      if (groupBlocks.length < MIN_OCCURRENCES) continue;
-      const expandedBlocks = [];
-      for (const block of groupBlocks) {
-        const matching = hashGroups.get(block.hash) ?? [];
-        expandedBlocks.push(...matching);
-      }
-      const uniqueLocations = filterOverlappingBlocks(expandedBlocks);
-      if (uniqueLocations.length >= MIN_OCCURRENCES) {
-        let totalSim = 0;
-        let comparisons = 0;
-        const sampleSize = Math.min(groupBlocks.length, MAX_SIMILARITY_SAMPLES);
-        for (let i = 0; i < sampleSize; i++) {
-          for (let j = i + 1; j < sampleSize; j++) {
-            const blockI = groupBlocks[i];
-            const blockJ = groupBlocks[j];
-            if (blockI && blockJ) {
-              totalSim += calculateSimilarityFast(blockI.normalized, blockJ.normalized);
-              comparisons++;
-            }
-          }
-        }
-        const avgSimilarity = comparisons > 0 ? totalSim / comparisons : 1;
-        similarDuplicates.push({
-          id: groupId++,
-          similarity: avgSimilarity,
-          lineCount: Math.round(
-            uniqueLocations.reduce((sum, b) => sum + b.lineCount, 0) / uniqueLocations.length
-          ),
-          occurrences: uniqueLocations.length,
-          matches: uniqueLocations.map((b) => ({
-            filePath: b.filePath,
-            startLine: b.startLine,
-            endLine: b.endLine,
-            content: b.content
-          })),
-          pattern: groupBlocks[0]?.normalized ?? ""
-        });
-      }
-    }
-  }
-  const filteredSimilar = similarDuplicates.filter((g) => g.similarity >= minSimilarity);
-  const allDuplicates = [...exactDuplicates, ...filteredSimilar];
-  allDuplicates.sort((a, b) => {
-    const impactA = a.occurrences * a.lineCount;
-    const impactB = b.occurrences * b.lineCount;
-    return impactB - impactA;
-  });
-  const dedupedGroups = deduplicateGroups(allDuplicates);
-  return dedupedGroups.map((group) => ({
-    ...group,
-    suggestion: generateRefactoringSuggestion(group, basePath)
-  }));
-}
-function filterOverlappingBlocks(blocks) {
-  const byFile = /* @__PURE__ */ new Map();
-  for (const block of blocks) {
-    const existing = byFile.get(block.filePath) ?? [];
-    existing.push(block);
-    byFile.set(block.filePath, existing);
-  }
-  const result = [];
-  for (const [, fileBlocks] of byFile) {
-    fileBlocks.sort((a, b) => a.startLine - b.startLine);
-    const kept = [];
-    for (const block of fileBlocks) {
-      const overlaps = kept.some(
-        (k) => block.startLine >= k.startLine && block.startLine <= k.endLine || block.endLine >= k.startLine && block.endLine <= k.endLine || block.startLine <= k.startLine && block.endLine >= k.endLine
-      );
-      if (!overlaps) {
-        kept.push(block);
-      }
-    }
-    result.push(...kept);
-  }
-  return result;
-}
-function extractPackageInfo(filePath) {
-  const match2 = filePath.match(/(apps|packages|libs)\/([^/]+)\/(.+)/);
-  if (match2) {
-    return {
-      type: match2[1],
-      name: match2[2] ?? "unknown",
-      subPath: match2[3] ?? ""
-    };
-  }
-  const parts = filePath.split("/");
-  return {
-    type: "unknown",
-    name: parts[0] ?? "unknown",
-    subPath: parts.slice(1).join("/")
-  };
-}
-function inferSuggestedName(_pattern, matches) {
-  const firstMatch = matches[0];
-  if (!firstMatch) return void 0;
-  const content = firstMatch.content;
-  const patterns = [
-    // Schema definitions (Zod, etc)
-    { regex: /(?:const|export const)\s+([A-Z]\w*Schema)\s*=/, minLength: 6 },
-    // Type/interface definitions
-    { regex: /(?:export\s+)?interface\s+([A-Z]\w+)/, minLength: 3 },
-    { regex: /(?:export\s+)?type\s+([A-Z]\w+)\s*=/, minLength: 3 },
-    // Class definitions
-    { regex: /(?:export\s+)?class\s+([A-Z]\w+)/, minLength: 3 },
-    // Function definitions (exported or async)
-    { regex: /(?:export\s+)?(?:async\s+)?function\s+(\w{3,})\s*[(<]/, minLength: 3 },
-    // React component definitions
-    { regex: /(?:export\s+)?(?:const|function)\s+([A-Z]\w+)\s*[=:].*(?:React|FC|Component|=>)/, minLength: 3 },
-    // Named exports with PascalCase (likely important)
-    { regex: /(?:export\s+)?const\s+([A-Z]\w{2,})\s*=/, minLength: 3 },
-    // Arrow function assignments (camelCase, min 4 chars)
-    { regex: /(?:export\s+)?const\s+([a-z][a-zA-Z]{3,})\s*=\s*(?:async\s*)?\(/, minLength: 4 }
-  ];
-  for (const { regex, minLength } of patterns) {
-    const match2 = content.match(regex);
-    if (match2?.[1] && match2[1].length >= minLength) {
-      const skipNames = /* @__PURE__ */ new Set(["result", "data", "error", "response", "value", "item", "index", "key", "match", "pool", "client", "db"]);
-      if (!skipNames.has(match2[1].toLowerCase())) {
-        return match2[1];
-      }
-    }
-  }
-  const fileNames = matches.map((m) => {
-    const parts = m.filePath.split("/");
-    const fileName = parts[parts.length - 1] ?? "";
-    return fileName.replace(/\.(ts|tsx|js|jsx)$/, "");
-  });
-  const uniqueNames = [...new Set(fileNames)];
-  if (uniqueNames.length === 1 && uniqueNames[0] && uniqueNames[0].length >= 3) {
-    const name = uniqueNames[0];
-    if (name.includes("-") || name.includes("_")) {
-      return name.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-    }
-    return name;
-  }
-  return void 0;
-}
-function generateRefactoringSuggestion(group, _basePath) {
-  const matches = group.matches;
-  const packageInfos = matches.map((m) => extractPackageInfo(m.filePath));
-  const uniquePackages = /* @__PURE__ */ new Map();
-  for (const info of packageInfos) {
-    const key = `${info.type}/${info.name}`;
-    if (!uniquePackages.has(key)) {
-      uniquePackages.set(key, info);
-    }
-  }
-  const packageList = Array.from(uniquePackages.values());
-  const suggestedName = inferSuggestedName(group.pattern, matches);
-  if (packageList.length === 1 && packageList[0]) {
-    const pkg = packageList[0];
-    const subPaths = packageInfos.map((p) => p.subPath);
-    const commonPrefix = findCommonPrefix(subPaths);
-    if (pkg.type === "app") {
-      return {
-        targetLocation: `${pkg.type}s/${pkg.name}/lib/shared/${commonPrefix || "utils"}`,
-        reason: `All ${matches.length} occurrences are within ${pkg.name}`,
-        confidence: "high",
-        suggestedName
-      };
-    } else {
-      return {
-        targetLocation: `${pkg.type}/${pkg.name}/src/shared`,
-        reason: `All ${matches.length} occurrences are within ${pkg.name}`,
-        confidence: "high",
-        suggestedName
-      };
-    }
-  }
-  const hasOnlyApps = packageList.every((p) => p.type === "app");
-  if (hasOnlyApps) {
-    const appNames = packageList.map((p) => p.name);
-    return {
-      targetLocation: "packages/shared/src",
-      reason: `Duplicated across ${appNames.length} apps: ${appNames.join(", ")}`,
-      confidence: "high",
-      suggestedName
-    };
-  }
-  const packages = packageList.filter((p) => p.type === "package");
-  const apps = packageList.filter((p) => p.type === "app");
-  if (packages.length > 0) {
-    const sharedPackage = packages.find(
-      (p) => p.name === "shared" || p.name === "common" || p.name === "utils"
-    ) ?? packages[0];
-    if (!sharedPackage) return { targetLocation: "packages/shared/src", reason: "Duplicated across packages", confidence: "low", suggestedName };
-    return {
-      targetLocation: `packages/${sharedPackage.name}/src`,
-      reason: `Already exists in ${sharedPackage.name}, also duplicated in ${apps.map((a) => a.name).join(", ")}`,
-      confidence: "medium",
-      suggestedName
-    };
-  }
-  const libs = packageList.filter((p) => p.type === "lib");
-  if (libs.length > 0) {
-    return {
-      targetLocation: `libs/shared/src`,
-      reason: `Duplicated across ${libs.length} libraries`,
-      confidence: "medium",
-      suggestedName
-    };
-  }
-  return {
-    targetLocation: "packages/shared/src",
-    reason: `Duplicated across ${packageList.length} locations`,
-    confidence: "low",
-    suggestedName
-  };
-}
-function findCommonPrefix(paths) {
-  if (paths.length === 0) return "";
-  if (paths.length === 1) return paths[0]?.split("/")[0] ?? "";
-  const splitPaths = paths.map((p) => p.split("/"));
-  const minLength = Math.min(...splitPaths.map((p) => p.length));
-  const commonParts = [];
-  for (let i = 0; i < minLength - 1; i++) {
-    const part = splitPaths[0]?.[i];
-    if (part && splitPaths.every((p) => p[i] === part)) {
-      commonParts.push(part);
-    } else {
-      break;
-    }
-  }
-  return commonParts.join("/");
-}
-function rangesOverlap(aStart, aEnd, bStart, bEnd) {
-  return aStart <= bEnd && bStart <= aEnd;
-}
-function deduplicateGroups(groups) {
-  const result = [];
-  for (const group of groups) {
-    let coveredCount = 0;
-    for (const match2 of group.matches) {
-      let isCovered = false;
-      for (const existing of result) {
-        for (const existingMatch of existing.matches) {
-          if (match2.filePath === existingMatch.filePath && rangesOverlap(
-            match2.startLine,
-            match2.endLine,
-            existingMatch.startLine,
-            existingMatch.endLine
-          )) {
-            isCovered = true;
-            break;
-          }
-        }
-        if (isCovered) break;
-      }
-      if (isCovered) coveredCount++;
-    }
-    if (coveredCount < group.matches.length * GROUP_OVERLAP_THRESHOLD) {
-      result.push(group);
-    }
-  }
-  return result;
-}
-function findDeclarationDuplicates(declarations, minSimilarity) {
-  const duplicates = [];
-  let groupId = 0;
-  const byType = /* @__PURE__ */ new Map();
-  for (const decl of declarations) {
-    const existing = byType.get(decl.type) ?? [];
-    existing.push(decl);
-    byType.set(decl.type, existing);
-  }
-  for (const [type, typeDecls] of byType) {
-    const processed = /* @__PURE__ */ new Set();
-    for (let i = 0; i < typeDecls.length; i++) {
-      if (processed.has(i)) continue;
-      const declA = typeDecls[i];
-      if (!declA) continue;
-      const matches = [{
-        name: declA.name,
-        filePath: declA.filePath,
-        startLine: declA.startLine,
-        endLine: declA.endLine,
-        content: declA.content,
-        exported: declA.exported
-      }];
-      let bestNameSim = 0;
-      let bestContentSim = 0;
-      for (let j = i + 1; j < typeDecls.length; j++) {
-        if (processed.has(j)) continue;
-        const declB = typeDecls[j];
-        if (!declB) continue;
-        if (declA.filePath === declB.filePath && Math.abs(declA.startLine - declB.startLine) < 5) continue;
-        const nameSim = calculateNameSimilarity(declA.name, declB.name);
-        const contentSim = calculateSimilarityFast(declA.normalized, declB.normalized);
-        const combined = Math.max(
-          nameSim * 0.4 + contentSim * 0.6,
-          nameSim >= 0.9 ? nameSim : 0,
-          contentSim >= 0.9 ? contentSim : 0
-        );
-        if (combined >= minSimilarity || nameSim >= 0.8 && contentSim >= 0.5) {
-          processed.add(j);
-          matches.push({
-            name: declB.name,
-            filePath: declB.filePath,
-            startLine: declB.startLine,
-            endLine: declB.endLine,
-            content: declB.content,
-            exported: declB.exported
-          });
-          bestNameSim = Math.max(bestNameSim, nameSim);
-          bestContentSim = Math.max(bestContentSim, contentSim);
-        }
-      }
-      if (matches.length >= 2) {
-        processed.add(i);
-        const exported = matches.find((m) => m.exported);
-        const suggestion = exported ? `Import \`${exported.name}\` from \`${exported.filePath.replace(/.*\/(src|lib)\//, "")}\`` : `Consider extracting \`${declA.name}\` to a shared location`;
-        duplicates.push({
-          id: groupId++,
-          type,
-          similarity: Math.max(bestNameSim, bestContentSim),
-          nameSimilarity: bestNameSim,
-          contentSimilarity: bestContentSim,
-          matches,
-          suggestion
-        });
-      }
-    }
-  }
-  duplicates.sort((a, b) => {
-    const scoreA = a.matches.length * a.similarity;
-    const scoreB = b.matches.length * b.similarity;
-    return scoreB - scoreA;
-  });
-  return duplicates;
-}
-
 // src/ast.ts
 var import_parser = __toESM(require_lib(), 1);
 var import_traverse = __toESM(require_lib8(), 1);
 var t = __toESM(require_lib4(), 1);
 var traverse = import_traverse.default.default || import_traverse.default;
-function simpleHash2(str) {
+function simpleHash(str) {
   let hash = 0;
   for (let i = 0; i < str.length; i++) {
     hash = (hash << 5) - hash + str.charCodeAt(i);
@@ -44584,8 +43800,8 @@ function extractASTBlocks(content, filePath) {
       errorRecovery: true
     });
     traverse(ast, {
-      FunctionDeclaration(path5) {
-        const node = path5.node;
+      FunctionDeclaration(path6) {
+        const node = path6.node;
         if (!node.id || !node.loc || node.start === null || node.end === null) return;
         const idMap = /* @__PURE__ */ new Map();
         const counter = { val: 0 };
@@ -44595,15 +43811,15 @@ function extractASTBlocks(content, filePath) {
           name: node.id.name,
           content: content.slice(node.start, node.end),
           normalized,
-          hash: simpleHash2(normalized),
+          hash: simpleHash(normalized),
           filePath,
           startLine: node.loc.start.line,
           endLine: node.loc.end.line,
-          exported: t.isExportNamedDeclaration(path5.parent) || t.isExportDefaultDeclaration(path5.parent)
+          exported: t.isExportNamedDeclaration(path6.parent) || t.isExportDefaultDeclaration(path6.parent)
         });
       },
-      VariableDeclaration(path5) {
-        const node = path5.node;
+      VariableDeclaration(path6) {
+        const node = path6.node;
         for (const decl of node.declarations) {
           if (!t.isIdentifier(decl.id) || !decl.init || !decl.loc) continue;
           if (decl.start === null || decl.end === null) continue;
@@ -44616,16 +43832,16 @@ function extractASTBlocks(content, filePath) {
             name: decl.id.name,
             content: content.slice(decl.start, decl.end),
             normalized,
-            hash: simpleHash2(normalized),
+            hash: simpleHash(normalized),
             filePath,
             startLine: decl.loc.start.line,
             endLine: decl.loc.end.line,
-            exported: t.isExportNamedDeclaration(path5.parent)
+            exported: t.isExportNamedDeclaration(path6.parent)
           });
         }
       },
-      ClassDeclaration(path5) {
-        const node = path5.node;
+      ClassDeclaration(path6) {
+        const node = path6.node;
         if (!node.id || !node.loc || node.start === null || node.end === null) return;
         const idMap = /* @__PURE__ */ new Map();
         const counter = { val: 0 };
@@ -44635,15 +43851,15 @@ function extractASTBlocks(content, filePath) {
           name: node.id.name,
           content: content.slice(node.start, node.end),
           normalized,
-          hash: simpleHash2(normalized),
+          hash: simpleHash(normalized),
           filePath,
           startLine: node.loc.start.line,
           endLine: node.loc.end.line,
-          exported: t.isExportNamedDeclaration(path5.parent) || t.isExportDefaultDeclaration(path5.parent)
+          exported: t.isExportNamedDeclaration(path6.parent) || t.isExportDefaultDeclaration(path6.parent)
         });
       },
-      TSTypeAliasDeclaration(path5) {
-        const node = path5.node;
+      TSTypeAliasDeclaration(path6) {
+        const node = path6.node;
         if (!node.loc || node.start === null || node.end === null) return;
         const nodeContent = content.slice(node.start, node.end);
         blocks.push({
@@ -44651,15 +43867,15 @@ function extractASTBlocks(content, filePath) {
           name: node.id.name,
           content: nodeContent,
           normalized: nodeContent.replace(/\s+/g, " "),
-          hash: simpleHash2(nodeContent.replace(/\s+/g, " ")),
+          hash: simpleHash(nodeContent.replace(/\s+/g, " ")),
           filePath,
           startLine: node.loc.start.line,
           endLine: node.loc.end.line,
-          exported: t.isExportNamedDeclaration(path5.parent)
+          exported: t.isExportNamedDeclaration(path6.parent)
         });
       },
-      TSInterfaceDeclaration(path5) {
-        const node = path5.node;
+      TSInterfaceDeclaration(path6) {
+        const node = path6.node;
         if (!node.loc || node.start === null || node.end === null) return;
         const nodeContent = content.slice(node.start, node.end);
         blocks.push({
@@ -44667,11 +43883,11 @@ function extractASTBlocks(content, filePath) {
           name: node.id.name,
           content: nodeContent,
           normalized: nodeContent.replace(/\s+/g, " "),
-          hash: simpleHash2(nodeContent.replace(/\s+/g, " ")),
+          hash: simpleHash(nodeContent.replace(/\s+/g, " ")),
           filePath,
           startLine: node.loc.start.line,
           endLine: node.loc.end.line,
-          exported: t.isExportNamedDeclaration(path5.parent)
+          exported: t.isExportNamedDeclaration(path6.parent)
         });
       }
     });
@@ -44713,22 +43929,37 @@ function findASTDuplicates(blocks, _minSimilarity) {
     });
   }
   groups.sort((a, b) => b.matches.length - a.matches.length);
-  return groups;
+  const crossFileGroups = groups.filter((group) => {
+    const uniqueFiles = new Set(group.matches.map((m) => m.filePath));
+    return uniqueFiles.size > 1;
+  });
+  return crossFileGroups;
 }
 
 // src/formatter.ts
 var import_node_path = __toESM(require("node:path"), 1);
+var MAX_PATH_LENGTH = 60;
+var SEPARATOR = "\u2500".repeat(80);
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m",
+  gray: "\x1B[90m"
+};
 var { reset, bold, dim, red, green, yellow, cyan, magenta, gray } = COLORS;
 function truncatePath(filePath, basePath) {
   const absoluteBase = import_node_path.default.resolve(basePath);
   let relativePath = filePath;
   if (filePath.startsWith(absoluteBase)) {
     relativePath = filePath.slice(absoluteBase.length);
-    if (relativePath.startsWith("/") || relativePath.startsWith("\\")) {
-      relativePath = relativePath.slice(1);
-    }
+    if (relativePath.startsWith("/")) relativePath = relativePath.slice(1);
   }
-  if (relativePath.length > MAX_PATH_DISPLAY_LENGTH) {
+  if (relativePath.length > MAX_PATH_LENGTH) {
     const parts = relativePath.split(import_node_path.default.sep);
     if (parts.length > 3) {
       relativePath = `${parts[0]}/.../${parts.slice(-2).join("/")}`;
@@ -44736,176 +43967,7 @@ function truncatePath(filePath, basePath) {
   }
   return relativePath;
 }
-function getSimilarityBadge(similarity) {
-  const percent = Math.round(similarity * 100);
-  if (similarity === 1) {
-    return `${red}${bold}EXACT${reset}`;
-  } else if (similarity >= 0.9) {
-    return `${yellow}${percent}%${reset}`;
-  } else {
-    return `${cyan}${percent}%${reset}`;
-  }
-}
-function formatGroup(group, index, basePath) {
-  const lines = [];
-  const badge = getSimilarityBadge(group.similarity);
-  const impact = group.occurrences * group.lineCount;
-  lines.push(`${bold}Group ${index + 1}${reset} \u2502 ${badge} \u2502 ${group.lineCount} lines \xD7 ${group.occurrences} occurrences = ${green}${impact} lines${reset} of duplication`);
-  lines.push("");
-  const matchesToShow = group.matches.slice(0, MAX_MATCHES_IN_SUMMARY);
-  const hasMore = group.matches.length > MAX_MATCHES_IN_SUMMARY;
-  for (const match2 of matchesToShow) {
-    const displayPath = truncatePath(match2.filePath, basePath);
-    lines.push(`  ${dim}\u251C\u2500${reset} ${displayPath}:${yellow}${match2.startLine}${reset}-${yellow}${match2.endLine}${reset}`);
-  }
-  if (hasMore) {
-    lines.push(`  ${dim}\u2514\u2500${reset} ${gray}... and ${group.matches.length - MAX_MATCHES_IN_SUMMARY} more${reset}`);
-  }
-  const firstMatch = group.matches[0];
-  if (firstMatch) {
-    lines.push("");
-    lines.push(`  ${dim}Code preview:${reset}`);
-    const previewLines = firstMatch.content.split("\n").slice(0, CODE_PREVIEW_CONTEXT_LINES).map((line) => `  ${gray}\u2502${reset} ${dim}${line.slice(0, 80)}${line.length > 80 ? "..." : ""}${reset}`);
-    lines.push(...previewLines);
-    if (firstMatch.content.split("\n").length > CODE_PREVIEW_CONTEXT_LINES) {
-      lines.push(`  ${gray}\u2502${reset} ${dim}...${reset}`);
-    }
-  }
-  if (group.suggestion) {
-    lines.push("");
-    const confidenceColor = group.suggestion.confidence === "high" ? green : group.suggestion.confidence === "medium" ? yellow : gray;
-    lines.push(`  ${magenta}\u2192 Suggestion:${reset} Move to ${cyan}${group.suggestion.targetLocation}${reset}`);
-    if (group.suggestion.suggestedName) {
-      lines.push(`  ${dim}  Name: ${group.suggestion.suggestedName}${reset}`);
-    }
-    lines.push(`  ${dim}  ${group.suggestion.reason} ${confidenceColor}[${group.suggestion.confidence}]${reset}`);
-  }
-  return lines.join("\n");
-}
-function formatOutput(groups, basePath) {
-  if (groups.length === 0) {
-    return `${green}No duplicates found!${reset}`;
-  }
-  const lines = [];
-  lines.push(SECTION_SEPARATOR);
-  lines.push(`${bold}DUPLICATE CODE DETECTED${reset}`);
-  lines.push(SECTION_SEPARATOR);
-  lines.push("");
-  const groupsToShow = groups.slice(0, MAX_GROUPS_DETAILED);
-  for (let i = 0; i < groupsToShow.length; i++) {
-    const group = groupsToShow[i];
-    if (group) {
-      lines.push(formatGroup(group, i, basePath));
-      lines.push("");
-    }
-  }
-  if (groups.length > MAX_GROUPS_DETAILED) {
-    lines.push(`${dim}... and ${groups.length - MAX_GROUPS_DETAILED} more groups${reset}`);
-    lines.push("");
-  }
-  lines.push(SECTION_SEPARATOR);
-  return lines.join("\n");
-}
-function formatStats(groups) {
-  if (groups.length === 0) {
-    return "";
-  }
-  const totalDuplicateLines = groups.reduce(
-    (sum, g) => sum + g.lineCount * g.occurrences,
-    0
-  );
-  const exactMatches = groups.filter((g) => g.similarity === 1).length;
-  const similarMatches = groups.length - exactMatches;
-  const avgSimilarity = groups.reduce((sum, g) => sum + g.similarity, 0) / groups.length;
-  const uniqueFiles = /* @__PURE__ */ new Set();
-  for (const group of groups) {
-    for (const match2 of group.matches) {
-      uniqueFiles.add(match2.filePath);
-    }
-  }
-  const lines = [];
-  lines.push(`${bold}SUMMARY${reset}`);
-  lines.push(SECTION_SEPARATOR);
-  lines.push(`  Total duplicate groups:    ${bold}${groups.length}${reset}`);
-  lines.push(`  Exact matches:             ${bold}${exactMatches}${reset}`);
-  lines.push(`  Similar matches:           ${bold}${similarMatches}${reset}`);
-  lines.push(`  Files affected:            ${bold}${uniqueFiles.size}${reset}`);
-  lines.push(`  Total duplicate lines:     ${red}${bold}${totalDuplicateLines.toLocaleString()}${reset}`);
-  lines.push(`  Average similarity:        ${bold}${Math.round(avgSimilarity * 100)}%${reset}`);
-  lines.push(SECTION_SEPARATOR);
-  lines.push("");
-  lines.push(`${dim}Tip: Use --json for machine-readable output${reset}`);
-  return lines.join("\n");
-}
 var TYPE_LABELS = {
-  type: "Type",
-  interface: "Interface",
-  function: "Function",
-  class: "Class",
-  const: "Constant",
-  enum: "Enum"
-};
-function formatDeclarationGroup(group, index, basePath) {
-  const lines = [];
-  const typeLabel = TYPE_LABELS[group.type] || group.type;
-  const simBadge = group.similarity >= 0.95 ? `${red}${bold}EXACT${reset}` : `${yellow}${Math.round(group.similarity * 100)}%${reset}`;
-  lines.push(`${bold}${typeLabel} ${index + 1}${reset} \u2502 ${simBadge} \u2502 ${group.matches.length} occurrences`);
-  if (group.nameSimilarity > 0 && group.nameSimilarity < 1) {
-    lines.push(`  ${dim}Name similarity: ${Math.round(group.nameSimilarity * 100)}%${reset}`);
-  }
-  lines.push("");
-  for (const match2 of group.matches.slice(0, 5)) {
-    const displayPath = truncatePath(match2.filePath, basePath);
-    const exportBadge = match2.exported ? `${green}exported${reset}` : `${gray}local${reset}`;
-    lines.push(`  ${dim}\u251C\u2500${reset} ${cyan}${match2.name}${reset} [${exportBadge}]`);
-    lines.push(`     ${displayPath}:${yellow}${match2.startLine}${reset}-${yellow}${match2.endLine}${reset}`);
-  }
-  if (group.matches.length > 5) {
-    lines.push(`  ${dim}\u2514\u2500${reset} ${gray}... and ${group.matches.length - 5} more${reset}`);
-  }
-  lines.push("");
-  lines.push(`  ${magenta}\u2192${reset} ${group.suggestion}`);
-  return lines.join("\n");
-}
-function formatDeclarations(groups, basePath) {
-  if (groups.length === 0) {
-    return "";
-  }
-  const lines = [];
-  lines.push("");
-  lines.push(SECTION_SEPARATOR);
-  lines.push(`${bold}DUPLICATE DECLARATIONS${reset}`);
-  lines.push(SECTION_SEPARATOR);
-  lines.push("");
-  const byType = /* @__PURE__ */ new Map();
-  for (const group of groups) {
-    const existing = byType.get(group.type) || [];
-    existing.push(group);
-    byType.set(group.type, existing);
-  }
-  let globalIndex = 0;
-  for (const [type, typeGroups] of byType) {
-    const typeLabel = TYPE_LABELS[type] || type;
-    lines.push(`${bold}${typeLabel}s (${typeGroups.length})${reset}`);
-    lines.push("");
-    for (const group of typeGroups.slice(0, 10)) {
-      lines.push(formatDeclarationGroup(group, globalIndex++, basePath));
-      lines.push("");
-    }
-    if (typeGroups.length > 10) {
-      lines.push(`${dim}... and ${typeGroups.length - 10} more ${typeLabel.toLowerCase()}s${reset}`);
-      lines.push("");
-    }
-  }
-  lines.push(SECTION_SEPARATOR);
-  const totalDups = groups.reduce((sum, g) => sum + g.matches.length, 0);
-  lines.push(`${bold}Declaration Summary${reset}`);
-  lines.push(`  Duplicate groups: ${bold}${groups.length}${reset}`);
-  lines.push(`  Total occurrences: ${bold}${totalDups}${reset}`);
-  lines.push(SECTION_SEPARATOR);
-  return lines.join("\n");
-}
-var AST_TYPE_LABELS = {
   function: "Function",
   arrow: "Arrow Function",
   class: "Class",
@@ -44915,17 +43977,16 @@ var AST_TYPE_LABELS = {
 function formatASTDuplicates(groups, basePath) {
   if (groups.length === 0) return "";
   const lines = [];
+  lines.push(SEPARATOR);
+  lines.push(`${bold}DUPLICATE FUNCTIONS/TYPES${reset}`);
+  lines.push(SEPARATOR);
   lines.push("");
-  lines.push(SECTION_SEPARATOR);
-  lines.push(`${bold}DUPLICATE FUNCTIONS (AST-based)${reset}`);
-  lines.push(SECTION_SEPARATOR);
-  lines.push("");
-  lines.push(`${dim}These functions have identical structure (ignoring variable names)${reset}`);
+  lines.push(`${dim}These have identical structure (ignoring variable names)${reset}`);
   lines.push("");
   for (let i = 0; i < Math.min(groups.length, 20); i++) {
     const group = groups[i];
     if (!group) continue;
-    const typeLabel = AST_TYPE_LABELS[group.type] || group.type;
+    const typeLabel = TYPE_LABELS[group.type] || group.type;
     lines.push(`${bold}${typeLabel} ${i + 1}${reset} \u2502 ${red}${bold}IDENTICAL${reset} \u2502 ${group.matches.length} occurrences`);
     lines.push("");
     for (const match2 of group.matches.slice(0, 5)) {
@@ -44948,21 +44009,18 @@ function formatASTDuplicates(groups, basePath) {
     lines.push("");
   }
   if (groups.length > 20) {
-    lines.push(`${dim}... and ${groups.length - 20} more duplicate functions${reset}`);
+    lines.push(`${dim}... and ${groups.length - 20} more${reset}`);
     lines.push("");
   }
-  lines.push(SECTION_SEPARATOR);
-  const totalDups = groups.reduce((sum, g) => sum + g.matches.length, 0);
-  lines.push(`${bold}AST Summary${reset}`);
-  lines.push(`  Duplicate groups: ${bold}${groups.length}${reset}`);
-  lines.push(`  Total occurrences: ${bold}${totalDups}${reset}`);
-  lines.push(SECTION_SEPARATOR);
+  lines.push(SEPARATOR);
+  lines.push(`${bold}Summary${reset}: ${groups.length} duplicate groups, ${groups.reduce((sum, g) => sum + g.matches.length, 0)} total occurrences`);
+  lines.push(SEPARATOR);
   return lines.join("\n");
 }
 
 // src/scanner.ts
-var import_promises2 = require("node:fs/promises");
-var import_node_path3 = __toESM(require("node:path"), 1);
+var import_promises3 = require("node:fs/promises");
+var import_node_path4 = __toESM(require("node:path"), 1);
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a, b, str) => {
@@ -49093,12 +48151,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path5) {
-    if (!path5) {
+  resolve(path6) {
+    if (!path6) {
       return this;
     }
-    const rootPath = this.getRootString(path5);
-    const dir = path5.substring(rootPath.length);
+    const rootPath = this.getRootString(path6);
+    const dir = path6.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -49850,8 +48908,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path5) {
-    return import_node_path2.win32.parse(path5).root;
+  getRootString(path6) {
+    return import_node_path2.win32.parse(path6).root;
   }
   /**
    * @internal
@@ -49897,8 +48955,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path5) {
-    return path5.startsWith("/") ? "/" : "";
+  getRootString(path6) {
+    return path6.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -49987,11 +49045,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path5 = this.cwd) {
-    if (typeof path5 === "string") {
-      path5 = this.cwd.resolve(path5);
+  depth(path6 = this.cwd) {
+    if (typeof path6 === "string") {
+      path6 = this.cwd.resolve(path6);
     }
-    return path5.depth();
+    return path6.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -50478,9 +49536,9 @@ var PathScurryBase = class {
     process2();
     return results;
   }
-  chdir(path5 = this.cwd) {
+  chdir(path6 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path5 === "string" ? this.cwd.resolve(path5) : path5;
+    this.cwd = typeof path6 === "string" ? this.cwd.resolve(path6) : path6;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -50836,8 +49894,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path5, n]) => [
-      path5,
+    return [...this.store.entries()].map(([path6, n]) => [
+      path6,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -51042,9 +50100,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path5, opts) {
+  constructor(patterns, path6, opts) {
     this.patterns = patterns;
-    this.path = path5;
+    this.path = path6;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -51063,11 +50121,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path5) {
-    return this.seen.has(path5) || !!this.#ignore?.ignored?.(path5);
+  #ignored(path6) {
+    return this.seen.has(path6) || !!this.#ignore?.ignored?.(path6);
   }
-  #childrenIgnored(path5) {
-    return !!this.#ignore?.childrenIgnored?.(path5);
+  #childrenIgnored(path6) {
+    return !!this.#ignore?.childrenIgnored?.(path6);
   }
   // backpressure mechanism
   pause() {
@@ -51282,8 +50340,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path5, opts) {
-    super(patterns, path5, opts);
+  constructor(patterns, path6, opts) {
+    super(patterns, path6, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -51320,8 +50378,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path5, opts) {
-    super(patterns, path5, opts);
+  constructor(patterns, path6, opts) {
+    super(patterns, path6, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -51614,59 +50672,113 @@ var glob = Object.assign(glob_, {
 });
 glob.glob = glob;
 
-// src/scanner.ts
-function simpleHash3(str) {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
+// src/cache.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_path3 = __toESM(require("node:path"), 1);
+var CACHE_VERSION = 2;
+var CACHE_FILE = ".dslop-cache";
+var ASTCache = class {
+  cache = { version: CACHE_VERSION, files: {} };
+  cachePath;
+  dirty = false;
+  hits = 0;
+  misses = 0;
+  constructor(targetPath) {
+    this.cachePath = import_node_path3.default.join(import_node_path3.default.resolve(targetPath), CACHE_FILE);
+  }
+  async load() {
+    try {
+      const data = await (0, import_promises2.readFile)(this.cachePath, "utf-8");
+      const parsed = JSON.parse(data);
+      if (parsed.version !== CACHE_VERSION) {
+        this.cache = { version: CACHE_VERSION, files: {} };
+        return;
+      }
+      this.cache = parsed;
+    } catch {
+      this.cache = { version: CACHE_VERSION, files: {} };
+    }
   }
-  return hash.toString(36);
-}
-function isSkippableLine(line) {
-  const trimmed = line.trim();
-  if (trimmed.length === 0) return true;
-  return SKIP_LINE_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
-}
-function extractBlocks(content, filePath, minLines, shouldNormalize) {
-  const lines = content.split("\n");
-  const blocks = [];
-  if (lines.length < minLines) {
-    return blocks;
-  }
-  const blockSizes = [minLines];
-  const maxSize = Math.min(MAX_BLOCK_SIZE, lines.length);
-  for (let size = Math.floor(minLines * BLOCK_SIZE_MULTIPLIER); size <= maxSize; size = Math.floor(size * BLOCK_SIZE_MULTIPLIER)) {
-    blockSizes.push(size);
-  }
-  for (const blockSize of blockSizes) {
-    const step = blockSize < 10 ? 1 : Math.max(1, Math.floor(blockSize / SLIDING_WINDOW_STEP_DIVISOR));
-    for (let i = 0; i <= lines.length - blockSize; i += step) {
-      const blockLines = lines.slice(i, i + blockSize);
-      const blockContent = blockLines.join("\n");
-      const meaningfulLines = blockLines.filter(
-        (line) => !isSkippableLine(line)
-      );
-      if (meaningfulLines.length < blockSize * MIN_MEANINGFUL_LINE_RATIO) {
-        continue;
+  async get(filePath) {
+    const cached = this.cache.files[filePath];
+    if (!cached) {
+      this.misses++;
+      return null;
+    }
+    try {
+      const fileStat = await (0, import_promises2.stat)(filePath);
+      if (fileStat.mtimeMs !== cached.mtime || fileStat.size !== cached.size) {
+        this.misses++;
+        return null;
       }
-      const normalized = shouldNormalize ? normalizeCode(blockContent) : blockContent;
-      const hash = simpleHash3(normalized);
-      blocks.push({
-        content: blockContent,
-        normalized,
-        hash,
+      this.hits++;
+      return cached.blocks.map((b) => ({
+        type: b.type,
+        name: b.name,
+        content: "",
+        // Don't cache content - we can re-read if needed
+        normalized: b.normalized,
+        hash: b.hash,
         filePath,
-        startLine: i + 1,
-        // 1-indexed
-        endLine: i + blockSize,
-        lineCount: blockSize
-      });
+        startLine: b.startLine,
+        endLine: b.endLine,
+        exported: b.exported
+      }));
+    } catch {
+      this.misses++;
+      return null;
     }
   }
-  return blocks;
-}
+  async set(filePath, blocks) {
+    try {
+      const fileStat = await (0, import_promises2.stat)(filePath);
+      this.cache.files[filePath] = {
+        mtime: fileStat.mtimeMs,
+        size: fileStat.size,
+        blocks: blocks.map((b) => ({
+          type: b.type,
+          name: b.name,
+          hash: b.hash,
+          normalized: b.normalized,
+          startLine: b.startLine,
+          endLine: b.endLine,
+          exported: b.exported
+        }))
+      };
+      this.dirty = true;
+    } catch {
+    }
+  }
+  async save() {
+    if (!this.dirty) return;
+    try {
+      const dir = import_node_path3.default.dirname(this.cachePath);
+      await (0, import_promises2.mkdir)(dir, { recursive: true });
+      const prunedFiles = {};
+      for (const [filePath, cached] of Object.entries(this.cache.files)) {
+        try {
+          await (0, import_promises2.stat)(filePath);
+          prunedFiles[filePath] = cached;
+        } catch {
+        }
+      }
+      this.cache.files = prunedFiles;
+      await (0, import_promises2.writeFile)(this.cachePath, JSON.stringify(this.cache), "utf-8");
+    } catch {
+    }
+  }
+  getStats() {
+    const total = this.hits + this.misses;
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? this.hits / total : 0
+    };
+  }
+};
+
+// src/scanner.ts
+var MAX_FILE_SIZE = 1024 * 1024;
 function shouldIgnore(filePath, ignorePatterns) {
   const normalizedPath = filePath.toLowerCase();
   return ignorePatterns.some((pattern) => {
@@ -51674,14 +50786,16 @@ function shouldIgnore(filePath, ignorePatterns) {
     return normalizedPath.includes(`/${normalizedPattern}/`) || normalizedPath.includes(`\\${normalizedPattern}\\`) || normalizedPath.endsWith(`/${normalizedPattern}`) || normalizedPath.endsWith(`\\${normalizedPattern}`);
   });
 }
-async function scanDirectory(targetPath, options, enableAST = true) {
-  const { extensions, ignorePatterns, minLines, normalize: normalize2 } = options;
-  const absolutePath = import_node_path3.default.resolve(targetPath);
-  const blocks = [];
-  const declarations = [];
+async function scanDirectory(targetPath, options, useCache = true) {
+  const { extensions, ignorePatterns } = options;
+  const absolutePath = import_node_path4.default.resolve(targetPath);
   const astBlocks = [];
   let fileCount = 0;
   let totalLines = 0;
+  const cache = useCache ? new ASTCache(targetPath) : null;
+  if (cache) {
+    await cache.load();
+  }
   const pattern = extensions.length === 1 ? `**/*.${extensions[0]}` : `**/*.{${extensions.join(",")}}`;
   const files = await glob(pattern, {
     cwd: absolutePath,
@@ -51689,49 +50803,70 @@ async function scanDirectory(targetPath, options, enableAST = true) {
     nodir: true,
     ignore: ignorePatterns.map((p) => `**/${p}/**`)
   });
-  const isTypeScript = extensions.some((ext2) => ext2 === "ts" || ext2 === "tsx");
   for (const filePath of files) {
     if (shouldIgnore(filePath, ignorePatterns)) {
       continue;
     }
+    if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx") && !filePath.endsWith(".js") && !filePath.endsWith(".jsx")) {
+      continue;
+    }
     try {
-      const fileStat = await (0, import_promises2.stat)(filePath);
+      const fileStat = await (0, import_promises3.stat)(filePath);
       if (fileStat.size > MAX_FILE_SIZE) {
         continue;
       }
-      const content = await (0, import_promises2.readFile)(filePath, "utf-8");
-      const lines = content.split("\n").length;
-      totalLines += lines;
-      fileCount++;
-      const fileBlocks = extractBlocks(
-        content,
-        filePath,
-        minLines,
-        normalize2
-      );
-      blocks.push(...fileBlocks);
-      if (enableAST && isTypeScript && (filePath.endsWith(".ts") || filePath.endsWith(".tsx"))) {
+      const cachedAST = cache ? await cache.get(filePath) : null;
+      if (cachedAST) {
+        astBlocks.push(...cachedAST);
+        const content = await (0, import_promises3.readFile)(filePath, "utf-8");
+        totalLines += content.split("\n").length;
+        fileCount++;
+      } else {
+        const content = await (0, import_promises3.readFile)(filePath, "utf-8");
+        totalLines += content.split("\n").length;
+        fileCount++;
         const fileAST = extractASTBlocks(content, filePath);
         astBlocks.push(...fileAST);
-        const fileDeclarations = extractDeclarations(content, filePath);
-        declarations.push(...fileDeclarations);
+        if (cache) {
+          await cache.set(filePath, fileAST);
+        }
       }
     } catch {
-      console.warn(`Warning: Could not read ${filePath}`);
     }
   }
-  return { blocks, declarations, astBlocks, fileCount, totalLines };
+  if (cache) {
+    await cache.save();
+  }
+  return {
+    astBlocks,
+    fileCount,
+    totalLines,
+    cacheStats: cache?.getStats()
+  };
 }
 
 // index.ts
-var VERSION = process.env.npm_package_version || "1.6.1";
+var VERSION = process.env.npm_package_version || "1.7.1";
+var DEFAULT_EXTENSIONS = ["ts", "tsx", "js", "jsx"];
+var DEFAULT_IGNORE_PATTERNS = [
+  "node_modules",
+  "dist",
+  ".git",
+  "build",
+  ".next",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "migrations",
+  "__generated__"
+];
 function parseDiffOutput(diff, cwd) {
   const changes = /* @__PURE__ */ new Map();
   let currentFile = null;
   let newLineNum = 0;
   for (const line of diff.split("\n")) {
     if (line.startsWith("+++ b/")) {
-      currentFile = import_node_path4.default.resolve(cwd, line.slice(6));
+      currentFile = import_node_path5.default.resolve(cwd, line.slice(6));
       if (!changes.has(currentFile)) {
         changes.set(currentFile, []);
       }
@@ -51759,7 +50894,7 @@ function parseDiffOutput(diff, cwd) {
   return changes;
 }
 function getChangedLines(targetPath) {
-  const absolutePath = import_node_path4.default.resolve(targetPath);
+  const absolutePath = import_node_path5.default.resolve(targetPath);
   const allChanges = /* @__PURE__ */ new Map();
   const mergeChanges = (newChanges) => {
     for (const [file, ranges] of newChanges) {
@@ -51769,16 +50904,14 @@ function getChangedLines(targetPath) {
     }
   };
   const addFullFile = (filePath) => {
-    const resolved = import_node_path4.default.resolve(absolutePath, filePath);
+    const resolved = import_node_path5.default.resolve(absolutePath, filePath);
     if (!allChanges.has(resolved)) {
       allChanges.set(resolved, [{ start: 1, end: 999999 }]);
     }
   };
   try {
-    const stagedDiff = (0, import_node_child_process.execSync)("git diff --cached", { cwd: absolutePath, encoding: "utf-8" });
-    mergeChanges(parseDiffOutput(stagedDiff, absolutePath));
-    const unstagedDiff = (0, import_node_child_process.execSync)("git diff", { cwd: absolutePath, encoding: "utf-8" });
-    mergeChanges(parseDiffOutput(unstagedDiff, absolutePath));
+    mergeChanges(parseDiffOutput((0, import_node_child_process.execSync)("git diff --cached", { cwd: absolutePath, encoding: "utf-8" }), absolutePath));
+    mergeChanges(parseDiffOutput((0, import_node_child_process.execSync)("git diff", { cwd: absolutePath, encoding: "utf-8" }), absolutePath));
     const untracked = (0, import_node_child_process.execSync)("git ls-files --others --exclude-standard", { cwd: absolutePath, encoding: "utf-8" });
     for (const file of untracked.split("\n")) {
       if (file.trim()) addFullFile(file.trim());
@@ -51789,8 +50922,7 @@ function getChangedLines(targetPath) {
       if (currentBranch !== baseBranch) {
         const mergeBase = (0, import_node_child_process.execSync)(`git merge-base ${baseBranch} HEAD 2>/dev/null || echo ""`, { cwd: absolutePath, encoding: "utf-8" }).trim();
         if (mergeBase) {
-          const branchDiff = (0, import_node_child_process.execSync)(`git diff ${mergeBase}...HEAD`, { cwd: absolutePath, encoding: "utf-8" });
-          mergeChanges(parseDiffOutput(branchDiff, absolutePath));
+          mergeChanges(parseDiffOutput((0, import_node_child_process.execSync)(`git diff ${mergeBase}...HEAD`, { cwd: absolutePath, encoding: "utf-8" }), absolutePath));
         }
       }
     } catch {
@@ -51807,50 +50939,35 @@ function isInChangedLines(filePath, blockStart, blockEnd, changes) {
 }
 function showHelp() {
   console.log(`
-dslop - Detect Similar/Duplicate Lines Of Programming
+dslop - Find duplicate functions and types
 
 Usage:
   dslop [path] [options]
 
-By default, checks your branch changes against the codebase.
-If no changes are found, automatically scans the entire path.
-
-Arguments:
-  path                  Directory to scan (default: current directory)
-
 Options:
   -a, --all             Force full codebase scan
   -c, --changes         Force changes-only mode (exit if no changes found)
-  -m, --min-lines <n>   Minimum block size in lines (default: ${DEFAULT_MIN_LINES})
-  -s, --similarity <n>  Minimum similarity threshold 0-100 (default: ${Math.round(DEFAULT_SIMILARITY * 100)})
-  -e, --extensions <s>  File extensions to scan (default: ${DEFAULT_EXTENSIONS.join(",")})
-  -i, --ignore <s>      Patterns to ignore (default: ${DEFAULT_IGNORE_PATTERNS.slice(0, 4).join(",")},...)
-  --no-normalize        Disable string/number normalization
-  --cross-package       Only show duplicates across different packages/apps (monorepo mode)
-  --json                Output as JSON
-  -h, --help            Show this help message
+  -e, --extensions <s>  File extensions (default: ts,tsx,js,jsx)
+  -i, --ignore <s>      Patterns to ignore
+  --no-cache            Disable caching
+  --cross-package       Only cross-package duplicates (monorepos)
+  --json                JSON output
+  -h, --help            Show help
   -v, --version         Show version
 
 Examples:
-  dslop                            Check your PR changes (or full scan if none)
-  dslop ./apps/web                 Scan apps/web (full scan if no changes there)
-  dslop -c                         Check PR changes only, exit if none
-  dslop --cross-package            Cross-package duplicates
+  dslop                   Check PR changes (or full scan if none)
+  dslop --all             Full codebase scan
+  dslop --cross-package   Cross-package duplicates
 `);
 }
-function showVersion() {
-  console.log(`dslop v${VERSION}`);
-}
 async function main() {
   const { values, positionals } = (0, import_node_util.parseArgs)({
     args: process.argv.slice(2),
     options: {
-      "min-lines": { type: "string", short: "m", default: String(DEFAULT_MIN_LINES) },
-      similarity: { type: "string", short: "s", default: String(Math.round(DEFAULT_SIMILARITY * 100)) },
       extensions: { type: "string", short: "e", default: DEFAULT_EXTENSIONS.join(",") },
       ignore: { type: "string", short: "i", default: DEFAULT_IGNORE_PATTERNS.join(",") },
-      normalize: { type: "boolean", default: true },
-      "no-normalize": { type: "boolean", default: false },
+      "no-cache": { type: "boolean", default: false },
       all: { type: "boolean", short: "a", default: false },
       changes: { type: "boolean", short: "c", default: false },
       "cross-package": { type: "boolean", default: false },
@@ -51865,109 +50982,66 @@ async function main() {
     process.exit(0);
   }
   if (values.version) {
-    showVersion();
+    console.log(`dslop v${VERSION}`);
     process.exit(0);
   }
   const targetPath = positionals[0] || ".";
-  const minLines = parseInt(values["min-lines"], 10);
-  const similarity = parseInt(values.similarity, 10) / 100;
   const extensions = values.extensions.split(",").map((e) => e.trim());
   const ignorePatterns = values.ignore.split(",").map((p) => p.trim());
-  const normalize2 = !values["no-normalize"];
+  const useCache = !values["no-cache"];
   const forceAll = values.all;
   const forceChanges = values.changes;
   const crossPackage = values["cross-package"];
   const jsonOutput = values.json;
-  const hasExplicitPath = positionals.length > 0;
-  if (minLines < 2) {
-    console.error("Error: --min-lines must be at least 2");
-    process.exit(1);
-  }
-  if (similarity < 0 || similarity > 1) {
-    console.error("Error: --similarity must be between 0 and 100");
-    process.exit(1);
-  }
-  const scanOptions = {
-    extensions,
-    ignorePatterns,
-    minLines,
-    normalize: normalize2
-  };
+  const scanOptions = { extensions, ignorePatterns };
   let scanAll = forceAll;
   let changedLines = null;
   if (!forceAll) {
     changedLines = getChangedLines(targetPath);
     if (changedLines.size === 0) {
       if (forceChanges) {
-        console.log("\nNo changes found on current branch.");
+        console.log("\nNo changes found.");
         process.exit(0);
       }
       scanAll = true;
       if (!jsonOutput) {
         console.log(`
-No changes detected${hasExplicitPath ? ` in ${targetPath}` : ""}, defaulting to full scan...`);
+No changes detected, running full scan...`);
       }
     }
   }
   if (!jsonOutput) {
     console.log(`
 Scanning ${targetPath}...`);
-    if (!scanAll && changedLines && changedLines.size > 0) {
-      console.log(`  Mode: checking changed lines in ${changedLines.size} files`);
-    } else {
-      console.log(`  Mode: full codebase scan`);
-    }
-    console.log(`  Extensions: ${extensions.join(", ")}`);
-    console.log(`  Min block size: ${minLines} lines`);
-    console.log(`  Similarity threshold: ${Math.round(similarity * 100)}%`);
-    if (crossPackage) {
-      console.log(`  Cross-package: enabled`);
-    }
+    console.log(`  Mode: ${scanAll ? "full scan" : `checking ${changedLines?.size} changed files`}`);
+    if (crossPackage) console.log(`  Cross-package: enabled`);
     console.log();
   }
   try {
     const startTime = performance.now();
-    const { blocks, declarations, astBlocks, fileCount, totalLines } = await scanDirectory(targetPath, scanOptions, true);
+    const { astBlocks, fileCount, totalLines, cacheStats } = await scanDirectory(targetPath, scanOptions, useCache);
     const scanTime = performance.now() - startTime;
     if (!jsonOutput) {
       console.log(`Scanned ${fileCount} files (${totalLines.toLocaleString()} lines) in ${Math.round(scanTime)}ms`);
-      console.log(`Extracted ${blocks.length.toLocaleString()} blocks, ${astBlocks.length.toLocaleString()} functions/classes
+      if (cacheStats && (cacheStats.hits > 0 || cacheStats.misses > 0)) {
+        console.log(`Cache: ${cacheStats.hits} hits, ${cacheStats.misses} misses (${Math.round(cacheStats.hitRate * 100)}% hit rate)`);
+      }
+      console.log(`Found ${astBlocks.length.toLocaleString()} functions/types
 `);
     }
-    if (blocks.length === 0 && astBlocks.length === 0) {
-      console.log("No code found to analyze.");
+    if (astBlocks.length === 0) {
+      if (jsonOutput) {
+        console.log(JSON.stringify({ summary: { duplicateGroups: 0 }, duplicates: [] }, null, 2));
+      } else {
+        console.log("No code found to analyze.");
+      }
       process.exit(0);
     }
     const detectStart = performance.now();
-    let duplicates = findDuplicates(blocks, similarity, targetPath);
-    let astDuplicates = findASTDuplicates(astBlocks, similarity);
-    let declDuplicates = findDeclarationDuplicates(declarations, similarity);
+    let duplicates = findASTDuplicates(astBlocks, 0.7);
     const detectTime = performance.now() - detectStart;
     if (!scanAll && changedLines) {
-      const changedFilePaths = new Set(changedLines.keys());
       duplicates = duplicates.filter((group) => {
-        const inChanged = group.matches.filter(
-          (m) => isInChangedLines(m.filePath, m.startLine, m.endLine, changedLines)
-        );
-        const notInChanged = group.matches.filter(
-          (m) => !isInChangedLines(m.filePath, m.startLine, m.endLine, changedLines)
-        );
-        if (inChanged.length === 0 || notInChanged.length === 0) return false;
-        const inOtherFiles = notInChanged.some((m) => !changedFilePaths.has(m.filePath));
-        const inSameFileOutsideChanges = notInChanged.some((m) => changedFilePaths.has(m.filePath));
-        if (inOtherFiles && group.matches.length > 10) return false;
-        return inOtherFiles || inSameFileOutsideChanges;
-      });
-      astDuplicates = astDuplicates.filter((group) => {
-        const inChanged = group.matches.filter(
-          (m) => isInChangedLines(m.filePath, m.startLine, m.endLine, changedLines)
-        );
-        const notInChanged = group.matches.filter(
-          (m) => !isInChangedLines(m.filePath, m.startLine, m.endLine, changedLines)
-        );
-        return inChanged.length > 0 && notInChanged.length > 0;
-      });
-      declDuplicates = declDuplicates.filter((group) => {
         const inChanged = group.matches.filter(
           (m) => isInChangedLines(m.filePath, m.startLine, m.endLine, changedLines)
         );
@@ -51978,52 +51052,30 @@ Scanning ${targetPath}...`);
       });
     }
     if (crossPackage) {
-      const filterCrossPackage = (groups) => {
-        return groups.filter((group) => {
-          const packages = new Set(
-            group.matches.map((m) => {
-              const match2 = m.filePath.match(/(?:apps|packages|libs)\/([^/]+)/);
-              return match2 ? match2[1] : m.filePath.split("/")[0];
-            })
-          );
-          return packages.size > 1;
-        });
-      };
-      duplicates = filterCrossPackage(duplicates);
-      astDuplicates = filterCrossPackage(astDuplicates);
-      declDuplicates = filterCrossPackage(declDuplicates);
+      duplicates = duplicates.filter((group) => {
+        const packages = new Set(
+          group.matches.map((m) => {
+            const match2 = m.filePath.match(/(?:apps|packages|libs)\/([^/]+)/);
+            return match2 ? match2[1] : m.filePath.split("/")[0];
+          })
+        );
+        return packages.size > 1;
+      });
     }
-    const totalGroups = duplicates.length + astDuplicates.length + declDuplicates.length;
     if (!jsonOutput) {
-      console.log(`Found ${totalGroups} duplicate groups in ${Math.round(detectTime)}ms`);
-      if (astDuplicates.length > 0 || declDuplicates.length > 0) {
-        console.log(`  (${duplicates.length} blocks, ${astDuplicates.length} AST, ${declDuplicates.length} declarations)
+      console.log(`Found ${duplicates.length} duplicate groups in ${Math.round(detectTime)}ms
 `);
-      } else {
-        console.log();
-      }
     }
-    if (totalGroups === 0) {
+    if (duplicates.length === 0) {
       if (jsonOutput) {
-        console.log(JSON.stringify({ duplicates: [], ast: [], declarations: [] }, null, 2));
-      } else if (!scanAll) {
-        console.log("No duplicates in your changes. You're good!");
-      } else if (crossPackage) {
-        console.log("No cross-package duplicates found!");
+        console.log(JSON.stringify({ summary: { duplicateGroups: 0 }, duplicates: [] }, null, 2));
       } else {
-        console.log("No duplicates found!");
+        console.log(crossPackage ? "No cross-package duplicates found!" : "No duplicates found!");
       }
       process.exit(0);
     }
     if (jsonOutput) {
-      const compactDuplicates = duplicates.slice(0, 100).map((d) => ({
-        lines: d.lineCount,
-        occurrences: d.occurrences,
-        similarity: Math.round(d.similarity * 100),
-        preview: d.matches[0]?.content.split("\n").slice(0, 3).join("\n") || "",
-        locations: d.matches.slice(0, 10).map((m) => `${m.filePath.replace(process.cwd() + "/", "")}:${m.startLine}`)
-      }));
-      const compactAST = astDuplicates.slice(0, 50).map((a) => ({
+      const compactAST = duplicates.slice(0, 50).map((a) => ({
         type: a.type,
         name: a.matches[0]?.name || "unknown",
         occurrences: a.matches.length,
@@ -52035,25 +51087,11 @@ Scanning ${targetPath}...`);
         }))
       }));
       console.log(JSON.stringify({
-        summary: {
-          duplicateGroups: duplicates.length,
-          astGroups: astDuplicates.length,
-          declarationGroups: declDuplicates.length
-        },
-        duplicates: compactDuplicates,
-        ast: compactAST
+        summary: { duplicateGroups: duplicates.length },
+        duplicates: compactAST
       }, null, 2));
     } else {
-      if (astDuplicates.length > 0) {
-        console.log(formatASTDuplicates(astDuplicates, targetPath));
-      }
-      if (duplicates.length > 0) {
-        console.log(formatOutput(duplicates, targetPath));
-        console.log(formatStats(duplicates));
-      }
-      if (declDuplicates.length > 0) {
-        console.log(formatDeclarations(declDuplicates, targetPath));
-      }
+      console.log(formatASTDuplicates(duplicates, targetPath));
     }
   } catch (error) {
     console.error("Error:", error instanceof Error ? error.message : error);