@datadog/esbuild-plugin 2.3.1-dev-9 → 2.3.1-dev-12

package/dist/src/index.mjs

@@ -7,9 +7,9 @@ import { lstat, readdir as readdir$1, readlink, realpath } from 'node:fs/promise
 import { EventEmitter as EventEmitter$1 } from 'node:events';
 import Stream$1 from 'node:stream';
 import { StringDecoder } from 'node:string_decoder';
-import require$$1, { resolve as resolve$1, extname, isAbsolute, normalize as normalize$1 } from 'path';
+import path$i, { resolve as resolve$1, extname, isAbsolute, normalize as normalize$1 } from 'path';
 import require$$0$1 from 'tty';
-import require$$1$1 from 'util';
+import require$$1 from 'util';
 import { spawn } from 'child_process';
 import { URL as URL$1, fileURLToPath as fileURLToPath$1 } from 'url';
 import { readFile as readFile$1 } from 'fs/promises';
@@ -21,6 +21,7 @@ import require$$5 from 'assert';
 import { performance as performance$1 } from 'perf_hooks';
 import * as querystring from 'querystring';
 import process2 from 'process';
+import esbuild from 'esbuild';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -2271,8 +2272,8 @@ var retry$2 = /*@__PURE__*/getDefaultExportFromCjs(lib$3);
 
 const PREPARATION_PLUGIN_NAME = "datadog-injection-preparation-plugin";
 const PLUGIN_NAME$4 = "datadog-injection-plugin";
-const RESOLUTION_PLUGIN_NAME = "datadog-injection-resolution-plugin";
-const INJECTED_FILE = "__DATADOG_INJECTION_STUB";
+const INJECTED_FILE = "__datadog-helper-file";
+const INJECTED_FILE_PATH = `${INJECTED_FILE}.js`;
 const DISTANT_FILE_RX = /^https?:\/\//;
 
 const formatDuration = (duration) => {
@@ -2283,7 +2284,7 @@ const formatDuration = (duration) => {
   const minutes = d.getUTCMinutes();
   const seconds = d.getUTCSeconds();
   const milliseconds = d.getUTCMilliseconds();
-  return `${days ? `${days}d ` : ""}${hours ? `${hours}h ` : ""}${minutes ? `${minutes}m ` : ""}${seconds ? `${seconds}s ` : ""}${milliseconds}ms`.trim();
+  return `${days ? `${days}d ` : ""}${hours ? `${hours}h ` : ""}${minutes ? `${minutes}m ` : ""}${seconds ? `${seconds}s ` : ""}${milliseconds ? `${milliseconds}ms` : ""}`.trim();
 };
 const getResolvedPath = (filepath) => {
   try {
@@ -2353,7 +2354,7 @@ const truncateString = (str, maxLength = 60, placeholder = "[...]") => {
   const rightStop = stringLength - leftStop;
   return `${str.slice(0, leftStop)}${placeholder}${str.slice(-rightStop)}`;
 };
-const isInjection = (filename) => filename.includes(INJECTED_FILE);
+const isInjectionFile = (filename) => filename.includes(INJECTED_FILE);
 
 var balancedMatch = balanced$1;
 function balanced$1(a, b, str) {
@@ -11309,18 +11310,13 @@ const cleanReport = (report, filepath, filter) => {
     const cleanedPath = cleanPath(reportFilepath);
     if (
       // Don't add injections.
-      isInjection(reportFilepath) || // Don't add itself into it.
+      isInjectionFile(reportFilepath) || // Don't add itself into it.
       cleanedPath === filepath || // Remove common specific files injected by bundlers.
       BUNDLER_SPECIFICS.includes(cleanedPath)
     ) {
       continue;
     }
-    if (filter) {
-      const filteredValue = filter(cleanedPath);
-      if (filteredValue) {
-        cleanedReport.add(filteredValue);
-      }
-    } else {
+    {
       cleanedReport.add(cleanedPath);
     }
   }
@@ -11330,16 +11326,16 @@ const cleanPath = (filepath) => {
   return filepath.split("!").pop().split(QUERY_RX).shift().replace(/^[^\w\s.,!@#$%^&*()=+~`\-/]+/, "");
 };
 const getAbsolutePath = (cwd, filepath) => {
-  if (isInjection(filepath)) {
+  if (isInjectionFile(filepath)) {
     return INJECTED_FILE;
   }
   if (filepath.startsWith(cwd)) {
     return filepath;
   }
-  return require$$1.resolve(cwd, filepath);
+  return path$i.resolve(cwd, filepath);
 };
 const cleanName = (context, filepath) => {
-  if (isInjection(filepath)) {
+  if (isInjectionFile(filepath)) {
     return INJECTED_FILE;
   }
   if (filepath === "unknown") {
@@ -11413,8 +11409,24 @@ const getEsbuildPlugin$2 = (context, log) => {
         const reportOutputsIndexed = {};
         const metaInputsIndexed = reIndexMeta(result.metafile.inputs, cwd);
         const metaOutputsIndexed = reIndexMeta(result.metafile.outputs, cwd);
+        const getRealPathFromInjectionProxy = (entryPoint) => {
+          if (!isInjectionFile(entryPoint)) {
+            return entryPoint;
+          }
+          const metaInput = metaInputsIndexed[getAbsolutePath(cwd, entryPoint)];
+          if (!metaInput) {
+            return entryPoint;
+          }
+          const actualImport = metaInput.imports.find(
+            (imp) => !isInjectionFile(imp.path)
+          );
+          if (!actualImport) {
+            return entryPoint;
+          }
+          return actualImport.path;
+        };
         for (const [filename, input] of Object.entries(result.metafile.inputs)) {
-          if (isInjection(filename)) {
+          if (isInjectionFile(filename)) {
             continue;
           }
           const filepath = getAbsolutePath(cwd, filename);
@@ -11435,7 +11447,7 @@ const getEsbuildPlugin$2 = (context, log) => {
           const cleanedName = cleanName(context, fullPath);
           const inputFiles = [];
           for (const inputName of Object.keys(output.inputs)) {
-            if (isInjection(inputName)) {
+            if (isInjectionFile(inputName)) {
               continue;
             }
             const inputFound = reportInputsIndexed[getAbsolutePath(cwd, inputName)];
@@ -11468,7 +11480,7 @@ const getEsbuildPlugin$2 = (context, log) => {
           if (!output.entryPoint) {
             continue;
           }
-          const inputFile = reportInputsIndexed[getAbsolutePath(cwd, output.entryPoint)];
+          const inputFile = reportInputsIndexed[getAbsolutePath(cwd, getRealPathFromInjectionProxy(output.entryPoint))];
           if (inputFile) {
             if (!entryNames.get(inputFile.name)) {
               continue;
@@ -11503,7 +11515,7 @@ const getEsbuildPlugin$2 = (context, log) => {
         };
         const FILE_EXCEPTIONS_RX = /(<runtime>|https:|file:|data:|#)/g;
         const isFileSupported = (filePath) => {
-          if (isInjection(filePath) || filePath.match(FILE_EXCEPTIONS_RX)) {
+          if (isInjectionFile(filePath) || filePath.match(FILE_EXCEPTIONS_RX)) {
             return false;
           }
           return true;
@@ -11780,239 +11792,183 @@ const getRollupPlugin$1 = (context, log) => {
 };
 
 const getWebpackPlugin$2 = (context, PLUGIN_NAME, log) => (compiler) => {
-  compiler.hooks.afterEmit.tap(PLUGIN_NAME, (compilation) => {
-    const inputs = [];
-    const outputs = [];
-    const entries = [];
-    context.build.errors = compilation.errors.map((err) => err.message) || [];
-    context.build.warnings = compilation.warnings.map((err) => err.message) || [];
-    const warn = (warning) => {
-      context.build.warnings.push(warning);
-      log(warning, "warn");
-    };
-    const stats = compilation.getStats().toJson({
-      all: false,
-      assets: true,
-      children: true,
-      chunks: true,
-      chunkGroupAuxiliary: true,
-      chunkGroupChildren: true,
-      chunkGroups: true,
-      chunkModules: true,
-      chunkRelations: true,
-      entrypoints: true,
-      errors: true,
-      ids: true,
-      modules: true,
-      nestedModules: true,
-      reasons: true,
-      relatedAssets: true,
-      warnings: true
-    });
-    const chunks = stats.chunks || [];
-    const assets = compilation.getAssets();
-    const modules = [];
-    const entrypoints = stats.entrypoints || [];
-    const tempSourcemaps = [];
-    const tempDeps = {};
-    const reportInputsIndexed = {};
-    const reportOutputsIndexed = {};
-    const modulePerId = /* @__PURE__ */ new Map();
-    const modulePerIdentifier = /* @__PURE__ */ new Map();
-    const concatModulesPerId = /* @__PURE__ */ new Map();
-    const concatModulesPerIdentifier = /* @__PURE__ */ new Map();
-    for (const module of stats.modules || []) {
-      if (module.modules) {
-        if (module.id) {
-          concatModulesPerId.set(module.id, module.modules);
-        }
-        if (module.identifier) {
-          concatModulesPerIdentifier.set(module.identifier, module.modules);
-        }
-        for (const subModule of module.modules) {
-          modules.push(subModule);
-          if (subModule.id) {
-            modulePerId.set(subModule.id, subModule);
-          }
-          if (subModule.identifier) {
-            modulePerIdentifier.set(subModule.identifier, subModule);
+  const inputs = [];
+  const outputs = [];
+  const entries = [];
+  const warnings = [];
+  const reportInputsIndexed = /* @__PURE__ */ new Map();
+  const reportOutputsIndexed = /* @__PURE__ */ new Map();
+  const modulesPerFile = /* @__PURE__ */ new Map();
+  const tempSourcemaps = [];
+  const tempDeps = /* @__PURE__ */ new Map();
+  const isModuleSupported = (moduleIdentifier) => {
+    return (
+      // Ignore unidentified modules and runtimes.
+      !!moduleIdentifier && !moduleIdentifier.startsWith("webpack/runtime") && !moduleIdentifier.includes("/webpack4/buildin/") && !moduleIdentifier.startsWith("multi ")
+    );
+  };
+  const warn = (warning) => {
+    warnings.push(warning);
+    log(warning, "warn");
+  };
+  compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+    compilation.hooks.finishModules.tap(PLUGIN_NAME, (finishedModules) => {
+      const getModuleFromDep = (dep) => {
+        return compilation.moduleGraph ? compilation.moduleGraph.getModule(dep) : dep.module;
+      };
+      for (const module of finishedModules) {
+        const moduleIdentifier = module.identifier();
+        const dependencies = new Set(
+          [...module.dependencies, ...module.blocks.flatMap((b) => b.dependencies)].filter(
+            (dep) => (
+              // Ignore side effects.
+              dep.type !== "harmony side effect evaluation" && // Ignore those we can't identify.
+              getModuleFromDep(dep)?.identifier() && // Only what we support.
+              isModuleSupported(getModuleFromDep(dep)?.identifier()) && // Don't add itself as a dependency.
+              getModuleFromDep(dep)?.identifier() !== moduleIdentifier
+            )
+          ).map((dep) => {
+            return getModuleFromDep(dep)?.identifier();
+          }).filter(Boolean)
+        );
+        if (!isModuleSupported(moduleIdentifier)) {
+          continue;
+        }
+        for (const depIdentifier of dependencies) {
+          const depDeps = tempDeps.get(depIdentifier) || {
+            dependencies: /* @__PURE__ */ new Set(),
+            dependents: /* @__PURE__ */ new Set()
+          };
+          depDeps.dependents.add(moduleIdentifier);
+          tempDeps.set(depIdentifier, depDeps);
+        }
+        const moduleDeps = tempDeps.get(moduleIdentifier) || {
+          dependents: /* @__PURE__ */ new Set(),
+          dependencies: /* @__PURE__ */ new Set()
+        };
+        for (const moduleDep of dependencies) {
+          moduleDeps.dependencies.add(moduleDep);
+        }
+        tempDeps.set(moduleIdentifier, moduleDeps);
+        const file = {
+          size: module.size() || 0,
+          name: cleanName(context, moduleIdentifier),
+          dependencies: /* @__PURE__ */ new Set(),
+          dependents: /* @__PURE__ */ new Set(),
+          filepath: moduleIdentifier,
+          type: getType(moduleIdentifier)
+        };
+        inputs.push(file);
+        reportInputsIndexed.set(moduleIdentifier, file);
+      }
+      for (const input of inputs) {
+        const depsReport = tempDeps.get(input.filepath);
+        if (!depsReport) {
+          warn(`Could not find dependency report for ${input.name}`);
+          continue;
+        }
+        for (const dependency of depsReport.dependencies) {
+          const depInput = reportInputsIndexed.get(dependency);
+          if (!depInput) {
+            warn(`Could not find input of dependency ${dependency}`);
+            continue;
           }
+          input.dependencies.add(depInput);
         }
-      } else {
-        modules.push(module);
-        if (module.id) {
-          modulePerId.set(module.id, module);
+        for (const dependent of depsReport.dependents) {
+          const depInput = reportInputsIndexed.get(dependent);
+          if (!depInput) {
+            warn(`Could not find input of dependent ${dependent}`);
+            continue;
+          }
+          input.dependents.add(depInput);
         }
-        if (module.identifier) {
-          modulePerIdentifier.set(module.identifier, module);
+      }
+    });
+  });
+  compiler.hooks.afterEmit.tap(PLUGIN_NAME, (result) => {
+    const chunks = result.chunks;
+    const assets = result.getAssets();
+    const getChunkFiles = (chunk) => {
+      return [...chunk.files || [], ...chunk.auxiliaryFiles || []].map(
+        (f) => getAbsolutePath(context.bundler.outDir, f)
+      );
+    };
+    const chunkGraph = result.chunkGraph;
+    for (const chunk of chunks) {
+      const files = getChunkFiles(chunk);
+      const chunkModules = (chunkGraph ? chunkGraph?.getChunkModules(chunk) : chunk.getModules()).flatMap((m) => {
+        return "modules" in m && Array.isArray(m.modules) ? m.modules.map((m2) => m2.identifier()) : m.identifier();
+      }).filter(isModuleSupported);
+      for (const file of files) {
+        if (getType(file) === "map") {
+          continue;
         }
+        const fileModules = modulesPerFile.get(file) || [];
+        modulesPerFile.set(file, [...fileModules, ...chunkModules]);
       }
     }
     for (const asset of assets) {
       const file = {
-        size: asset.info.size || 0,
+        size: asset.source.size() || 0,
         name: asset.name,
         inputs: [],
         filepath: getAbsolutePath(context.bundler.outDir, asset.name),
         type: getType(asset.name)
       };
-      reportOutputsIndexed[file.filepath] = file;
+      reportOutputsIndexed.set(file.filepath, file);
       outputs.push(file);
       if (file.type === "map") {
         tempSourcemaps.push(file);
-      }
-    }
-    for (const sourcemap of tempSourcemaps) {
-      const outputFound = reportOutputsIndexed[sourcemap.filepath.replace(/\.map$/, "")];
-      if (!outputFound) {
-        warn(`Output not found for sourcemap ${sourcemap.name}`);
         continue;
       }
-      sourcemap.inputs.push(outputFound);
-    }
-    const getModulePath = (module) => {
-      return module.nameForCondition ? module.nameForCondition : module.name ? getAbsolutePath(context.cwd, module.name) : module.identifier ? module.identifier : "unknown";
-    };
-    const isModuleSupported = (module) => {
-      if (isInjection(getModulePath(module)) || // Do not report runtime modules as they are very specific to webpack.
-      module.moduleType === "runtime" || module.name?.startsWith("(webpack)") || // Also ignore orphan modules
-      module.type === "orphan modules") {
-        return false;
-      }
-      return true;
-    };
-    const getModules = (reason) => {
-      const { moduleIdentifier, moduleId } = reason;
-      if (!moduleIdentifier && !moduleId) {
-        return [];
-      }
-      const modulesFound = [];
-      if (moduleId) {
-        const module = modulePerId.get(moduleId);
-        if (module) {
-          modulesFound.push(module);
-        }
-        const concatModules = concatModulesPerId.get(moduleId);
-        if (concatModules) {
-          modulesFound.push(...concatModules);
-        }
-      }
-      if (moduleIdentifier) {
-        const module = modulePerIdentifier.get(moduleIdentifier);
-        if (module) {
-          modulesFound.push(module);
-        }
-        const concatModules = concatModulesPerIdentifier.get(moduleIdentifier);
-        if (concatModules) {
-          modulesFound.push(...concatModules);
-        }
-      }
-      return Array.from(new Set(modulesFound.map(getModulePath)));
-    };
-    const modulesDone = /* @__PURE__ */ new Set();
-    for (const module of modules) {
-      if (!isModuleSupported(module)) {
+      const fileModules = modulesPerFile.get(file.filepath);
+      if (!fileModules) {
+        warn(`Could not find modules for ${file.name}`);
         continue;
       }
-      const modulePath = getModulePath(module);
-      if (modulesDone.has(modulePath)) {
-        continue;
-      }
-      modulesDone.add(modulePath);
-      if (modulePath === "unknown") {
-        warn(`Unknown module: ${JSON.stringify(module)}`);
-      }
-      if (module.reasons) {
-        const moduleDeps = tempDeps[modulePath] || {
-          dependencies: /* @__PURE__ */ new Set(),
-          dependents: /* @__PURE__ */ new Set()
-        };
-        const dependents = module.reasons.flatMap(getModules);
-        for (const dependent of dependents) {
-          const reasonDeps = tempDeps[dependent] || {
-            dependencies: /* @__PURE__ */ new Set(),
-            dependents: /* @__PURE__ */ new Set()
-          };
-          reasonDeps.dependencies.add(modulePath);
-          tempDeps[dependent] = reasonDeps;
-          moduleDeps.dependents.add(dependent);
-        }
-        tempDeps[modulePath] = moduleDeps;
-      }
-      const file = {
-        size: module.size || 0,
-        name: cleanName(context, modulePath),
-        dependencies: /* @__PURE__ */ new Set(),
-        dependents: /* @__PURE__ */ new Set(),
-        filepath: modulePath,
-        type: getType(modulePath)
-      };
-      for (const chunkId of module.chunks || []) {
-        const chunkFound = chunks.find((chunk) => chunk.id === chunkId);
-        if (!chunkFound) {
-          continue;
-        }
-        const chunkFiles = chunkFound.files || [];
-        if (chunkFound.auxiliaryFiles) {
-          chunkFiles.push(...chunkFound.auxiliaryFiles);
-        }
-        const outputFound = outputs.find((output) => chunkFiles.includes(output.name));
-        if (!outputFound) {
-          warn(`Output not found for ${file.name}`);
+      for (const moduleIdentifier of fileModules) {
+        const inputFound = reportInputsIndexed.get(moduleIdentifier);
+        if (!inputFound) {
+          warn(`Could not find input of ${moduleIdentifier}`);
           continue;
         }
-        if (!outputFound.inputs.includes(file)) {
-          outputFound.inputs.push(file);
-        }
+        file.inputs.push(inputFound);
       }
-      reportInputsIndexed[modulePath] = file;
-      inputs.push(file);
     }
-    const getInput = (filepath) => {
-      const inputFound = reportInputsIndexed[filepath];
-      if (!inputFound) {
-        warn(`Could not find input of ${filepath}`);
-      }
-      return inputFound;
-    };
-    for (const input of inputs) {
-      const depsReport = tempDeps[input.filepath];
-      if (!depsReport) {
-        warn(`Could not find dependency report for ${input.name}`);
+    for (const sourcemap of tempSourcemaps) {
+      const outputFound = reportOutputsIndexed.get(
+        sourcemap.filepath.replace(/\.map$/, "")
+      );
+      if (!outputFound) {
+        warn(`Output not found for sourcemap ${sourcemap.name}`);
         continue;
       }
-      input.dependencies = cleanReport(depsReport.dependencies, input.filepath, getInput);
-      input.dependents = cleanReport(depsReport.dependents, input.filepath, getInput);
+      sourcemap.inputs.push(outputFound);
     }
-    for (const [name, entry] of Object.entries(entrypoints)) {
+    for (const [name, entrypoint] of result.entrypoints) {
       const entryOutputs = [];
       const entryInputs = [];
       let size = 0;
-      const entryAssets = entry.assets || [];
-      if (entry.auxiliaryAssets) {
-        entryAssets.push(...entry.auxiliaryAssets);
-      }
-      for (const asset of entryAssets) {
-        let assetPath;
-        if (typeof asset === "string") {
-          assetPath = getAbsolutePath(context.bundler.outDir, asset);
-        } else if (typeof asset.name === "string") {
-          assetPath = getAbsolutePath(context.bundler.outDir, asset.name);
-        }
-        if (!assetPath || !reportOutputsIndexed[assetPath]) {
-          warn(`Could not find output of ${JSON.stringify(asset)}`);
+      const entryFiles = entrypoint.chunks.flatMap(getChunkFiles);
+      const entryFilename = entrypoint.chunks.filter(
+        (c) => (
+          // Webpack5 forces you to use the chunkGraph to get the modules.
+          chunkGraph ? chunkGraph.getNumberOfEntryModules(c) > 0 : c.hasEntryModule()
+        )
+      ).flatMap((c) => Array.from(c.files))[0];
+      for (const file2 of entryFiles) {
+        const outputFound = reportOutputsIndexed.get(file2);
+        if (!file2 || !outputFound) {
+          warn(`Could not find output of ${JSON.stringify(file2)}`);
           continue;
         }
-        const outputFound = reportOutputsIndexed[assetPath];
-        if (outputFound) {
-          if (outputFound.type !== "map" && !entryOutputs.includes(outputFound)) {
-            entryOutputs.push(outputFound);
-            entryInputs.push(...outputFound.inputs);
-            size += outputFound.size;
-          }
+        if (outputFound.type !== "map" && !entryOutputs.includes(outputFound)) {
+          entryOutputs.push(outputFound);
+          entryInputs.push(...outputFound.inputs);
+          size += outputFound.size;
         }
       }
-      const entryFilename = stats.assetsByChunkName?.[name]?.[0];
       const file = {
         name,
         filepath: entryFilename ? getAbsolutePath(context.bundler.outDir, entryFilename) : "unknown",
@@ -12023,6 +11979,8 @@ const getWebpackPlugin$2 = (context, PLUGIN_NAME, log) => (compiler) => {
       };
       entries.push(file);
     }
+    context.build.errors = result.errors.map((err) => err.message);
+    context.build.warnings = [...warnings, ...result.warnings.map((err) => err.message)];
     context.build.inputs = inputs;
     context.build.outputs = outputs;
     context.build.entries = entries;
@@ -12069,7 +12027,7 @@ const getBundlerReportPlugin = (opts, globalContext) => {
           globalContext.bundler.outDir = build.initialOptions.outdir;
         }
         if (build.initialOptions.outfile) {
-          globalContext.bundler.outDir = require$$1.dirname(build.initialOptions.outfile);
+          globalContext.bundler.outDir = path$i.dirname(build.initialOptions.outfile);
         }
         build.initialOptions.metafile = true;
       }
@@ -12990,7 +12948,7 @@ function requireNode$1 () {
 	hasRequiredNode$1 = 1;
 	(function (module, exports) {
 		const tty = require$$0$1;
-		const util = require$$1$1;
+		const util = require$$1;
 
 		/**
 		 * This is the Node.js implementation of `debug()`.
@@ -13903,7 +13861,7 @@ function requireNode () {
 	hasRequiredNode = 1;
 	(function (module, exports) {
 		const tty = require$$0$1;
-		const util = require$$1$1;
+		const util = require$$1;
 
 		/**
 		 * This is the Node.js implementation of `debug()`.
@@ -19049,7 +19007,7 @@ const processInjections = async (toInject, log) => {
   return results.filter(Boolean);
 };
 
-const getInjectionPlugins = (opts, context, toInject) => {
+const getInjectionPlugins = (bundler, opts, context, toInject) => {
   const log = getLogger(opts.logLevel, PLUGIN_NAME$4);
   const contentToInject = [];
   const getContentToInject = () => {
@@ -19071,27 +19029,7 @@ ${after}`;
       return "";
     }
   };
-  return [
-    // Resolve the injected file for all bundlers.
-    {
-      name: RESOLUTION_PLUGIN_NAME,
-      enforce: "pre",
-      async resolveId(id) {
-        if (isInjection(id)) {
-          return { id, moduleSideEffects: true };
-        }
-      },
-      loadInclude(id) {
-        if (isInjection(id)) {
-          return true;
-        }
-      },
-      load(id) {
-        if (isInjection(id)) {
-          return getContentToInject();
-        }
-      }
-    },
+  const plugins = [
     // Prepare and fetch the content to inject for all bundlers.
     {
       name: PREPARATION_PLUGIN_NAME,
@@ -19100,103 +19038,93 @@ ${after}`;
       async buildStart() {
         const results = await processInjections(toInject, log);
         contentToInject.push(...results);
+        if (context.bundler.name !== "esbuild") {
+          return;
+        }
+        const absolutePathInjectFile = path$i.resolve(
+          context.bundler.outDir,
+          INJECTED_FILE_PATH
+        );
+        try {
+          await fs$j.promises.mkdir(path$i.dirname(absolutePathInjectFile), {
+            recursive: true
+          });
+          await fs$j.promises.writeFile(absolutePathInjectFile, getContentToInject());
+        } catch (e) {
+          log(`Could not create the file: ${e.message}`, "error");
+        }
+      },
+      async buildEnd() {
+        if (context.bundler.name !== "esbuild") {
+          return;
+        }
+        const absolutePathInjectFile = path$i.resolve(
+          context.bundler.outDir,
+          INJECTED_FILE_PATH
+        );
+        await fs$j.promises.rm(absolutePathInjectFile, {
+          force: true,
+          maxRetries: 3,
+          recursive: true
+        });
       }
     },
-    // Inject the virtual file that will be home of all injected content.
+    // Inject the file that will be home of all injected content.
     // Each bundler has its own way to inject a file.
     {
       name: PLUGIN_NAME$4,
       esbuild: {
         setup(build) {
           const { initialOptions } = build;
-          build.onResolve({ filter: /.*/ }, async (args) => {
-            if (args.kind !== "entry-point") {
-              return null;
-            }
-            if (initialOptions.inject?.includes(args.path)) {
-              return null;
-            }
-            return {
-              pluginName: PLUGIN_NAME$4,
-              path: require$$1.isAbsolute(args.path) ? args.path : require$$1.join(args.resolveDir, args.path),
-              pluginData: {
-                isInjectionResolver: true,
-                originalPath: args.path,
-                originalResolveDir: args.resolveDir
-              },
-              // Adding a suffix prevents esbuild from marking the entrypoint as resolved,
-              // avoiding a dependency loop with the proxy module.
-              // This ensures esbuild continues to traverse the module tree
-              // and re-resolves the entrypoint when imported from the proxy module.
-              suffix: "?datadogInjected=true"
-            };
-          });
-          build.onLoad({ filter: /.*/ }, async (args) => {
-            if (!args.pluginData?.isInjectionResolver) {
-              return null;
-            }
-            const originalPath = args.pluginData.originalPath;
-            const originalResolveDir = args.pluginData.originalResolveDir;
-            const contents = `
-import ${JSON.stringify(INJECTED_FILE)};
-import * as OriginalModule from ${JSON.stringify(originalPath)};
-export default OriginalModule['default'.toString()];
-export * from ${JSON.stringify(originalPath)};
-`;
-            return {
-              loader: "js",
-              pluginName: PLUGIN_NAME$4,
-              contents,
-              resolveDir: originalResolveDir
-            };
-          });
+          const absolutePathInjectFile = path$i.resolve(
+            context.bundler.outDir,
+            INJECTED_FILE_PATH
+          );
+          initialOptions.inject = initialOptions.inject || [];
+          initialOptions.inject.push(absolutePathInjectFile);
         }
       },
       webpack: (compiler) => {
-        const injectEntry = (originalEntry) => {
-          if (!originalEntry) {
-            return [INJECTED_FILE];
-          }
-          if (Array.isArray(originalEntry)) {
-            return [INJECTED_FILE, ...originalEntry];
-          }
-          if (typeof originalEntry === "function") {
-            return async () => {
-              const originEntry = await originalEntry();
-              return [INJECTED_FILE, originEntry];
-            };
-          }
-          if (typeof originalEntry === "string") {
-            return [INJECTED_FILE, originalEntry];
-          }
-          if (typeof originalEntry === "object") {
-            const newEntry = {};
-            if (Object.keys(originalEntry).length === 0) {
-              newEntry[INJECTED_FILE] = // Webpack 4 and 5 have different entry formats.
-              context.bundler.variant === "5" ? { import: [INJECTED_FILE] } : INJECTED_FILE;
-              return newEntry;
-            }
-            for (const entryName in originalEntry) {
-              if (!Object.hasOwn(originalEntry, entryName)) {
-                continue;
+        const BannerPlugin = compiler?.webpack?.BannerPlugin || bundler?.BannerPlugin || bundler?.default?.BannerPlugin;
+        compiler?.webpack?.ChunkGraph || bundler?.ChunkGraph || bundler?.default?.ChunkGraph;
+        if (!BannerPlugin) {
+          log("Missing BannerPlugin", "error");
+        }
+        let chunkGraph;
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME$4, (compilation) => {
+          compilation.hooks.afterChunks.tap(PLUGIN_NAME$4, () => {
+            chunkGraph = compilation.chunkGraph;
+          });
+        });
+        compiler.options.plugins = compiler.options.plugins || [];
+        compiler.options.plugins.push(
+          new BannerPlugin({
+            // Not wrapped in comments.
+            raw: true,
+            // Doesn't seem to work, but it's supposed to only add
+            // the banner to entry modules.
+            entryOnly: true,
+            banner(data) {
+              if (context.bundler.variant === "5") {
+                if (!chunkGraph || chunkGraph.getNumberOfEntryModules(data.chunk) === 0) {
+                  return "";
+                }
+                return getContentToInject();
+              } else {
+                if (!data.chunk?.hasEntryModule()) {
+                  return "";
+                }
+                return getContentToInject();
               }
-              const entry = originalEntry[entryName];
-              newEntry[entryName] = // Webpack 4 and 5 have different entry formats.
-              typeof entry === "string" ? [INJECTED_FILE, entry] : {
-                ...entry,
-                import: [INJECTED_FILE, ...entry.import]
-              };
             }
-            return newEntry;
-          }
-          return [INJECTED_FILE, originalEntry];
-        };
-        compiler.options.entry = injectEntry(compiler.options.entry);
+          })
+        );
       },
       rollup: rollupInjectionPlugin,
       vite: rollupInjectionPlugin
     }
   ];
+  return plugins;
 };
 
 const getInternalPlugins = (options, meta) => {
@@ -19210,7 +19138,8 @@ const getInternalPlugins = (options, meta) => {
       name: meta.framework,
       fullName: `${meta.framework}${variant}`,
       variant,
-      outDir: cwd
+      outDir: cwd,
+      version: meta.bundler.version || meta.bundler.VERSION
     },
     build: {
       errors: [],
@@ -19226,7 +19155,7 @@ const getInternalPlugins = (options, meta) => {
   const bundlerReportPlugin = getBundlerReportPlugin(options, globalContext);
   const buildReportPlugin = getBuildReportPlugin(options, globalContext);
   const gitPlugin = getGitPlugin(options, globalContext);
-  const injectionPlugins = getInjectionPlugins(options, globalContext, toInject);
+  const injectionPlugins = getInjectionPlugins(meta.bundler, options, globalContext, toInject);
   return {
     globalContext,
     internalPlugins: [bundlerReportPlugin, buildReportPlugin, gitPlugin, ...injectionPlugins]
@@ -19400,12 +19329,12 @@ if (typeof module !== "undefined") {
 }
 
 const decomposePath = (options, context, sourcemapFilePath) => {
-  if (require$$1.extname(sourcemapFilePath) !== ".map") {
+  if (path$i.extname(sourcemapFilePath) !== ".map") {
     throw new Error(`The file ${chalk.green.bold(sourcemapFilePath)} is not a sourcemap.`);
   }
   const minifiedFilePath = sourcemapFilePath.replace(/\.map$/, "");
   const relativePath = minifiedFilePath.replace(context.bundler.outDir, "");
-  const minifiedUrl = options.minifiedPathPrefix ? require$$1.join(options.minifiedPathPrefix, relativePath) : relativePath;
+  const minifiedUrl = options.minifiedPathPrefix ? path$i.join(options.minifiedPathPrefix, relativePath) : relativePath;
   return {
     minifiedFilePath,
     minifiedUrl,
@@ -20278,7 +20207,7 @@ const getPayload = async (sourcemap, metadata, prefix, git) => {
                 sourcemap.sourcemapFilePath,
                 (reason) => {
                   warnings.push(
-                    `${require$$1.basename(sourcemap.sourcemapFilePath)}: "${reason}"`
+                    `${path$i.basename(sourcemap.sourcemapFilePath)}: "${reason}"`
                   );
                 }
               ),
@@ -21099,7 +21028,7 @@ var polyfills = polyfills$1;
 var legacy = legacyStreams;
 var clone = clone_1;
 
-var util = require$$1$1;
+var util = require$$1;
 
 /* istanbul ignore next - node 0.x polyfill */
 var gracefulQueue;
@@ -21649,7 +21578,7 @@ function retry () {
 	}; 
 } (fs$i));
 
-const path$g = require$$1;
+const path$g = path$i;
 
 // get drive on windows
 function getRootPath (p) {
@@ -21674,7 +21603,7 @@ var win32 = {
 };
 
 const fs$g = gracefulFs;
-const path$f = require$$1;
+const path$f = path$i;
 const invalidWin32Path$1 = win32.invalidWin32Path;
 
 const o777$1 = parseInt('0777', 8);
@@ -21736,7 +21665,7 @@ function mkdirs$2 (p, opts, callback, made) {
 var mkdirs_1$1 = mkdirs$2;
 
 const fs$f = gracefulFs;
-const path$e = require$$1;
+const path$e = path$i;
 const invalidWin32Path = win32.invalidWin32Path;
 
 const o777 = parseInt('0777', 8);
@@ -21804,7 +21733,7 @@ var mkdirs_1 = {
 
 const fs$e = gracefulFs;
 const os = require$$0;
-const path$d = require$$1;
+const path$d = path$i;
 
 // HFS, ext{2,3}, FAT do not, Node.js v0.10 does not
 function hasMillisResSync () {
@@ -21893,7 +21822,7 @@ var buffer$1 = function (size) {
 };
 
 const fs$d = gracefulFs;
-const path$c = require$$1;
+const path$c = path$i;
 const mkdirpSync$1 = mkdirs_1.mkdirsSync;
 const utimesSync = utimes$1.utimesMillisSync;
 
@@ -22101,7 +22030,7 @@ var pathExists_1 = {
 };
 
 const fs$b = gracefulFs;
-const path$b = require$$1;
+const path$b = path$i;
 const mkdirp$1 = mkdirs_1.mkdirs;
 const pathExists$7 = pathExists_1.pathExists;
 const utimes = utimes$1.utimesMillis;
@@ -22351,7 +22280,7 @@ var copy$1 = {
 };
 
 const fs$a = gracefulFs;
-const path$a = require$$1;
+const path$a = path$i;
 const assert = require$$5;
 
 const isWindows = (process.platform === 'win32');
@@ -22673,7 +22602,7 @@ var remove$3 = {
 
 const u$7 = universalify.fromCallback;
 const fs$9 = fs$j;
-const path$9 = require$$1;
+const path$9 = path$i;
 const mkdir$5 = mkdirs_1;
 const remove$2 = remove$3;
 
@@ -22719,7 +22648,7 @@ var empty$2 = {
 };
 
 const u$6 = universalify.fromCallback;
-const path$8 = require$$1;
+const path$8 = path$i;
 const fs$8 = gracefulFs;
 const mkdir$4 = mkdirs_1;
 const pathExists$6 = pathExists_1.pathExists;
@@ -22767,7 +22696,7 @@ var file$1 = {
 };
 
 const u$5 = universalify.fromCallback;
-const path$7 = require$$1;
+const path$7 = path$i;
 const fs$7 = gracefulFs;
 const mkdir$3 = mkdirs_1;
 const pathExists$5 = pathExists_1.pathExists;
@@ -22826,7 +22755,7 @@ var link$1 = {
   createLinkSync
 };
 
-const path$6 = require$$1;
+const path$6 = path$i;
 const fs$6 = gracefulFs;
 const pathExists$4 = pathExists_1.pathExists;
 
@@ -22955,7 +22884,7 @@ var symlinkType_1 = {
 };
 
 const u$4 = universalify.fromCallback;
-const path$5 = require$$1;
+const path$5 = path$i;
 const fs$4 = gracefulFs;
 const _mkdirs = mkdirs_1;
 const mkdirs = _mkdirs.mkdirs;
@@ -23184,7 +23113,7 @@ var jsonfile = {
   writeJsonSync: jsonFile$3.writeFileSync
 };
 
-const path$4 = require$$1;
+const path$4 = path$i;
 const mkdir$2 = mkdirs_1;
 const pathExists$2 = pathExists_1.pathExists;
 const jsonFile$2 = jsonfile;
@@ -23211,7 +23140,7 @@ function outputJson (file, data, options, callback) {
 var outputJson_1 = outputJson;
 
 const fs$3 = gracefulFs;
-const path$3 = require$$1;
+const path$3 = path$i;
 const mkdir$1 = mkdirs_1;
 const jsonFile$1 = jsonfile;
 
@@ -23243,7 +23172,7 @@ jsonFile.readJSONSync = jsonFile.readJsonSync;
 var json = jsonFile;
 
 const fs$2 = gracefulFs;
-const path$2 = require$$1;
+const path$2 = path$i;
 const copySync = copySync$1.copySync;
 const removeSync = remove$3.removeSync;
 const mkdirpSync = mkdirs_1.mkdirsSync;
@@ -23360,7 +23289,7 @@ var moveSync_1 = {
 
 const u$1 = universalify.fromCallback;
 const fs$1 = gracefulFs;
-const path$1 = require$$1;
+const path$1 = path$i;
 const copy = copy$1.copy;
 const remove$1 = remove$3.remove;
 const mkdirp = mkdirs_1.mkdirp;
@@ -23441,7 +23370,7 @@ var move_1 = {
 
 const u = universalify.fromCallback;
 const fs = gracefulFs;
-const path = require$$1;
+const path = path$i;
 const mkdir = mkdirs_1;
 const pathExists = pathExists_1.pathExists;
 
@@ -23911,7 +23840,7 @@ const outputFiles = async (data, outputOptions, log, cwd) => {
   } else if (typeof outputOptions === "string") {
     destination = outputOptions;
   }
-  const outputPath = require$$1.resolve(cwd, destination);
+  const outputPath = path$i.resolve(cwd, destination);
   try {
     const errors = {};
     const filesToWrite = {};
@@ -23930,7 +23859,7 @@ const outputFiles = async (data, outputOptions, log, cwd) => {
     const proms = Object.keys(filesToWrite).map((file) => {
       const start = Date.now();
       log(`Start writing ${file}.json.`);
-      return writeFile(require$$1.join(outputPath, `${file}.json`), filesToWrite[file].content).then(() => {
+      return writeFile(path$i.join(outputPath, `${file}.json`), filesToWrite[file].content).then(() => {
         log(`Wrote ${file}.json in ${formatDuration(Date.now() - start)}`);
       }).catch((e) => {
         log(
@@ -34302,7 +34231,7 @@ virtualStats.VirtualStats = VirtualStats;
 var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-const path_1 = __importDefault(require$$1);
+const path_1 = __importDefault(path$i);
 const virtual_stats_1 = virtualStats;
 let inode = 45000000;
 const ALL = 'all';
@@ -34586,7 +34515,7 @@ var VirtualModulesPlugin$1 = /*@__PURE__*/getDefaultExportFromCjs(lib);
 
 // node_modules/.pnpm/tsup@8.0.2_typescript@5.4.5/node_modules/tsup/assets/esm_shims.js
 var getFilename = () => fileURLToPath$1(import.meta.url);
-var getDirname = () => require$$1.dirname(getFilename());
+var getDirname = () => path$i.dirname(getFilename());
 var __dirname = /* @__PURE__ */ getDirname();
 
 // node_modules/.pnpm/@jridgewell+sourcemap-codec@1.4.15/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
@@ -35387,7 +35316,7 @@ var ExtToLoader = {
   ".txt": "text"
 };
 function guessLoader(code, id) {
-  return ExtToLoader[require$$1.extname(id).toLowerCase()] || "js";
+  return ExtToLoader[path$i.extname(id).toLowerCase()] || "js";
 }
 function unwrapLoader(loader, code, id) {
   if (typeof loader === "function")
@@ -35461,8 +35390,8 @@ function createBuildContext(initialOptions) {
     emitFile(emittedFile) {
       const outFileName = emittedFile.fileName || emittedFile.name;
       if (initialOptions.outdir && emittedFile.source && outFileName) {
-        const outPath = require$$1.resolve(initialOptions.outdir, outFileName);
-        const outDir = require$$1.dirname(outPath);
+        const outPath = path$i.resolve(initialOptions.outdir, outFileName);
+        const outDir = path$i.dirname(outPath);
         if (!fs$j.existsSync(outDir))
           fs$j.mkdirSync(outDir, { recursive: true });
         fs$j.writeFileSync(outPath, emittedFile.source);
@@ -35663,7 +35592,7 @@ function buildSetup(meta) {
         onLoad({ filter: onLoadFilter }, async (args) => {
           const id = args.path + args.suffix;
           const { errors, warnings, mixedContext } = createPluginContext(context);
-          const resolveDir = require$$1.dirname(args.path);
+          const resolveDir = path$i.dirname(args.path);
           let code, map;
           if (plugin.load && (!plugin.loadInclude || plugin.loadInclude(id))) {
             const result = await plugin.load.call(mixedContext, id);
@@ -35694,7 +35623,7 @@ function buildSetup(meta) {
           if (plugin.transformInclude && !plugin.transformInclude(id))
             return;
           const { mixedContext, errors, warnings } = createPluginContext(context);
-          const resolveDir = require$$1.dirname(args.path);
+          const resolveDir = path$i.dirname(args.path);
           let code = await args.getContents();
           let map;
           const result = await plugin.transform.call(mixedContext, code, id);
@@ -35786,7 +35715,7 @@ var ExtToLoader2 = {
   ".node": "napi"
 };
 function guessIdLoader(id) {
-  return ExtToLoader2[require$$1.extname(id).toLowerCase()] || "js";
+  return ExtToLoader2[path$i.extname(id).toLowerCase()] || "js";
 }
 function transformQuery(context) {
   const queryParamsObject = {};
@@ -35876,7 +35805,7 @@ function toFarmPlugin(plugin, options) {
     farmPlugin.resolve = {
       filters: { sources: [".*", ...filters], importers: [".*"] },
       async executor(params, context) {
-        const resolvedIdPath = require$$1.resolve(
+        const resolvedIdPath = path$i.resolve(
           process.cwd(),
           params.importer ?? ""
         );
@@ -36458,6 +36387,7 @@ const validateOptions = (options = {}) => {
 };
 const HOST_NAME = "datadog-build-plugins";
 const buildPluginFactory = ({
+  bundler,
   version
 }) => {
   return createUnplugin((opts, unpluginMetaContext) => {
@@ -36466,6 +36396,7 @@ const buildPluginFactory = ({
       unpluginMetaContext.esbuildHostName = HOST_NAME;
     }
     const { globalContext, internalPlugins } = getInternalPlugins(options, {
+      bundler,
       version,
       ...unpluginMetaContext
     });
@@ -36488,7 +36419,7 @@ const buildPluginFactory = ({
 
 var name = "@datadog/esbuild-plugin";
 var packageManager = "yarn@4.0.2";
-var version$1 = "2.3.1-dev-9";
+var version$1 = "2.3.1-dev-12";
 var license = "MIT";
 var author = "Datadog";
 var description = "Datadog ESBuild Plugin";
@@ -36576,6 +36507,7 @@ var pkg = {
 };
 
 const datadogEsbuildPlugin = buildPluginFactory({
+  bundler: esbuild,
   version: pkg.version
 }).esbuild;
 const version = pkg.version;