import-in-the-middle 1.7.4 → 1.8.1

package/README.md

@@ -18,7 +18,7 @@ imported in ESM files, regardless of whether they're imported statically or
 dynamically.
 
 ```js
-import Hook from 'import-in-the-middle'
+import { Hook } from 'import-in-the-middle'
 import { foo } from 'package-i-want-to-modify'
 
 console.log(foo) // whatever that module exported

package/hook.js

@@ -2,7 +2,7 @@
 //
 // This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc.
 
-const { randomBytes } = require('crypto')
+const { URL } = require('url')
 const specifiers = new Map()
 const isWin = process.platform === 'win32'
 
@@ -19,7 +19,7 @@ let getExports
 if (NODE_MAJOR >= 20 || (NODE_MAJOR === 18 && NODE_MINOR >= 19)) {
   getExports = require('./lib/get-exports.js')
 } else {
-  getExports = ({ url }) => import(url).then(Object.keys)
+  getExports = (url) => import(url).then(Object.keys)
 }
 
 function hasIitm (url) {
@@ -91,135 +91,112 @@ function isStarExportLine (line) {
   return /^\* from /.test(line)
 }
 
-/**
- * @typedef {object} ProcessedModule
- * @property {string[]} imports A set of ESM import lines to be added to the
- * shimmed module source.
- * @property {string[]} namespaces A set of identifiers representing the
- * modules in `imports`, e.g. for `import * as foo from 'bar'`, "foo" will be
- * present in this array.
- * @property {Map<string, string>} setters The shimmed setters for all the
- * exports from the module and any transitive export all modules. The key is
- * used to deduplicate conflicting exports, assigning a priority to `default`
- * exports.
- */
+function isBareSpecifier (specifier) {
+  // Relative and absolute paths are not bare specifiers.
+  if (
+    specifier.startsWith('.') ||
+    specifier.startsWith('/')) {
+    return false
+  }
+
+  // Valid URLs are not bare specifiers. (file:, http:, node:, etc.)
+
+  // eslint-disable-next-line no-prototype-builtins
+  if (URL.hasOwnProperty('canParse')) {
+    return !URL.canParse(specifier)
+  }
+
+  try {
+    // eslint-disable-next-line no-new
+    new URL(specifier)
+    return false
+  } catch (err) {
+    return true
+  }
+}
 
 /**
- * Processes a module's exports and builds a set of new import statements,
- * namespace names, and setter blocks. If an export all export if encountered,
- * the target exports will be hoisted to the current module via a generated
- * namespace.
+ * Processes a module's exports and builds a set of setter blocks.
  *
  * @param {object} params
  * @param {string} params.srcUrl The full URL to the module to process.
  * @param {object} params.context Provided by the loaders API.
- * @param {Function} params.parentGetSource Provides the source code for the
- * parent module.
- * @param {string} [params.ns='namespace'] A string identifier that will be
- * used as the namespace for the identifiers exported by the module.
- * @param {string} [params.defaultAs='default'] The name to give the default
- * identifier exported by the module (if one exists). This is really only
- * useful in a recursive situation where a transitive module's default export
- * needs to be renamed to the name of the module.
+ * @param {Function} params.parentGetSource Provides the source code for the parent module.
+ * @param {bool} params.excludeDefault Exclude the default export.
  *
- * @returns {Promise<ProcessedModule>}
+ * @returns {Promise<Map<string, string>>} The shimmed setters for all the exports
+ * from the module and any transitive export all modules.
  */
-async function processModule ({
-  srcUrl,
-  context,
-  parentGetSource,
-  ns = 'namespace',
-  defaultAs = 'default'
-}) {
-  const exportNames = await getExports({
-    url: srcUrl,
-    context,
-    parentLoad: parentGetSource,
-    defaultAs
-  })
-  const imports = [`import * as ${ns} from ${JSON.stringify(srcUrl)}`]
-  const namespaces = [ns]
-
-  // As we iterate found module exports we will add setter code blocks
-  // to this map that will eventually be inserted into the shim module's
-  // source code. We utilize a map in order to prevent duplicate exports.
-  // As a consequence of default renaming, it is possible that a file named
-  // `foo.mjs` which has `export function foo() {}` and `export default foo`
-  // exports will result in the "foo" export being defined twice in our shim.
-  // The map allows us to avoid this situation at the cost of losing the
-  // named export in favor of the default export.
+async function processModule ({ srcUrl, context, parentGetSource, parentResolve, excludeDefault }) {
+  const exportNames = await getExports(srcUrl, context, parentGetSource)
+  const starExports = new Set()
   const setters = new Map()
 
+  const addSetter = (name, setter, isStarExport = false) => {
+    if (setters.has(name)) {
+      if (isStarExport) {
+        // If there's already a matching star export, delete it
+        if (starExports.has(name)) {
+          setters.delete(name)
+        }
+        // and return so this is excluded
+        return
+      }
+
+      // if we already have this export but it is from a * export, overwrite it
+      if (starExports.has(name)) {
+        starExports.delete(name)
+        setters.set(name, setter)
+      }
+    } else {
+      // Store export * exports so we know they can be overridden by explicit
+      // named exports
+      if (isStarExport) {
+        starExports.add(name)
+      }
+
+      setters.set(name, setter)
+    }
+  }
+
   for (const n of exportNames) {
+    if (n === 'default' && excludeDefault) continue
+
     if (isStarExportLine(n) === true) {
       const [, modFile] = n.split('* from ')
-      const normalizedModName = normalizeModName(modFile)
-      const modUrl = new URL(modFile, srcUrl).toString()
-      const modName = Buffer.from(modFile, 'hex') + Date.now() + randomBytes(4).toString('hex')
 
-      const data = await processModule({
+      let modUrl
+      if (isBareSpecifier(modFile)) {
+        // Bare specifiers need to be resolved relative to the parent module.
+        const result = await parentResolve(modFile, { parentURL: srcUrl })
+        modUrl = result.url
+      } else {
+        modUrl = new URL(modFile, srcUrl).href
+      }
+
+      const setters = await processModule({
         srcUrl: modUrl,
         context,
         parentGetSource,
-        ns: `$${modName}`,
-        defaultAs: normalizedModName
+        parentResolve,
+        excludeDefault: true
       })
-      Array.prototype.push.apply(imports, data.imports)
-      Array.prototype.push.apply(namespaces, data.namespaces)
-      for (const [k, v] of data.setters.entries()) {
-        setters.set(k, v)
+      for (const [name, setter] of setters.entries()) {
+        addSetter(name, setter, true)
       }
-
-      continue
-    }
-
-    const matches = /^rename (.+) as (.+)$/.exec(n)
-    if (matches !== null) {
-      // Transitive modules that export a default identifier need to have
-      // that identifier renamed to the name of module. And our shim setter
-      // needs to utilize that new name while being initialized from the
-      // corresponding origin namespace.
-      const renamedExport = matches[2]
-      setters.set(`$${renamedExport}${ns}`, `
-      let $${renamedExport} = ${ns}.default
-      export { $${renamedExport} as ${renamedExport} }
-      set.${renamedExport} = (v) => {
-        $${renamedExport} = v
+    } else {
+      addSetter(n, `
+      let $${n} = _.${n}
+      export { $${n} as ${n} }
+      set.${n} = (v) => {
+        $${n} = v
         return true
       }
       `)
-      continue
     }
-
-    setters.set(`$${n}` + ns, `
-    let $${n} = ${ns}.${n}
-    export { $${n} as ${n} }
-    set.${n} = (v) => {
-      $${n} = v
-      return true
-    }
-    `)
   }
 
-  return { imports, namespaces, setters }
-}
-
-/**
- * Given a module name, e.g. 'foo-bar' or './foo-bar.js', normalize it to a
- * string that is a valid JavaScript identifier, e.g. `fooBar`. Normalization
- * means converting kebab-case to camelCase while removing any path tokens and
- * file extensions.
- *
- * @param {string} name The module name to normalize.
- *
- * @returns {string} The normalized identifier.
- */
-function normalizeModName (name) {
-  return name
-    .split('/')
-    .pop()
-    .replace(/(.+)\.(?:js|mjs)$/, '$1')
-    .replaceAll(/(-.)/g, x => x[1].toUpperCase())
+  return setters
 }
 
 function addIitm (url) {
@@ -229,7 +206,20 @@ function addIitm (url) {
 }
 
 function createHook (meta) {
+  let cachedResolve
+  const iitmURL = new URL('lib/register.js', meta.url).toString()
+
   async function resolve (specifier, context, parentResolve) {
+    cachedResolve = parentResolve
+
+    // See github.com/DataDog/import-in-the-middle/pull/76.
+    if (specifier === iitmURL) {
+      return {
+        url: specifier,
+        shortCircuit: true
+      }
+    }
+
     const { parentURL = '' } = context
     const newSpecifier = deleteIitm(specifier)
     if (isWin && parentURL.indexOf('file:node') === 0) {
@@ -253,6 +243,15 @@ function createHook (meta) {
       return url
     }
 
+    // If the file is referencing itself, we need to skip adding the iitm search params
+    if (url.url === parentURL) {
+      return {
+        url: url.url,
+        shortCircuit: true,
+        format: url.format
+      }
+    }
+
     specifiers.set(url.url, specifier)
 
     return {
@@ -262,67 +261,52 @@ function createHook (meta) {
     }
   }
 
-  const iitmURL = new URL('lib/register.js', meta.url).toString()
   async function getSource (url, context, parentGetSource) {
     if (hasIitm(url)) {
       const realUrl = deleteIitm(url)
-      const { imports, namespaces, setters: mapSetters } = await processModule({
-        srcUrl: realUrl,
-        context,
-        parentGetSource
-      })
-      const setters = Array.from(mapSetters.values())
-
-      // When we encounter modules that re-export all identifiers from other
-      // modules, it is possible that the transitive modules export a default
-      // identifier. Due to us having to merge all transitive modules into a
-      // single common namespace, we need to recognize these default exports
-      // and remap them to a name based on the module name. This prevents us
-      // from overriding the top-level module's (the one actually being imported
-      // by some source code) default export when we merge the namespaces.
-      const renamedDefaults = setters
-        .map(s => {
-          const matches = /let \$(.+) = (\$.+)\.default/.exec(s)
-          if (matches === null) return undefined
-          return `_['${matches[1]}'] = ${matches[2]}.default`
+
+      try {
+        const setters = await processModule({
+          srcUrl: realUrl,
+          context,
+          parentGetSource,
+          parentResolve: cachedResolve
         })
-        .filter(s => s)
-
-      // The for loops are how we merge namespaces into a common namespace that
-      // can be proxied. We can't use a simple `Object.assign` style merging
-      // because transitive modules can export a default identifier that would
-      // override the desired default identifier. So we need to do manual
-      // merging with some logic around default identifiers.
-      //
-      // Additionally, we need to make sure any renamed default exports in
-      // transitive dependencies are added to the common namespace. This is
-      // accomplished through the `renamedDefaults` array.
-      return {
-        source: `
+        return {
+          source: `
 import { register } from '${iitmURL}'
-${imports.join('\n')}
+import * as namespace from ${JSON.stringify(realUrl)}
 
-const namespaces = [${namespaces.join(', ')}]
 // Mimic a Module object (https://tc39.es/ecma262/#sec-module-namespace-objects).
-const _ = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } })
+const _ = Object.assign(
+  Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } }),
+  namespace
+)
 const set = {}
 
-const primary = namespaces.shift()
-for (const [k, v] of Object.entries(primary)) {
-  _[k] = v
-}
-for (const ns of namespaces) {
-  for (const [k, v] of Object.entries(ns)) {
-    if (k === 'default') continue
-    _[k] = v
-  }
-}
-
-${setters.join('\n')}
-${renamedDefaults.join('\n')}
+${Array.from(setters.values()).join('\n')}
 
 register(${JSON.stringify(realUrl)}, _, set, ${JSON.stringify(specifiers.get(realUrl))})
 `
+        }
+      } catch (cause) {
+        // If there are other ESM loader hooks registered as well as iitm,
+        // depending on the order they are registered, source might not be
+        // JavaScript.
+        //
+        // If we fail to parse a module for exports, we should fall back to the
+        // parent loader. These modules will not be wrapped with proxies and
+        // cannot be Hook'ed but at least this does not take down the entire app
+        // and block iitm from being used.
+        //
+        // We log the error because there might be bugs in iitm and without this
+        // it would be very tricky to debug
+        const err = new Error(`'import-in-the-middle' failed to wrap '${realUrl}'`)
+        err.cause = cause
+        console.warn(err)
+
+        // Revert back to the non-iitm URL
+        url = realUrl
       }
     }
 

package/index.d.ts

@@ -27,7 +27,7 @@ export type Options = {
   internals?: boolean
 }
 
-declare class Hook {
+export declare class Hook {
   /**
    * Creates a hook to be run on any already loaded modules and any that will
    * be loaded in the future. It will be run once per loaded module. If

package/index.js

@@ -89,5 +89,6 @@ Hook.prototype.unhook = function () {
 }
 
 module.exports = Hook
+module.exports.Hook = Hook
 module.exports.addHook = addHook
 module.exports.removeHook = removeHook

package/lib/get-esm-exports.js

@@ -18,30 +18,21 @@ function warn (txt) {
  * Utilizes an AST parser to interpret ESM source code and build a list of
  * exported identifiers. In the baseline case, the list of identifiers will be
  * the simple identifier names as written in the source code of the module.
- * However, there are some special cases:
+ * However, there is a special case:
  *
- * 1. When an `export * from './foo.js'` line is encountered it is rewritten
+ * When an `export * from './foo.js'` line is encountered it is rewritten
  * as `* from ./foo.js`. This allows the interpreting code to recognize a
  * transitive export and recursively parse the indicated module. The returned
  * identifier list will have "* from ./foo.js" as an item.
  *
- * 2. When `defaultAs` has a value other than 'default', the export line will
- * be rewritten as `rename <identifier> as <defaultAsValue>`. This rename string
- * will be an item in the returned identifier list.
- *
  * @param {object} params
  * @param {string} params.moduleSource The source code of the module to parse
  * and interpret.
- * @param {string} [defaultAs='default'] When anything other than 'default' any
- * `export default` lines will be rewritten utilizing the value provided. For
- * example, if a module 'foo-bar.js' has the line `export default foo` and the
- * value of this parameter is 'baz', then the export will be rewritten to
- * `rename foo as baz`.
  *
- * @returns {string[]} The identifiers exported by the module along with any
+ * @returns {Set<string>} The identifiers exported by the module along with any
  * custom directives.
  */
-function getEsmExports ({ moduleSource, defaultAs = 'default' }) {
+function getEsmExports (moduleSource) {
   const exportedNames = new Set()
   const tree = parser.parse(moduleSource, acornOpts)
   for (const node of tree.body) {
@@ -56,19 +47,7 @@ function getEsmExports ({ moduleSource, defaultAs = 'default' }) {
         break
 
       case 'ExportDefaultDeclaration': {
-        if (defaultAs === 'default') {
-          exportedNames.add('default')
-          break
-        }
-
-        if (node.declaration.type.toLowerCase() === 'identifier') {
-          // e.g. `export default foo`
-          exportedNames.add(`rename ${node.declaration.name} as ${defaultAs}`)
-        } else {
-          // e.g. `export function foo () {}
-          exportedNames.add(`rename ${node.declaration.id.name} as ${defaultAs}`)
-        }
-
+        exportedNames.add('default')
         break
       }
 
@@ -83,7 +62,7 @@ function getEsmExports ({ moduleSource, defaultAs = 'default' }) {
         warn('unrecognized export type: ' + node.type)
     }
   }
-  return Array.from(exportedNames)
+  return exportedNames
 }
 
 function parseDeclaration (node, exportedNames) {

package/lib/get-exports.js

@@ -1,36 +1,60 @@
 'use strict'
 
 const getEsmExports = require('./get-esm-exports.js')
-const { parse: getCjsExports } = require('cjs-module-lexer')
-const fs = require('fs')
+const { parse: parseCjs } = require('cjs-module-lexer')
+const { readFileSync } = require('fs')
+const { builtinModules } = require('module')
 const { fileURLToPath, pathToFileURL } = require('url')
+const { dirname } = require('path')
 
 function addDefault (arr) {
-  return Array.from(new Set(['default', ...arr]))
+  return new Set(['default', ...arr])
+}
+
+// Cached exports for Node built-in modules
+const BUILT_INS = new Map()
+
+function getExportsForNodeBuiltIn (name) {
+  let exports = BUILT_INS.get()
+
+  if (!exports) {
+    exports = new Set(addDefault(Object.keys(require(name))))
+    BUILT_INS.set(name, exports)
+  }
+
+  return exports
 }
 
 const urlsBeingProcessed = new Set() // Guard against circular imports.
 
-async function getFullCjsExports (url, context, parentLoad, source) {
+async function getCjsExports (url, context, parentLoad, source) {
   if (urlsBeingProcessed.has(url)) {
     return []
   }
   urlsBeingProcessed.add(url)
 
-  const ex = getCjsExports(source)
-  const full = Array.from(new Set([
-    ...addDefault(ex.exports),
-    ...(await Promise.all(ex.reexports.map(re => getExports(({
-      url: (/^(..?($|\/|\\))/).test(re)
-        ? pathToFileURL(require.resolve(fileURLToPath(new URL(re, url)))).toString()
-        : pathToFileURL(require.resolve(re)).toString(),
-      context,
-      parentLoad
-    }))))).flat()
-  ]))
-
-  urlsBeingProcessed.delete(url)
-  return full
+  try {
+    const result = parseCjs(source)
+    const full = addDefault(result.exports)
+
+    await Promise.all(result.reexports.map(async re => {
+      if (re.startsWith('node:') || builtinModules.includes(re)) {
+        for (const each of getExportsForNodeBuiltIn(re)) {
+          full.add(each)
+        }
+      } else {
+        // Resolve the re-exported module relative to the current module.
+        const newUrl = pathToFileURL(require.resolve(re, { paths: [dirname(fileURLToPath(url))] })).href
+        for (const each of await getExports(newUrl, context, parentLoad)) {
+          full.add(each)
+        }
+      }
+    }))
+
+    return full
+  } finally {
+    urlsBeingProcessed.delete(url)
+  }
 }
 
 /**
@@ -38,25 +62,18 @@ async function getFullCjsExports (url, context, parentLoad, source) {
  * source code for said module from the loader API, and parses the result
  * for the entities exported from that module.
  *
- * @param {object} params
- * @param {string} params.url A file URL string pointing to the module that
+ * @param {string} url A file URL string pointing to the module that
  * we should get the exports of.
- * @param {object} params.context Context object as provided by the `load`
+ * @param {object} context Context object as provided by the `load`
  * hook from the loaders API.
- * @param {Function} params.parentLoad Next hook function in the loaders API
+ * @param {Function} parentLoad Next hook function in the loaders API
  * hook chain.
- * @param {string} [defaultAs='default'] When anything other than 'default',
- * will trigger remapping of default exports in ESM source files to the
- * provided name. For example, if a submodule has `export default foo` and
- * 'myFoo' is provided for this parameter, the export line will be rewritten
- * to `rename foo as myFoo`. This is key to being able to support
- * `export * from 'something'` exports.
  *
- * @returns {Promise<string[]>} An array of identifiers exported by the module.
+ * @returns {Promise<Set<string>>} An array of identifiers exported by the module.
  * Please see {@link getEsmExports} for caveats on special identifiers that may
  * be included in the result set.
  */
-async function getExports ({ url, context, parentLoad, defaultAs = 'default' }) {
+async function getExports (url, context, parentLoad) {
   // `parentLoad` gives us the possibility of getting the source
   // from an upstream loader. This doesn't always work though,
   // so later on we fall back to reading it from disk.
@@ -64,34 +81,34 @@ async function getExports ({ url, context, parentLoad, defaultAs = 'default' })
   let source = parentCtx.source
   const format = parentCtx.format
 
-  // TODO support non-node/file urls somehow?
-  if (format === 'builtin') {
-    // Builtins don't give us the source property, so we're stuck
-    // just requiring it to get the exports.
-    return addDefault(Object.keys(require(url)))
-  }
-
   if (!source) {
-    // Sometimes source is retrieved by parentLoad, sometimes it isn't.
-    source = fs.readFileSync(fileURLToPath(url), 'utf8')
+    if (format === 'builtin') {
+      // Builtins don't give us the source property, so we're stuck
+      // just requiring it to get the exports.
+      return getExportsForNodeBuiltIn(url)
+    }
+
+    // Sometimes source is retrieved by parentLoad, CommonJs isn't.
+    source = readFileSync(fileURLToPath(url), 'utf8')
   }
 
   if (format === 'module') {
-    return getEsmExports({ moduleSource: source, defaultAs })
+    return getEsmExports(source)
   }
+
   if (format === 'commonjs') {
-    return getFullCjsExports(url, context, parentLoad, source)
+    return getCjsExports(url, context, parentLoad, source)
   }
 
   // At this point our `format` is either undefined or not known by us. Fall
   // back to parsing as ESM/CJS.
-  const esmExports = getEsmExports({ moduleSource: source, defaultAs })
+  const esmExports = getEsmExports(source)
   if (!esmExports.length) {
     // TODO(bengl) it's might be possible to get here if somehow the format
     // isn't set at first and yet we have an ESM module with no exports.
     // I couldn't construct an example that would do this, so maybe it's
     // impossible?
-    return getFullCjsExports(url, context, parentLoad, source)
+    return getCjsExports(url, context, parentLoad, source)
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "import-in-the-middle",
-  "version": "1.7.4",
+  "version": "1.8.1",
   "description": "Intercept imports in Node.js",
   "main": "index.js",
   "scripts": {
@@ -36,15 +36,19 @@
     "@babel/core": "^7.23.7",
     "@babel/eslint-parser": "^7.23.3",
     "@babel/plugin-syntax-import-assertions": "^7.23.3",
+    "@react-email/components": "^0.0.19",
     "@types/node": "^18.0.6",
     "c8": "^7.8.0",
+    "date-fns": "^3.6.0",
     "eslint": "^8.55.0",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.29.0",
     "eslint-plugin-n": "^16.4.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^6.1.1",
+    "got": "^14.3.0",
     "imhotap": "^2.1.0",
+    "openai": "^4.47.2",
     "ts-node": "^10.9.1",
     "typescript": "^4.7.4"
   },

package/test/README.md

@@ -11,7 +11,7 @@ options (assuming they're run from the project root):
 
 ```
 --require ./test/version-check.js
---experimental-loader ./test/generic-loader.mmjs
+--experimental-loader ./test/generic-loader.mjs
 ```
 
 The entire test suite can be run with `npm test`.

package/test/fixtures/cyclical-self.mjs

@@ -0,0 +1,8 @@
+// File generated from our OpenAPI spec by Stainless.
+import * as BatchesAPI from './cyclical-self.mjs'
+export class Batches {}
+export class BatchesPage {}
+(function (Batches) {
+  Batches.BatchesPage = BatchesAPI.BatchesPage
+// eslint-disable-next-line no-class-assign
+})(Batches || (Batches = {}))

package/test/fixtures/duplicate-a.mjs

@@ -0,0 +1,4 @@
+export const foo = 'a'
+export default function () {
+  return 'c'
+}

package/test/fixtures/duplicate-b.mjs

@@ -0,0 +1 @@
+export const foo = 'b'

package/test/fixtures/duplicate-c.mjs

@@ -0,0 +1 @@
+export const foo = 'c'

package/test/fixtures/duplicate-explicit.mjs

@@ -0,0 +1,5 @@
+export * from './duplicate-a.mjs'
+export * from './duplicate-b.mjs'
+export { foo } from './duplicate-c.mjs'
+export * from './duplicate-a.mjs'
+export * from './duplicate-b.mjs'

package/test/fixtures/duplicate.mjs

@@ -0,0 +1,5 @@
+export * from './duplicate-a.mjs'
+export * from './duplicate-b.mjs'
+
+const foo = 'foo'
+export default foo

package/test/fixtures/export-types/default-call-expression-renamed.mjs

@@ -0,0 +1,2 @@
+export * from './default-call-expression.mjs'
+export { default as somethingElse } from './default-call-expression.mjs'

package/test/fixtures/export-types/default-call-expression.mjs

@@ -0,0 +1 @@
+export default parseInt('1')

package/test/fixtures/got-alike.mjs

@@ -1,7 +1,3 @@
-// The purpose of this fixture is to replicate a situation where we may
-// end up exporting `default` twice: first from this script itself and second
-// via the `export * from` line.
-//
 // This replicates the way the in-the-wild `got` module does things:
 // https://github.com/sindresorhus/got/blob/3822412/source/index.ts
 
@@ -12,6 +8,4 @@ class got {
 export default got
 export { got }
 export * from './something.mjs'
-export * from './default-class.mjs'
-export * from './snake_case.mjs'
 export { default as renamedDefaultExport } from './lib/baz.mjs'

package/test/fixtures/json-attributes.mjs

@@ -0,0 +1,5 @@
+import coolFile from './something.json' with { type: 'json' }
+
+export default {
+  data: coolFile.data
+}

package/test/fixtures/re-export-cjs-built-in.js

@@ -0,0 +1 @@
+module.exports = require('util').deprecate

package/test/fixtures/re-export-cjs.js

@@ -0,0 +1 @@
+module.exports = require('some-external-cjs-module').foo

package/test/fixtures/re-export-star-external.mjs

@@ -0,0 +1 @@
+export * from 'some-external-module'

package/test/fixtures/sub-directory/re-export-star-external.mjs

@@ -0,0 +1 @@
+export * from 'some-external-module/sub'

package/test/get-esm-exports/v20-get-esm-exports.js

@@ -15,7 +15,7 @@ fixture.split('\n').forEach(line => {
   if (expectedNames[0] === '') {
     expectedNames.length = 0
   }
-  const names = getEsmExports({ moduleSource: mod })
+  const names = Array.from(getEsmExports(mod))
   assert.deepEqual(expectedNames, names)
   console.log(`${mod}\n  ✅ contains exports: ${testStr}`)
 })

package/test/hook/cyclical-self.mjs

@@ -0,0 +1,4 @@
+import { Batches, BatchesPage } from '../fixtures/cyclical-self.mjs'
+import { strictEqual } from 'assert'
+
+strictEqual(Batches.BatchesPage, BatchesPage)

package/test/hook/default-export.mjs

@@ -12,6 +12,8 @@ import gfn from '../fixtures/export-types/default-generator.mjs'
 import afn from '../fixtures/export-types/default-function-anon.mjs'
 import acn from '../fixtures/export-types/default-class-anon.mjs'
 import agfn from '../fixtures/export-types/default-generator-anon.mjs'
+import callEx from '../fixtures/export-types/default-call-expression.mjs'
+import { somethingElse } from '../fixtures/export-types/default-call-expression-renamed.mjs'
 import defaultImportExport from '../fixtures/export-types/import-default-export.mjs'
 import varDefaultExport from '../fixtures/export-types/variable-default-export.mjs'
 import { strictEqual } from 'assert'
@@ -61,6 +63,10 @@ Hook((exports, name) => {
     exports.default = function () {
       return orig4() + 1
     }
+  } else if (name.match(/default-call-expression\.m?js/)) {
+    exports.default += 1
+  } else if (name.match(/default-call-expression-renamed\.m?js/)) {
+    exports.somethingElse += 1
   }
 })
 
@@ -76,3 +82,5 @@ strictEqual(new acn().getFoo(), 2)
 strictEqual(agfn().next().value, 2)
 strictEqual(n, 2)
 strictEqual(s, 'dogdawg')
+strictEqual(callEx, 2)
+strictEqual(somethingElse, 2)

package/test/hook/duplicate-exports-explicit.mjs

@@ -0,0 +1,13 @@
+import * as lib from '../fixtures/duplicate-explicit.mjs'
+import { strictEqual } from 'assert'
+import Hook from '../../index.js'
+
+Hook((exports, name) => {
+  if (name.endsWith('duplicate-explicit.mjs')) {
+    strictEqual(exports.foo, 'c')
+    exports.foo += '-wrapped'
+  }
+})
+
+// foo should not be exported because there are duplicate exports
+strictEqual(lib.foo, 'c-wrapped')

package/test/hook/duplicate-exports.mjs

@@ -0,0 +1,19 @@
+import * as lib from '../fixtures/duplicate.mjs'
+import { notEqual, strictEqual } from 'assert'
+import Hook from '../../index.js'
+
+Hook((exports, name) => {
+  if (name.match(/duplicate\.mjs/)) {
+    // foo should not be exported because there are duplicate * exports
+    strictEqual('foo' in exports, false)
+    // default should be exported
+    strictEqual(exports.default, 'foo')
+  }
+})
+
+notEqual(lib, undefined)
+
+// foo should not be exported because there are duplicate exports
+strictEqual('foo' in lib, false)
+// default should be exported
+strictEqual(lib.default, 'foo')

package/test/hook/dynamic-import.js

@@ -2,7 +2,7 @@
 //
 // This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc.
 
-const Hook = require('../../index.js')
+const { Hook } = require('../../index.js')
 const { strictEqual } = require('assert')
 
 Hook((exports, name) => {

package/test/hook/re-export-cjs.mjs

@@ -0,0 +1,19 @@
+import Hook from '../../index.js'
+import foo from '../fixtures/re-export-cjs-built-in.js'
+import foo2 from '../fixtures/re-export-cjs.js'
+import { strictEqual } from 'assert'
+
+Hook((exports, name) => {
+  if (name.endsWith('fixtures/re-export-cjs-built-in.js')) {
+    strictEqual(typeof exports.default, 'function')
+    exports.default = '1'
+  }
+
+  if (name.endsWith('fixtures/re-export-cjs.js')) {
+    strictEqual(exports.default, 'bar')
+    exports.default = '2'
+  }
+})
+
+strictEqual(foo, '1')
+strictEqual(foo2, '2')

package/test/hook/re-export-star-module.mjs

@@ -0,0 +1,17 @@
+import Hook from '../../index.js'
+import { foo } from '../fixtures/re-export-star-external.mjs'
+import { bar } from '../fixtures/sub-directory/re-export-star-external.mjs'
+import { strictEqual } from 'assert'
+
+Hook((exports, name) => {
+  if (name.endsWith('fixtures/re-export-star-external.mjs')) {
+    exports.foo = '1'
+  }
+
+  if (name.endsWith('fixtures/sub-directory/re-export-star-external.mjs')) {
+    exports.bar = '2'
+  }
+})
+
+strictEqual(foo, '1')
+strictEqual(bar, '2')

package/test/hook/static-import-default.mjs

@@ -2,7 +2,7 @@
 //
 // This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc.
 
-import Hook from '../../index.js'
+import { Hook } from '../../index.js'
 import barMjs from '../fixtures/something.mjs'
 import barJs from '../fixtures/something.js'
 import { strictEqual } from 'assert'

package/test/hook/v14-date-fns.mjs

@@ -0,0 +1,10 @@
+import { format, parse } from 'date-fns'
+import Hook from '../../index.js'
+
+Hook((exports, name) => {
+  if (name === 'date-fns') {
+    //
+  }
+})
+
+console.assert(format, parse)

package/test/hook/v14-react-email-components.mjs

@@ -0,0 +1,16 @@
+import * as lib from '@react-email/components'
+import { Heading } from '@react-email/components'
+import Hook from '../../index.js'
+import { strictEqual } from 'assert'
+
+Hook((exports, name) => {
+  if (name.match(/@react-email\/components/)) {
+    exports.Heading = function wrappedHeading () {
+      return 'heading-wrapped'
+    }
+  }
+})
+
+strictEqual(typeof lib.Button, 'function')
+strictEqual(lib.Heading(), 'heading-wrapped')
+strictEqual(Heading(), 'heading-wrapped')

package/test/hook/v16-got.mjs

@@ -0,0 +1,16 @@
+import got, { Options } from 'got'
+import { strictEqual } from 'assert'
+import Hook from '../../index.js'
+
+Hook((exports, name) => {
+  if (name === 'got' && 'Options' in exports) {
+    exports.Options = 'nothing'
+  }
+})
+
+strictEqual(typeof got, 'function')
+strictEqual(typeof got.post, 'function')
+strictEqual(typeof got.stream, 'function')
+strictEqual(typeof got.extend, 'function')
+
+strictEqual(Options, 'nothing')

package/test/hook/v18.19-openai.mjs

@@ -0,0 +1,16 @@
+import OpenAI from 'openai'
+import Hook from '../../index.js'
+
+Hook((exports, name) => {
+  if (name === 'openai') {
+    console.assert(name, exports)
+  }
+})
+
+console.assert(OpenAI)
+
+const openAI = new OpenAI({
+  apiKey: 'doesnt-matter'
+})
+
+console.assert(openAI)

package/test/hook/v18.19-static-import-gotalike.mjs

@@ -3,10 +3,8 @@ import Hook from '../../index.js'
 Hook((exports, name) => {
   if (/got-alike\.mjs/.test(name) === false) return
 
-  const bar = exports.something
-  exports.something = function barWrapped () {
-    return bar() + '-wrapped'
-  }
+  const foo = exports.foo
+  exports.foo = foo + '-wrapped'
 
   const renamedDefaultExport = exports.renamedDefaultExport
   exports.renamedDefaultExport = function bazWrapped () {
@@ -15,21 +13,14 @@ Hook((exports, name) => {
 })
 
 /* eslint-disable import/no-named-default */
-/* eslint-disable camelcase */
 import {
   default as Got,
-  something,
-  defaultClass as DefaultClass,
-  snake_case,
+  foo,
   renamedDefaultExport
 } from '../fixtures/got-alike.mjs'
 
-strictEqual(something(), '42-wrapped')
+strictEqual(foo, '42-wrapped')
 const got = new Got()
 strictEqual(got.foo, 'foo')
 
-const dc = new DefaultClass()
-strictEqual(dc.value, 'DefaultClass')
-
-strictEqual(snake_case, 'snake_case')
 strictEqual(renamedDefaultExport(), 'baz-wrapped')

package/test/hook/v20.10-static-import-attributes.mjs

@@ -0,0 +1,17 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2.0 License.
+//
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc.
+
+import jsonMjs from '../fixtures/json-attributes.mjs'
+import { strictEqual } from 'assert'
+
+// Acorn does not support import attributes so an error is logged but the import
+// still works!
+//
+// Hook((exports, name) => {
+//   if (name.match(/json\.mjs/)) {
+//     exports.default.data += '-dawg'
+//   }
+// })
+
+strictEqual(jsonMjs.data, 'dog')

package/test/multiple-loaders/multiple-loaders.test.mjs

@@ -0,0 +1,6 @@
+import { register } from 'node:module'
+
+register('./typescript-loader.mjs', import.meta.url)
+register('../../hook.mjs', import.meta.url)
+
+await import('node:util')

package/test/multiple-loaders/typescript-loader.mjs

@@ -0,0 +1,26 @@
+/**
+ * This simulates what something like `tsx` (https://github.com/privatenumber/tsx)
+ * will do: it will try to resolve a URL with a `.js` extension to a `.ts` extension.
+ *
+ * Combined with the test case in the adjacent `multiple-loaders.test.mjs` file,
+ * this forces `import-in-the-middle` into what used to be a failure state: where
+ * `context.parentURL` is a `node:*` specifier and the `specifier` refers to a file
+ * that does not exist.
+ *
+ * See https://github.com/nodejs/node/issues/52987 for more details.
+ */
+export async function resolve (specifier, context, defaultResolve) {
+  if (!specifier.endsWith('.js') && !specifier.endsWith('.mjs')) {
+    return await defaultResolve(specifier, context)
+  }
+
+  try {
+    return await defaultResolve(specifier.replace(/\.m?js/, '.ts'), context)
+  } catch (err) {
+    if (err.code !== 'ERR_MODULE_NOT_FOUND') {
+      throw err
+    }
+
+    return await defaultResolve(specifier, context)
+  }
+}

package/test/other/v20.10-import-executable.mjs

@@ -0,0 +1,8 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2.0 License.
+//
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc.
+
+(async () => {
+  const lib = await import('../fixtures/executable')
+  console.assert(lib)
+})()

package/test/typescript/ts-node.test.mts

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict'
-import { addHook } from '../../index.js'
+import defaultHook, { Hook, addHook } from '../../index.js'
 import { sayHi } from '../fixtures/say-hi.mjs'
 
 addHook((url, exported) => {
@@ -8,4 +8,12 @@ addHook((url, exported) => {
   }
 })
 
-assert.equal(sayHi('test'), 'Hooked')
+new defaultHook((exported: any, name: string, baseDir: string|void)  => {
+
+});
+
+new Hook((exported: any, name: string, baseDir: string|void)  => {
+
+});
+
+assert.equal(sayHi('test'), 'Hooked')

package/test/version-check.js

@@ -12,10 +12,11 @@ process.env.IITM_TEST_FILE = filename
 
 const [processMajor, processMinor] = process.versions.node.split('.').map(Number)
 
-const match = filename.match(/v([0-9]+)(?:\.([0-9]+))?/)
+const match = filename.match(/v([0-9]+)(?:\.([0-9]+))?(?:-v([0-9]+))?/)
 
 const majorRequirement = match ? match[1] : 0
 const minorRequirement = match && match[2]
+const majorMax = match ? match[3] : Infinity
 
 if (processMajor < majorRequirement) {
   console.log(`skipping ${filename} as this is Node.js v${processMajor} and test wants v${majorRequirement}`)
@@ -25,3 +26,8 @@ if (processMajor <= majorRequirement && processMinor < minorRequirement) {
   console.log(`skipping ${filename} as this is Node.js v${processMajor}.${processMinor} and test wants >=v${majorRequirement}.${minorRequirement}`)
   process.exit(0)
 }
+
+if (processMajor > majorMax) {
+  console.log(`skipping ${filename} as this is Node.js v${processMajor} and test wants <=v${majorMax}`)
+  process.exit(0)
+}

package/fix.patch

@@ -1,52 +0,0 @@
-From 5a9ae09d53e43a30709c7162fb351f3a57626f79 Mon Sep 17 00:00:00 2001
-From: Bryan English <bryan.english@datadoghq.com>
-Date: Fri, 21 Jul 2023 11:50:34 -0400
-Subject: [PATCH] sanitize URLs
-
----
- hook.js                          |  4 ++--
- test/low-level/sanitized-url.mjs | 11 +++++++++++
- 2 files changed, 13 insertions(+), 2 deletions(-)
- create mode 100644 test/low-level/sanitized-url.mjs
-
-diff --git a/hook.js b/hook.js
-index 884ee3a..3639fbf 100644
---- a/hook.js
-+++ b/hook.js
-@@ -122,7 +122,7 @@ function createHook (meta) {
-       return {
-         source: `
- import { register } from '${iitmURL}'
--import * as namespace from '${url}'
-+import * as namespace from ${JSON.stringify(url)}
- const set = {}
- ${exportNames.map((n) => `
- let $${n} = namespace.${n}
-@@ -132,7 +132,7 @@ set.${n} = (v) => {
-   return true
- }
- `).join('\n')}
--register('${realUrl}', namespace, set, '${specifiers.get(realUrl)}')
-+register(${JSON.stringify(realUrl)}, namespace, set, ${JSON.stringify(specifiers.get(realUrl))})
- `
-       }
-     }
-diff --git a/test/low-level/sanitized-url.mjs b/test/low-level/sanitized-url.mjs
-new file mode 100644
-index 0000000..6fe5e81
---- /dev/null
-+++ b/test/low-level/sanitized-url.mjs
-@@ -0,0 +1,11 @@
-+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2.0 License.
-+//
-+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc.
-+
-+import { addHook } from '../../index.js'
-+
-+addHook(() => {})
-+
-+;(async () => {
-+  await import("../fixtures/something.mjs#*/'/*';eval('process.exit\x281\x29\x0A')")
-+})()
--- 
-2.39.0

package/test/fixtures/default-class.mjs

@@ -1,3 +0,0 @@
-export default class DefaultClass {
-  value = 'DefaultClass'
-}

package/test/fixtures/snake_case.mjs

@@ -1,2 +0,0 @@
-const snakeCase = 'snake_case'
-export default snakeCase

package/test/other/import-executable.mjs

@@ -1,19 +0,0 @@
-// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2.0 License.
-//
-// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc.
-
-import { rejects } from 'assert'
-(async () => {
-  const [processMajor, processMinor] = process.versions.node.split('.').map(Number)
-  const extensionlessSupported = processMajor >= 21 ||
-    (processMajor === 20 && processMinor >= 10) ||
-    (processMajor === 18 && processMinor >= 19)
-  if (extensionlessSupported) {
-    // Files without extension are supported in Node.js ^21, ^20.10.0, and ^18.19.0
-    return
-  }
-  await rejects(() => import('./executable'), {
-    name: 'TypeError',
-    code: 'ERR_UNKNOWN_FILE_EXTENSION'
-  })
-})()