@openclaw/diagnostics-otel 2026.7.2-beta.7 → 2026.7.34

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/lib/get-esm-exports.mjs

@@ -1,151 +1,116 @@
 'use strict'
 
-import { readFileSync } from 'fs'
-import { createRequire, Module } from 'module'
-import { initSync, parse as parseWasm } from 'es-module-lexer'
+import { Parser } from 'acorn'
+import { importAttributesOrAssertions } from 'acorn-import-attributes'
 
-const require = createRequire(import.meta.url)
-
-// The default es-module-lexer build is WebAssembly backed and decodes string
-// literals (import specifiers, quoted export names) with an internal `eval`.
-// Under `--disallow-code-generation-from-strings` that `eval` silently no-ops,
-// so specifiers and quoted names come back undecoded (`* from undefined`,
-// `"string name"` with the quotes still attached). The eval-free asm.js build
-// (`es-module-lexer/js`) does the same work, so fall back to it when code
-// generation from strings is disallowed. Resolve the parser once at load time
-// so the per-module path stays a bare `parse(source)` call.
-const flag = '--disallow-code-generation-from-strings'
-// Node.js versions with broken maglev compiler
-const hasBrokenMaglev = process.version.startsWith('v20.') &&
-  process.version[5] === '.' &&
-  Number(process.version[4]) < 9
-const disallowCodegen = process.execArgv.includes(flag) ||
-  (process.env.NODE_OPTIONS?.includes(flag) ?? false) ||
-  hasBrokenMaglev
-
-// initSync compiles the Wasm module up front so `parse` can run inside
-// synchronous loader hooks (`module.registerHooks`) as well as the off-thread
-// loader; it is a one-time cost on the first ESM module either way. It stays the
-// default and remains callable even under the flag, so a parse before the asm.js
-// swap still works (with the flag's known specifier-decoding limitation) rather
-// than throwing.
-initSync()
-
-let parse = parseWasm
-
-if (disallowCodegen) {
-  parse = loadAsmParse()
+const acornOpts = {
+  ecmaVersion: 'latest',
+  sourceType: 'module'
 }
 
-/**
- * Loads the eval-free asm.js parser synchronously, on every Node version.
- *
- * The asm.js build (`es-module-lexer/js`) is ESM-only with no CommonJS variant,
- * and its only export is a top-level `parse` (no async wasm `init` to await).
- * `require`-ing it is not portable: before require(esm) (Node < 20.19 / < 22.12)
- * it throws `ERR_REQUIRE_ESM`, and `import()`-ing it from inside a loader hook
- * deadlocks the loader on itself. Compiling the source as CommonJS sidesteps
- * both: it runs synchronously, keeps this module require()-able for the
- * synchronous `module.registerHooks` path, and never re-enters the ESM loader.
- *
- * `Module._compile` uses V8's script compiler, not `eval`, so it is unaffected
- * by `--disallow-code-generation-from-strings` — the same reason the asm.js
- * build itself decodes specifiers under the flag. The only export is rewritten
- * to a CommonJS one; the source is a vendored build we control.
- *
- * @returns {typeof parseWasm} The asm.js parse function.
- */
-function loadAsmParse () {
-  const asmPath = require.resolve('es-module-lexer/js')
-  const source = readFileSync(asmPath, 'utf8')
-    .replace('export function parse', 'function parse') +
-    '\nmodule.exports = { parse }\n'
-  const mod = new Module(asmPath)
-  mod.filename = asmPath
-  mod._compile(source, asmPath)
-  return mod.exports.parse
-}
+const parser = Parser.extend(importAttributesOrAssertions)
 
-/**
- * Decodes an exported identifier the way the JS engine would. es-module-lexer
- * leaves Unicode escapes in bare identifier exports (`export const \u0061 = 1`)
- * as their raw spelling, while the module namespace exposes the cooked name
- * (`a`). Quoted export names are already decoded by the lexer and start with a
- * quote in the source, so the cheap quote check keeps them on the fast path;
- * only a bare identifier carrying a backslash needs cooking. A malformed escape
- * falls back to the raw name rather than throwing inside the loader.
- *
- * @param {string} name The export name as reported by the lexer.
- * @returns {string} The cooked export name.
- */
-function decodeExportName (name) {
-  const first = name.charCodeAt(0)
-  if (first === 0x22 /* " */ || first === 0x27 /* ' */ || !name.includes('\\')) {
-    return name
-  }
-  try {
-    return JSON.parse(`"${name}"`)
-  } catch {
-    return name
-  }
+function warn (txt) {
+  process.emitWarning(txt, 'get-esm-exports')
 }
 
-// es-module-lexer reports a bare `export * from <mod>` only as an import with no
-// matching export entry, indistinguishable from `import <mod>` except by the
-// statement text. This matches that text to rewrite it as the transitive
-// `* from <specifier>` marker the interpreting code recognizes. `export * as ns
-// from` binds a real name and is reported as a normal export, so it must not
-// match here. `GAP` allows whitespace and comments between the tokens, the way
-// the parser does (e.g. `export /* c */ * from`).
-const GAP = '(?:\\s|/\\*[^]*?\\*/|//[^\\n]*\\n)*'
-const STAR_REEXPORT = new RegExp(`^export${GAP}\\*${GAP}from`)
-
 /**
- * Lexes ESM source code with es-module-lexer and builds a list of exported
- * identifiers. In the baseline case the list is the simple identifier names as
- * written in the source. There is one special case:
+ * 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 is a special case:
+ *
+ * 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.
  *
- * When an `export * from './foo.js'` line is encountered it is rewritten as
- * `* from ./foo.js`. This lets the interpreting code recognize a transitive
- * export and recursively parse the indicated module. The returned identifier
- * list will have "* from ./foo.js" as an item.
+ * @param {object} params
+ * @param {string} params.moduleSource The source code of the module to parse
+ * and interpret.
  *
- * @param {string} moduleSource The source code of the module to lex.
  * @returns {Set<string>} The identifiers exported by the module along with any
  * custom directives.
  */
 export default function getEsmExports (moduleSource) {
-  return lexEsm(moduleSource).exportNames
+  const exportedNames = new Set()
+  const tree = parser.parse(moduleSource, acornOpts)
+  for (const node of tree.body) {
+    if (!node.type.startsWith('Export')) continue
+    switch (node.type) {
+      case 'ExportNamedDeclaration':
+        if (node.declaration) {
+          parseDeclaration(node, exportedNames)
+        } else {
+          parseSpecifiers(node, exportedNames)
+        }
+        break
+
+      case 'ExportDefaultDeclaration': {
+        exportedNames.add('default')
+        break
+      }
+
+      case 'ExportAllDeclaration':
+        if (node.exported) {
+          exportedNames.add(node.exported.name)
+        } else {
+          exportedNames.add(`* from ${node.source.value}`)
+        }
+        break
+      default:
+        warn('unrecognized export type: ' + node.type)
+    }
+  }
+  return exportedNames
 }
 
-/**
- * Lexes ESM source code once and reports both the exported identifiers and
- * whether the source uses ESM syntax. Sharing a single `parse` lets the
- * unknown-format path in `getExports` decide between ESM and CommonJS without a
- * second pass over the source.
- *
- * `hasModuleSyntax` is es-module-lexer's own signal: static `import`/`export`
- * and `import.meta` set it, while a lone dynamic `import(...)` (valid in CJS)
- * does not.
- *
- * @param {string} moduleSource The source code of the module to lex.
- * @returns {{ exportNames: Set<string>, hasModuleSyntax: boolean }}
- */
-export function lexEsm (moduleSource) {
-  const exportNames = new Set()
-  const [imports, exports, , hasModuleSyntax] = parse(moduleSource)
+function parseDeclaration (node, exportedNames) {
+  switch (node.declaration.type) {
+    case 'FunctionDeclaration':
+      exportedNames.add(node.declaration.id.name)
+      break
+    case 'VariableDeclaration':
+      for (const varDecl of node.declaration.declarations) {
+        parseVariableDeclaration(varDecl, exportedNames)
+      }
+      break
+    case 'ClassDeclaration':
+      exportedNames.add(node.declaration.id.name)
+      break
+    default:
+      warn('unknown declaration type: ' + node.delcaration.type)
+  }
+}
 
-  for (const exported of exports) {
-    exportNames.add(decodeExportName(exported.n))
+function parseVariableDeclaration (node, exportedNames) {
+  switch (node.id.type) {
+    case 'Identifier':
+      exportedNames.add(node.id.name)
+      break
+    case 'ObjectPattern':
+      for (const prop of node.id.properties) {
+        exportedNames.add(prop.value.name)
+      }
+      break
+    case 'ArrayPattern':
+      for (const elem of node.id.elements) {
+        exportedNames.add(elem.name)
+      }
+      break
+    default:
+      warn('unknown variable declaration type: ' + node.id.type)
   }
+}
 
-  // Bare `export * from <mod>` re-exports report no export name; reconstruct
-  // the transitive marker from the import statement that carries the specifier.
-  for (const imported of imports) {
-    if (STAR_REEXPORT.test(moduleSource.slice(imported.ss, imported.se))) {
-      exportNames.add(`* from ${imported.n}`)
+function parseSpecifiers (node, exportedNames) {
+  for (const specifier of node.specifiers) {
+    if (specifier.exported.type === 'Identifier') {
+      exportedNames.add(specifier.exported.name)
+    } else if (specifier.exported.type === 'Literal') {
+      exportedNames.add(specifier.exported.value)
+    } else {
+      warn('unrecognized specifier type: ' + specifier.exported.type)
     }
   }
-
-  return { exportNames, hasModuleSyntax }
 }

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/lib/get-exports.mjs

@@ -1,6 +1,6 @@
 'use strict'
 
-import { lexEsm } from './get-esm-exports.mjs'
+import getEsmExports from './get-esm-exports.mjs'
 import { parse as parseCjs, initSync } from 'cjs-module-lexer'
 import { readFileSync, existsSync } from 'fs'
 import { builtinModules, createRequire } from 'module'
@@ -11,11 +11,6 @@ import { LOAD } from './io.mjs'
 const nodeMajor = Number(process.versions.node.split('.')[0])
 export const hasModuleExportsCJSDefault = nodeMajor >= 23
 
-// Resolve `stripTypeScriptTypes` (Node >= 22.13) via `getBuiltinModule` rather
-// than a static named import (throws on older runtimes) or `require` (re-enters
-// iitm's own loader hooks). `undefined` on runtimes that lack it.
-const stripTypeScriptTypes = process.getBuiltinModule?.('module')?.stripTypeScriptTypes
-
 let parserInitialized = false
 
 // The CJS export scanner is backed by WebAssembly. `initSync` compiles it
@@ -33,6 +28,127 @@ function addDefault (arr) {
   return new Set(['default', ...arr])
 }
 
+function hasEsmSyntax (source) {
+  // Lightweight scan (no full parse) to determine if the *source code*
+  // contains ESM-specific syntax. This is used only when:
+  // - the loader chain didn't tell us a `format`, and
+  // - `getEsmExports()` found no exports.
+  //
+  // Notes:
+  // - We ignore comments and strings to reduce false positives.
+  // - We treat `import.meta` and static `import ...` as ESM.
+  // - We do NOT treat `import(` (dynamic import) as ESM because it is allowed
+  //   in CJS as an expression.
+  if (source.indexOf('import') === -1) return false
+
+  const isIdentCharCode = (code) => (
+    (code >= 48 && code <= 57) || // 0-9
+    (code >= 65 && code <= 90) || // A-Z
+    (code >= 97 && code <= 122) || // a-z
+    code === 95 || // _
+    code === 36 // $
+  )
+
+  const skipWhitespace = (idx) => {
+    while (idx < source.length) {
+      const c = source.charCodeAt(idx)
+      // space, tab, cr, lf
+      if (c !== 32 && c !== 9 && c !== 13 && c !== 10) break
+      idx++
+    }
+    return idx
+  }
+
+  let i = 0
+  while (i < source.length) {
+    const ch = source[i]
+
+    // Line comment
+    if (ch === '/' && source[i + 1] === '/') {
+      i += 2
+      while (i < source.length && source[i] !== '\n') i++
+      continue
+    }
+
+    // Block comment
+    if (ch === '/' && source[i + 1] === '*') {
+      i += 2
+      while (i < source.length && !(source[i] === '*' && source[i + 1] === '/')) i++
+      i += 2
+      continue
+    }
+
+    // Strings: '...' or "..."
+    if (ch === '\'' || ch === '"') {
+      const quote = ch
+      i++
+      while (i < source.length) {
+        const c = source[i]
+        if (c === '\\') {
+          i += 2
+          continue
+        }
+        if (c === quote) {
+          i++
+          break
+        }
+        i++
+      }
+      continue
+    }
+
+    // Template strings: `...`
+    if (ch === '`') {
+      i++
+      while (i < source.length) {
+        const c = source[i]
+        if (c === '\\') {
+          i += 2
+          continue
+        }
+        if (c === '`') {
+          i++
+          break
+        }
+        i++
+      }
+      continue
+    }
+
+    // Keyword scan (word-boundary): import
+    if (ch === 'i') {
+      const prev = source.charCodeAt(i - 1)
+      if (i > 0 && isIdentCharCode(prev)) {
+        i++
+        continue
+      }
+
+      if (source.startsWith('import', i)) {
+        const next = source.charCodeAt(i + 6)
+        if (isIdentCharCode(next)) {
+          i++
+          continue
+        }
+
+        const j = skipWhitespace(i + 6)
+        // `import.meta` is ESM-only
+        if (source[j] === '.') return true
+        // `import(` is dynamic import, allowed in CJS
+        if (source[j] === '(') {
+          i = j + 1
+          continue
+        }
+        // Otherwise assume it's a static import form
+        return true
+      }
+    }
+
+    i++
+  }
+
+  return false
+}
+
 // Cached exports for Node built-in modules
 const BUILT_INS = new Map()
 
@@ -73,24 +189,6 @@ function getExportsForNodeBuiltIn (name) {
 
 const urlsBeingProcessed = new Set() // Guard against circular imports.
 
-// Memoizes an ESM module's export names by URL. A leaf reached from several
-// barrels (`export *`) would otherwise be read and lexed once per barrel, and
-// the same URL reached from separate top-level wraps would be lexed once per
-// wrap; the first lex serves every later one.
-//
-// This assumes a module's export names are stable for the process: the memo
-// serves a later, independent scan without re-running the loader chain's
-// `load()`, so a loader that returns a *different export set* for the same URL
-// across calls (a stateful codegen loader, or one keyed off `context`) is a
-// deliberately unsupported case — it would be served the first scan's names.
-// Idempotent transforms (type stripping, AST instrumentation such as
-// OrchestrionJS, minifiers) are stable and unaffected; the wrapper's real
-// namespace `load()` still runs every time, so per-load source differences in
-// the *executed* module are preserved (see the wrapper's `import * as
-// namespace`). Only the pure ESM result is cached: the CommonJS path mutates
-// `context.format` and resolves re-exports, and builtins memoize via BUILT_INS.
-const esmExportsCache = new Map()
-
 /**
  * This function looks for the package.json which contains the specifier trying to resolve.
  * Once the package.json file has been found, we extract the file path from the specifier
@@ -230,11 +328,6 @@ function * getCjsExports (url, context, source) {
  * be included in the result set.
  */
 export function * getExports (url, context) {
-  const cached = esmExportsCache.get(url)
-  if (cached !== undefined) {
-    return cached.exportNames
-  }
-
   // `[LOAD, ...]` 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.
@@ -269,38 +362,28 @@ export function * getExports (url, context) {
   }
 
   try {
-    // Node hands the load hook the original TypeScript source, so strip the
-    // types before the JS parsers run, then treat the module as the JS it
-    // compiles to. Early type-stripping releases tag the format but lack the
-    // API; the un-stripped parse then fails cleanly into onWrapFailure.
-    let moduleFormat = format
-    if (format === 'module-typescript' || format === 'commonjs-typescript') {
-      if (stripTypeScriptTypes !== undefined) {
-        source = stripTypeScriptTypes(source, { mode: 'strip' })
-      }
-      moduleFormat = format === 'module-typescript' ? 'module' : 'commonjs'
+    if (format === 'module') {
+      return getEsmExports(source)
     }
 
-    if (moduleFormat === 'commonjs') {
+    if (format === 'commonjs') {
       return yield * getCjsExports(url, context, source)
     }
 
-    const { exportNames, hasModuleSyntax } = lexEsm(source)
-
-    if (moduleFormat === 'module') {
-      esmExportsCache.set(url, { exportNames })
-      return exportNames
-    }
-
-    // At this point our `format` is either undefined or not known by us. When
-    // there are no exports and no ESM syntax, fall back to CommonJS detection.
-    // Strong evidence of ESM (static import/import.meta) keeps the empty ESM
-    // export set rather than incorrectly treating the module as CJS.
-    if (!exportNames.size && !hasModuleSyntax) {
-      return yield * getCjsExports(url, context, source)
+    // At this point our `format` is either undefined or not known by us. Fall
+    // back to parsing as ESM/CJS.
+    const esmExports = getEsmExports(source)
+    if (!esmExports.size) {
+      // If there's strong evidence this is ESM (static import/import.meta),
+      // prefer returning the empty ESM export set over incorrectly treating it
+      // as CJS.
+      if (!hasEsmSyntax(source)) {
+        // It might be possible to get here if the format
+        // isn't set at first and yet we have an ESM module with no exports.
+        return yield * getCjsExports(url, context, source)
+      }
     }
-    esmExportsCache.set(url, { exportNames })
-    return exportNames
+    return esmExports
   } catch (cause) {
     const err = new Error(`Failed to parse '${url}'`)
     err.cause = cause

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/lib/register.js

@@ -55,143 +55,7 @@ function register (name, namespace, set, get, specifier) {
   toHook.push([name, proxy, specifier])
 }
 
-// Delays (ms) for re-reading exports that were still in their temporal dead zone
-// when the wrapper first ran (circular imports). Retried on a microtask first,
-// then at these intervals; unref'd so best-effort retries never hold the process
-// open. Frozen once at module load rather than rebuilt per wrapper.
-const RETRY_DELAYS = [0, 10, 50]
-
-/**
- * Per-wrapped-module state a generated wrapper builds once to expose its exports
- * through iitm's proxy. Each wrapper holds a local binding per export plus
- * `write`/`read` closures over it; `bind` seeds that binding from the real
- * module and installs the proxy's `set`/`get` for the name, and `flush` resolves
- * any export that was undefined (circular import) once it becomes available.
- *
- * This is the boilerplate the wrapper used to inline in full per module. Hoisting
- * it here compiles it once instead of once per wrapped module and keeps the
- * per-export bind call site monomorphic.
- */
-class ModuleBinder {
-  // Mimics a Module namespace object (https://tc39.es/ecma262/#sec-module-namespace-objects).
-  namespace = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } })
-  set = {}
-  get = {}
-  #overridden = Object.create(null)
-  #pending = []
-
-  /**
-   * Seeds `key` from `source` and installs its proxy accessors. A value that is
-   * undefined or throws `ReferenceError` (temporal dead zone during a circular
-   * import) is deferred to `flush`; any other throw propagates.
-   *
-   * @param {string} key The export name.
-   * @param {object} source The real module namespace to read the value from.
-   * @param {(value: unknown) => void} write Assigns the wrapper's local binding.
-   * @param {() => unknown} read Reads the wrapper's local binding.
-   * @param {boolean} useFallback Fall back to `source.default` (the synthetic
-   * `module.exports` name a builtin does not expose on its ESM namespace).
-   * @returns {void}
-   */
-  bind (key, source, write, read, useFallback) {
-    const readSource = useFallback
-      ? () => source[key] ?? source.default
-      : () => source[key]
-    this.#overridden[key] = false
-    let deferred = false
-    try {
-      const value = readSource()
-      write(value)
-      this.namespace[key] = value
-    } catch (error) {
-      if (!(error instanceof ReferenceError)) throw error
-      deferred = true
-    }
-    if (deferred || read() === undefined) {
-      this.#pending.push(this.#makeUpdater(key, readSource, write))
-    }
-    this.set[key] = (value) => {
-      this.#overridden[key] = true
-      write(value)
-      return true
-    }
-    this.get[key] = read
-  }
-
-  /**
-   * @param {string} key The export name to update.
-   * @param {() => unknown} readSource Reads the current value from the real module.
-   * @param {(value: unknown) => void} write Assigns the wrapper's local binding.
-   * @returns {() => boolean} Updater returning whether the value is now settled.
-   */
-  #makeUpdater (key, readSource, write) {
-    return () => {
-      if (this.#overridden[key] === true) return true
-      try {
-        const value = readSource()
-        if (value !== undefined) {
-          write(value)
-          this.namespace[key] = value
-          return true
-        }
-        return false
-      } catch (error) {
-        if (error instanceof ReferenceError) return false
-        // Only reached if a getter starts throwing a non-ReferenceError after the
-        // initial bind read already succeeded or deferred; surfaces in flush's
-        // microtask. Kept as-is from the inline wrapper.
-        /* c8 ignore next */
-        throw error
-      }
-    }
-  }
-
-  #flushOnce () {
-    const next = []
-    for (const updater of this.#pending) {
-      // If it still throws ReferenceError, keep it for the (single) next attempt.
-      if (updater() !== true) next.push(updater)
-    }
-    this.#pending = next
-  }
-
-  /**
-   * Resolves exports deferred by `bind` (undefined or TDZ at wrapper-eval time).
-   * Retries on a microtask, then at `RETRY_DELAYS`, giving up afterwards to avoid
-   * unbounded retries. A no-op when nothing was deferred.
-   *
-   * @returns {void}
-   */
-  flush () {
-    if (this.#pending.length === 0) return
-    queueMicrotask(() => {
-      this.#flushOnce()
-      this.#scheduleRetry(0)
-    })
-  }
-
-  /**
-   * @param {number} attempt Index into `RETRY_DELAYS` for the next retry.
-   * @returns {void}
-   */
-  #scheduleRetry (attempt) {
-    if (this.#pending.length === 0) return
-    if (attempt >= RETRY_DELAYS.length) {
-      // Give up: leave exports as-is to avoid unbounded retries.
-      this.#pending = []
-      return
-    }
-    const timer = setTimeout(() => {
-      this.#flushOnce()
-      this.#scheduleRetry(attempt + 1)
-    }, RETRY_DELAYS[attempt])
-    // Don't keep the process alive just for best-effort retries.
-    if (timer && typeof timer.unref === 'function') timer.unref()
-  }
-}
-
 exports.register = register
-exports.ModuleBinder = ModuleBinder
 exports.importHooks = importHooks
 exports.specifiers = specifiers
 exports.toHook = toHook

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/package.json

@@ -1,6 +1,6 @@
 {
   "name": "import-in-the-middle",
-  "version": "3.3.2",
+  "version": "3.2.0",
   "description": "Intercept imports in Node.js",
   "engines": {
     "node": ">=18"
@@ -59,8 +59,9 @@
     "vue": "^3.5.26"
   },
   "dependencies": {
+    "acorn": "^8.15.0",
+    "acorn-import-attributes": "^1.9.5",
     "cjs-module-lexer": "^2.2.0",
-    "es-module-lexer": "^2.2.0",
     "module-details-from-path": "^1.0.4"
   }
 }

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/register-hooks.d.ts

@@ -17,8 +17,7 @@ export type RegisterHooksOptions = {
  * synchronous hooks run on the application thread, so `Hook()` registrations are
  * visible to the loader directly and no acknowledgement step is required.
  *
- * Requires a Node.js version where {@link supportsSyncHooks} is `true`
- * (>= 22.22.3, >= 24.11.1, >= 25.1.0, or >= 26.0.0).
+ * Requires a Node.js version with `module.registerHooks()` (>= 22.15.0 / >= 24).
  *
  * ```ts
  * import { register } from 'import-in-the-middle/register-hooks.mjs'
@@ -31,14 +30,6 @@ export type RegisterHooksOptions = {
  * })
  * ```
  *
- * @throws If {@link supportsSyncHooks} is `false` in the running Node.js.
+ * @throws If `module.registerHooks()` is unavailable in the running Node.js.
  */
 export declare function register(options?: RegisterHooksOptions): void
-
-/**
- * Whether the running Node.js can correctly run the synchronous loader via
- * `module.registerHooks()`. `false` on versions that ship `module.registerHooks()`
- * but predate the nullish-CommonJS-`source` fix (nodejs/node#59929); branch on it
- * to fall back to the asynchronous `module.register()` loader.
- */
-export declare function supportsSyncHooks(): boolean

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/register-hooks.mjs

@@ -1,6 +1,5 @@
 import * as module from 'module'
-import { createHook } from './create-hook.mjs'
-import { supportsSyncHooks } from './supports-sync-hooks.mjs'
+import { createHook, supportsSyncHooks } from './create-hook.mjs'
 
 export { supportsSyncHooks }