@davidwells/extract-deps 0.1.11 → 0.1.13

package/package.json

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

package/src/dep-graph.js

@@ -3,9 +3,82 @@ 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')
 
+/**
+ * Parsed deps per file, keyed on mtime + size: callers walk the same shared
+ * files for every entry point (and a walk parses each import target twice:
+ * to verify the importer's names, then to recurse). Results are read-only.
+ * @type {Map<string, { key: string, deps: ReturnType<typeof extractDeps> }>}
+ */
+const parseCache = new Map()
+
+/**
+ * @param {string} filePath
+ * @returns {ReturnType<typeof extractDeps>}
+ */
+function readDeps(filePath) {
+  const stat = fs.statSync(filePath)
+  const key = `${stat.mtimeMs}:${stat.size}`
+  const cached = parseCache.get(filePath)
+  if (cached && cached.key === key) return cached.deps
+  const deps = extractDeps(fs.readFileSync(filePath, 'utf8'))
+  parseCache.set(filePath, { key, deps })
+  return deps
+}
+
+/** @type {Map<string, string | null>} `${baseDir}\0${importPath}` -> resolved file (or null) */
+const relativeResolveCache = new Map()
+/** @type {Map<string, { url: string } | { error: Error }>} `${parentDir}\0${specifier}` -> package resolution */
+const packageResolveCache = new Map()
+/** @type {Map<string, string>} path -> realpath */
+const realpathCache = new Map()
+
+/**
+ * fs.realpathSync, memoized per path.
+ * @param {string} filePath
+ * @returns {string}
+ */
+function realpath(filePath) {
+  let real = realpathCache.get(filePath)
+  if (real === undefined) {
+    real = fs.realpathSync(filePath)
+    realpathCache.set(filePath, real)
+  }
+  return real
+}
+
+/**
+ * resolveImport (import-meta-resolve) memoized per importing directory: a
+ * bare specifier resolves the same from every file in one directory.
+ * @param {string} specifier
+ * @param {string} parentPath - Importing file
+ * @returns {string} resolved URL
+ */
+function resolvePackageImport(specifier, parentPath) {
+  const key = `${path.dirname(parentPath)}\0${specifier}`
+  let cached = packageResolveCache.get(key)
+  if (!cached) {
+    try {
+      cached = { url: resolveImport(specifier, pathToFileURL(parentPath).href) }
+    } catch (error) {
+      cached = { error: /** @type {Error} */ (error) }
+    }
+    packageResolveCache.set(key, cached)
+  }
+  if ('error' in cached) throw cached.error
+  return cached.url
+}
+
+/** Drop memoized parses and resolutions (e.g. between runs in a long-lived process). */
+function clearDepGraphCache() {
+  parseCache.clear()
+  relativeResolveCache.clear()
+  packageResolveCache.clear()
+  realpathCache.clear()
+}
+
 function fsExistsSync(path) {
   try {
     fs.accessSync(path, fs.constants.F_OK)
@@ -30,6 +103,21 @@ function isFileSync(filePath) {
  * @returns {string|null} - Resolved file path or null if not found
  */
 function resolveImportPath(baseDir, importPath) {
+  const key = `${baseDir}\0${importPath}`
+  let resolved = relativeResolveCache.get(key)
+  if (resolved === undefined) {
+    resolved = resolveImportPathUncached(baseDir, importPath)
+    relativeResolveCache.set(key, resolved)
+  }
+  return resolved
+}
+
+/**
+ * @param {string} baseDir
+ * @param {string} importPath
+ * @returns {string|null}
+ */
+function resolveImportPathUncached(baseDir, importPath) {
   const possibleExtensions = ['.js', '.mjs', '.ts', '.json', '']
 
   // Try direct file resolution (must be a file, not directory)
@@ -198,7 +286,7 @@ function buildGraphRecursively(
   visited = new Set(),
 ) {
   // Avoid infinite loops
-  const normalizedPath = fs.realpathSync(filePath)
+  const normalizedPath = realpath(filePath)
   if (visited.has(normalizedPath)) {
     return
   }
@@ -210,8 +298,7 @@ function buildGraphRecursively(
   }
 
   // Read and extract deps from this file
-  const content = fs.readFileSync(filePath, 'utf8')
-  const deps = extractDeps(content)
+  const deps = readDeps(filePath)
 
   // Collect all relative dependencies
   const relativeDeps = []
@@ -255,15 +342,14 @@ function buildGraphRecursively(
 
     // Add edge to graph if building
     if (graph !== null) {
-      const normalizedResolvedPath = fs.realpathSync(resolvedPath)
+      const normalizedResolvedPath = realpath(resolvedPath)
       graph.get(normalizedPath).push(normalizedResolvedPath)
     }
 
     // Verify imports if verification is enabled
     if (verify) {
       // Extract deps from the imported file
-      const targetContent = fs.readFileSync(resolvedPath, 'utf8')
-      const targetDeps = extractDeps(targetContent)
+      const targetDeps = readDeps(resolvedPath)
 
       // Verify the imported values are exported
       verifyImportedValuesExist(dep, targetDeps, resolvedPath, filePath, errors, throwOnFirstError)
@@ -282,8 +368,6 @@ function buildGraphRecursively(
 
   // Verify node_modules dependencies if enabled (skip built-ins)
   if (verifyNodeModules && nodeModuleDeps.length > 0) {
-    const parentURL = pathToFileURL(filePath).href
-
     for (const dep of nodeModuleDeps) {
       const { from, line } = dep
 
@@ -295,7 +379,7 @@ function buildGraphRecursively(
       let resolvedPath
       try {
         // resolveImport throws if file doesn't exist
-        const resolved = resolveImport(from, parentURL)
+        const resolved = resolvePackageImport(from, filePath)
         resolvedPath = fileURLToPath(resolved)
       } catch (error) {
         const err = new Error(
@@ -313,8 +397,7 @@ function buildGraphRecursively(
 
       // Verify import/export styles match (only needed for ESM imports)
       if (dep.isESM) {
-        const targetContent = fs.readFileSync(resolvedPath, 'utf8')
-        const targetDeps = extractDeps(targetContent)
+        const targetDeps = readDeps(resolvedPath)
         verifyImportedValuesExist(dep, targetDeps, resolvedPath, filePath, errors, throwOnFirstError)
       }
     }
@@ -470,5 +553,6 @@ if (require.main === module) {
 
 module.exports = {
   depGraph,
-  resolveDepPaths
+  resolveDepPaths,
+  clearDepGraphCache
 }

package/src/get-cjs-exports.js

@@ -41,9 +41,11 @@ function getCjsExports(code) {
   // values) keeps working off the same indices.
   const sanitizedCode = stripCommentsAndStrings(code)
 
-  const assignmentExports = getModuleExportsAssignment(code, sanitizedCode)
-  const modulePropertyExports = getModuleExportsProperty(code, sanitizedCode)
-  const propertyExports = getExportsProperty(code, sanitizedCode)
+  // Their regexes need `module.exports` / `exports` in the sanitized text.
+  const hasModuleExports = sanitizedCode.includes('module.exports')
+  const assignmentExports = hasModuleExports ? getModuleExportsAssignment(code, sanitizedCode) : []
+  const modulePropertyExports = hasModuleExports ? getModuleExportsProperty(code, sanitizedCode) : []
+  const propertyExports = sanitizedCode.includes('exports') ? getExportsProperty(code, sanitizedCode) : []
 
   // Quick pre-checks to avoid expensive regex operations when not needed
   const objectAssignExports = sanitizedCode.includes('Object.assign')

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,6 +16,8 @@ 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 = {}) {
+  // Every pattern below needs the word `export`; stripping never adds one.
+  if (!code.includes('export')) return []
   // 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
@@ -303,4 +305,4 @@ module.exports = {
   getNamespaceExports,
   getTypeExports,
   getAssertionExports
-} 
+} 

package/src/get-imports.js

@@ -37,6 +37,8 @@ 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 = {}) {
+  // Every pattern below needs the word `import`; stripping never adds one.
+  if (!code.includes('import')) return []
   // 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

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,6 +105,8 @@ function getStaticRequires(targetText = '') {
 }
 
 function getRequires(code) {
+  // Both scanners need the word `require`; stripping never adds one.
+  if (!code.includes('require')) return []
   // 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

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,32 +35,64 @@ 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
+  const special = /[/"'`]/g
+
+  while (i < code.length) {
+    // Copy the run of ordinary characters up to the next / or quote in one go.
+    special.lastIndex = i
+    const next = special.exec(code)
+    const stop = next ? next.index : code.length
+    if (stop > i) {
+      output += code.slice(i, stop)
+      i = stop
+      if (i >= code.length) break
+    }
+    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
+  }
 
-// Unified regex matching whichever comes first at each position: block
-// comment, line comment, single-quoted string, double-quoted string, or
-// template literal. Matching left-to-right means a comment that starts
-// first consumes its body — including any apostrophes or backticks inside
-// — before they can start a spurious string match a few lines later. That
-// solves the JSDoc-apostrophe-shifts-backtick-pairing class of bugs that
-// arose when comments and strings were stripped in two separate passes.
-const COMMENT_OR_STRING_RE = /\/\*[\s\S]*?\*\/|\/\/[^\n]*|"(?:[^"\\\n]|\\[\s\S])*"|'(?:[^'\\\n]|\\[\s\S])*'|`(?:[^`\\]|\\[\s\S])*`/g
+  return output
+}
 
 /**
- * Single-regex pass that blanks comment bodies and code-bearing
- * string/template bodies together. Solves two bugs that occurred when the
- * string-strip and comment-strip ran in separate passes:
+ * 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
@@ -83,6 +100,8 @@ const COMMENT_OR_STRING_RE = /\/\*[\s\S]*?\*\/|\/\/[^\n]*|"(?:[^"\\\n]|\\[\s\S])
  *     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.
@@ -99,38 +118,177 @@ const COMMENT_OR_STRING_RE = /\/\*[\s\S]*?\*\/|\/\/[^\n]*|"(?:[^"\\\n]|\\[\s\S])
  * @returns {string}
  */
 function stripCommentsAndStrings(code) {
-  return code.replace(COMMENT_OR_STRING_RE, (match) => {
-    const first = match[0]
-    // Comments (line or block) are fully blanked — they have no extractable
-    // content. Newlines are preserved so line counts hold.
-    if (first === '/') {
-      return match.replace(/[^\n]/g, ' ')
+  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
     }
-    // Strings/templates — only blank if the body references code keywords;
-    // otherwise leave the literal intact so `'lodash'` etc. remain readable.
-    const body = match.slice(1, -1)
-    if (!EMBEDDED_CODE_RE.test(body)) {
-      return match
+    if (code[i] === quote) return i + 1
+    if (quote !== '`' && (code[i] === '\n' || code[i] === '\r')) return i
+    i++
+  }
+  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
     }
-    return first + body.replace(/[^\n]/g, ' ') + first
-  })
+    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
+  const special = /[/"'`]/g
+
+  while (i < code.length) {
+    // Copy the run of ordinary characters up to the next / or quote in one go.
+    special.lastIndex = i
+    const found = special.exec(code)
+    const stop = found ? found.index : code.length
+    if (stop > i) {
+      output += code.slice(i, stop)
+      i = stop
+      if (i >= code.length) break
+    }
+    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 output
 }
 
 /**
- * Strip comments from code, preserving :// in URLs
+ * 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) {
-  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
+  return stripCommentsImpl(code)
 }
 
 /**
@@ -351,4 +509,4 @@ module.exports = {
   isRelativeImportWithQuotes,
   getNames,
   extractExportName
-}
+}