diff --git a/packages/app/src/components/ApiTree/ApiTree.tsx b/packages/app/src/components/ApiTree/ApiTree.tsx
index 5531108..190f0a5 100644
--- a/packages/app/src/components/ApiTree/ApiTree.tsx
+++ b/packages/app/src/components/ApiTree/ApiTree.tsx
@@ -208,7 +208,7 @@ export default function ApiTree(props: {
     >
       <div className="absolute bottom-6 inset-x-4 z-10 flex justify-around">
         <div className="flex gap-3 items-center">
-          <div className="bg-background-light dark:bg-background-dark flex gap-4 py-2 px-3 rounded-md">
+          <div className="bg-background-light dark:bg-background-dark flex gap-4 py-2 px-3 rounded-lg">
             <Button
               size="1"
               variant="ghost"
diff --git a/packages/cli/CHANGELOG.md b/packages/cli/CHANGELOG.md
index e8f0c2c..919bd4a 100644
--- a/packages/cli/CHANGELOG.md
+++ b/packages/cli/CHANGELOG.md
@@ -2,6 +2,8 @@
 
 ## [Unreleased]
 
+Add support for require import in javascript
+
 ## [0.0.14] - 2024-10-30
 
 Fix padding and size discrepancy with toolbar
diff --git a/packages/cli/src/helper/dependencies.ts b/packages/cli/src/helper/dependencies.ts
index 7ed502a..b6aa841 100644
--- a/packages/cli/src/helper/dependencies.ts
+++ b/packages/cli/src/helper/dependencies.ts
@@ -1,12 +1,8 @@
 import fs from "fs";
 import Parser from "tree-sitter";
-import {
-  extractJavascriptFileImports,
-  removeInvalidJavascriptFileImports,
-  removeJavascriptAnnotations,
-  removeJavascriptDeletedImportUsage,
-  removeUnusedJavascriptImports,
-} from "./languages/javascript";
+import { cleanupJavascriptFile } from "./languages/javascript/cleanup";
+import { extractJavascriptFileImports } from "./languages/javascript/imports";
+
 import { getParserLanguageFromFile, resolveFilePath } from "./file";
 import { Dependencies, Group } from "./types";
 
@@ -28,11 +24,10 @@ export function getDependencyTree(filePath: string): Dependencies {
     parser.setLanguage(language);
 
     const sourceCode = fs.readFileSync(currentFilePath, "utf8");
-    const tree = parser.parse(sourceCode);
 
     let imports: string[] = [];
     if (["javascript", "typescript"].includes(language.name)) {
-      imports = extractJavascriptFileImports(tree.rootNode);
+      imports = extractJavascriptFileImports(parser, sourceCode);
     } else {
       throw new Error(`Unsupported language: ${language.name}`);
     }
@@ -61,51 +56,31 @@ export function cleanupFile(filePath: string, group: Group) {
   parser.setLanguage(language);
 
   const sourceCode = fs.readFileSync(filePath, "utf8");
-  let tree = parser.parse(sourceCode);
 
   let dependencies: string[] = [];
   if (["javascript", "typescript"].includes(language.name)) {
-    dependencies = extractJavascriptFileImports(tree.rootNode);
+    dependencies = extractJavascriptFileImports(parser, sourceCode);
   } else {
     throw new Error(`Unsupported language: ${language.language}`);
   }
 
-  // Check if we can resolve the path for each dependency
-  // If we cannot, we need to remove it
+  // Check if we can resolve the path for each dependency. If we cannot, we need to remove it
   const invalidDependencies = dependencies.filter(
     (dep) => !resolveFilePath(dep, filePath),
   );
 
+  let updatedSourceCode: string;
+
   if (["javascript", "typescript"].includes(language.name)) {
-    const newSourceCode = removeJavascriptAnnotations(
-      tree.rootNode,
+    updatedSourceCode = cleanupJavascriptFile(
+      parser,
       sourceCode,
       group,
+      invalidDependencies,
     );
-    tree = parser.parse(newSourceCode);
-
-    const { updatedSourceCode, removedImportsNames } =
-      removeInvalidJavascriptFileImports(
-        tree.rootNode,
-        newSourceCode,
-        invalidDependencies,
-      );
-    tree = parser.parse(updatedSourceCode);
-
-    let finalUpdatedSourceCode = removeJavascriptDeletedImportUsage(
-      tree.rootNode,
-      updatedSourceCode,
-      removedImportsNames,
-    );
-    tree = parser.parse(finalUpdatedSourceCode);
-
-    finalUpdatedSourceCode = removeUnusedJavascriptImports(
-      tree.rootNode,
-      finalUpdatedSourceCode,
-    );
-
-    fs.writeFileSync(filePath, finalUpdatedSourceCode, "utf8");
   } else {
     throw new Error(`Unsupported language: ${language.language}`);
   }
+
+  fs.writeFileSync(filePath, updatedSourceCode, "utf8");
 }
diff --git a/packages/cli/src/helper/languages/javascript.ts b/packages/cli/src/helper/languages/javascript.ts
deleted file mode 100644
index 1d394d3..0000000
--- a/packages/cli/src/helper/languages/javascript.ts
+++ /dev/null
@@ -1,283 +0,0 @@
-import Parser from "tree-sitter";
-import { Group } from "../types";
-import { getNanoApiAnnotationFromCommentValue } from "../file";
-
-// extract the dependencies from the AST
-export function extractJavascriptFileImports(node: Parser.SyntaxNode) {
-  const dependencies: string[] = [];
-
-  // Traverse the AST to find import and require statements
-  function traverse(node: Parser.SyntaxNode) {
-    if (node.type === "import_statement") {
-      const stringNode = node.namedChildren.find(
-        (n: Parser.SyntaxNode) => n.type === "string",
-      );
-      if (stringNode) {
-        const importName = stringNode.text.slice(1, -1); // Remove quotes
-        // check if stringNode is a file path, we ignore import from node_modules
-        if (importName.startsWith(".")) {
-          dependencies.push(importName);
-        }
-      }
-    }
-    for (let i = 0; i < node.childCount; i++) {
-      traverse(node.child(i) as Parser.SyntaxNode);
-    }
-  }
-
-  traverse(node);
-  return dependencies;
-}
-
-export function removeJavascriptAnnotations(
-  rootNode: Parser.SyntaxNode,
-  sourceCode: string,
-  groupToKeep: Group,
-): string {
-  let updatedSourceCode = sourceCode;
-
-  function traverse(node: Parser.SyntaxNode) {
-    if (node.type === "comment") {
-      const commentText = node.text;
-      const annotationFromComment =
-        getNanoApiAnnotationFromCommentValue(commentText);
-      if (!annotationFromComment) return;
-
-      const endpointToKeep = groupToKeep.endpoints.find(
-        (e) =>
-          e.path === annotationFromComment.path &&
-          e.method === annotationFromComment.method,
-      );
-
-      if (!endpointToKeep) {
-        const nextNode = node.nextNamedSibling;
-        if (!nextNode) {
-          throw new Error("Could not find next node");
-        }
-        // delete this node (comment) and the next node (api endpoint)
-        updatedSourceCode = updatedSourceCode.replace(
-          sourceCode.substring(node.startIndex, nextNode.endIndex + 1),
-          "",
-        );
-      }
-    }
-
-    node.children.forEach((child) => {
-      traverse(child);
-    });
-  }
-
-  traverse(rootNode);
-
-  return updatedSourceCode;
-}
-
-export function removeInvalidJavascriptFileImports(
-  rootNode: Parser.SyntaxNode,
-  sourceCode: string,
-  invalidDependencies: string[],
-) {
-  let updatedSourceCode = sourceCode;
-  const removedImportsNames: string[] = [];
-
-  function extractImportName(node: Parser.SyntaxNode) {
-    if (node.type === "string_fragment") {
-      throw new Error("Invalid node type");
-    }
-
-    const importStatement = node.parent;
-    if (!importStatement || importStatement.type !== "import_statement") {
-      throw new Error("Invalid parent node type");
-    }
-
-    const importClause = importStatement.namedChildren.find(
-      (n) => n.type === "import_clause",
-    );
-    if (!importClause) {
-      throw new Error("Invalid import statement, missing import clause");
-    }
-
-    let importIdentifier = importClause.namedChildren.find(
-      (n) => n.type === "identifier",
-    );
-    if (!importIdentifier) {
-      const namespaceImport = importClause.namedChildren.find(
-        (n) => n.type === "namespace_import",
-      );
-      if (!namespaceImport) {
-        throw new Error("Invalid import statement, missing import identifier");
-      }
-      importIdentifier = namespaceImport.namedChildren.find(
-        (n) => n.type === "identifier",
-      );
-      if (!importIdentifier) {
-        throw new Error("Invalid import statement, missing import identifier");
-      }
-    }
-
-    return importIdentifier.text;
-  }
-
-  function traverse(node: Parser.SyntaxNode) {
-    // TODO this handles import, we also need to handle require statements
-    if (node.type === "import_statement") {
-      const stringNode = node.namedChildren.find((n) => n.type === "string");
-      if (stringNode) {
-        const importPath = stringNode.text.slice(1, -1); // Remove quotes
-        if (invalidDependencies.includes(importPath)) {
-          const importName = extractImportName(stringNode);
-          removedImportsNames.push(importName);
-
-          // Remove the import statement
-          updatedSourceCode = updatedSourceCode.replace(
-            sourceCode.substring(node.startIndex, node.endIndex + 1),
-            "",
-          );
-        }
-      }
-    }
-
-    node.children.forEach((child) => traverse(child));
-  }
-
-  traverse(rootNode);
-
-  return { updatedSourceCode, removedImportsNames };
-}
-
-export function removeJavascriptDeletedImportUsage(
-  rootNode: Parser.SyntaxNode,
-  sourceCode: string,
-  removedImportsNames: string[],
-): string {
-  let updatedSourceCode = sourceCode;
-
-  function traverse(node: Parser.SyntaxNode) {
-    if (node.type === "identifier" && removedImportsNames.includes(node.text)) {
-      // find the next parent expression statement (can be several levels up)
-      let parent = node.parent;
-      while (parent && parent.type !== "expression_statement") {
-        parent = parent.parent;
-      }
-      if (!parent) {
-        throw new Error("Could not find parent expression statement");
-      }
-
-      // Remove the expression statement
-      updatedSourceCode = updatedSourceCode.replace(
-        sourceCode.substring(parent.startIndex, parent.endIndex + 1),
-        "",
-      );
-    }
-
-    node.children.forEach((child) => {
-      traverse(child);
-    });
-  }
-
-  traverse(rootNode);
-
-  return updatedSourceCode;
-}
-
-export function removeUnusedJavascriptImports(
-  rootNode: Parser.SyntaxNode,
-  sourceCode: string,
-) {
-  let updatedSourceCode = sourceCode;
-
-  // Step 1: find all the import statements node
-  const importStatements: Parser.SyntaxNode[] = [];
-
-  function traverseGetImports(node: Parser.SyntaxNode) {
-    if (node.type === "import_statement") {
-      importStatements.push(node);
-    }
-
-    node.children.forEach((child) => {
-      traverseGetImports(child);
-    });
-  }
-  traverseGetImports(rootNode);
-
-  importStatements.forEach((importStatement) => {
-    // Step 2: get all import identifiers from the import
-    const importIdentifiers: Parser.SyntaxNode[] = [];
-
-    function traverseGetImportIdentifiers(node: Parser.SyntaxNode) {
-      if (node.type === "identifier") {
-        importIdentifiers.push(node);
-      }
-
-      node.children.forEach((child) => {
-        traverseGetImportIdentifiers(child);
-      });
-    }
-    traverseGetImportIdentifiers(importStatement);
-
-    let removeImportStatement = false;
-    const importSpecifiersToRemove: Parser.SyntaxNode[] = [];
-
-    importIdentifiers.forEach((importIdentifier) => {
-      // Step 3: check if the import identifier is used in the source code
-      let isUsed = false;
-
-      function traverseCheckIfUsed(node: Parser.SyntaxNode) {
-        if (
-          node.id !== importIdentifier.id &&
-          node.type === "identifier" &&
-          node.text === importIdentifier.text
-        ) {
-          isUsed = true;
-        }
-
-        node.children.forEach((child) => {
-          traverseCheckIfUsed(child);
-        });
-      }
-      traverseCheckIfUsed(rootNode);
-
-      // if used, we continue to the next import identifier
-      if (isUsed) {
-        return;
-      }
-
-      // Step 4: check if parent is import clause, eg: import express from "express";
-      // or if it is a namespace import, eg: import * as express from "express";
-      if (
-        importIdentifier.parent?.type === "import_clause" ||
-        importIdentifier.parent?.type === "namespace_import"
-      ) {
-        removeImportStatement = true;
-        // Step 5: check if parent is import specifier, eg: import { Router } from "express";
-      } else if (importIdentifier.parent?.type === "import_specifier") {
-        importSpecifiersToRemove.push(importIdentifier);
-      }
-    });
-
-    if (
-      removeImportStatement ||
-      importSpecifiersToRemove.length === importIdentifiers.length
-    ) {
-      updatedSourceCode = updatedSourceCode.replace(
-        sourceCode.substring(
-          importStatement.startIndex,
-          importStatement.endIndex + 1,
-        ),
-        "",
-      );
-    } else {
-      importSpecifiersToRemove.forEach((importSpecifier) => {
-        updatedSourceCode = updatedSourceCode.replace(
-          sourceCode.substring(
-            importSpecifier.startIndex,
-            importSpecifier.endIndex + 1,
-          ),
-          "",
-        );
-      });
-    }
-  });
-
-  return updatedSourceCode;
-}
diff --git a/packages/cli/src/helper/languages/javascript/cleanup.ts b/packages/cli/src/helper/languages/javascript/cleanup.ts
new file mode 100644
index 0000000..2e97f9c
--- /dev/null
+++ b/packages/cli/src/helper/languages/javascript/cleanup.ts
@@ -0,0 +1,330 @@
+import Parser from "tree-sitter";
+import { Group } from "../../types";
+import { getNanoApiAnnotationFromCommentValue } from "../../file";
+import {
+  getImportStatements,
+  extractFileImportsFromImportStatements,
+  getRequireDeclarations,
+  extractFileImportsFromRequireDeclarations,
+  extractIdentifiersFromImportStatement,
+  extractIdentifiersFromRequireDeclaration,
+} from "./imports";
+
+function removeAnnotations(
+  rootNode: Parser.SyntaxNode,
+  sourceCode: string,
+  groupToKeep: Group,
+): string {
+  let updatedSourceCode = sourceCode;
+
+  function traverse(node: Parser.SyntaxNode) {
+    if (node.type === "comment") {
+      const commentText = node.text;
+      const annotationFromComment =
+        getNanoApiAnnotationFromCommentValue(commentText);
+      if (!annotationFromComment) return;
+
+      const endpointToKeep = groupToKeep.endpoints.find(
+        (e) =>
+          e.path === annotationFromComment.path &&
+          e.method === annotationFromComment.method,
+      );
+
+      if (!endpointToKeep) {
+        const nextNode = node.nextNamedSibling;
+        if (!nextNode) {
+          throw new Error("Could not find next node");
+        }
+        // TODO support decorator. Lots of framework uses these (eg: nestjs)
+        // delete this node (comment) and the next node (api endpoint)
+        updatedSourceCode = updatedSourceCode.replace(
+          sourceCode.substring(node.startIndex, nextNode.endIndex + 1),
+          "",
+        );
+      }
+    }
+
+    node.children.forEach((child) => {
+      traverse(child);
+    });
+  }
+
+  traverse(rootNode);
+
+  return updatedSourceCode;
+}
+
+function removeInvalidFileImports(
+  rootNode: Parser.SyntaxNode,
+  sourceCode: string,
+  invalidDependencies: string[],
+) {
+  let updatedSourceCode = sourceCode;
+  const removedIdentifiers: Parser.SyntaxNode[] = [];
+
+  const importStatements = getImportStatements(rootNode);
+
+  importStatements.forEach((importStatement) => {
+    const importName = extractFileImportsFromImportStatements(importStatement);
+    if (importName && invalidDependencies.includes(importName)) {
+      const identifiers =
+        extractIdentifiersFromImportStatement(importStatement);
+      removedIdentifiers.push(...identifiers);
+
+      // Remove the import statement
+      updatedSourceCode = updatedSourceCode.replace(
+        sourceCode.substring(
+          importStatement.startIndex,
+          importStatement.endIndex,
+        ),
+        "",
+      );
+    }
+  });
+
+  return { updatedSourceCode, removedIdentifiers };
+}
+
+function removeInvalidFileRequires(
+  rootNode: Parser.SyntaxNode,
+  sourceCode: string,
+  invalidDependencies: string[],
+) {
+  let updatedSourceCode = sourceCode;
+  const removedIdentifiers: Parser.SyntaxNode[] = [];
+
+  const requireStatements = getRequireDeclarations(rootNode);
+  requireStatements.forEach((requireStatement) => {
+    const importName =
+      extractFileImportsFromRequireDeclarations(requireStatement);
+    if (importName && invalidDependencies.includes(importName)) {
+      const identifiers =
+        extractIdentifiersFromRequireDeclaration(requireStatement);
+      removedIdentifiers.push(...identifiers);
+
+      // Remove the require statement
+      updatedSourceCode = updatedSourceCode.replace(
+        sourceCode.substring(
+          requireStatement.startIndex,
+          requireStatement.endIndex,
+        ),
+        "",
+      );
+    }
+  });
+
+  return { updatedSourceCode, removedIdentifiers };
+}
+
+function removeDeletedImportUsage(
+  rootNode: Parser.SyntaxNode,
+  sourceCode: string,
+  removedImportsNames: Parser.SyntaxNode[],
+): string {
+  let updatedSourceCode = sourceCode;
+
+  removedImportsNames.forEach((removedImportsName) => {
+    function traverse(node: Parser.SyntaxNode) {
+      if (node.type === "identifier" && removedImportsName.text === node.text) {
+        // find the next parent expression statement (can be several levels up)
+        let parent = node.parent;
+        while (parent && parent.type !== "expression_statement") {
+          parent = parent.parent;
+        }
+        if (!parent) {
+          throw new Error("Could not find parent expression statement");
+        }
+
+        // Remove the expression statement
+        updatedSourceCode = updatedSourceCode.replace(
+          sourceCode.substring(parent.startIndex, parent.endIndex),
+          "",
+        );
+      }
+
+      node.children.forEach((child) => {
+        traverse(child);
+      });
+    }
+
+    traverse(rootNode);
+  });
+
+  return updatedSourceCode;
+}
+
+function isIdentifierUsed(
+  node: Parser.SyntaxNode,
+  identifier: Parser.SyntaxNode,
+) {
+  let isUsed = false;
+
+  function traverseCheckIfUsed(node: Parser.SyntaxNode) {
+    if (
+      node.id !== identifier.id &&
+      node.type === "identifier" &&
+      node.text === identifier.text
+    ) {
+      isUsed = true;
+      return;
+    }
+
+    node.children.forEach((child) => {
+      traverseCheckIfUsed(child);
+    });
+  }
+  traverseCheckIfUsed(node);
+
+  return isUsed;
+}
+
+function cleanUnusedImportsStatements(
+  rootNode: Parser.SyntaxNode,
+  sourceCode: string,
+) {
+  let updatedSourceCode = sourceCode;
+
+  const importStatements = getImportStatements(rootNode);
+
+  importStatements.forEach((importStatement) => {
+    const importIdentifiers =
+      extractIdentifiersFromImportStatement(importStatement);
+
+    const importIdentifiersToRemove: Parser.SyntaxNode[] = [];
+
+    importIdentifiers.forEach((importIdentifier) => {
+      const isUsed = isIdentifierUsed(rootNode, importIdentifier);
+      if (!isUsed) {
+        importIdentifiersToRemove.push(importIdentifier);
+      }
+    });
+
+    const removeImportStatement =
+      importIdentifiersToRemove.length === importIdentifiers.length;
+
+    if (removeImportStatement) {
+      updatedSourceCode = updatedSourceCode.replace(
+        sourceCode.substring(
+          importStatement.startIndex,
+          importStatement.endIndex + 1,
+        ),
+        "",
+      );
+    }
+
+    importIdentifiersToRemove.forEach((importIdentifier) => {
+      updatedSourceCode = updatedSourceCode.replace(
+        sourceCode.substring(
+          importIdentifier.startIndex,
+          importIdentifier.endIndex + 1,
+        ),
+        "",
+      );
+    });
+  });
+
+  return updatedSourceCode;
+}
+
+function cleanUnusedRequireDeclarations(
+  rootNode: Parser.SyntaxNode,
+  sourceCode: string,
+) {
+  let updatedSourceCode = sourceCode;
+
+  const requireDeclarations = getRequireDeclarations(rootNode);
+
+  requireDeclarations.forEach((requireDeclaration) => {
+    const requireIdentifiers =
+      extractIdentifiersFromRequireDeclaration(requireDeclaration);
+
+    const requireIdentifiersToRemove: Parser.SyntaxNode[] = [];
+
+    requireIdentifiers.forEach((requireIdentifier) => {
+      const isUsed = isIdentifierUsed(rootNode, requireIdentifier);
+      if (!isUsed) {
+        requireIdentifiersToRemove.push(requireIdentifier);
+      }
+    });
+
+    const removeRequireDeclaration =
+      requireIdentifiersToRemove.length === requireIdentifiers.length;
+
+    if (removeRequireDeclaration) {
+      updatedSourceCode = updatedSourceCode.replace(
+        sourceCode.substring(
+          requireDeclaration.startIndex,
+          requireDeclaration.endIndex + 1,
+        ),
+        "",
+      );
+    }
+
+    requireIdentifiersToRemove.forEach((requireIdentifier) => {
+      updatedSourceCode = updatedSourceCode.replace(
+        sourceCode.substring(
+          requireIdentifier.startIndex,
+          requireIdentifier.endIndex + 1,
+        ),
+        "",
+      );
+    });
+  });
+
+  return updatedSourceCode;
+}
+
+export function cleanupJavascriptFile(
+  parser: Parser,
+  sourceCode: string,
+  group: Group,
+  invalidDependencies: string[],
+): string {
+  let tree = parser.parse(sourceCode);
+
+  let updatedSourceCode = removeAnnotations(tree.rootNode, sourceCode, group);
+
+  tree = parser.parse(updatedSourceCode);
+
+  const resultAfterImportCleaning = removeInvalidFileImports(
+    tree.rootNode,
+    updatedSourceCode,
+    invalidDependencies,
+  );
+  updatedSourceCode = resultAfterImportCleaning.updatedSourceCode;
+  const removedIdentifiers = resultAfterImportCleaning.removedIdentifiers;
+
+  tree = parser.parse(updatedSourceCode);
+
+  const resultAfterRequireCleaning = removeInvalidFileRequires(
+    tree.rootNode,
+    updatedSourceCode,
+    invalidDependencies,
+  );
+  updatedSourceCode = resultAfterRequireCleaning.updatedSourceCode;
+  removedIdentifiers.push(...resultAfterRequireCleaning.removedIdentifiers);
+
+  tree = parser.parse(updatedSourceCode);
+
+  updatedSourceCode = removeDeletedImportUsage(
+    tree.rootNode,
+    updatedSourceCode,
+    removedIdentifiers,
+  );
+
+  tree = parser.parse(updatedSourceCode);
+
+  updatedSourceCode = cleanUnusedImportsStatements(
+    tree.rootNode,
+    updatedSourceCode,
+  );
+
+  tree = parser.parse(updatedSourceCode);
+
+  updatedSourceCode = cleanUnusedRequireDeclarations(
+    tree.rootNode,
+    updatedSourceCode,
+  );
+
+  return updatedSourceCode;
+}
diff --git a/packages/cli/src/helper/languages/javascript/imports.ts b/packages/cli/src/helper/languages/javascript/imports.ts
new file mode 100644
index 0000000..9715777
--- /dev/null
+++ b/packages/cli/src/helper/languages/javascript/imports.ts
@@ -0,0 +1,204 @@
+import Parser from "tree-sitter";
+
+export function getImportStatements(node: Parser.SyntaxNode) {
+  const importStatements: Parser.SyntaxNode[] = [];
+
+  function traverse(node: Parser.SyntaxNode) {
+    if (node.type === "import_statement") {
+      importStatements.push(node);
+    }
+
+    for (let i = 0; i < node.childCount; i++) {
+      traverse(node.child(i) as Parser.SyntaxNode);
+    }
+  }
+
+  traverse(node);
+
+  return importStatements;
+}
+
+export function getRequireDeclarations(node: Parser.SyntaxNode) {
+  const requireStatements: Parser.SyntaxNode[] = [];
+
+  function traverse(node: Parser.SyntaxNode) {
+    if (node.type === "call_expression") {
+      const requireNode = node.namedChildren.find(
+        (n: Parser.SyntaxNode) =>
+          n.type === "identifier" && n.text === "require",
+      );
+      if (requireNode) {
+        let declarationNode = node;
+        while (true) {
+          if (
+            ["variable_declaration", "lexical_declaration"].includes(
+              declarationNode.type,
+            )
+          ) {
+            break;
+          }
+
+          if (!declarationNode.parent) {
+            break;
+          }
+          declarationNode = declarationNode.parent;
+        }
+
+        if (
+          declarationNode.type === "variable_declaration" ||
+          declarationNode.type === "lexical_declaration"
+        ) {
+          requireStatements.push(declarationNode);
+        } else {
+          throw new Error(
+            "Unexcpected error, Could not find require declaration",
+          );
+        }
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) {
+      traverse(node.child(i) as Parser.SyntaxNode);
+    }
+  }
+
+  traverse(node);
+
+  return requireStatements;
+}
+
+export function extractFileImportsFromImportStatements(
+  importNode: Parser.SyntaxNode,
+) {
+  const stringNode = importNode.namedChildren.find(
+    (n: Parser.SyntaxNode) => n.type === "string",
+  );
+  if (stringNode) {
+    const importName = stringNode.text.slice(1, -1); // Remove quotes
+    // check if stringNode is a file path, we ignore import from node_modules
+    if (importName.startsWith(".")) {
+      return importName;
+    }
+  }
+}
+
+export function extractFileImportsFromRequireDeclarations(
+  requireNode: Parser.SyntaxNode,
+) {
+  let fileImportName: string | undefined;
+
+  function traverse(node: Parser.SyntaxNode) {
+    if (node.type === "call_expression") {
+      const requireNode = node.namedChildren.find(
+        (n: Parser.SyntaxNode) =>
+          n.type === "identifier" && n.text === "require",
+      );
+      if (requireNode) {
+        const argumentsNode = node.namedChildren.find(
+          (n: Parser.SyntaxNode) => n.type === "arguments",
+        );
+        if (!argumentsNode) {
+          throw new Error("Could not find arguments node");
+        }
+
+        const stringNode = argumentsNode.namedChildren.find(
+          (n: Parser.SyntaxNode) => n.type === "string",
+        );
+        if (!stringNode) {
+          throw new Error("Could not find string node");
+        }
+
+        const importName = stringNode.text.slice(1, -1); // Remove quotes
+
+        // check if stringNode is a file path, we ignore import from node_modules
+        if (importName.startsWith(".")) {
+          fileImportName = importName;
+          return;
+        }
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) {
+      traverse(node.child(i) as Parser.SyntaxNode);
+    }
+  }
+
+  traverse(requireNode);
+
+  return fileImportName;
+}
+
+export function extractIdentifiersFromImportStatement(node: Parser.SyntaxNode) {
+  const identifier: Parser.SyntaxNode[] = [];
+
+  function traverse(node: Parser.SyntaxNode) {
+    if (node.type === "identifier") {
+      identifier.push(node);
+    }
+
+    for (let i = 0; i < node.childCount; i++) {
+      traverse(node.child(i) as Parser.SyntaxNode);
+    }
+  }
+
+  traverse(node);
+
+  return identifier;
+}
+
+export function extractIdentifiersFromRequireDeclaration(
+  node: Parser.SyntaxNode,
+) {
+  const identifier: Parser.SyntaxNode[] = [];
+
+  function traverse(node: Parser.SyntaxNode) {
+    // We do not care about the identifier of the require call
+    if (node.type === "call_expression") {
+      return;
+    }
+
+    if (
+      ["identifier", "shorthand_property_identifier_pattern"].includes(
+        node.type,
+      )
+    ) {
+      identifier.push(node);
+    }
+
+    for (let i = 0; i < node.childCount; i++) {
+      traverse(node.child(i) as Parser.SyntaxNode);
+    }
+  }
+
+  traverse(node);
+
+  return identifier;
+}
+
+export function extractJavascriptFileImports(
+  parser: Parser,
+  sourceCode: string,
+) {
+  const tree = parser.parse(sourceCode);
+
+  const importNodes = getImportStatements(tree.rootNode);
+  const requireNodes = getRequireDeclarations(tree.rootNode);
+
+  const dependenciesFromImports: string[] = [];
+  importNodes.forEach((node) => {
+    const importName = extractFileImportsFromImportStatements(node);
+    if (importName) {
+      dependenciesFromImports.push(importName);
+    }
+  });
+
+  const dependenciesFromRequires: string[] = [];
+  requireNodes.forEach((node) => {
+    const importName = extractFileImportsFromRequireDeclarations(node);
+    if (importName) {
+      dependenciesFromRequires.push(importName);
+    }
+  });
+
+  return [...dependenciesFromImports, ...dependenciesFromRequires];
+}