import-in-the-middle 1.7.3 → 1.8.0

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,94 @@ 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 duplicates = new Set()
   const setters = new Map()
 
+  const addSetter = (name, setter) => {
+    // When doing an `import *` duplicates become undefined, so do the same
+    if (setters.has(name)) {
+      duplicates.add(name)
+      setters.delete(name)
+    } else if (!duplicates.has(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
+        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)
       }
-
-      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 +188,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 +225,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,63 +243,28 @@ 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({
+      const setters = await processModule({
         srcUrl: realUrl,
         context,
-        parentGetSource
+        parentGetSource,
+        parentResolve: cachedResolve
       })
-      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`
-        })
-        .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: `
 import { register } from '${iitmURL}'
-${imports.join('\n')}
+import * as namespace from ${JSON.stringify(realUrl)}
 
-const namespaces = [${namespaces.join(', ')}]
-const _ = {}
+// Mimic a Module object (https://tc39.es/ecma262/#sec-module-namespace-objects).
+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))})
 `

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const { Parser } = require('acorn')
-const { importAssertions } = require('acorn-import-assertions')
+const { importAssertions } = require('acorn-import-attributes')
 
 const acornOpts = {
   ecmaVersion: 'latest',
@@ -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
  * 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
       }
 

package/lib/get-exports.js

@@ -20,13 +20,13 @@ async function getFullCjsExports (url, context, parentLoad, source) {
   const ex = getCjsExports(source)
   const full = Array.from(new Set([
     ...addDefault(ex.exports),
-    ...(await Promise.all(ex.reexports.map(re => getExports(({
-      url: (/^(..?($|\/|\\))/).test(re)
+    ...(await Promise.all(ex.reexports.map(re => getExports(
+      (/^(..?($|\/|\\))/).test(re)
         ? pathToFileURL(require.resolve(fileURLToPath(new URL(re, url)))).toString()
         : pathToFileURL(require.resolve(re)).toString(),
       context,
       parentLoad
-    }))))).flat()
+    )))).flat()
   ]))
 
   urlsBeingProcessed.delete(url)
@@ -38,25 +38,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.
  * 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.
@@ -77,7 +70,7 @@ async function getExports ({ url, context, parentLoad, defaultAs = 'default' })
   }
 
   if (format === 'module') {
-    return getEsmExports({ moduleSource: source, defaultAs })
+    return getEsmExports(source)
   }
   if (format === 'commonjs') {
     return getFullCjsExports(url, context, parentLoad, source)
@@ -85,7 +78,7 @@ async function getExports ({ url, context, parentLoad, defaultAs = 'default' })
 
   // 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "import-in-the-middle",
-  "version": "1.7.3",
+  "version": "1.8.0",
   "description": "Intercept imports in Node.js",
   "main": "index.js",
   "scripts": {
@@ -36,21 +36,25 @@
     "@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"
   },
   "dependencies": {
     "acorn": "^8.8.2",
-    "acorn-import-assertions": "^1.9.0",
+    "acorn-import-attributes": "^1.9.5",
     "cjs-module-lexer": "^1.2.2",
     "module-details-from-path": "^1.0.3"
   }

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 = 'a'

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/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 = 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.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(exports.foo, undefined)
+    // default should be exported
+    strictEqual(exports.default, 'foo')
+  }
+})
+
+notEqual(lib, undefined)
+
+// foo should not be exported because there are duplicate exports
+strictEqual(lib.foo, undefined)
+// 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/module-toStringTag.mjs

@@ -0,0 +1,25 @@
+// 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 Hook from '../../index.js'
+import { foo as fooMjs } from '../fixtures/something.mjs'
+import { foo as fooJs } from '../fixtures/something.js'
+import { strictEqual, deepStrictEqual } from 'assert'
+
+let hookedExports
+
+Hook((exports, name) => {
+  hookedExports = exports
+})
+
+strictEqual(fooMjs, 42)
+strictEqual(fooJs, 42)
+
+strictEqual(hookedExports[Symbol.toStringTag], 'Module')
+deepStrictEqual(Object.getOwnPropertyDescriptor(hookedExports, Symbol.toStringTag), {
+  value: 'Module',
+  enumerable: false,
+  writable: false,
+  configurable: false
+})

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,10 @@
+import OpenAI from 'openai'
+import Hook from '../../index.js'
+
+Hook((exports, name) => {
+  if (name === 'openai') {
+    console.assert(name, exports)
+  }
+})
+
+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/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/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/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