@davidwells/extract-deps 0.1.11 → 0.1.13

package/tests/dep-graph.test.js

@@ -2,7 +2,7 @@
 const { test } = require('uvu')
 const assert = require('uvu/assert')
 const path = require('path')
-const { depGraph, resolveDepPaths } = require('../src/dep-graph.js')
+const { depGraph, resolveDepPaths, clearDepGraphCache } = require('../src/dep-graph.js')
 
 const CJS_FIXTURE_PATH = path.resolve(__dirname, './fixtures/cjs-example/index.js')
 const ESM_FIXTURE_PATH = path.resolve(__dirname, './fixtures/esm-fixture/index.js')
@@ -654,6 +654,7 @@ test('dynamic import should still build the dep edge', () => {
 
 // TypeScript patterns fixture — exercises all fixed false positive patterns
 const TS_PATTERNS_FIXTURE = path.resolve(__dirname, './fixtures/ts-patterns-fixture/index.ts')
+const TS_REGEX_EXPORT_FIXTURE = path.resolve(__dirname, './fixtures/ts-regex-export-fixture/index.ts')
 
 test('TS patterns: import type, inline type, import * as, $-prefixed names should all pass', () => {
   // This fixture contains:
@@ -700,4 +701,58 @@ test('TS patterns: resolveDepPaths with returnErrors should have zero errors', (
   assert.is(result.errors.length, 0, 'Should have zero verification errors')
 })
 
+test('TS regex exports: verifies named imports from .js specifier resolved to .ts file', () => {
+  assert.not.throws(() => {
+    depGraph(TS_REGEX_EXPORT_FIXTURE, { verifyGraph: true })
+  }, 'Regex literals in the target module should not hide later exports')
+})
+
+test('TS regex exports: should build dependency edge to resolved .ts module', () => {
+  const graph = depGraph(TS_REGEX_EXPORT_FIXTURE, { verifyGraph: true })
+
+  const indexPath = Array.from(graph.keys()).find(key => key.includes('ts-regex-export-fixture/index.ts'))
+  assert.ok(indexPath, 'Should have index.ts in graph')
+
+  const deps = graph.get(indexPath)
+  assert.ok(deps.some(d => d.includes('ts-regex-export-fixture/message-builder.ts')), 'Should depend on message-builder.ts')
+})
+
+test('TS regex exports: resolveDepPaths with returnErrors should have zero errors', () => {
+  const result = resolveDepPaths(TS_REGEX_EXPORT_FIXTURE, { returnErrors: true })
+
+  assert.ok(Array.isArray(result.errors), 'Should have errors array')
+  if (result.errors.length > 0) {
+    console.log('Unexpected errors:', result.errors.map(e => e.message))
+  }
+  assert.is(result.errors.length, 0, 'Should have zero verification errors')
+})
+
+test('memoized walks see edited files and new files after clearDepGraphCache', () => {
+  const fs = require('fs')
+  const os = require('os')
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'dep-graph-memo-')))
+  const entry = path.join(dir, 'index.js')
+  fs.writeFileSync(entry, "const a = require('./a')\nmodule.exports = a")
+  fs.writeFileSync(path.join(dir, 'a.js'), 'module.exports = 1')
+  try {
+    assert.equal(resolveDepPaths(entry).files.map(f => path.basename(f)), ['a.js', 'index.js'])
+    // Edit: a new import. mtime moves, so the file is parsed again.
+    fs.writeFileSync(path.join(dir, 'b.js'), 'module.exports = 2')
+    fs.writeFileSync(entry, "const a = require('./a')\nconst b = require('./b')\nmodule.exports = a + b")
+    const later = new Date(Date.now() + 5000)
+    fs.utimesSync(entry, later, later)
+    assert.equal(resolveDepPaths(entry).files.map(f => path.basename(f)).sort(), ['a.js', 'b.js', 'index.js'])
+    // A missing import stays missing until the cache is cleared.
+    fs.writeFileSync(entry, "const c = require('./c')\nmodule.exports = c")
+    const later2 = new Date(Date.now() + 10000)
+    fs.utimesSync(entry, later2, later2)
+    assert.is(resolveDepPaths(entry, { returnErrors: true }).errors.length, 1)
+    fs.writeFileSync(path.join(dir, 'c.js'), 'module.exports = 3')
+    clearDepGraphCache()
+    assert.is(resolveDepPaths(entry, { returnErrors: true }).errors.length, 0)
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true })
+  }
+})
+
 test.run()

package/tests/fixtures/ts-regex-export-fixture/index.ts

@@ -0,0 +1,8 @@
+import { buildRawMessage, DeliveryStatus, sanitizeEmailHtml } from './message-builder.js'
+
+const clean = sanitizeEmailHtml('<a href="https://example.com">ok</a>')
+
+export const result = buildRawMessage({
+  htmlBody: clean,
+  status: DeliveryStatus.Ready,
+})

package/tests/fixtures/ts-regex-export-fixture/message-builder.ts

@@ -0,0 +1,23 @@
+export enum DeliveryStatus {
+  Ready = 'ready',
+}
+
+function escapeHtmlAttribute(value: string): string {
+  return value.replace(/`/g, '`')
+}
+
+export function sanitizeEmailHtml(html: string): string {
+  return html.replace(/<!--[\s\S]*?-->/g, '').replace(/<(script|style)\b[\s\S]*?<\/\1>/gi, '').replace(
+    /<\/?([a-z][a-z0-9]*)\b([^>]*)>/gi,
+    (tag, rawName: string, rawAttributes: string) => {
+      const hrefMatch = rawAttributes.match(/\shref\s*=\s*("([^"]*)"|'([^']*)'|([^\s>]+))/i)
+      const href = hrefMatch?.[2] ?? hrefMatch?.[3] ?? hrefMatch?.[4] ?? ''
+      if (!/^https?:\/\//i.test(href)) return '<a>'
+      return `<a href="${escapeHtmlAttribute(href)}">`
+    },
+  )
+}
+
+export function buildRawMessage({ htmlBody, status }: { htmlBody: string; status: DeliveryStatus }): string {
+  return `${status}:${htmlBody}`
+}

package/tests/get-exports.test.js

@@ -78,11 +78,13 @@ export var thirdVariable = 'value'
 export function myFunction() {}
 export class MyClass {}
 export async function asyncFunction() {}
+export enum MyEnum {}
+export const enum MyConstEnum {}
   `
   
   const foundExports = getNamedExports(code)
 
-  assert.ok(foundExports.length === 6, 'Should find 6 named exports')
+  assert.ok(foundExports.length === 8, 'Should find 8 named exports')
 
   const exportNames = foundExports.map(exp => exp.exportName)
   assert.ok(exportNames.includes('myVariable'), 'Should find const export')
@@ -91,6 +93,8 @@ export async function asyncFunction() {}
   assert.ok(exportNames.includes('myFunction'), 'Should find function export')
   assert.ok(exportNames.includes('MyClass'), 'Should find class export')
   assert.ok(exportNames.includes('asyncFunction'), 'Should find async function export')
+  assert.ok(exportNames.includes('MyEnum'), 'Should find enum export')
+  assert.ok(exportNames.includes('MyConstEnum'), 'Should find const enum export')
 
   foundExports.forEach(exp => {
     assert.equal(exp.exportType, 'named')
@@ -615,4 +619,25 @@ const dq = "export { foo } from 'fake'"
   assert.equal(names, ['real'], 'Only the real export should be detected')
 })
 
-test.run() 
+test('finds exports after regex literals that contain //', () => {
+  const code = `
+export function sanitizeEmailHtml(html: string): string {
+  return html.replace(/<!--[\\s\\S]*?-->/g, '')
+    .replace(/<(script|style)\\b[\\s\\S]*?<\\/\\1>/gi, '')
+    .replace(/<\\/?([a-z][a-z0-9]*)\\b([^>]*)>/gi, (tag, rawName: string) => {
+      if (!/^https?:\\/\\//i.test(tag)) return '<a>'
+      return '<a>'
+    })
+}
+
+export function buildRawMessage(input: { htmlBody: string }): string {
+  return input.htmlBody
+}
+  `
+
+  const found = getExports(code)
+  const names = found.map(e => e.exportName).sort()
+  assert.equal(names, ['buildRawMessage', 'sanitizeEmailHtml'])
+})
+
+test.run() 

package/tests/index.test.js

@@ -199,4 +199,15 @@ test('should handle packages with no dependencies gracefully', async () => {
   }
 })
 
+test('extractDeps - repeat calls on same code return equal, independent results', () => {
+  const code = `const path = require('path')\nimport foo from './foo'\nexport const bar = 1\n`
+  const first = extractDeps(code)
+  first.requires[0].from = 'mutated'
+  first.imports.length = 0
+  const second = extractDeps(code)
+  assert.is(second.requires[0].from, 'path')
+  assert.is(second.imports.length, 1)
+  assert.equal(extractDeps(code), second)
+})
+
 test.run()

package/tests/parser-edge-cases.test.js

@@ -0,0 +1,101 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { detectSyntax, extractDeps } = require('../src')
+
+function exportNames(code) {
+  return extractDeps(code).exports.map(exp => exp.exportName).filter(Boolean).sort()
+}
+
+function cjsExportNames(code) {
+  return extractDeps(code).moduleExports.map(exp => exp.exportName).filter(Boolean).sort()
+}
+
+test('regex literals with // do not hide later ESM exports', () => {
+  const code = `
+const protocol = /^https?:\\/\\//i
+const slashy = /\\/\\*not-a-comment\\*\\//
+export function sanitizeEmailHtml(html: string): string {
+  return html
+}
+export function buildRawMessage(): string {
+  return ''
+}
+  `
+
+  assert.equal(exportNames(code), ['buildRawMessage', 'sanitizeEmailHtml'])
+})
+
+test('regex literals with // do not hide later imports, requires, or CJS exports', () => {
+  const code = `
+const protocol = /^https?:\\/\\//i
+const commentText = /\\/\\/ not really a comment/
+import real from './real.js'
+const actual = require('./actual.js')
+module.exports.afterRegex = { real, actual }
+  `
+
+  const deps = extractDeps(code)
+  assert.equal(deps.imports.map(dep => dep.from), ['./real.js'])
+  assert.equal(deps.requires.map(dep => dep.from), ['./actual.js'])
+  assert.equal(cjsExportNames(code), ['afterRegex'])
+})
+
+test('regex literals with backticks do not start fake template literals', () => {
+  const code = `
+function escapeHtmlAttribute(value: string): string {
+  return value.replace(/\\\`/g, '`')
+}
+
+export const afterBacktickRegex = true
+  `
+
+  assert.equal(exportNames(code), ['afterBacktickRegex'])
+})
+
+test('regex literals containing parser keywords are not imports/requires/exports', () => {
+  const code = `
+const importPattern = /import\\s+fake\\s+from/
+const exportPattern = /export\\s+const\\s+fake/
+const requirePattern = /require\\(['"]fake['"]\\)/
+const cjsPattern = /module\\.exports\\.fake/
+
+import real from './real.js'
+const actual = require('./actual.js')
+export const realExport = true
+module.exports.cjsExport = actual
+  `
+
+  const deps = extractDeps(code)
+  assert.equal(deps.imports.map(dep => dep.from), ['./real.js'])
+  assert.equal(deps.requires.map(dep => dep.from), ['./actual.js'])
+  assert.equal(exportNames(code), ['realExport'])
+  assert.equal(cjsExportNames(code), ['cjsExport'])
+})
+
+test('detectSyntax ignores parser keywords inside regex literals', () => {
+  const result = detectSyntax(`
+const importPattern = /import\\s+fake\\s+from/
+const exportPattern = /export\\s+const\\s+fake/
+const requirePattern = /require\\(['"]fake['"]\\)/
+const cjsPattern = /module\\.exports\\.fake/
+  `)
+
+  assert.equal(result, { hasESM: false, hasCJS: false, isMixed: false })
+})
+
+test('TypeScript enum exports are named exports', () => {
+  const code = `
+export enum DeliveryStatus {
+  Pending = 'pending',
+  Sent = 'sent',
+}
+
+export const enum InlineStatus {
+  Ready = 'ready',
+}
+  `
+
+  assert.equal(exportNames(code), ['DeliveryStatus', 'InlineStatus'])
+})
+
+test.run()

package/tests/utils.test.js

@@ -142,4 +142,12 @@ test('stripStringContents — neutralizes // inside code-bearing strings so stri
   assert.ok(after.includes('"\nconst y = 1'), 'closing quote and following code survive')
 })
 
+test('stripComments — preserves regex literals that contain //', () => {
+  const input = `if (!/^https?:\\/\\//i.test(href)) return '<a>'\nexport function afterRegex() {}`
+  const output = stripComments(input)
+
+  assert.ok(output.includes('/^https?:\\/\\//i.test(href)'), 'regex literal survives')
+  assert.ok(output.includes('export function afterRegex() {}'), 'following export survives')
+})
+
 test.run()

package/types/dep-graph.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Build dependency graph for a file and its dependencies
+ * @param {string} filePath - File to analyze
+ * @param {object} options - Options
+ * @param {boolean} [options.buildGraph] - If true, build and return dependency graph. Default: true
+ * @param {boolean} [options.verifyGraph] - If true, verify imports/exports. Default: true
+ * @param {boolean} [options.verifyNodeModules] - If true, verify node_modules packages can be resolved. Default: false
+ * @param {boolean} [options.includeNodeModules] - If true, include node_modules package names in the graph. Default: false
+ * @param {boolean} [options.throwOnFirstError] - If true, throw immediately on first error. Default: false
+ * @param {boolean} [options.returnErrors] - If true, return { graph, errors } instead of throwing. Default: false
+ * @returns {Map<string, string[]>|{graph: Map, errors: Error[]}|undefined} - Dependency graph, or { graph, errors } if returnErrors is true. Returns undefined if buildGraph is false.
+ */
+export function depGraph(filePath: string, options?: {
+    buildGraph?: boolean;
+    verifyGraph?: boolean;
+    verifyNodeModules?: boolean;
+    includeNodeModules?: boolean;
+    throwOnFirstError?: boolean;
+    returnErrors?: boolean;
+}): Map<string, string[]> | {
+    graph: Map<any, any>;
+    errors: Error[];
+} | undefined;
+/**
+ * Get all dependency file paths in build order (dependencies first), deduplicated
+ * @param {string} filePath - Entry file path
+ * @param {object} options - Options to pass to depGraph
+ * @param {boolean} [options.verifyGraph] - If true, verify imports/exports. Default: true
+ * @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[], 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;
+    verifyNodeModules?: boolean;
+    throwOnFirstError?: boolean;
+    returnErrors?: boolean;
+}): {
+    files: string[];
+    nodeModules: string[];
+    builtIns: string[];
+    errors?: Error[];
+};
+//# sourceMappingURL=dep-graph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dep-graph.d.ts","sourceRoot":"","sources":["../src/dep-graph.js"],"names":[],"mappings":"AAmUA;;;;;;;;;;;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

@@ -0,0 +1,39 @@
+/**
+ * Options for detecting syntax within a code string.
+ */
+export type DetectSyntaxOptions = {
+    /**
+     * - Indicates whether comments should be stripped from the code before syntax checking.
+     */
+    stripComments?: boolean;
+};
+/**
+ * Options for detecting syntax within a code string.
+ * @typedef {Object} DetectSyntaxOptions
+ * @property {boolean} [stripComments=false] - Indicates whether comments should be stripped from the code before syntax checking.
+ */
+/**
+ * Determines if a given code string contains ECMAScript module syntax.
+ *
+ * @param {string} code - The source code to analyze.
+ * @param {DetectSyntaxOptions} opts - See {@link DetectSyntaxOptions}.
+ * @returns {boolean} `true` if the code contains ESM syntax, otherwise `false`.
+ */
+export function hasESMSyntax(code: string, opts?: DetectSyntaxOptions): boolean;
+/**
+ * Determines if a given string of code contains CommonJS syntax.
+ *
+ * @param {string} code - The source code to analyze.
+ * @param {DetectSyntaxOptions} opts - See {@link DetectSyntaxOptions}.
+ * @returns {boolean} `true` if the code contains CommonJS syntax, `false` otherwise.
+ */
+export function hasCJSSyntax(code: string, opts?: DetectSyntaxOptions): boolean;
+/**
+ * Analyzes the supplied code to determine if it contains ECMAScript module syntax, CommonJS syntax, or both.
+ *
+ * @param {string} code - The source code to analyze.
+ * @param {DetectSyntaxOptions} opts - See {@link DetectSyntaxOptions}.
+ * @returns {Object} An object indicating the presence of ESM syntax (`hasESM`), CJS syntax (`hasCJS`) and whether both syntaxes are present (`isMixed`).
+ */
+export function detectSyntax(code: string, opts?: DetectSyntaxOptions): any;
+//# sourceMappingURL=detect-syntax.d.ts.map

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

@@ -0,0 +1 @@
+{"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-cjs-exports.d.ts

@@ -0,0 +1,45 @@
+export function getCjsExports(code: any): any[];
+export function getModuleExportsAssignment(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportDefinitionName: any;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getModuleExportsProperty(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getExportsProperty(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getObjectAssignExports(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getDefinePropertyExports(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportValue: string;
+    exportDefinitionName: string;
+    index: number;
+    isExport: boolean;
+    isDefineProperty: boolean;
+}[];
+//# sourceMappingURL=get-cjs-exports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-cjs-exports.d.ts","sourceRoot":"","sources":["../src/get-cjs-exports.js"],"names":[],"mappings":"AAoCA,gDAgDC;AA+BD;;;;;;;;IAqGC;AAED;;;;;;;IAqBC;AAED;;;;;;;IAqBC;AAED;;;;;;;IAiDC;AAED;;;;;;;;;IAwEC"}

package/types/get-exports.d.ts

@@ -0,0 +1,54 @@
+export function getExports(code?: string, options?: {}): any[];
+export function getDefaultExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportDefinitionName: any;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getNamedExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getNamedDeclarationExports(targetText?: string): any[];
+export function getAllExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    from: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getNamespaceExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    namespace: string;
+    from: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getTypeExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getAssertionExports(targetText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    definitions: any;
+    keys: any;
+    from: string;
+    assertion: string;
+    assertionType: string;
+    index: number;
+    isExport: boolean;
+    isAssertion: boolean;
+}[];
+//# sourceMappingURL=get-exports.d.ts.map

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

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

package/types/get-imports.d.ts

@@ -0,0 +1,59 @@
+export function getImports(code?: string, options?: {}): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isImport: boolean;
+    isRelative: boolean;
+    isBuiltIn: boolean;
+}[];
+export function getStaticImports(targetText?: string): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isImport: boolean;
+    isRelative: boolean;
+    isBuiltIn: boolean;
+}[];
+export function getTypeImports(targetText?: string): {
+    importStatement: string;
+    importPath: string;
+    importName: string;
+    index: number;
+    isImport: boolean;
+    isTypeImport: boolean;
+    isRelative: boolean;
+    isBuiltIn: boolean;
+}[];
+export function getDynamicImports(targetText?: string): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isImport: boolean;
+    isRelative: boolean;
+    isBuiltIn: boolean;
+    isDynamic: boolean;
+}[];
+export function getAssertionImports(targetText?: string): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    assertion: string;
+    assertionType: string;
+    index: number;
+    isImport: boolean;
+    isRelative: boolean;
+    isBuiltIn: boolean;
+    isAssertion: boolean;
+}[];
+//# sourceMappingURL=get-imports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-imports.d.ts","sourceRoot":"","sources":["../src/get-imports.js"],"names":[],"mappings":"AAsCA;;;;;;;;;;IAcC;AAGD;;;;;;;;;;IAsCC;AAED;;;;;;;;;IAkBC;AAED;;;;;;;;;;;IAuBC;AAED;;;;;;;;;;;;;IA0BC"}

package/types/get-requires.d.ts

@@ -0,0 +1,37 @@
+export function getRequires(code: any): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isRequire: boolean;
+    isRelative: boolean;
+    isBuiltIn: boolean;
+    isDynamic: boolean;
+}[];
+export function getStaticRequires(targetText?: string): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isRequire: boolean;
+    isRelative: boolean;
+    isBuiltIn: boolean;
+    isDynamic: boolean;
+}[];
+export function getDynamicRequires(code: any): {
+    line: string;
+    varType: string;
+    varName: string;
+    definitions: any;
+    from: string;
+    index: number;
+    isRequire: boolean;
+    isRelative: boolean;
+    isBuiltIn: boolean;
+    isDynamic: boolean;
+}[];
+//# sourceMappingURL=get-requires.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-requires.d.ts","sourceRoot":"","sources":["../src/get-requires.js"],"names":[],"mappings":"AA0GA;;;;;;;;;;;IAUC;AArCD;;;;;;;;;;;IAyBC;AA/FD;;;;;;;;;;;IA6BC"}

package/types/index.d.ts

@@ -0,0 +1,25 @@
+export function extractDeps(code: any, filePath?: string): any;
+/**
+ * Cached extraction. Returns a shared object — callers must treat it as
+ * read-only. Use `extractDeps` for a private copy.
+ * @param {string} code
+ */
+export function extractDepsShared(code: string): any;
+import { hasESMSyntax } from "./detect-syntax";
+import { hasCJSSyntax } from "./detect-syntax";
+import { detectSyntax } from "./detect-syntax";
+import { getRequires } from "./get-requires";
+import { getDynamicRequires } from "./get-requires";
+import { getStaticRequires } from "./get-requires";
+import { getImports } from "./get-imports";
+import { getStaticImports } from "./get-imports";
+import { getDynamicImports } from "./get-imports";
+import { getExports } from "./get-exports";
+import { getDefaultExports } from "./get-exports";
+import { getNamedExports } from "./get-exports";
+import { getNamedDeclarationExports } from "./get-exports";
+import { getAllExports } from "./get-exports";
+import { getNamespaceExports } from "./get-exports";
+import { getTypeExports } from "./get-exports";
+export { hasESMSyntax, hasCJSSyntax, detectSyntax, getRequires, getDynamicRequires, getStaticRequires, getImports, getStaticImports, getDynamicImports, getExports, getDefaultExports, getNamedExports, getNamedDeclarationExports, getAllExports, getNamespaceExports, getTypeExports };
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AA0CA,+DAEC;AAnBD;;;;GAIG;AACH,wCAFW,MAAM,OAYhB"}