@sentry/bundler-plugin-core 0.5.1 → 0.7.0

package/dist/cjs/index.js

@@ -14,6 +14,7 @@ var crypto = require('crypto');
 require('@sentry/tracing');
 var util = require('util');
 var glob = require('glob');
+var webpackSources = require('webpack-sources');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -45,7 +46,6 @@ var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
 var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
 var util__namespace = /*#__PURE__*/_interopNamespace(util);
-var util__default = /*#__PURE__*/_interopDefaultLegacy(util);
 
 function _regeneratorRuntime() {
   /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
@@ -981,6 +981,7 @@ function normalizeUserOptions(userOptions) {
     injectReleasesMap: (_userOptions$injectRe = userOptions.injectReleasesMap) !== null && _userOptions$injectRe !== void 0 ? _userOptions$injectRe : false,
     injectRelease: (_userOptions$injectRe2 = userOptions.injectRelease) !== null && _userOptions$injectRe2 !== void 0 ? _userOptions$injectRe2 : true,
     uploadSourceMaps: (_userOptions$uploadSo = userOptions.uploadSourceMaps) !== null && _userOptions$uploadSo !== void 0 ? _userOptions$uploadSo : true,
+    sourcemaps: userOptions.sourcemaps,
     _experiments: (_userOptions$_experim = userOptions._experiments) !== null && _userOptions$_experim !== void 0 ? _userOptions$_experim : {},
     // These options and can also be set via env variables or the config file.
     // If they're set in the options, we simply pass them to the CLI constructor.
@@ -1032,6 +1033,10 @@ function normalizeReleaseInjectionTargets(userReleaseInjectionTargets) {
 
 
 function normalizeInclude(userOptions) {
+  if (!userOptions.include) {
+    return [];
+  }
+
   return arrayify(userOptions.include).map(function (includeItem) {
     return typeof includeItem === "string" ? {
       paths: [includeItem]
@@ -1121,7 +1126,7 @@ function makeSentryClient(dsn, allowedToSendTelemetryPromise, userProject) {
     // a dashboard.
     // Yes, this is slightly abusing the purpose of this field.
     dist: userProject,
-    release: "0.5.1",
+    release: "0.7.0",
     integrations: [],
     tracePropagationTargets: ["sentry.io/api"],
     stackParser: node.defaultStackParser,
@@ -1224,7 +1229,7 @@ function addPluginOptionInformationToHub(options, hub, bundler) {
       errorHandler = options.errorHandler,
       deploy = options.deploy,
       include = options.include,
-      _experiments = options._experiments;
+      sourcemaps = options.sourcemaps;
   hub.setTag("include", include.length > 1 ? "multiple-entries" : "single-entry"); // Optional release pipeline steps
 
   if (cleanArtifacts) {
@@ -1256,7 +1261,7 @@ function addPluginOptionInformationToHub(options, hub, bundler) {
     hub.setTag("error-handler", "custom");
   }
 
-  if (_experiments.debugIdUpload) {
+  if (sourcemaps !== null && sourcemaps !== void 0 && sourcemaps.assets) {
     hub.setTag("debug-id-upload", true);
   }
 
@@ -1901,12 +1906,14 @@ function getDryRunCLI(cli, logger) {
 }
 
 var DEBUG_ID_INJECTOR_SNIPPET = ';!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="__SENTRY_DEBUG_ID__",e._sentryDebugIdIdentifier="sentry-dbid-__SENTRY_DEBUG_ID__")}catch(e){}}();';
-function injectDebugIdSnippetIntoChunk(code) {
+function injectDebugIdSnippetIntoChunk(code, filename) {
   var _code$match;
 
   var debugId = stringToUUID(code); // generate a deterministic debug ID
 
-  var ms = new MagicString__default["default"](code);
+  var ms = new MagicString__default["default"](code, {
+    filename: filename
+  });
   var codeToInject = DEBUG_ID_INJECTOR_SNIPPET.replace(/__SENTRY_DEBUG_ID__/g, debugId); // We need to be careful not to inject the snippet before any `"use strict";`s.
   // As an additional complication `"use strict";`s may come after any number of comments.
 
@@ -2144,6 +2151,8 @@ function _prepareSourceMapForDebugIdUpload() {
 var ALLOWED_TRANSFORMATION_FILE_ENDINGS = [".js", ".ts", ".jsx", ".tsx", ".mjs"];
 
 var releaseInjectionFilePath = require.resolve("@sentry/bundler-plugin-core/sentry-release-injection-file");
+
+var esbuildDebugIdInjectionFilePath = require.resolve("@sentry/bundler-plugin-core/sentry-esbuild-debugid-injection-file");
 /**
  * The sentry bundler plugin concerns itself with two things:
  * - Release injection
@@ -2173,15 +2182,15 @@ var releaseInjectionFilePath = require.resolve("@sentry/bundler-plugin-core/sent
  */
 
 
-var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext) {
-  var internalOptions = normalizeUserOptions(options);
-  var allowedToSendTelemetryPromise = shouldSendTelemetry(internalOptions);
+var unplugin = unplugin$1.createUnplugin(function (userOptions, unpluginMetaContext) {
+  var options = normalizeUserOptions(userOptions);
+  var allowedToSendTelemetryPromise = shouldSendTelemetry(options);
 
-  var _makeSentryClient = makeSentryClient("https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737", allowedToSendTelemetryPromise, internalOptions.project),
+  var _makeSentryClient = makeSentryClient("https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737", allowedToSendTelemetryPromise, options.project),
       sentryHub = _makeSentryClient.sentryHub,
       sentryClient = _makeSentryClient.sentryClient;
 
-  addPluginOptionInformationToHub(internalOptions, sentryHub, unpluginMetaContext.framework); //TODO: This call is problematic because as soon as we set our hub as the current hub
+  addPluginOptionInformationToHub(options, sentryHub, unpluginMetaContext.framework); //TODO: This call is problematic because as soon as we set our hub as the current hub
   //      we might interfere with other plugins that use Sentry. However, for now, we'll
   //      leave it in because without it, we can't get distributed traces (which are pretty nice)
   //      Let's keep it until someone complains about interference.
@@ -2190,25 +2199,26 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
   node.makeMain(sentryHub);
   var logger = createLogger({
     prefix: "[sentry-".concat(unpluginMetaContext.framework, "-plugin]"),
-    silent: internalOptions.silent,
-    debug: internalOptions.debug
+    silent: options.silent,
+    debug: options.debug
   });
 
-  if (!validateOptions(internalOptions, logger)) {
-    handleError(new Error("Options were not set correctly. See output above for more details."), logger, internalOptions.errorHandler);
+  if (!validateOptions(options, logger)) {
+    handleError(new Error("Options were not set correctly. See output above for more details."), logger, options.errorHandler);
   }
 
-  var cli = getSentryCli(internalOptions, logger);
+  var cli = getSentryCli(options, logger);
   var releaseNamePromise = new Promise(function (resolve) {
-    if (options.release) {
-      resolve(options.release);
+    if (userOptions.release) {
+      resolve(userOptions.release);
     } else {
       resolve(cli.releases.proposeVersion());
     }
   });
   var transaction;
   var releaseInjectionSpan;
-  return {
+  var plugins = [];
+  plugins.push({
     name: "sentry-plugin",
     enforce: "pre",
     // needed for Vite to call resolveId hook
@@ -2256,7 +2266,7 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
 
                 // At this point, we either have determined a release or we have to bail
                 if (!releaseName) {
-                  handleError(new Error("Unable to determine a release name. Make sure to set the `release` option or use an environment that supports auto-detection https://docs.sentry.io/cli/releases/#creating-releases`"), logger, internalOptions.errorHandler);
+                  handleError(new Error("Unable to determine a release name. Make sure to set the `release` option or use an environment that supports auto-detection https://docs.sentry.io/cli/releases/#creating-releases`"), logger, options.errorHandler);
                 }
 
                 transaction = sentryHub.startTransaction({
@@ -2313,6 +2323,10 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
         id: id
       });
 
+      if (id.includes("sentry-release-injection-file")) {
+        return true;
+      }
+
       if (id.match(/\\node_modules\\|\/node_modules\//)) {
         return false; // never transform 3rd party modules
       } // We normalize the id because vite always passes `id` as a unix style path which causes problems when a user passes
@@ -2321,17 +2335,13 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
 
       var normalizedId = path__default["default"].normalize(id);
 
-      if (id.includes("sentry-release-injection-file")) {
-        return true;
-      }
-
-      if (internalOptions.releaseInjectionTargets) {
+      if (options.releaseInjectionTargets) {
         // If there's an `releaseInjectionTargets` option transform (ie. inject the release varible) when the file path matches the option.
-        if (typeof internalOptions.releaseInjectionTargets === "function") {
-          return internalOptions.releaseInjectionTargets(normalizedId);
+        if (typeof options.releaseInjectionTargets === "function") {
+          return options.releaseInjectionTargets(normalizedId);
         }
 
-        return internalOptions.releaseInjectionTargets.some(function (entry) {
+        return options.releaseInjectionTargets.some(function (entry) {
           if (entry instanceof RegExp) {
             return entry.test(normalizedId);
           } else {
@@ -2367,7 +2377,7 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
                   id: id
                 });
 
-                if (internalOptions.injectRelease) {
+                if (options.injectRelease) {
                   _context2.next = 3;
                   break;
                 }
@@ -2390,10 +2400,10 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
 
               case 9:
                 _context2.t2 = _context2.sent;
-                _context2.t3 = internalOptions.injectReleasesMap;
-                _context2.t4 = internalOptions._experiments.injectBuildInformation || false;
-                _context2.t5 = internalOptions.org;
-                _context2.t6 = internalOptions.project;
+                _context2.t3 = options.injectReleasesMap;
+                _context2.t4 = options._experiments.injectBuildInformation || false;
+                _context2.t5 = options.org;
+                _context2.t6 = options.project;
                 _context2.t7 = {
                   release: _context2.t2,
                   injectReleasesMap: _context2.t3,
@@ -2442,14 +2452,14 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
      * Sentry.io, uploading sourcemaps, associating commits and deploys and finalizing the release)
      */
     writeBundle: function writeBundle() {
-      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
         var _releaseInjectionSpan;
 
-        var releasePipelineSpan, ctx, releaseName, tmpUploadFolder, _transaction, debugIdChunkFilePaths, sourceFileUploadFolderPromise, _transaction2, _transaction3;
+        var releasePipelineSpan, ctx, releaseName, tmpUploadFolder, _transaction, _options$sourcemaps, debugIdChunkFilePaths, sourceFileUploadFolderPromise, _transaction2, _transaction3;
 
-        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) {
-            switch (_context4.prev = _context4.next) {
+            switch (_context5.prev = _context5.next) {
               case 0:
                 logger.debug('Called "writeBundle"');
                 (_releaseInjectionSpan = releaseInjectionSpan) === null || _releaseInjectionSpan === void 0 ? void 0 : _releaseInjectionSpan.finish();
@@ -2469,50 +2479,59 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
                   logger: logger,
                   cli: cli
                 };
-                _context4.next = 7;
+                _context5.next = 7;
                 return releaseNamePromise;
 
               case 7:
-                releaseName = _context4.sent;
-                _context4.prev = 8;
+                releaseName = _context5.sent;
+                _context5.prev = 8;
 
-                if (!internalOptions._experiments.debugIdUpload) {
-                  _context4.next = 21;
+                if (unpluginMetaContext.watchMode) {
+                  _context5.next = 37;
                   break;
                 }
 
-                _context4.next = 12;
-                return glob.glob(internalOptions._experiments.debugIdUpload.include, {
+                if (!((_options$sourcemaps = options.sourcemaps) !== null && _options$sourcemaps !== void 0 && _options$sourcemaps.assets)) {
+                  _context5.next = 25;
+                  break;
+                }
+
+                _context5.next = 13;
+                return glob.glob(options.sourcemaps.assets, {
                   absolute: true,
                   nodir: true,
-                  ignore: internalOptions._experiments.debugIdUpload.ignore
+                  ignore: options.sourcemaps.ignore
                 });
 
-              case 12:
-                debugIdChunkFilePaths = _context4.sent.filter(function (p) {
-                  return p.endsWith(".js") || p.endsWith(".mjs");
+              case 13:
+                debugIdChunkFilePaths = _context5.sent.filter(function (p) {
+                  return p.endsWith(".js") || p.endsWith(".mjs") || p.endsWith(".cjs");
                 });
-                sourceFileUploadFolderPromise = util__default["default"].promisify(fs__default["default"].mkdtemp)(path__default["default"].join(os__default["default"].tmpdir(), "sentry-bundler-plugin-upload-"));
-                _context4.next = 16;
+
+                if (!(unpluginMetaContext.framework === "esbuild")) {
+                  _context5.next = 17;
+                  break;
+                }
+
+                _context5.next = 17;
                 return Promise.all(debugIdChunkFilePaths.map( /*#__PURE__*/function () {
-                  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(chunkFilePath, chunkIndex) {
+                  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(debugIdChunkFilePath) {
+                    var chunkFileContents, debugId, newChunkFileContents;
                     return _regeneratorRuntime().wrap(function _callee3$(_context3) {
                       while (1) {
                         switch (_context3.prev = _context3.next) {
                           case 0:
-                            _context3.t0 = prepareBundleForDebugIdUpload;
-                            _context3.t1 = chunkFilePath;
-                            _context3.next = 4;
-                            return sourceFileUploadFolderPromise;
+                            _context3.next = 2;
+                            return util.promisify(fs__default["default"].readFile)(debugIdChunkFilePath, "utf-8");
 
-                          case 4:
-                            _context3.t2 = _context3.sent;
-                            _context3.t3 = String(chunkIndex);
-                            _context3.t4 = logger;
-                            _context3.next = 9;
-                            return (0, _context3.t0)(_context3.t1, _context3.t2, _context3.t3, _context3.t4);
+                          case 2:
+                            chunkFileContents = _context3.sent;
+                            debugId = stringToUUID(chunkFileContents);
+                            newChunkFileContents = chunkFileContents.replace(/__SENTRY_DEBUG_ID__/g, debugId);
+                            _context3.next = 7;
+                            return util.promisify(fs__default["default"].writeFile)(debugIdChunkFilePath, newChunkFileContents, "utf-8");
 
-                          case 9:
+                          case 7:
                           case "end":
                             return _context3.stop();
                         }
@@ -2520,61 +2539,95 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
                     }, _callee3);
                   }));
 
-                  return function (_x, _x2) {
+                  return function (_x) {
                     return _ref2.apply(this, arguments);
                   };
                 }()));
 
-              case 16:
-                _context4.next = 18;
-                return sourceFileUploadFolderPromise;
+              case 17:
+                sourceFileUploadFolderPromise = util.promisify(fs__default["default"].mkdtemp)(path__default["default"].join(os__default["default"].tmpdir(), "sentry-bundler-plugin-upload-"));
+                _context5.next = 20;
+                return Promise.all(debugIdChunkFilePaths.map( /*#__PURE__*/function () {
+                  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(chunkFilePath, chunkIndex) {
+                    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+                      while (1) {
+                        switch (_context4.prev = _context4.next) {
+                          case 0:
+                            _context4.t0 = prepareBundleForDebugIdUpload;
+                            _context4.t1 = chunkFilePath;
+                            _context4.next = 4;
+                            return sourceFileUploadFolderPromise;
 
-              case 18:
-                tmpUploadFolder = _context4.sent;
-                _context4.next = 21;
-                return uploadDebugIdSourcemaps(internalOptions, ctx, tmpUploadFolder, releaseName);
+                          case 4:
+                            _context4.t2 = _context4.sent;
+                            _context4.t3 = String(chunkIndex);
+                            _context4.t4 = logger;
+                            _context4.next = 9;
+                            return (0, _context4.t0)(_context4.t1, _context4.t2, _context4.t3, _context4.t4);
 
-              case 21:
-                _context4.next = 23;
-                return createNewRelease(internalOptions, ctx, releaseName);
+                          case 9:
+                          case "end":
+                            return _context4.stop();
+                        }
+                      }
+                    }, _callee4);
+                  }));
 
-              case 23:
-                _context4.next = 25;
-                return cleanArtifacts(internalOptions, ctx, releaseName);
+                  return function (_x2, _x3) {
+                    return _ref3.apply(this, arguments);
+                  };
+                }()));
+
+              case 20:
+                _context5.next = 22;
+                return sourceFileUploadFolderPromise;
+
+              case 22:
+                tmpUploadFolder = _context5.sent;
+                _context5.next = 25;
+                return uploadDebugIdSourcemaps(options, ctx, tmpUploadFolder, releaseName);
 
               case 25:
-                _context4.next = 27;
-                return uploadSourceMaps(internalOptions, ctx, releaseName);
+                _context5.next = 27;
+                return createNewRelease(options, ctx, releaseName);
 
               case 27:
-                _context4.next = 29;
-                return setCommits(internalOptions, ctx, releaseName);
+                _context5.next = 29;
+                return cleanArtifacts(options, ctx, releaseName);
 
               case 29:
-                _context4.next = 31;
-                return finalizeRelease(internalOptions, ctx, releaseName);
+                _context5.next = 31;
+                return uploadSourceMaps(options, ctx, releaseName);
 
               case 31:
-                _context4.next = 33;
-                return addDeploy(internalOptions, ctx, releaseName);
+                _context5.next = 33;
+                return setCommits(options, ctx, releaseName);
 
               case 33:
+                _context5.next = 35;
+                return finalizeRelease(options, ctx, releaseName);
+
+              case 35:
+                _context5.next = 37;
+                return addDeploy(options, ctx, releaseName);
+
+              case 37:
                 (_transaction = transaction) === null || _transaction === void 0 ? void 0 : _transaction.setStatus("ok");
-                _context4.next = 41;
+                _context5.next = 45;
                 break;
 
-              case 36:
-                _context4.prev = 36;
-                _context4.t0 = _context4["catch"](8);
+              case 40:
+                _context5.prev = 40;
+                _context5.t0 = _context5["catch"](8);
                 (_transaction2 = transaction) === null || _transaction2 === void 0 ? void 0 : _transaction2.setStatus("cancelled");
                 sentryHub.addBreadcrumb({
                   level: "error",
                   message: "Error during writeBundle"
                 });
-                handleError(_context4.t0, logger, internalOptions.errorHandler);
+                handleError(_context5.t0, logger, options.errorHandler);
 
-              case 41:
-                _context4.prev = 41;
+              case 45:
+                _context5.prev = 45;
 
                 if (tmpUploadFolder) {
                   fs__default["default"].rm(tmpUploadFolder, {
@@ -2586,33 +2639,33 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
 
                 releasePipelineSpan === null || releasePipelineSpan === void 0 ? void 0 : releasePipelineSpan.finish();
                 (_transaction3 = transaction) === null || _transaction3 === void 0 ? void 0 : _transaction3.finish();
-                _context4.next = 47;
+                _context5.next = 51;
                 return sentryClient.flush().then(null, function () {
                   logger.warn("Sending of telemetry failed");
                 });
 
-              case 47:
-                return _context4.finish(41);
+              case 51:
+                return _context5.finish(45);
 
-              case 48:
+              case 52:
                 sentryHub.addBreadcrumb({
                   category: "writeBundle:finish",
                   level: "info"
                 });
 
-              case 49:
+              case 53:
               case "end":
-                return _context4.stop();
+                return _context5.stop();
             }
           }
-        }, _callee4, null, [[8, 36, 41, 48]]);
+        }, _callee5, null, [[8, 40, 45, 52]]);
       }))();
     },
     rollup: {
       renderChunk: function renderChunk(code, chunk) {
-        var _options$_experiments;
+        var _options$sourcemaps2;
 
-        if ((_options$_experiments = options._experiments) !== null && _options$_experiments !== void 0 && _options$_experiments.debugIdUpload && [".js", ".mjs"].some(function (ending) {
+        if ((_options$sourcemaps2 = options.sourcemaps) !== null && _options$sourcemaps2 !== void 0 && _options$sourcemaps2.assets && [".js", ".mjs", ".cjs"].some(function (ending) {
           return chunk.fileName.endsWith(ending);
         }) // chunks could be any file (html, md, ...)
         ) {
@@ -2624,9 +2677,9 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
     },
     vite: {
       renderChunk: function renderChunk(code, chunk) {
-        var _options$_experiments2;
+        var _options$sourcemaps3;
 
-        if ((_options$_experiments2 = options._experiments) !== null && _options$_experiments2 !== void 0 && _options$_experiments2.debugIdUpload && [".js", ".mjs"].some(function (ending) {
+        if ((_options$sourcemaps3 = options.sourcemaps) !== null && _options$sourcemaps3 !== void 0 && _options$sourcemaps3.assets && [".js", ".mjs", ".cjs"].some(function (ending) {
           return chunk.fileName.endsWith(ending);
         }) // chunks could be any file (html, md, ...)
         ) {
@@ -2635,8 +2688,76 @@ var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext)
           return null; // returning null means not modifying the chunk at all
         }
       }
+    },
+    webpack: function webpack(compiler) {
+      var _options$sourcemaps4;
+
+      if ((_options$sourcemaps4 = options.sourcemaps) !== null && _options$sourcemaps4 !== void 0 && _options$sourcemaps4.assets) {
+        // Cache inspired by https://github.com/webpack/webpack/pull/15454
+        var cache = new WeakMap();
+        compiler.hooks.compilation.tap("sentry-plugin", function (compilation) {
+          compilation.hooks.optimizeChunkAssets.tap("sentry-plugin", function (chunks) {
+            chunks.forEach(function (chunk) {
+              var fileNames = chunk.files;
+              fileNames.forEach(function (fileName) {
+                var source = compilation.assets[fileName];
+
+                if (!source) {
+                  logger.warn("Unable to access compilation assets. If you see this warning, it is likely a bug in the Sentry webpack plugin. Feel free to open an issue at https://github.com/getsentry/sentry-javascript-bundler-plugins with reproduction steps.");
+                  return;
+                }
+
+                compilation.updateAsset(fileName, function (oldSource) {
+                  var cached = cache.get(oldSource);
+
+                  if (cached) {
+                    return cached;
+                  }
+
+                  var originalCode = source.source().toString(); // The source map type is very annoying :(
+                  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+
+                  var originalSourceMap = source.map();
+
+                  var _injectDebugIdSnippet = injectDebugIdSnippetIntoChunk(originalCode, fileName),
+                      newCode = _injectDebugIdSnippet.code,
+                      newSourceMap = _injectDebugIdSnippet.map; // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+
+
+                  newSourceMap.sources = originalSourceMap.sources; // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+
+                  newSourceMap.sourcesContent = originalSourceMap.sourcesContent;
+                  var newSource = new webpackSources.SourceMapSource(newCode, fileName, // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                  originalSourceMap, originalCode, newSourceMap, false);
+                  cache.set(oldSource, newSource);
+                  return newSource;
+                });
+              });
+            });
+          });
+        });
+      }
     }
-  };
+  });
+
+  if (unpluginMetaContext.framework === "esbuild") {
+    var _options$sourcemaps5;
+
+    if ((_options$sourcemaps5 = options.sourcemaps) !== null && _options$sourcemaps5 !== void 0 && _options$sourcemaps5.assets) {
+      plugins.push({
+        name: "sentry-esbuild-debug-id-plugin",
+        esbuild: {
+          setup: function setup(_ref4) {
+            var initialOptions = _ref4.initialOptions;
+            initialOptions.inject = initialOptions.inject || [];
+            initialOptions.inject.push(esbuildDebugIdInjectionFilePath);
+          }
+        }
+      });
+    }
+  }
+
+  return plugins;
 });
 
 function handleError(unknownError, logger, errorHandler) {
@@ -2662,12 +2783,12 @@ function handleError(unknownError, logger, errorHandler) {
  */
 
 
-function generateGlobalInjectorCode(_ref3) {
-  var release = _ref3.release,
-      injectReleasesMap = _ref3.injectReleasesMap,
-      injectBuildInformation = _ref3.injectBuildInformation,
-      org = _ref3.org,
-      project = _ref3.project;
+function generateGlobalInjectorCode(_ref5) {
+  var release = _ref5.release,
+      injectReleasesMap = _ref5.injectReleasesMap,
+      injectBuildInformation = _ref5.injectBuildInformation,
+      org = _ref5.org,
+      project = _ref5.project;
   // The code below is mostly ternary operators because it saves bundle size.
   // The checks are to support as many environments as possible. (Node.js, Browser, webworkers, etc.)
   var code = "\n    var _global =\n      typeof window !== 'undefined' ?\n        window :\n        typeof global !== 'undefined' ?\n          global :\n          typeof self !== 'undefined' ?\n            self :\n            {};\n\n    _global.SENTRY_RELEASE={id:\"".concat(release, "\"};");
@@ -2688,12 +2809,12 @@ function generateGlobalInjectorCode(_ref3) {
 function getBuildInformation() {
   var packageJson = getPackageJson();
 
-  var _ref4 = packageJson ? getDependencies(packageJson) : {
+  var _ref6 = packageJson ? getDependencies(packageJson) : {
     deps: [],
     depsVersions: {}
   },
-      deps = _ref4.deps,
-      depsVersions = _ref4.depsVersions;
+      deps = _ref6.deps,
+      depsVersions = _ref6.depsVersions;
 
   return {
     deps: deps,