@davidwells/extract-deps 0.1.9 → 0.1.12

package/package.json

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

package/src/dep-graph.js

@@ -3,7 +3,7 @@ const path = require('path')
 const fs = require('fs')
 const { pathToFileURL, fileURLToPath } = require('url')
 const { resolve: resolveImport } = require('@dual-bundle/import-meta-resolve')
-const { extractDeps } = require('./index')
+const { extractDepsShared: extractDeps } = require('./index')
 const { isBuiltIn } = require('./utils')
 
 function fsExistsSync(path) {

package/src/get-cjs-exports.js

@@ -1,6 +1,6 @@
 // Extracts CommonJS module.exports and exports patterns from JavaScript code
 
-const { getNames, extractExportName, stripStringContents } = require('./utils')
+const { getNames, extractExportName, stripCommentsAndStrings } = require('./utils')
 
 // Matches: module.exports = ... or exports = module.exports = ...
 // https://regex101.com/r/example/cjs-1
@@ -35,13 +35,11 @@ function stripComments(code) {
 }
 
 function getCjsExports(code) {
-  // Blank string/template literal contents before stripping comments so
-  // `exports.X = ...` lines embedded inside template literals aren't matched
-  // as real exports, and so the comment regex doesn't mis-strip `//` inside
-  // string bodies.
-  code = stripStringContents(code)
-  // Strip comments to prevent false positives from commented code
-  const sanitizedCode = stripComments(code)
+  // Single tokenizer-based pass that blanks comments and code-bearing
+  // strings/templates together. Length is preserved so the position-based
+  // logic below (which slices into the original `code` for full export
+  // values) keeps working off the same indices.
+  const sanitizedCode = stripCommentsAndStrings(code)
 
   const assignmentExports = getModuleExportsAssignment(code, sanitizedCode)
   const modulePropertyExports = getModuleExportsProperty(code, sanitizedCode)

package/src/get-exports.js

@@ -3,7 +3,7 @@ const { getNames, extractExportName, stripComments, stripStringContents } = requ
 // 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
 // https://regex101.com/r/example/2
-const EXPORT_NAMED_REGEX = /export\s+(?:const|let|var|function|class|async\s+function)\s+([\w$]+)/gm
+const EXPORT_NAMED_REGEX = /export\s+(?:const\s+enum|enum|const|let|var|function|class|async\s+function)\s+([\w$]+)/gm
 // https://regex101.com/r/example/3
 const EXPORT_NAMED_DECLARATION_REGEX = /export\s*{([^}]+)}/gm
 // https://regex101.com/r/example/4
@@ -16,12 +16,12 @@ const EXPORT_TYPE_REGEX = /export\s+(?:type|interface)\s+([\w$]+)/gm
 const EXPORT_ASSERTION_REGEX = /export\s+(?:["'\s]*([\w*{}\n\r\t, ]+)from\s*)?["'\s](.*[@\w_-]+)["'\s]+(assert|with)\s*\{([^}]+)\};?$/gm
 
 function getExports(code = '', options = {}) {
-  // Blank string/template contents first so embedded `export` keywords inside
-  // string literals don't get parsed as real exports, and so `stripComments`
-  // doesn't mis-strip `//` or `/* */` that appear inside strings.
-  code = stripStringContents(code)
-  // Strip comments to avoid false positives
+  // Comments first, then strings — order matters. Running stripStringContents
+  // alone would mis-pair an apostrophe inside a JSDoc comment (`Netlify's …`)
+  // with a later quote and shift subsequent backtick pairing, which could
+  // swallow real `export` declarations a few lines later.
   code = stripComments(code)
+  code = stripStringContents(code)
   const defaultExports = getDefaultExports(code)
   const namedExports = getNamedExports(code)
   const namedDeclarationExports = getNamedDeclarationExports(code)
@@ -303,4 +303,4 @@ module.exports = {
   getNamespaceExports,
   getTypeExports,
   getAssertionExports
-} 
+} 

package/src/get-imports.js

@@ -37,13 +37,12 @@ const DYNAMIC_IMPORT_REGEX = /(?:(const|var|let)\s+([\w*{}\n\r\t,:= $]+)\s*=\s*)
 const ASSERTION_IMPORT_REGEX = /(?:^|\n)\s*import\s+(?:["'\s]*([\w*{}\n\r\t, $]+)from\s*)?["'\s]+([^"'`\n;\s]+)\s*["']\s+(assert|with)\s*\{([^}]+)\}/gm
 
 function getImports(code = '', options = {}) {
-  // Blank string/template contents first so the comment stripper doesn't
-  // mis-strip `//` or `/* */` sequences inside literals, and so the regex
-  // doesn't pick up `import`/`export` keywords that appear inside strings
-  // (e.g. fenced code in JSDoc-style template literals).
-  code = stripStringContents(code)
-  // Strip comments to avoid false positives
+  // Strip comments FIRST so apostrophes/backticks inside JSDoc text get
+  // removed before `stripStringContents` looks for string literals.
+  // (Running the two in the opposite order let comment chars masquerade as
+  // string openers and swallow real `import`/`export` lines further down.)
   code = stripComments(code)
+  code = stripStringContents(code)
   const staticImports = getStaticImports(code)
   const dynamicImports = getDynamicImports(code)
   if (options.includeAssertionImports) {

package/src/get-requires.js

@@ -38,11 +38,51 @@ function getDynamicRequires(code) {
   return results
 }
 
+// Sticky copy of REQUIRE_REGEX: matches only at an exact start position.
+const REQUIRE_REGEX_AT = new RegExp(REQUIRE_REGEX.source, 'my')
+// Every char REQUIRE_REGEX can consume before its literal `require(`.
+const REQUIRE_PREFIX_CHAR = /[\w\s*{}:=,$]/
+
+/**
+ * Same result as `REQUIRE_REGEX.exec` with `lastIndex = from`, but only
+ * attempts start positions that can reach a `require(` literal. Scanning
+ * every position is quadratic on long lines because of the leading
+ * `(?!.*await\s+import)` lookahead.
+ *
+ * A match starting at `s` must contain `require(` at some `p >= s` with
+ * every char in [s, p) matching REQUIRE_PREFIX_CHAR. `(` is not in that set,
+ * so the match uses the first `require(` at or after `s`. For each
+ * `require(` at `p`, the only viable starts are therefore [q, p], where q
+ * walks back from p over prefix chars. Trying those in ascending order finds
+ * the same leftmost match.
+ * @param {string} text
+ * @param {number} from
+ */
+function execRequireFrom(text, from) {
+  let searchFrom = from
+  let tried = from
+  while (true) {
+    const requireIndex = text.indexOf('require(', searchFrom)
+    if (requireIndex === -1) return null
+    let start = requireIndex
+    while (start > tried && REQUIRE_PREFIX_CHAR.test(text[start - 1])) start--
+    for (; start <= requireIndex; start++) {
+      REQUIRE_REGEX_AT.lastIndex = start
+      const match = REQUIRE_REGEX_AT.exec(text)
+      if (match) return match
+    }
+    tried = requireIndex + 1
+    searchFrom = requireIndex + 1
+  }
+}
+
 // https://regex101.com/r/sR1TIP/1
 function getStaticRequires(targetText = '') {
   let requireStatements = []
   var result;
-  while((result = REQUIRE_REGEX.exec(targetText)) !== null) {
+  let searchStart = 0
+  while((result = execRequireFrom(targetText, searchStart)) !== null) {
+    searchStart = result.index + result[0].length
     const [ line, varType, names, from ] = result
     // console.log('getStaticRequires result', result)
     const importLocation = from
@@ -65,11 +105,12 @@ function getStaticRequires(targetText = '') {
 }
 
 function getRequires(code) {
-  // Blank string/template contents first so `require()` calls embedded in
-  // string literals (e.g. fenced code in template strings) aren't matched as
-  // real requires. Then strip comments so `// require('./fake')` is ignored.
-  code = stripStringContents(code)
+  // Strip comments first, then strings — order matters. `stripComments`
+  // alone would mis-eat `//` inside strings; running it first instead means
+  // comment chars (incl. apostrophes/backticks inside JSDoc) disappear
+  // before `stripStringContents` looks for real string literals.
   code = stripComments(code)
+  code = stripStringContents(code)
   const staticRequires = getStaticRequires(code)
   const dynamicRequires = getDynamicRequires(code)
   return staticRequires.concat(dynamicRequires).sort((a, b) => a.index - b.index)

package/src/index.js

@@ -16,7 +16,35 @@ const {
 // https://github.com/ganeshkbhat/get-imports/blob/main/index.js
 // Alt get imports https://github.com/beenotung/fix-esm-import-path/blob/master/fix-esm-import-path.js#L186
 
+// Parse results keyed by source text. Extraction is a pure function of the
+// code, and dep-graph walks re-visit the same shared modules once per entry
+// point, so repeat parses dominate runtime without this. Bounded FIFO so a
+// long-lived process scanning many files doesn't grow without limit.
+const PARSE_CACHE_MAX = 2000
+const parseCache = new Map()
+
+/**
+ * Cached extraction. Returns a shared object — callers must treat it as
+ * read-only. Use `extractDeps` for a private copy.
+ * @param {string} code
+ */
+function extractDepsShared(code) {
+  let result = parseCache.get(code)
+  if (result === undefined) {
+    result = parseDeps(code)
+    if (parseCache.size >= PARSE_CACHE_MAX) {
+      parseCache.delete(parseCache.keys().next().value)
+    }
+    parseCache.set(code, result)
+  }
+  return result
+}
+
 function extractDeps(code, filePath = '') {
+  return structuredClone(extractDepsShared(code))
+}
+
+function parseDeps(code) {
   const imports = getImports(code)
   //console.log('imports', imports)
   const requires = getRequires(code)
@@ -94,6 +122,7 @@ const { execSync, spawnSync } = require('child_process')
 
 module.exports = {
   extractDeps,
+  extractDepsShared,
   /* syntax detection */
   hasESMSyntax,
   hasCJSSyntax,

package/src/utils.js

@@ -1,22 +1,6 @@
 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__'
-
-// Single-quoted and double-quoted strings can't contain unescaped newlines
-// (per JS spec — they'd need `\n` escapes or `\<NL>` line continuations). The
-// `[^"\\\n]` / `[^'\\\n]` char classes enforce that, so an unbalanced quote
-// followed by a newline doesn't sweep up the next several lines as "string".
-// Template literals (`` `...` ``) DO span newlines, so their inner class only
-// excludes backtick and backslash. Escape sequences (`\.`) are allowed in all
-// three so escaped quotes don't prematurely end the match.
-// Note: this treats `${...}` interpolations as part of the string body — code
-// inside `${...}` (rare, but possible: `${import('./x.js')}`) gets blanked too.
-// Acceptable for the change-detection use case; a full tokenizer would be
-// needed to preserve interpolations.
-const STRING_LITERAL_RE = /"(?:[^"\\\n]|\\[\s\S])*"|'(?:[^'\\\n]|\\[\s\S])*'|`(?:[^`\\]|\\[\s\S])*`/g
-
 // Strings whose bodies contain these tokens are treated as embedded code
 // samples (template strings, generator helpers, fenced docs) and get blanked.
 // Plain module specifiers like `'lodash'` or `'./foo.js'` don't contain any
@@ -38,8 +22,9 @@ const EMBEDDED_CODE_RE = /\b(?:import|export|require|module\.exports)\b/
  * Without this pass, regex-based extractors falsely match `import`, `export`,
  * and `require` keywords that appear inside code samples embedded in strings.
  *
- * Run this BEFORE `stripComments` — the existing comment regex would otherwise
- * mis-strip `//` and `/* *\/` sequences that occur inside strings.
+ * Run after `stripComments` in the import/require/export extractors. The
+ * comment scanner already skips strings and regex literals, so this pass can
+ * focus on embedded-code strings without risking `//` in URLs or regexes.
  *
  * Caveat: `${...}` interpolations inside template literals are treated as
  * part of the body, so a runtime `${import('./x.js')}` inside a template
@@ -50,34 +35,240 @@ const EMBEDDED_CODE_RE = /\b(?:import|export|require|module\.exports)\b/
  * @returns {string}
  */
 function stripStringContents(code) {
-  return code.replace(STRING_LITERAL_RE, (match) => {
+  let output = ''
+  let i = 0
+
+  while (i < code.length) {
+    const char = code[i]
+
+    if (char === '/' && isRegexLiteralStart(code, i)) {
+      const end = readRegexLiteral(code, i)
+      output += code.slice(i, end)
+      i = end
+      continue
+    }
+
+    if (char !== '"' && char !== "'" && char !== '`') {
+      output += char
+      i++
+      continue
+    }
+
+    const end = readQuoted(code, i, char)
+    const match = code.slice(i, end)
+    if (match.length < 2 || match[match.length - 1] !== char) {
+      output += char
+      i++
+      continue
+    }
+
     const body = match.slice(1, -1)
     if (!EMBEDDED_CODE_RE.test(body)) {
       // Plain string — leave it alone so module specifiers stay extractable.
-      return match
+      output += match
+      i = end
+      continue
     }
     const opener = match[0]
     const closer = match[match.length - 1]
     const middle = body.replace(/[^\n]/g, ' ')
-    return opener + middle + closer
-  })
+    output += opener + middle + closer
+    i = end
+  }
+
+  return output
 }
 
 /**
- * Strip comments from code, preserving :// in URLs
+ * Blank comment bodies and code-bearing string/template bodies together.
+ * Solves two bugs that occurred when the string-strip and comment-strip ran
+ * as naive regex passes:
+ *
+ *   - Apostrophes inside JSDoc comments (e.g. `* Netlify's \`...`) were
+ *     mis-paired with later quotes, which shifted subsequent backtick
+ *     pairing and could swallow real `export` declarations a few lines
+ *     later in the same file.
+ *   - `//` and `/* *\/` sequences inside string bodies were mis-stripped
+ *     as comments.
+ *   - `//` inside regex literals such as `/^https?:\/\//i` was mis-stripped
+ *     as a line comment.
+ *
+ * Length is preserved (each consumed char replaced by a space or newline
+ * kept verbatim) so downstream character indices stay valid.
+ *
+ * Strings whose bodies don't reference `import` / `export` / `require` /
+ * `module.exports` pass through unchanged, so module specifiers like
+ * `'lodash'` or `'./foo.js'` stay readable by the downstream regexes.
+ *
+ * Caveat: `${...}` interpolations inside template literals are part of the
+ * body, so `${import('./x.js')}` inside a template gets blanked. Rare in
+ * practice; a full parser would be needed otherwise.
+ *
  * @param {string} code
  * @returns {string}
  */
-function stripComments(code) {
-  const hasProtocol = code.indexOf('://') > -1
-  if (hasProtocol) {
-    code = code.replace(/:\/\//g, PROTOCOL_PLACEHOLDER)
+function stripCommentsAndStrings(code) {
+  return stripStringContents(stripCommentsImpl(code, { preserveLength: true }))
+}
+
+const REGEX_PREFIX_KEYWORDS = new Set([
+  'case',
+  'delete',
+  'do',
+  'else',
+  'in',
+  'instanceof',
+  'of',
+  'return',
+  'throw',
+  'typeof',
+  'void',
+  'yield',
+  'await',
+])
+
+function isRegexLiteralStart(code, slashIndex) {
+  let i = slashIndex - 1
+  while (i >= 0 && /\s/.test(code[i])) i--
+  if (i < 0) return true
+
+  const previousChar = code[i]
+  if ('([{=,:;!&|?+-*~^<>'.includes(previousChar)) return true
+
+  // Same result as `code.slice(0, i + 1).match(/([A-Za-z_$][\w$]*)$/)[1]`
+  // without copying and re-scanning the whole prefix on every `/` (quadratic
+  // on large files): the leftmost match starts at the first non-digit of the
+  // trailing run of [\w$] chars.
+  let start = i
+  while (start >= 0 && isIdentifierChar(code.charCodeAt(start))) start--
+  start++
+  while (start <= i && isDigit(code.charCodeAt(start))) start++
+  if (start > i) return false
+  return REGEX_PREFIX_KEYWORDS.has(code.slice(start, i + 1))
+}
+
+function isDigit(charCode) {
+  return charCode >= 48 && charCode <= 57
+}
+
+// [\w$] — ASCII letters, digits, underscore, dollar
+function isIdentifierChar(charCode) {
+  return (
+    (charCode >= 97 && charCode <= 122) ||
+    (charCode >= 65 && charCode <= 90) ||
+    isDigit(charCode) ||
+    charCode === 95 ||
+    charCode === 36
+  )
+}
+
+function readQuoted(code, start, quote) {
+  let i = start + 1
+  while (i < code.length) {
+    if (code[i] === '\\') {
+      i += 2
+      continue
+    }
+    if (code[i] === quote) return i + 1
+    if (quote !== '`' && (code[i] === '\n' || code[i] === '\r')) return i
+    i++
   }
-  code = code.replace(COMMENT_RE, '')
-  if (hasProtocol) {
-    code = code.replace(/__PROTO_SLASH__/g, '://')
+  return i
+}
+
+function readRegexLiteral(code, start) {
+  let i = start + 1
+  let inCharacterClass = false
+
+  while (i < code.length) {
+    const char = code[i]
+    if (char === '\\') {
+      i += 2
+      continue
+    }
+    if (char === '[') {
+      inCharacterClass = true
+      i++
+      continue
+    }
+    if (char === ']') {
+      inCharacterClass = false
+      i++
+      continue
+    }
+    if (char === '/' && !inCharacterClass) {
+      i++
+      while (i < code.length && /[a-z]/i.test(code[i])) i++
+      return i
+    }
+    if (char === '\n' || char === '\r') return i
+    i++
+  }
+
+  return i
+}
+
+function appendSkippedComment(output, commentText, preserveLength) {
+  if (!preserveLength) {
+    return output + commentText.replace(/[^\n\r]/g, '')
+  }
+  return output + commentText.replace(/[^\n\r]/g, ' ')
+}
+
+function stripCommentsImpl(code, { preserveLength = false } = {}) {
+  let output = ''
+  let i = 0
+
+  while (i < code.length) {
+    const char = code[i]
+    const next = code[i + 1]
+
+    if (char === '"' || char === "'" || char === '`') {
+      const end = readQuoted(code, i, char)
+      output += code.slice(i, end)
+      i = end
+      continue
+    }
+
+    if (char === '/' && next === '/') {
+      let end = i + 2
+      while (end < code.length && code[end] !== '\n' && code[end] !== '\r') end++
+      output = appendSkippedComment(output, code.slice(i, end), preserveLength)
+      i = end
+      continue
+    }
+
+    if (char === '/' && next === '*') {
+      let end = code.indexOf('*/', i + 2)
+      end = end === -1 ? code.length : end + 2
+      output = appendSkippedComment(output, code.slice(i, end), preserveLength)
+      i = end
+      continue
+    }
+
+    if (char === '/' && isRegexLiteralStart(code, i)) {
+      const end = readRegexLiteral(code, i)
+      output += code.slice(i, end)
+      i = end
+      continue
+    }
+
+    output += char
+    i++
   }
-  return code
+
+  return output
+}
+
+/**
+ * Strip comments from code while skipping strings, templates, and regex
+ * literals. Regex literals can legally contain `//`, for example `/https?:\/\//`,
+ * and must not be treated as line comments.
+ * @param {string} code
+ * @returns {string}
+ */
+function stripComments(code) {
+  return stripCommentsImpl(code)
 }
 
 /**
@@ -292,9 +483,10 @@ function extractExportName(exportValue) {
 module.exports = {
   stripComments,
   stripStringContents,
+  stripCommentsAndStrings,
   isBuiltIn,
   isRelativeImport,
   isRelativeImportWithQuotes,
   getNames,
   extractExportName
-}
+}

package/tests/dep-graph.test.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,30 @@ 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.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')
@@ -563,6 +567,41 @@ export const real = 'value' // this comment should be stripped
   assert.equal(foundExports[2].exportName, 'real', 'Should find real export')
 })
 
+test('apostrophe inside JSDoc with surrounding backticks does not swallow later exports', () => {
+  // Regression: when `stripStringContents` ran BEFORE `stripComments`, an
+  // apostrophe inside a JSDoc block (e.g. `Netlify's \`promptType: 'foo'\``)
+  // was treated as the opener of a single-quoted string and consumed text up
+  // to the next `'`, shifting every subsequent backtick pair by one. The
+  // newly mis-paired template literal then spanned multiple lines, including
+  // the real `export async function` declaration that followed the JSDoc,
+  // and the embedded-code heuristic blanked it. The fix runs `stripComments`
+  // first so JSDoc-internal punctuation is gone before string matching.
+  //
+  // This fixture replicates the structural shape of the AWS SDK adapter file
+  // that originally surfaced the bug: a JSDoc block containing both an
+  // apostrophe and multiple backticks, followed by an `export async function`,
+  // followed by ANOTHER JSDoc with backticks.
+  const code = `
+/**
+ * Stuff with \`code-one\`. Netlify's \`promptType: 'foo'\`. End \`Error\` on
+ * non-2xx upstream responses or malformed bodies.
+ */
+export async function generateThing(request) {
+  return request
+}
+/** Test seam: override the global \`fetch\` for unit tests. */
+export const helper = 1
+  `
+
+  const found = getExports(code)
+  const names = found.map(e => e.exportName).sort()
+  assert.equal(
+    names,
+    ['generateThing', 'helper'],
+    'Both exports must survive past the JSDoc apostrophe+backtick combo'
+  )
+})
+
 test('ignores ESM exports embedded in template literals and strings', () => {
   const code = `
 export const real = 'real'
@@ -580,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"}

package/types/utils.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Strip comments from code while skipping strings, templates, and regex
+ * literals. Regex literals can legally contain `//`, for example `/https?:\/\//`,
+ * and must not be treated as line comments.
+ * @param {string} code
+ * @returns {string}
+ */
+export function stripComments(code: string): string;
+/**
+ * Blank the contents of every string/template literal in `code` that looks
+ * like it contains embedded code (its body mentions `import`, `export`,
+ * `require`, or `module.exports`). The opening and closing quote chars are
+ * preserved, as are newlines. Total length is preserved so character indices
+ * remain stable.
+ *
+ * Strings whose bodies don't reference those keywords — including ordinary
+ * module specifiers like `'lodash'`, paths like `'./foo.js'`, URLs, and
+ * arbitrary user text — pass through untouched, so the static-import/require
+ * regexes can still read their content.
+ *
+ * Without this pass, regex-based extractors falsely match `import`, `export`,
+ * and `require` keywords that appear inside code samples embedded in strings.
+ *
+ * Run after `stripComments` in the import/require/export extractors. The
+ * comment scanner already skips strings and regex literals, so this pass can
+ * focus on embedded-code strings without risking `//` in URLs or regexes.
+ *
+ * Caveat: `${...}` interpolations inside template literals are treated as
+ * part of the body, so a runtime `${import('./x.js')}` inside a template
+ * would be blanked. Very rare in practice; a proper tokenizer would be
+ * needed to do better.
+ *
+ * @param {string} code
+ * @returns {string}
+ */
+export function stripStringContents(code: string): string;
+/**
+ * Blank comment bodies and code-bearing string/template bodies together.
+ * Solves two bugs that occurred when the string-strip and comment-strip ran
+ * as naive regex passes:
+ *
+ *   - Apostrophes inside JSDoc comments (e.g. `* Netlify's \`...`) were
+ *     mis-paired with later quotes, which shifted subsequent backtick
+ *     pairing and could swallow real `export` declarations a few lines
+ *     later in the same file.
+ *   - `//` and `/* *\/` sequences inside string bodies were mis-stripped
+ *     as comments.
+ *   - `//` inside regex literals such as `/^https?:\/\//i` was mis-stripped
+ *     as a line comment.
+ *
+ * Length is preserved (each consumed char replaced by a space or newline
+ * kept verbatim) so downstream character indices stay valid.
+ *
+ * Strings whose bodies don't reference `import` / `export` / `require` /
+ * `module.exports` pass through unchanged, so module specifiers like
+ * `'lodash'` or `'./foo.js'` stay readable by the downstream regexes.
+ *
+ * Caveat: `${...}` interpolations inside template literals are part of the
+ * body, so `${import('./x.js')}` inside a template gets blanked. Rare in
+ * practice; a full parser would be needed otherwise.
+ *
+ * @param {string} code
+ * @returns {string}
+ */
+export function stripCommentsAndStrings(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;
+export function extractExportName(exportValue: any): any;
+//# sourceMappingURL=utils.d.ts.map

package/types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAsQA;;;;;;GAMG;AACH,oCAHW,MAAM,GACJ,MAAM,CAIlB;AAtQD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,0CAHW,MAAM,GACJ,MAAM,CA6ClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,8CAHW,MAAM,GACJ,MAAM,CAIlB;AAkKD;;;;GAIG;AACH,sCAHW,MAAM,GACJ,OAAO,CAUnB;AAED,+DAEC;AAED,yEAKC;AAgFD,6DA+DC;AAGD,yDAqCC"}

package/types/vendor/inspect-parameters-declaration.d.ts

@@ -0,0 +1,4 @@
+export function inspectParameters(source: any): any;
+export function getParametersNames(source: any): any;
+export function getParametersNamesFromInspection(inspectedParameters: any): any;
+//# sourceMappingURL=inspect-parameters-declaration.d.ts.map

package/types/vendor/inspect-parameters-declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect-parameters-declaration.d.ts","sourceRoot":"","sources":["../../src/vendor/inspect-parameters-declaration.js"],"names":[],"mappings":"AA0QA,oDAaC;AAtBD,qDAGC;AAED,gFAEC"}

package/types/verify-package-entries.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Extract all entry points from package.json
+ * @param {string} packageJsonPath - Path to package.json
+ * @returns {Array<{field: string, path: string, resolvedPath: string}>} - Array of entry point objects
+ */
+export function getPackageEntryPoints(packageJsonPath: string): Array<{
+    field: string;
+    path: string;
+    resolvedPath: string;
+}>;
+/**
+ * Verify all package.json entry points and collect dependencies
+ * @param {string} packagePath - Path to package.json
+ * @param {object} options - Options
+ * @param {boolean} [options.collectDeps] - If true, collect dependency paths for each entry point. Default: true
+ * @param {boolean} [options.verifyGraph] - If true, verify imports/exports. Default: true
+ * @param {boolean} [options.throwIfErrors] - If true, throw an error if there are any errors. Default: false
+ * @returns {{entryPoints: Array, sourceFiles: Set, errors: Array}} - Verification results
+ */
+export function verifyPackageEntries(packagePath: string, options?: {
+    collectDeps?: boolean;
+    verifyGraph?: boolean;
+    throwIfErrors?: boolean;
+}): {
+    entryPoints: any[];
+    sourceFiles: Set<any>;
+    errors: any[];
+};
+export function collectEntryPoints(packageJson: any, packageDir: any): any[];
+//# sourceMappingURL=verify-package-entries.d.ts.map

package/types/verify-package-entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-package-entries.d.ts","sourceRoot":"","sources":["../src/verify-package-entries.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,uDAHW,MAAM,GACJ,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CAAC,CAOtE;AAmGD;;;;;;;;GAQG;AACH,kDAPW,MAAM,YAEd;IAA0B,WAAW,GAA7B,OAAO;IACW,WAAW,GAA7B,OAAO;IACW,aAAa,GAA/B,OAAO;CACf,GAAU;IAAC,WAAW,QAAQ;IAAC,WAAW,WAAM;IAAC,MAAM,QAAO;CAAC,CAoEjE;AA5KD,6EA8DC"}