@davidwells/extract-deps 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davidwells/extract-deps",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Get imports and requires from a codebase without AST",
   "main": "src/index.js",
   "exports": {

package/src/dep-graph.js

@@ -4,6 +4,7 @@ const fs = require('fs')
 const { pathToFileURL, fileURLToPath } = require('url')
 const { resolve: resolveImport } = require('@dual-bundle/import-meta-resolve')
 const { extractDeps } = require('./index')
+const { isBuiltIn } = require('./utils')
 
 function fsExistsSync(path) {
   try {
@@ -229,13 +230,18 @@ function buildGraphRecursively(
     }
   }
 
-  // Verify node_modules dependencies if enabled
+  // Verify node_modules dependencies if enabled (skip built-ins)
   if (verifyNodeModules && nodeModuleDeps.length > 0) {
     const parentURL = pathToFileURL(filePath).href
 
     for (const dep of nodeModuleDeps) {
       const { from, line } = dep
 
+      // Skip verification for built-in modules
+      if (dep.isBuiltIn) {
+        continue
+      }
+
       try {
         // Try to resolve the module using Node's resolution algorithm
         const resolved = resolveImport(from, parentURL)
@@ -308,7 +314,7 @@ function depGraph(filePath, options = {}) {
  * @param {boolean} [options.verifyNodeModules] - If true, verify node_modules packages can be resolved. Default: false
  * @param {boolean} [options.throwOnFirstError] - If true, throw immediately on first error. Default: false
  * @param {boolean} [options.returnErrors] - If true, include errors array in result instead of throwing
- * @returns {{ files: string[], nodeModules: string[], errors?: Error[] }} - Object with files in topological order and unique node_modules
+ * @returns {{ files: string[], nodeModules: string[], builtIns: string[], errors?: Error[] }} - Object with files in topological order, npm packages, and Node.js built-ins
  */
 function resolveDepPaths(filePath, options = {}) {
   const { returnErrors = false, ...restOptions } = options
@@ -330,12 +336,17 @@ function resolveDepPaths(filePath, options = {}) {
     )
   }
 
-  // Collect node_modules (non-path strings in dependency arrays)
+  // Collect node_modules and built-ins (non-path strings in dependency arrays)
   const nodeModulesSet = new Set()
+  const builtInsSet = new Set()
   for (const deps of graph.values()) {
     for (const dep of deps) {
       if (!dep.startsWith('/')) {
-        nodeModulesSet.add(dep)
+        if (isBuiltIn(dep)) {
+          builtInsSet.add(dep)
+        } else {
+          nodeModulesSet.add(dep)
+        }
       }
     }
   }
@@ -376,7 +387,8 @@ function resolveDepPaths(filePath, options = {}) {
 
   const result = {
     files: buildOrder,
-    nodeModules: Array.from(nodeModulesSet)
+    nodeModules: Array.from(nodeModulesSet),
+    builtIns: Array.from(builtInsSet)
   }
 
   if (returnErrors) {

package/src/detect-syntax.js

@@ -1,4 +1,5 @@
 // via https://github.com/unjs/mlly/blob/6bf5ad4d784e314319f872a8df41d64edd4e5505/src/syntax.ts#L7
+const { stripComments } = require('./utils')
 
 const ESM_RE =
   /([\s;]|^)(import\b[\s\w*,{}]*from|import\b\s*["'*{]|export\b\s*(?:[*{]|default|class|type|interface|enum|function|const|var|let|async function)|import\.meta\b)/m;
@@ -6,8 +7,6 @@ const ESM_RE =
 const CJS_RE =
   /([\s;]|^)(module\.exports\b|exports\.\w|require\s*\(|global\.\w)/m;
 
-const COMMENT_RE = /\/\*.+?\*\/|\/\/.*(?:\r?\n|$)/g;
-
 const BUILTIN_EXTENSIONS = new Set([".mjs", ".cjs", ".node", ".wasm"]);
 
 /**
@@ -25,8 +24,8 @@ const BUILTIN_EXTENSIONS = new Set([".mjs", ".cjs", ".node", ".wasm"]);
  */
 function hasESMSyntax(code, opts = {}) {
   // Always strip comments to avoid false positives from commented syntax
-  code = code.replace(COMMENT_RE, "");
-  return ESM_RE.test(code);
+  code = stripComments(code)
+  return ESM_RE.test(code)
 }
 
 /**
@@ -38,8 +37,8 @@ function hasESMSyntax(code, opts = {}) {
  */
 function hasCJSSyntax(code, opts = {}) {
   // Always strip comments to avoid false positives from commented syntax
-  code = code.replace(COMMENT_RE, "");
-  return CJS_RE.test(code);
+  code = stripComments(code)
+  return CJS_RE.test(code)
 }
 
 /**
@@ -51,16 +50,16 @@ function hasCJSSyntax(code, opts = {}) {
  */
 function detectSyntax(code, opts = {}) {
   // Always strip comments to avoid false positives from commented syntax
-  code = code.replace(COMMENT_RE, "");
+  code = stripComments(code)
   // We strip comments once hence not passing opts down to hasESMSyntax and hasCJSSyntax
-  const hasESM = hasESMSyntax(code, {});
-  const hasCJS = hasCJSSyntax(code, {});
+  const hasESM = hasESMSyntax(code, {})
+  const hasCJS = hasCJSSyntax(code, {})
 
   return {
     hasESM,
     hasCJS,
     isMixed: hasESM && hasCJS,
-  };
+  }
 }
 
 module.exports = {

package/src/get-exports.js

@@ -1,4 +1,4 @@
-const { getNames, extractExportName } = require('./utils')
+const { getNames, extractExportName, stripComments } = require('./utils')
 
 // https://regex101.com/r/example/1
 const EXPORT_DEFAULT_REGEX = /export\s+default\s+(?:(?:async\s+)?function\s+([\w$]+)|class\s+([\w$]+)|([\w$]+|\([^)]*\)\s*=>|{[\s\S]*?}|\[[\s\S]*?\]|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*`|[\w$]+(?:\s*[+\-*/%]\s*[\w$]+)*))/gm
@@ -15,7 +15,9 @@ const EXPORT_TYPE_REGEX = /export\s+(?:type|interface)\s+([\w$]+)/gm
 // https://regex101.com/r/example/7
 const EXPORT_ASSERTION_REGEX = /export\s+(?:["'\s]*([\w*{}\n\r\t, ]+)from\s*)?["'\s](.*[@\w_-]+)["'\s]+(assert|with)\s*\{([^}]+)\};?$/gm
 
-function getExports(code, options = {}) {
+function getExports(code = '', options = {}) {
+  // Strip comments to avoid false positives
+  code = stripComments(code)
   const defaultExports = getDefaultExports(code)
   const namedExports = getNamedExports(code)
   const namedDeclarationExports = getNamedDeclarationExports(code)

package/src/get-imports.js

@@ -1,4 +1,4 @@
-const { isRelativeImport, isRelativeImportWithQuotes, getNames } = require('./utils')
+const { isBuiltIn, isRelativeImport, isRelativeImportWithQuotes, getNames, stripComments } = require('./utils')
 
 // https://regex101.com/r/cfEmlm/1
 const IMPORT_REGEX = /import(?:["'\s]*([\w*{}\n\r\t, ]+)from\s*)?["'\s](.*[@\w_-]+)["'\s]+;?$/gm
@@ -9,7 +9,9 @@ const DYNAMIC_IMPORT_REGEX = /(?:(const|var|let)\s+([\w*{}\n\r\t,:= ]+)\s*=\s*)?
 // https://regex101.com/r/example/1
 const ASSERTION_IMPORT_REGEX = /(?:^|\n)\s*import\s+(?:["'\s]*([\w*{}\n\r\t, ]+)from\s*)?["'\s](.*[@\w_-]+)["'\s]+(assert|with)\s*\{([^}]+)\};?$/gm
 
-function getImports(code, options = {}) {
+function getImports(code = '', options = {}) {
+  // Strip comments to avoid false positives
+  code = stripComments(code)
   const staticImports = getStaticImports(code)
   const dynamicImports = getDynamicImports(code)
   if (options.includeAssertionImports) {
@@ -26,7 +28,7 @@ function getStaticImports(targetText = '') {
   while((result = IMPORT_REGEX.exec(targetText)) !== null) {
     const [ line, names, from ] = result
     const namesValues = (names || '').trim()
-    importStatements.push({ 
+    importStatements.push({
       line,
       varType: 'const',
       varName: namesValues,
@@ -34,7 +36,8 @@ function getStaticImports(targetText = '') {
       from,
       index: result.index,
       isImport: true,
-      isRelative: isRelativeImport(from)
+      isRelative: isRelativeImport(from),
+      isBuiltIn: isBuiltIn(from)
     })
   }
   return importStatements
@@ -53,7 +56,8 @@ function getTypeImports(targetText = '') {
       index: result.index,
       isImport: true,
       isTypeImport: true,
-      isRelative: isRelativeImport(importPath)
+      isRelative: isRelativeImport(importPath),
+      isBuiltIn: isBuiltIn(importPath)
     })
   }
   return importStatements
@@ -75,6 +79,7 @@ function getDynamicImports(targetText = '') {
       index: result.index,
       isImport: true,
       isRelative: isRelativeImport(from) || isRelativeImportWithQuotes(from),
+      isBuiltIn: isBuiltIn(from.trim()),
       isDynamic: true
     })
   }
@@ -101,6 +106,7 @@ function getAssertionImports(targetText = '') {
       index: result.index,
       isImport: true,
       isRelative: isRelativeImport(from),
+      isBuiltIn: isBuiltIn(from),
       isAssertion: true
     })
   }

package/src/get-requires.js

@@ -1,4 +1,4 @@
-const { isRelativeImport, getNames } = require('./utils')
+const { isBuiltIn, isRelativeImport, getNames } = require('./utils')
 
 // Updated regex to exclude ES6 dynamic imports
 const REQUIRE_REGEX = /(?!.*await\s+import)(const|var|let)(?:["'\s]*([\w*{}:=\n\r\t,:= ]+)\s*=\s*require\(\s*)?["'\s](.*[@\w_-]+)["'\s]+\);?$|(?!.*await\s+import)require\(["'\s](.*[@\w_-]+)["'\s]\)/gm
@@ -28,6 +28,7 @@ function getDynamicRequires(code) {
       index: match.index,
       isRequire: true,
       isRelative: false,
+      isBuiltIn: isBuiltIn(from.trim()),
       isDynamic: true
     })
   }
@@ -53,6 +54,7 @@ function getStaticRequires(targetText = '') {
       index: result.index,
       isRequire: true,
       isRelative: isRelativeImport(importLocation),
+      isBuiltIn: isBuiltIn(importLocation),
       isDynamic: false
     })
   }

package/src/utils.js

@@ -1,4 +1,40 @@
 const { inspectParameters, getParametersNames } = require('./vendor/inspect-parameters-declaration')
+const builtinModules = require('module').builtinModules
+
+const COMMENT_RE = /\/\*[\s\S]*?\*\/|\/\/.*(?:\r?\n|$)/g
+const PROTOCOL_PLACEHOLDER = '__PROTO_SLASH__'
+
+/**
+ * Strip comments from code, preserving :// in URLs
+ * @param {string} code
+ * @returns {string}
+ */
+function stripComments(code) {
+  const hasProtocol = code.indexOf('://') > -1
+  if (hasProtocol) {
+    code = code.replace(/:\/\//g, PROTOCOL_PLACEHOLDER)
+  }
+  code = code.replace(COMMENT_RE, '')
+  if (hasProtocol) {
+    code = code.replace(/__PROTO_SLASH__/g, '://')
+  }
+  return code
+}
+
+/**
+ * Check if a module specifier is a Node.js built-in
+ * @param {string} moduleName - The module specifier (e.g., 'fs', 'node:fs/promises')
+ * @returns {boolean}
+ */
+function isBuiltIn(moduleName) {
+  // Handle node: prefix (always a built-in)
+  if (moduleName.startsWith('node:')) {
+    return true
+  }
+  // Handle subpaths like 'fs/promises' - check the base name
+  const baseName = moduleName.split('/')[0]
+  return builtinModules.includes(baseName)
+}
 
 function isRelativeImport(importLocation) {
   return !!importLocation.match(/^\./)
@@ -195,6 +231,8 @@ function extractExportName(exportValue) {
 }
 
 module.exports = {
+  stripComments,
+  isBuiltIn,
   isRelativeImport,
   isRelativeImportWithQuotes,
   getNames,

package/tests/builtins.test.js

@@ -0,0 +1,134 @@
+// Test handling of Node.js built-in modules
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const path = require('path')
+const { isBuiltIn } = require('../src/utils')
+const { getStaticImports } = require('../src/get-imports')
+const { getStaticRequires } = require('../src/get-requires')
+const { resolveDepPaths } = require('../src/dep-graph')
+
+const BUILTINS_FIXTURE_PATH = path.resolve(__dirname, './fixtures/builtins-example/index.js')
+
+// isBuiltIn utility tests
+test('isBuiltIn should detect node: prefix', () => {
+  assert.is(isBuiltIn('node:fs'), true)
+  assert.is(isBuiltIn('node:path'), true)
+  assert.is(isBuiltIn('node:stream'), true)
+})
+
+test('isBuiltIn should detect node: prefix with subpaths', () => {
+  assert.is(isBuiltIn('node:fs/promises'), true)
+  assert.is(isBuiltIn('node:stream/promises'), true)
+  assert.is(isBuiltIn('node:timers/promises'), true)
+})
+
+test('isBuiltIn should detect legacy bare built-ins', () => {
+  assert.is(isBuiltIn('fs'), true)
+  assert.is(isBuiltIn('path'), true)
+  assert.is(isBuiltIn('stream'), true)
+  assert.is(isBuiltIn('http'), true)
+  assert.is(isBuiltIn('crypto'), true)
+})
+
+test('isBuiltIn should detect legacy bare built-ins with subpaths', () => {
+  assert.is(isBuiltIn('fs/promises'), true)
+  assert.is(isBuiltIn('stream/promises'), true)
+  assert.is(isBuiltIn('timers/promises'), true)
+})
+
+test('isBuiltIn should return false for npm packages', () => {
+  assert.is(isBuiltIn('lodash'), false)
+  assert.is(isBuiltIn('express'), false)
+  assert.is(isBuiltIn('@org/package'), false)
+  assert.is(isBuiltIn('uvu/assert'), false)
+})
+
+test('isBuiltIn should return false for relative imports', () => {
+  assert.is(isBuiltIn('./foo'), false)
+  assert.is(isBuiltIn('../bar'), false)
+  assert.is(isBuiltIn('./node/fake'), false)
+})
+
+// getStaticImports with isBuiltIn flag
+test('getStaticImports should mark built-ins with isBuiltIn flag', () => {
+  const code = `
+import fs from 'fs'
+import { readFile } from 'node:fs/promises'
+import path from 'path'
+import lodash from 'lodash'
+import { foo } from './local'
+  `
+
+  const imports = getStaticImports(code)
+
+  const fsImport = imports.find(i => i.from === 'fs')
+  const nodeFsImport = imports.find(i => i.from === 'node:fs/promises')
+  const pathImport = imports.find(i => i.from === 'path')
+  const lodashImport = imports.find(i => i.from === 'lodash')
+  const localImport = imports.find(i => i.from === './local')
+
+  assert.is(fsImport.isBuiltIn, true, 'fs should be built-in')
+  assert.is(nodeFsImport.isBuiltIn, true, 'node:fs/promises should be built-in')
+  assert.is(pathImport.isBuiltIn, true, 'path should be built-in')
+  assert.is(lodashImport.isBuiltIn, false, 'lodash should not be built-in')
+  assert.is(localImport.isBuiltIn, false, './local should not be built-in')
+})
+
+// getStaticRequires with isBuiltIn flag
+test('getStaticRequires should mark built-ins with isBuiltIn flag', () => {
+  const code = `
+const fs = require('fs')
+const { readFile } = require('node:fs/promises')
+const path = require('path')
+const lodash = require('lodash')
+const local = require('./local')
+  `
+
+  const requires = getStaticRequires(code)
+
+  const fsReq = requires.find(r => r.from === 'fs')
+  const nodeFsReq = requires.find(r => r.from === 'node:fs/promises')
+  const pathReq = requires.find(r => r.from === 'path')
+  const lodashReq = requires.find(r => r.from === 'lodash')
+  const localReq = requires.find(r => r.from === './local')
+
+  assert.is(fsReq.isBuiltIn, true, 'fs should be built-in')
+  assert.is(nodeFsReq.isBuiltIn, true, 'node:fs/promises should be built-in')
+  assert.is(pathReq.isBuiltIn, true, 'path should be built-in')
+  assert.is(lodashReq.isBuiltIn, false, 'lodash should not be built-in')
+  assert.is(localReq.isBuiltIn, false, './local should not be built-in')
+})
+
+// resolveDepPaths tests for builtIns
+test('resolveDepPaths should return separate builtIns array', () => {
+  const result = resolveDepPaths(BUILTINS_FIXTURE_PATH)
+
+  assert.ok(Array.isArray(result.builtIns), 'should have builtIns array')
+  assert.ok(Array.isArray(result.nodeModules), 'should have nodeModules array')
+  assert.ok(Array.isArray(result.files), 'should have files array')
+})
+
+test('resolveDepPaths should separate built-ins from nodeModules', () => {
+  const { builtIns, nodeModules } = resolveDepPaths(BUILTINS_FIXTURE_PATH)
+
+  // Built-ins should include fs, node:fs/promises, path, node:stream, node:crypto
+  assert.ok(builtIns.includes('fs'), 'builtIns should include fs')
+  assert.ok(builtIns.includes('node:fs/promises'), 'builtIns should include node:fs/promises')
+  assert.ok(builtIns.includes('path'), 'builtIns should include path')
+  assert.ok(builtIns.includes('node:stream'), 'builtIns should include node:stream')
+  assert.ok(builtIns.includes('node:crypto'), 'builtIns should include node:crypto')
+
+  // nodeModules should include lodash but not built-ins
+  assert.ok(nodeModules.includes('lodash'), 'nodeModules should include lodash')
+  assert.ok(!nodeModules.includes('fs'), 'nodeModules should NOT include fs')
+  assert.ok(!nodeModules.includes('node:fs/promises'), 'nodeModules should NOT include node:fs/promises')
+})
+
+test('resolveDepPaths builtIns should not duplicate entries', () => {
+  const { builtIns } = resolveDepPaths(BUILTINS_FIXTURE_PATH)
+
+  const uniqueBuiltIns = [...new Set(builtIns)]
+  assert.is(builtIns.length, uniqueBuiltIns.length, 'builtIns should be deduplicated')
+})
+
+test.run()

package/tests/fixtures/builtins-example/helper.js

@@ -0,0 +1,8 @@
+// Local helper using built-ins
+const { createHash } = require('node:crypto')
+
+function helper() {
+  return createHash('sha256')
+}
+
+module.exports = { helper }

package/tests/fixtures/builtins-example/index.js

@@ -0,0 +1,16 @@
+// Fixture using Node.js built-ins and npm packages
+const fs = require('fs')
+const { readFile } = require('node:fs/promises')
+const path = require('path')
+const { Transform } = require('node:stream')
+const lodash = require('lodash')
+const { helper } = require('./helper')
+
+module.exports = {
+  fs,
+  readFile,
+  path,
+  Transform,
+  lodash,
+  helper
+}

package/tests/get-exports.test.js

@@ -532,4 +532,35 @@ export {
   assert.equal(foundExports[0].exportAlias, 'myHandler', 'exportAlias should be "myHandler" without trailing comma')
 })
 
+test('should ignore commented-out exports', () => {
+  const code = `
+// export const foo = 'foo'
+/* export default bar */
+/*
+export const multiLine = 'test'
+*/
+export const realExport = 'real'
+  `
+
+  const foundExports = getExports(code)
+
+  assert.equal(foundExports.length, 1, 'Should only find 1 real export')
+  assert.equal(foundExports[0].exportName, 'realExport', 'Should find realExport')
+})
+
+test('should preserve URLs with :// in strings', () => {
+  const code = `
+export const url = 'http://example.com/path'
+export const https = 'https://secure.com'
+export const real = 'value' // this comment should be stripped
+  `
+
+  const foundExports = getExports(code)
+
+  assert.equal(foundExports.length, 3, 'Should find 3 exports')
+  assert.equal(foundExports[0].exportName, 'url', 'Should find url export')
+  assert.equal(foundExports[1].exportName, 'https', 'Should find https export')
+  assert.equal(foundExports[2].exportName, 'real', 'Should find real export')
+})
+
 test.run() 

package/tests/get-imports.test.js

@@ -50,7 +50,8 @@ test('getStaticImports', async () => {
       },
       from: 'url',
       isImport: true,
-      isRelative: false
+      isRelative: false,
+      isBuiltIn: true
     },
     {
       line: "import foo from 'fs'",
@@ -59,7 +60,8 @@ test('getStaticImports', async () => {
       definitions: { declaration: 'foo', name: 'foo' },
       from: 'fs',
       isImport: true,
-      isRelative: false
+      isRelative: false,
+      isBuiltIn: true
     },
     {
       line: "import * as Fs from 'fs'",
@@ -68,7 +70,8 @@ test('getStaticImports', async () => {
       definitions: { declaration: '* as Fs', name: '*', alias: 'Fs' },
       from: 'fs',
       isImport: true,
-      isRelative: false
+      isRelative: false,
+      isBuiltIn: true
     },
     {
       line: "import assert from 'uvu/assert'",
@@ -77,7 +80,8 @@ test('getStaticImports', async () => {
       definitions: { declaration: 'assert', name: 'assert' },
       from: 'uvu/assert',
       isImport: true,
-      isRelative: false
+      isRelative: false,
+      isBuiltIn: false
     }
   ])
 })
@@ -105,7 +109,8 @@ test('get jsDoc Imports', async () => {
         importName: 'hdhdhdhdhddh',
         isImport: true,
         isTypeImport: true,
-        isRelative: true
+        isRelative: true,
+        isBuiltIn: false
       },
       {
         importStatement: 'import("lodash").omit',
@@ -113,7 +118,8 @@ test('get jsDoc Imports', async () => {
         importName: 'omit',
         isImport: true,
         isTypeImport: true,
-        isRelative: false
+        isRelative: false,
+        isBuiltIn: false
       },
       {
         importStatement: 'import("uvu/assert")',
@@ -121,7 +127,8 @@ test('get jsDoc Imports', async () => {
         importName: '',
         isImport: true,
         isTypeImport: true,
-        isRelative: false
+        isRelative: false,
+        isBuiltIn: false
       }
     ])
 })
@@ -166,6 +173,7 @@ test('getDynamicImports', async () => {
     from: "'./module.js'",
     isImport: true,
     isRelative: true,
+    isBuiltIn: false,
     isDynamic: true
   },
   {
@@ -176,6 +184,7 @@ test('getDynamicImports', async () => {
     from: 'moduleName',
     isImport: true,
     isRelative: false,
+    isBuiltIn: false,
     isDynamic: true
   },
   {
@@ -186,6 +195,7 @@ test('getDynamicImports', async () => {
     from: '`./src/${folder}/Button.js`',
     isImport: true,
     isRelative: false,
+    isBuiltIn: false,
     isDynamic: true
   },
   {
@@ -196,6 +206,7 @@ test('getDynamicImports', async () => {
     from: 'modulePath',
     isImport: true,
     isRelative: false,
+    isBuiltIn: false,
     isDynamic: true
   },
   {
@@ -218,6 +229,7 @@ test('getDynamicImports', async () => {
     from: "'./Component.js'",
     isImport: true,
     isRelative: true,
+    isBuiltIn: false,
     isDynamic: true
   },
   {
@@ -228,6 +240,7 @@ test('getDynamicImports', async () => {
     from: 'getModulePath()',
     isImport: true,
     isRelative: false,
+    isBuiltIn: false,
     isDynamic: true
   }
 ])
@@ -324,6 +337,7 @@ import styles from './styles.css' with { type: 'css' }
       assertionType: 'assert',
       isImport: true,
       isRelative: true,
+      isBuiltIn: false,
       isAssertion: true
     },
     {
@@ -336,6 +350,7 @@ import styles from './styles.css' with { type: 'css' }
       assertionType: 'assert',
       isImport: true,
       isRelative: true,
+      isBuiltIn: false,
       isAssertion: true
     },
     {
@@ -348,6 +363,7 @@ import styles from './styles.css' with { type: 'css' }
       assertionType: 'with',
       isImport: true,
       isRelative: true,
+      isBuiltIn: false,
       isAssertion: true
     },
     {
@@ -360,6 +376,7 @@ import styles from './styles.css' with { type: 'css' }
       assertionType: 'with',
       isImport: true,
       isRelative: true,
+      isBuiltIn: false,
       isAssertion: true
     }
   ])
@@ -395,4 +412,31 @@ import styles from './styles.css' with { type: 'css' }
   assert.is(hasWithImport, true, 'Should have with import')
 })
 
+test('should ignore commented-out imports', () => {
+  const code = `
+// import foo from 'foo'
+/* import bar from 'bar' */
+/*
+import multiLine from 'multi'
+*/
+import realImport from 'real'
+  `
+
+  const importsFound = getImports(code)
+
+  assert.equal(importsFound.length, 1, 'Should only find 1 real import')
+  assert.equal(importsFound[0].from, 'real', 'Should find real import')
+})
+
+test('should preserve URLs with :// in strings', () => {
+  const code = `
+import foo from 'foo' // http://example.com
+  `
+
+  const importsFound = getImports(code)
+
+  assert.equal(importsFound.length, 1, 'Should find 1 import')
+  assert.equal(importsFound[0].from, 'foo', 'Should find foo import')
+})
+
 test.run()

package/tests/get-requires.test.js

@@ -33,6 +33,7 @@ test('getRequires', async () => {
       from: 'uvu',
       isRequire: true,
       isRelative: false,
+      isBuiltIn: false,
       isDynamic: false
     },
     {
@@ -43,6 +44,7 @@ test('getRequires', async () => {
       from: 'uvu/assert',
       isRequire: true,
       isRelative: false,
+      isBuiltIn: false,
       isDynamic: false
     },
     {
@@ -58,6 +60,7 @@ test('getRequires', async () => {
       from: './get-imports',
       isRequire: true,
       isRelative: true,
+      isBuiltIn: false,
       isDynamic: false
     }
   ])
@@ -96,6 +99,7 @@ test('getRequires 2', async () => {
       from: 'uvu',
       isRequire: true,
       isRelative: false,
+      isBuiltIn: false,
       isDynamic: false
     },
     {
@@ -106,6 +110,7 @@ test('getRequires 2', async () => {
       from: 'uvu/assert',
       isRequire: true,
       isRelative: false,
+      isBuiltIn: false,
       isDynamic: false
     },
     {
@@ -121,6 +126,7 @@ test('getRequires 2', async () => {
       from: './get-imports',
       isRequire: true,
       isRelative: true,
+      isBuiltIn: false,
       isDynamic: false
     }
   ])
@@ -151,6 +157,7 @@ test('getRequires with dynamic requires', async () => {
       from: 'moduleName',
       isRequire: true,
       isRelative: false,
+      isBuiltIn: false,
       isDynamic: true
     },
     {
@@ -161,6 +168,7 @@ test('getRequires with dynamic requires', async () => {
       from: "path.join(__dirname, 'utils')",
       isRequire: true,
       isRelative: false,
+      isBuiltIn: false,
       isDynamic: true
     },
     {
@@ -171,6 +179,7 @@ test('getRequires with dynamic requires', async () => {
       from: '`./${folder}/file`',
       isRequire: true,
       isRelative: false,
+      isBuiltIn: false,
       isDynamic: true
     },
     {
@@ -193,6 +202,7 @@ test('getRequires with dynamic requires', async () => {
       from: 'moduleTwo',
       isRequire: true,
       isRelative: false,
+      isBuiltIn: false,
       isDynamic: true
     }
   ])