@davidwells/extract-deps 0.1.2 → 0.1.4

package/package.json

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

package/src/dep-graph.js

@@ -106,23 +106,34 @@ function verifyImportedValuesExist(dep, targetDeps, targetPath, sourcePath, erro
       }
     }
   }
-  // For non-destructured imports, just verify there's a default export
+  // For non-destructured imports, verify there's a default export
+  // Only applies to ESM imports - CJS require() gets whatever module.exports is
   else {
-    const hasDefaultExport =
-      (targetDeps.moduleExports && targetDeps.moduleExports.length > 0) ||
-      (targetDeps.exports && targetDeps.exports.some(exp => exp.exportType === 'default'))
-
-    if (!hasDefaultExport) {
-      const error = new Error(
-        `Import not found: "${targetPath}" does not have a default export.\n` +
-        `Import statement: ${dep.line}\n` +
-        `Importing from: ${sourcePath}`
-      )
-      if (throwOnFirstError) {
-        throw error
+    if (dep.isESM) {
+      // ESM import X from 'pkg' requires a default export
+      const hasModuleExports = targetDeps.moduleExports && targetDeps.moduleExports.length > 0
+      const hasESMExports = targetDeps.exports && targetDeps.exports.length > 0
+      const hasDefaultExport =
+        hasModuleExports ||
+        (hasESMExports && targetDeps.exports.some(exp => exp.exportType === 'default'))
+
+      // Only fail if we can detect exports but none are default
+      // If we can't detect any exports (e.g., complex/minified file), assume valid
+      const hasDetectableExports = hasModuleExports || hasESMExports
+
+      if (hasDetectableExports && !hasDefaultExport) {
+        const error = new Error(
+          `Import not found: "${targetPath}" does not have a default export.\n` +
+          `Import statement: ${dep.line}\n` +
+          `Importing from: ${sourcePath}`
+        )
+        if (throwOnFirstError) {
+          throw error
+        }
+        errors.push(error)
       }
-      errors.push(error)
     }
+    // CJS require() can get any module.exports - no default check needed
   }
 }
 
@@ -166,20 +177,20 @@ function buildGraphRecursively(
   // Collect all relative dependencies
   const relativeDeps = []
   if (deps.requires && deps.requires.length > 0) {
-    relativeDeps.push(...deps.requires.filter(req => req.isRelative))
+    relativeDeps.push(...deps.requires.filter(req => req.isRelative).map(req => ({ ...req, isESM: false })))
   }
   if (deps.imports && deps.imports.length > 0) {
-    relativeDeps.push(...deps.imports.filter(imp => imp.isRelative))
+    relativeDeps.push(...deps.imports.filter(imp => imp.isRelative).map(imp => ({ ...imp, isESM: true })))
   }
 
   // Collect all non-relative dependencies (node_modules)
   const nodeModuleDeps = []
   if (verifyNodeModules || includeNodeModules) {
     if (deps.requires && deps.requires.length > 0) {
-      nodeModuleDeps.push(...deps.requires.filter(req => !req.isRelative))
+      nodeModuleDeps.push(...deps.requires.filter(req => !req.isRelative).map(req => ({ ...req, isESM: false })))
     }
     if (deps.imports && deps.imports.length > 0) {
-      nodeModuleDeps.push(...deps.imports.filter(imp => !imp.isRelative))
+      nodeModuleDeps.push(...deps.imports.filter(imp => !imp.isRelative).map(imp => ({ ...imp, isESM: true })))
     }
   }
 
@@ -242,11 +253,11 @@ function buildGraphRecursively(
         continue
       }
 
+      let resolvedPath
       try {
-        // Try to resolve the module using Node's resolution algorithm
+        // resolveImport throws if file doesn't exist
         const resolved = resolveImport(from, parentURL)
-        //console.log('resolved', resolved)
-        // If we get here, the module resolved successfully
+        resolvedPath = fileURLToPath(resolved)
       } catch (error) {
         const err = new Error(
           `"${line}" could not be resolved in ${filePath}\n\n` +
@@ -258,6 +269,14 @@ function buildGraphRecursively(
           throw err
         }
         errors.push(err)
+        continue
+      }
+
+      // Verify import/export styles match (only needed for ESM imports)
+      if (dep.isESM) {
+        const targetContent = fs.readFileSync(resolvedPath, 'utf8')
+        const targetDeps = extractDeps(targetContent)
+        verifyImportedValuesExist(dep, targetDeps, resolvedPath, filePath, errors, throwOnFirstError)
       }
     }
   }

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 { isBuiltIn, 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) {

package/src/utils.js

@@ -1,6 +1,26 @@
 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')
@@ -211,6 +231,7 @@ function extractExportName(exportValue) {
 }
 
 module.exports = {
+  stripComments,
   isBuiltIn,
   isRelativeImport,
   isRelativeImportWithQuotes,

package/tests/dep-graph.test.js

@@ -521,4 +521,33 @@ test('resolveDepPaths with returnErrors: true and no errors', () => {
   assert.is(result.errors.length, 0, 'Should have no errors')
 })
 
+// Node module export verification tests
+const NODE_MODULE_NAMED_FIXTURE = path.resolve(__dirname, './fixtures/node-module-named-export/handler.js')
+const NODE_MODULE_NAMED_CORRECT = path.resolve(__dirname, './fixtures/node-module-named-export/handler-correct.js')
+
+test('verifyNodeModules: true should catch default import when only named exports exist', () => {
+  let errorMessage = ''
+  try {
+    depGraph(NODE_MODULE_NAMED_FIXTURE, { verifyNodeModules: true })
+  } catch (error) {
+    errorMessage = error.message
+  }
+
+  assert.ok(errorMessage.includes('does not have a default export'), 'Should detect missing default export')
+  assert.ok(errorMessage.includes('fake-named-pkg'), 'Should mention the package')
+})
+
+test('verifyNodeModules: true should pass for correct named import', () => {
+  assert.not.throws(() => {
+    depGraph(NODE_MODULE_NAMED_CORRECT, { verifyNodeModules: true })
+  }, 'Should pass for correct named import')
+})
+
+test('verifyNodeModules with returnErrors should collect export mismatch errors', () => {
+  const result = depGraph(NODE_MODULE_NAMED_FIXTURE, { verifyNodeModules: true, returnErrors: true })
+
+  assert.ok(result.errors.length > 0, 'Should have errors')
+  assert.ok(result.errors[0].message.includes('does not have a default export'), 'Should be default export error')
+})
+
 test.run()

package/tests/fixtures/node-module-named-export/handler-correct.js

@@ -0,0 +1,6 @@
+// Correct: uses named import for named export
+import { namedFunc } from 'fake-named-pkg'
+
+export const hello = async () => {
+  return namedFunc()
+}

package/tests/fixtures/node-module-named-export/handler.js

@@ -0,0 +1,6 @@
+// Incorrect: imports as default when package only has named exports
+import pkg from 'fake-named-pkg'
+
+export const hello = async () => {
+  return pkg()
+}

package/tests/fixtures/node-module-named-export/node_modules/fake-named-pkg/index.js

@@ -0,0 +1,4 @@
+// Only has named export, no default export
+export function namedFunc() {
+  return 'Hello from named export'
+}

package/tests/fixtures/node-module-named-export/node_modules/fake-named-pkg/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "fake-named-pkg",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js"
+}

package/tests/fixtures/node-module-named-export/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "node-module-named-export-fixture",
+  "type": "module"
+}

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

@@ -412,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/types/dep-graph.d.ts

@@ -29,7 +29,7 @@ export function depGraph(filePath: string, 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
  */
 export function resolveDepPaths(filePath: string, options?: {
     verifyGraph?: boolean;
@@ -39,6 +39,7 @@ export function resolveDepPaths(filePath: string, options?: {
 }): {
     files: string[];
     nodeModules: string[];
+    builtIns: string[];
     errors?: Error[];
 };
 //# sourceMappingURL=dep-graph.d.ts.map

package/types/dep-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dep-graph.d.ts","sourceRoot":"","sources":["../src/dep-graph.js"],"names":[],"mappings":"AAmQA;;;;;;;;;;;GAWG;AACH,mCAVW,MAAM,YAEd;IAA0B,UAAU,GAA5B,OAAO;IACW,WAAW,GAA7B,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,kBAAkB,GAApC,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,YAAY,GAA9B,OAAO;CACf,GAAU,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAC;IAAC,KAAK,gBAAM;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAC,GAAC,SAAS,CA8BzE;AAGD;;;;;;;;;GASG;AACH,0CARW,MAAM,YAEd;IAA0B,WAAW,GAA7B,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,YAAY,GAA9B,OAAO;CACf,GAAU;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAA;CAAE,CA4ExE"}
+{"version":3,"file":"dep-graph.d.ts","sourceRoot":"","sources":["../src/dep-graph.js"],"names":[],"mappings":"AA4RA;;;;;;;;;;;GAWG;AACH,mCAVW,MAAM,YAEd;IAA0B,UAAU,GAA5B,OAAO;IACW,WAAW,GAA7B,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,kBAAkB,GAApC,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,YAAY,GAA9B,OAAO;CACf,GAAU,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAC;IAAC,KAAK,gBAAM;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAC,GAAC,SAAS,CA8BzE;AAGD;;;;;;;;;GASG;AACH,0CARW,MAAM,YAEd;IAA0B,WAAW,GAA7B,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,YAAY,GAA9B,OAAO;CACf,GAAU;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAA;CAAE,CAkF5F"}

package/types/detect-syntax.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detect-syntax.d.ts","sourceRoot":"","sources":["../src/detect-syntax.js"],"names":[],"mappings":";;;;;;;oBAec,OAAO;;AAHrB;;;;GAIG;AAEH;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,GACjB,OAAO,CAMnB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,GACjB,OAAO,CAMnB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,OAe7B"}
+{"version":3,"file":"detect-syntax.d.ts","sourceRoot":"","sources":["../src/detect-syntax.js"],"names":[],"mappings":";;;;;;;oBAcc,OAAO;;AAHrB;;;;GAIG;AAEH;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,GACjB,OAAO,CAMnB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,GACjB,OAAO,CAMnB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,SACN,mBAAmB,OAe7B"}

package/types/get-exports.d.ts

@@ -1,4 +1,4 @@
-export function getExports(code: any, options?: {}): any[];
+export function getExports(code?: string, options?: {}): any[];
 export function getDefaultExports(targetText?: string): {
     line: string;
     exportType: string;

package/types/get-exports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-exports.d.ts","sourceRoot":"","sources":["../src/get-exports.js"],"names":[],"mappings":"AAiBA,2DA+BC;AAED;;;;;;;;IAqDC;AAED;;;;;;IAeC;AAED,uEAuBC;AAED;;;;;;IAeC;AAED;;;;;;;IAgBC;AAED;;;;;;IAeC;AAED;;;;;;;;;;;;IA0BC"}
+{"version":3,"file":"get-exports.d.ts","sourceRoot":"","sources":["../src/get-exports.js"],"names":[],"mappings":"AAiBA,+DAiCC;AAED;;;;;;;;IAqDC;AAED;;;;;;IAeC;AAED,uEAuBC;AAED;;;;;;IAeC;AAED;;;;;;;IAgBC;AAED;;;;;;IAeC;AAED;;;;;;;;;;;;IA0BC"}

package/types/get-imports.d.ts

@@ -1,4 +1,4 @@
-export function getImports(code: any, options?: {}): {
+export function getImports(code?: string, options?: {}): {
     line: string;
     varType: string;
     varName: string;
@@ -7,6 +7,7 @@ export function getImports(code: any, options?: {}): {
     index: number;
     isImport: boolean;
     isRelative: boolean;
+    isBuiltIn: boolean;
 }[];
 export function getStaticImports(targetText?: string): {
     line: string;
@@ -17,6 +18,7 @@ export function getStaticImports(targetText?: string): {
     index: number;
     isImport: boolean;
     isRelative: boolean;
+    isBuiltIn: boolean;
 }[];
 export function getTypeImports(targetText?: string): {
     importStatement: string;
@@ -26,6 +28,7 @@ export function getTypeImports(targetText?: string): {
     isImport: boolean;
     isTypeImport: boolean;
     isRelative: boolean;
+    isBuiltIn: boolean;
 }[];
 export function getDynamicImports(targetText?: string): {
     line: string;
@@ -36,6 +39,7 @@ export function getDynamicImports(targetText?: string): {
     index: number;
     isImport: boolean;
     isRelative: boolean;
+    isBuiltIn: boolean;
     isDynamic: boolean;
 }[];
 export function getAssertionImports(targetText?: string): {
@@ -49,6 +53,7 @@ export function getAssertionImports(targetText?: string): {
     index: number;
     isImport: boolean;
     isRelative: boolean;
+    isBuiltIn: boolean;
     isAssertion: boolean;
 }[];
 //# sourceMappingURL=get-imports.d.ts.map

package/types/get-imports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-imports.d.ts","sourceRoot":"","sources":["../src/get-imports.js"],"names":[],"mappings":"AAWA;;;;;;;;;IAQC;AAGD;;;;;;;;;IAkBC;AAED;;;;;;;;IAiBC;AAED;;;;;;;;;;IAoBC;AAED;;;;;;;;;;;;IAwBC"}
+{"version":3,"file":"get-imports.d.ts","sourceRoot":"","sources":["../src/get-imports.js"],"names":[],"mappings":"AAWA;;;;;;;;;;IAUC;AAGD;;;;;;;;;;IAmBC;AAED;;;;;;;;;IAkBC;AAED;;;;;;;;;;;IAqBC;AAED;;;;;;;;;;;;;IAyBC"}

package/types/get-requires.d.ts

@@ -7,6 +7,7 @@ export function getRequires(code: any): {
     index: number;
     isRequire: boolean;
     isRelative: boolean;
+    isBuiltIn: boolean;
     isDynamic: boolean;
 }[];
 export function getStaticRequires(targetText?: string): {
@@ -18,6 +19,7 @@ export function getStaticRequires(targetText?: string): {
     index: number;
     isRequire: boolean;
     isRelative: boolean;
+    isBuiltIn: boolean;
     isDynamic: boolean;
 }[];
 export function getDynamicRequires(code: any): {
@@ -29,6 +31,7 @@ export function getDynamicRequires(code: any): {
     index: number;
     isRequire: boolean;
     isRelative: boolean;
+    isBuiltIn: boolean;
     isDynamic: boolean;
 }[];
 //# sourceMappingURL=get-requires.d.ts.map

package/types/get-requires.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-requires.d.ts","sourceRoot":"","sources":["../src/get-requires.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;IAIC;AA5BD;;;;;;;;;;IAsBC;AArDD;;;;;;;;;;IA4BC"}
+{"version":3,"file":"get-requires.d.ts","sourceRoot":"","sources":["../src/get-requires.js"],"names":[],"mappings":"AAgEA;;;;;;;;;;;IAIC;AA7BD;;;;;;;;;;;IAuBC;AAvDD;;;;;;;;;;;IA6BC"}

package/types/index.d.ts

@@ -8,6 +8,7 @@ export function extractDeps(code: any, filePath?: string): {
         index: number;
         isImport: boolean;
         isRelative: boolean;
+        isBuiltIn: boolean;
     }[];
     exports: any[];
     requires: {
@@ -19,6 +20,7 @@ export function extractDeps(code: any, filePath?: string): {
         index: number;
         isRequire: boolean;
         isRelative: boolean;
+        isBuiltIn: boolean;
         isDynamic: boolean;
     }[];
     moduleExports: any[];

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;EAgBC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBC"}

package/types/utils.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Strip comments from code, preserving :// in URLs
+ * @param {string} code
+ * @returns {string}
+ */
+export function stripComments(code: string): string;
+/**
+ * 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}
+ */
+export function isBuiltIn(moduleName: string): boolean;
 export function isRelativeImport(importLocation: any): boolean;
 export function isRelativeImportWithQuotes(importLocation: any): boolean;
 export function getNames(names: any, aliasKey?: string): any;

package/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAEA,+DAEC;AAED,yEAKC;AAgFD,6DA+DC;AAGD,yDAqCC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,oCAHW,MAAM,GACJ,MAAM,CAYlB;AAED;;;;GAIG;AACH,sCAHW,MAAM,GACJ,OAAO,CAUnB;AAED,+DAEC;AAED,yEAKC;AAgFD,6DA+DC;AAGD,yDAqCC"}