@sentry/bundler-plugin-core 2.0.0-alpha.0 → 2.0.0-alpha.2

package/dist/cjs/index.js

@@ -2,18 +2,74 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var unplugin$1 = require('unplugin');
-var MagicString = require('magic-string');
 var SentryCli = require('@sentry/cli');
-var node = require('@sentry/node');
-require('@sentry/tracing');
+var fs = require('fs');
+var MagicString = require('magic-string');
+var unplugin = require('unplugin');
+var findUp = require('find-up');
 var path = require('path');
+var os = require('os');
+var crypto = require('crypto');
+var childProcess = require('child_process');
+var glob = require('glob');
+var util = require('util');
+var node = require('@sentry/node');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
 var SentryCli__default = /*#__PURE__*/_interopDefaultLegacy(SentryCli);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
+var findUp__default = /*#__PURE__*/_interopDefaultLegacy(findUp);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
+var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
+var childProcess__default = /*#__PURE__*/_interopDefaultLegacy(childProcess);
+var util__namespace = /*#__PURE__*/_interopNamespace(util);
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+
+  return target;
+}
 
 function _regeneratorRuntime() {
   /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
@@ -396,502 +452,260 @@ function _asyncToGenerator(fn) {
   };
 }
 
-/** Internal global with common properties and Sentry extensions  */
-
-// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification
-// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js
-// core-js has the following licence:
-//
-// Copyright (c) 2014-2022 Denis Pushkarev
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-/** Returns 'obj' if it's the global object, otherwise returns undefined */
-function isGlobalObj(obj) {
-  return obj && obj.Math == Math ? obj : undefined;
-}
-
-/** Get's the global object for the current JavaScript runtime */
-const GLOBAL_OBJ =
-  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||
-  // eslint-disable-next-line no-restricted-globals
-  (typeof window == 'object' && isGlobalObj(window)) ||
-  (typeof self == 'object' && isGlobalObj(self)) ||
-  (typeof global == 'object' && isGlobalObj(global)) ||
-  (function () {
-    return this;
-  })() ||
-  {};
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
 
-/**
- * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8
- */
-function getGlobalObject() {
-  return GLOBAL_OBJ ;
+  return obj;
 }
 
 /**
- * Returns a global singleton contained in the global `__SENTRY__` object.
- *
- * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory
- * function and added to the `__SENTRY__` object.
+ * Checks whether the given input is already an array, and if it isn't, wraps it in one.
  *
- * @param name name of the global singleton on __SENTRY__
- * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`
- * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value
- * @returns the singleton
+ * @param maybeArray Input to turn into an array, if necessary
+ * @returns The input, if already an array, or an array with the input as the only element, if not
  */
-function getGlobalSingleton(name, creator, obj) {
-  const gbl = (obj || GLOBAL_OBJ) ;
-  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});
-  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
-  return singleton;
-}
 
-/** Prefix for logging strings */
-const PREFIX = 'Sentry Logger ';
-
-const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;
+function arrayify(maybeArray) {
+  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+}
 
 /**
- * Temporarily disable sentry console instrumentations.
- *
- * @param callback The function to run against the original `console` messages
- * @returns The results of the callback
+ * Get the closes package.json from a given starting point upwards.
+ * This handles a few edge cases:
+ * * Check if a given file package.json appears to be an actual NPM package.json file
+ * * Stop at the home dir, to avoid looking too deeply
  */
-function consoleSandbox(callback) {
-  if (!('console' in GLOBAL_OBJ)) {
-    return callback();
-  }
+function getPackageJson() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      cwd = _ref.cwd,
+      stopAt = _ref.stopAt;
 
-  const originalConsole = GLOBAL_OBJ.console ;
-  const wrappedLevels = {};
-
-  // Restore all wrapped console methods
-  CONSOLE_LEVELS.forEach(level => {
-    // TODO(v7): Remove this check as it's only needed for Node 6
-    const originalWrappedFunc =
-      originalConsole[level] && (originalConsole[level] ).__sentry_original__;
-    if (level in originalConsole && originalWrappedFunc) {
-      wrappedLevels[level] = originalConsole[level] ;
-      originalConsole[level] = originalWrappedFunc ;
-    }
-  });
-
-  try {
-    return callback();
-  } finally {
-    // Revert restoration to wrapped state
-    Object.keys(wrappedLevels).forEach(level => {
-      originalConsole[level] = wrappedLevels[level ];
-    });
-  }
+  return lookupPackageJson(cwd !== null && cwd !== void 0 ? cwd : process.cwd(), path__default["default"].normalize(stopAt !== null && stopAt !== void 0 ? stopAt : os__default["default"].homedir()));
 }
+function parseMajorVersion(version) {
+  // if it has a `v` prefix, remove it
+  if (version.startsWith("v")) {
+    version = version.slice(1);
+  } // First, try simple lookup of exact, ~ and ^ versions
 
-function makeLogger() {
-  let enabled = false;
-  const logger = {
-    enable: () => {
-      enabled = true;
-    },
-    disable: () => {
-      enabled = false;
-    },
-  };
 
-  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
-    CONSOLE_LEVELS.forEach(name => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      logger[name] = (...args) => {
-        if (enabled) {
-          consoleSandbox(() => {
-            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
-          });
-        }
-      };
-    });
-  } else {
-    CONSOLE_LEVELS.forEach(name => {
-      logger[name] = () => undefined;
-    });
-  }
+  var regex = /^[\^~]?(\d+)(\.\d+)?(\.\d+)?(-.+)?/;
+  var match = version.match(regex);
 
-  return logger ;
-}
+  if (match) {
+    return parseInt(match[1], 10);
+  } // Try to parse e.g. 1.x
 
-// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
-let logger;
-if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
-  logger = getGlobalSingleton('logger', makeLogger);
-} else {
-  logger = makeLogger();
-}
 
-/*
- * This module exists for optimizations in the build process through rollup and terser.  We define some global
- * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these
- * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will
- * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to
- * `logger` and preventing node-related code from appearing in browser bundles.
- *
- * Attention:
- * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by
- * users. These fags should live in their respective packages, as we identified user tooling (specifically webpack)
- * having issues tree-shaking these constants across package boundaries.
- * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want
- * users to be able to shake away expressions that it guards.
- */
+  var coerced = parseInt(version, 10);
 
-/**
- * Figures out if we're building a browser bundle.
- *
- * @returns true if this is a browser bundle build.
- */
-function isBrowserBundle() {
-  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;
-}
+  if (!Number.isNaN(coerced)) {
+    return coerced;
+  } // Match <= and >= ranges.
 
-/**
- * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,
- * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.
- */
 
-/**
- * Checks whether we're in the Node.js or Browser environment
- *
- * @returns Answer to given question
- */
-function isNodeEnv() {
-  // explicitly check for browser bundles as those can be optimized statically
-  // by terser/rollup.
-  return (
-    !isBrowserBundle() &&
-    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'
-  );
-}
+  var gteLteRegex = /^[<>]=\s*(\d+)(\.\d+)?(\.\d+)?(-.+)?/;
+  var gteLteMatch = version.match(gteLteRegex);
 
-/**
- * Requires a module which is protected against bundler minification.
- *
- * @param request The module path to resolve
- */
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-function dynamicRequire(mod, request) {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  return mod.require(request);
-}
+  if (gteLteMatch) {
+    return parseInt(gteLteMatch[1], 10);
+  } // match < ranges
 
-/* eslint-disable @typescript-eslint/explicit-function-return-type */
 
-/** SyncPromise internal states */
-var States; (function (States) {
-  /** Pending */
-  const PENDING = 0; States[States["PENDING"] = PENDING] = "PENDING";
-  /** Resolved / OK */
-  const RESOLVED = 1; States[States["RESOLVED"] = RESOLVED] = "RESOLVED";
-  /** Rejected / Error */
-  const REJECTED = 2; States[States["REJECTED"] = REJECTED] = "REJECTED";
-})(States || (States = {}));
+  var ltRegex = /^<\s*(\d+)(\.\d+)?(\.\d+)?(-.+)?/;
+  var ltMatch = version.match(ltRegex);
 
-// eslint-disable-next-line deprecation/deprecation
-const WINDOW = getGlobalObject();
+  if (ltMatch) {
+    // Two scenarios:
+    // a) < 2.0.0 --> return 1
+    // b) < 2.1.0 --> return 2
+    var major = parseInt(ltMatch[1], 10);
 
-/**
- * An object that can return the current timestamp in seconds since the UNIX epoch.
- */
+    if ( // minor version > 0
+    typeof ltMatch[2] === "string" && parseInt(ltMatch[2].slice(1), 10) > 0 || // patch version > 0
+    typeof ltMatch[3] === "string" && parseInt(ltMatch[3].slice(1), 10) > 0) {
+      return major;
+    }
 
-/**
- * A TimestampSource implementation for environments that do not support the Performance Web API natively.
- *
- * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier
- * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It
- * is more obvious to explain "why does my span have negative duration" than "why my spans have zero duration".
- */
-const dateTimestampSource = {
-  nowSeconds: () => Date.now() / 1000,
-};
+    return major - 1;
+  } // match > ranges
 
-/**
- * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
- * for accessing a high-resolution monotonic clock.
- */
 
-/**
- * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
- * support the API.
- *
- * Wrapping the native API works around differences in behavior from different browsers.
- */
-function getBrowserPerformance() {
-  const { performance } = WINDOW;
-  if (!performance || !performance.now) {
-    return undefined;
+  var gtRegex = /^>\s*(\d+)(\.\d+)?(\.\d+)?(-.+)?/;
+  var gtMatch = version.match(gtRegex);
+
+  if (gtMatch) {
+    // We always return the version here, even though it _may_ be incorrect
+    // E.g. if given > 2.0.0, it should be 2 if there exists any 2.x.x version, else 3
+    // Since there is no way for us to know this, we're going to assume any kind of patch/feature release probably exists
+    return parseInt(gtMatch[1], 10);
   }
 
-  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().
-  //
-  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +
-  // performance.now() gives a date arbitrarily in the past.
-  //
-  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is
-  // undefined.
-  //
-  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to
-  // interact with data coming out of performance entries.
-  //
-  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that
-  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes
-  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have
-  // observed skews that can be as long as days, weeks or months.
-  //
-  // See https://github.com/getsentry/sentry-javascript/issues/2590.
-  //
-  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload
-  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation
-  // transactions of long-lived web pages.
-  const timeOrigin = Date.now() - performance.now();
+  return undefined;
+} // This is an explicit list of packages where we want to include the (major) version number.
 
+var PACKAGES_TO_INCLUDE_VERSION = ["react", "@angular/core", "vue", "ember-source", "svelte", "@sveltejs/kit", "webpack", "vite", "gatsby", "next", "remix", "rollup", "esbuild"];
+function getDependencies(packageJson) {
+  var _packageJson$devDepen, _packageJson$dependen;
+
+  var dependencies = Object.assign({}, (_packageJson$devDepen = packageJson["devDependencies"]) !== null && _packageJson$devDepen !== void 0 ? _packageJson$devDepen : {}, (_packageJson$dependen = packageJson["dependencies"]) !== null && _packageJson$dependen !== void 0 ? _packageJson$dependen : {});
+  var deps = Object.keys(dependencies).sort();
+  var depsVersions = deps.reduce(function (depsVersions, depName) {
+    if (PACKAGES_TO_INCLUDE_VERSION.includes(depName)) {
+      var version = dependencies[depName];
+      var majorVersion = parseMajorVersion(version);
+
+      if (majorVersion) {
+        depsVersions[depName] = majorVersion;
+      }
+    }
+
+    return depsVersions;
+  }, {});
   return {
-    now: () => performance.now(),
-    timeOrigin,
+    deps: deps,
+    depsVersions: depsVersions
   };
 }
 
-/**
- * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't
- * implement the API.
- */
-function getNodePerformance() {
-  try {
-    const perfHooks = dynamicRequire(module, 'perf_hooks') ;
-    return perfHooks.performance;
-  } catch (_) {
+function lookupPackageJson(cwd, stopAt) {
+  var jsonPath = findUp__default["default"].sync(function (dirName) {
+    // Stop if we reach this dir
+    if (path__default["default"].normalize(dirName) === stopAt) {
+      return findUp__default["default"].stop;
+    }
+
+    return findUp__default["default"].sync.exists(dirName + "/package.json") ? "package.json" : undefined;
+  }, {
+    cwd: cwd
+  });
+
+  if (!jsonPath) {
     return undefined;
   }
-}
 
-/**
- * The Performance API implementation for the current platform, if available.
- */
-const platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
+  try {
+    var jsonStr = fs__default["default"].readFileSync(jsonPath, "utf8");
+    var json = JSON.parse(jsonStr); // Ensure it is an actual package.json
+    // This is very much not bulletproof, but should be good enough
 
-const timestampSource =
-  platformPerformance === undefined
-    ? dateTimestampSource
-    : {
-        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,
-      };
+    if ("name" in json || "private" in json) {
+      return json;
+    }
+  } catch (error) {// Ignore and walk up
+  } // Continue up the tree, if we find a fitting package.json
 
-/**
- * Returns a timestamp in seconds since the UNIX epoch using the Date API.
- */
-dateTimestampSource.nowSeconds.bind(dateTimestampSource);
 
+  var newCwd = path__default["default"].dirname(path__default["default"].resolve(jsonPath + "/.."));
+  return lookupPackageJson(newCwd, stopAt);
+}
 /**
- * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
- * availability of the Performance API.
- *
- * See `usingPerformanceAPI` to test whether the Performance API is used.
- *
- * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
- * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
- * skew can grow to arbitrary amounts like days, weeks or months.
- * See https://github.com/getsentry/sentry-javascript/issues/2590.
+ * Deterministically hashes a string and turns the hash into a uuid.
  */
-timestampSource.nowSeconds.bind(timestampSource);
 
+
+function stringToUUID(str) {
+  var md5sum = crypto__default["default"].createHash("md5");
+  md5sum.update(str);
+  var md5Hash = md5sum.digest("hex");
+  return (md5Hash.substring(0, 8) + "-" + md5Hash.substring(8, 12) + "-4" + md5Hash.substring(13, 16) + "-" + md5Hash.substring(16, 20) + "-" + md5Hash.substring(20)).toLowerCase();
+}
 /**
- * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
- * performance API is available.
+ * Tries to guess a release name based on environmental data.
  */
-(() => {
-  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or
-  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin
-  // data as reliable if they are within a reasonable threshold of the current time.
 
-  const { performance } = WINDOW;
-  if (!performance || !performance.now) {
-    return undefined;
-  }
+function determineReleaseName() {
+  var gitRevision;
 
-  const threshold = 3600 * 1000;
-  const performanceNow = performance.now();
-  const dateNow = Date.now();
-
-  // if timeOrigin isn't available set delta to threshold so it isn't used
-  const timeOriginDelta = performance.timeOrigin
-    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)
-    : threshold;
-  const timeOriginIsReliable = timeOriginDelta < threshold;
-
-  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
-  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
-  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always
-  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the
-  // Date API.
-  // eslint-disable-next-line deprecation/deprecation
-  const navigationStart = performance.timing && performance.timing.navigationStart;
-  const hasNavigationStart = typeof navigationStart === 'number';
-  // if navigationStart isn't available set delta to threshold so it isn't used
-  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;
-  const navigationStartIsReliable = navigationStartDelta < threshold;
-
-  if (timeOriginIsReliable || navigationStartIsReliable) {
-    // Use the more reliable time origin
-    if (timeOriginDelta <= navigationStartDelta) {
-      return performance.timeOrigin;
-    } else {
-      return navigationStart;
-    }
+  try {
+    gitRevision = childProcess__default["default"].execSync("git rev-parse --short HEAD").toString().trim();
+  } catch (e) {// noop
   }
-  return dateNow;
-})();
 
+  return (// GitHub Actions - https://help.github.com/en/actions/configuring-and-managing-workflows/using-environment-variables#default-environment-variables
+    process.env["GITHUB_SHA"] || // Netlify - https://docs.netlify.com/configure-builds/environment-variables/#build-metadata
+    process.env["COMMIT_REF"] || // Cloudflare Pages - https://developers.cloudflare.com/pages/platform/build-configuration/#environment-variables
+    process.env["CF_PAGES_COMMIT_SHA"] || // AWS CodeBuild - https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html
+    process.env["CODEBUILD_RESOLVED_SOURCE_VERSION"] || // CircleCI - https://circleci.com/docs/2.0/env-vars/
+    process.env["CIRCLE_SHA1"] || // Vercel - https://vercel.com/docs/v2/build-step#system-environment-variables
+    process.env["VERCEL_GIT_COMMIT_SHA"] || process.env["VERCEL_GITHUB_COMMIT_SHA"] || process.env["VERCEL_GITLAB_COMMIT_SHA"] || process.env["VERCEL_BITBUCKET_COMMIT_SHA"] || // Zeit (now known as Vercel)
+    process.env["ZEIT_GITHUB_COMMIT_SHA"] || process.env["ZEIT_GITLAB_COMMIT_SHA"] || process.env["ZEIT_BITBUCKET_COMMIT_SHA"] || gitRevision
+  );
+}
 /**
- * Checks whether the given input is already an array, and if it isn't, wraps it in one.
- *
- * @param maybeArray Input to turn into an array, if necessary
- * @returns The input, if already an array, or an array with the input as the only element, if not
+ * Generates code for the global injector which is responsible for setting the global
+ * `SENTRY_RELEASE` & `SENTRY_BUILD_INFO` variables.
  */
-function arrayify(maybeArray) {
-  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+
+function generateGlobalInjectorCode(_ref2) {
+  var release = _ref2.release,
+      injectBuildInformation = _ref2.injectBuildInformation;
+  // 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, "\"};");
+
+  if (injectBuildInformation) {
+    var buildInfo = getBuildInformation$1();
+    code += "\n      _global.SENTRY_BUILD_INFO=".concat(JSON.stringify(buildInfo), ";");
+  }
+
+  return code;
+}
+
+function getBuildInformation$1() {
+  var packageJson = getPackageJson();
+
+  var _ref3 = packageJson ? getDependencies(packageJson) : {
+    deps: [],
+    depsVersions: {}
+  },
+      deps = _ref3.deps,
+      depsVersions = _ref3.depsVersions;
+
+  return {
+    deps: deps,
+    depsVersions: depsVersions,
+    nodeVersion: parseMajorVersion(process.version)
+  };
 }
 
 var SENTRY_SAAS_URL = "https://sentry.io";
 function normalizeUserOptions(userOptions) {
-  var _userOptions$org, _userOptions$project, _ref, _userOptions$release, _ref2, _userOptions$url, _userOptions$finalize, _userOptions$cleanArt, _userOptions$dryRun, _userOptions$debug, _userOptions$silent, _userOptions$telemetr, _userOptions$injectRe;
+  var _userOptions$org, _userOptions$project, _userOptions$authToke, _ref, _userOptions$url, _userOptions$debug, _userOptions$silent, _userOptions$telemetr, _userOptions$disable, _process$env$SENTRY_V, _userOptions$_experim;
 
   var options = {
-    // include is the only strictly required option
-    // (normalizeInclude needs all userOptions to access top-level include options)
-    include: normalizeInclude(userOptions),
-    // These options must be set b/c we need them for release injection.
-    // They can also be set as environment variables. Technically, they
-    // could be set in the config file but this would be too late for
-    // release injection because we only pass the config file path
-    // to the CLI
     org: (_userOptions$org = userOptions.org) !== null && _userOptions$org !== void 0 ? _userOptions$org : process.env["SENTRY_ORG"],
     project: (_userOptions$project = userOptions.project) !== null && _userOptions$project !== void 0 ? _userOptions$project : process.env["SENTRY_PROJECT"],
-    // Falling back to the empty string here b/c at a later point, we use
-    // Sentry CLI to determine a release if none was specified via options
-    // or env vars. In case we don't find one, we'll bail at that point.
-    release: (_ref = (_userOptions$release = userOptions.release) !== null && _userOptions$release !== void 0 ? _userOptions$release : process.env["SENTRY_RELEASE"]) !== null && _ref !== void 0 ? _ref : "",
-    // We technically don't need the URL for anything release-specific
-    // but we want to make sure that we're only sending Sentry data
-    // of SaaS customers. Hence we want to read it anyway.
-    url: (_ref2 = (_userOptions$url = userOptions.url) !== null && _userOptions$url !== void 0 ? _userOptions$url : process.env["SENTRY_URL"]) !== null && _ref2 !== void 0 ? _ref2 : SENTRY_SAAS_URL,
-    // Options with default values
-    finalize: (_userOptions$finalize = userOptions.finalize) !== null && _userOptions$finalize !== void 0 ? _userOptions$finalize : true,
-    cleanArtifacts: (_userOptions$cleanArt = userOptions.cleanArtifacts) !== null && _userOptions$cleanArt !== void 0 ? _userOptions$cleanArt : false,
-    dryRun: (_userOptions$dryRun = userOptions.dryRun) !== null && _userOptions$dryRun !== void 0 ? _userOptions$dryRun : false,
+    authToken: (_userOptions$authToke = userOptions.authToken) !== null && _userOptions$authToke !== void 0 ? _userOptions$authToke : process.env["SENTRY_AUTH_TOKEN"],
+    url: (_ref = (_userOptions$url = userOptions.url) !== null && _userOptions$url !== void 0 ? _userOptions$url : process.env["SENTRY_URL"]) !== null && _ref !== void 0 ? _ref : SENTRY_SAAS_URL,
+    headers: userOptions.headers,
     debug: (_userOptions$debug = userOptions.debug) !== null && _userOptions$debug !== void 0 ? _userOptions$debug : false,
     silent: (_userOptions$silent = userOptions.silent) !== null && _userOptions$silent !== void 0 ? _userOptions$silent : false,
-    telemetry: (_userOptions$telemetr = userOptions.telemetry) !== null && _userOptions$telemetr !== void 0 ? _userOptions$telemetr : true,
-    injectReleasesMap: (_userOptions$injectRe = userOptions.injectReleasesMap) !== null && _userOptions$injectRe !== void 0 ? _userOptions$injectRe : false,
-    // 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.
-    // Sentry CLI will internally query env variables and read its config file if
-    // the passed options are undefined.
-    authToken: userOptions.authToken,
-    // env var: `SENTRY_AUTH_TOKEN`
-    headers: userOptions.headers,
-    vcsRemote: userOptions.vcsRemote,
-    // env var: `SENTRY_VSC_REMOTE`
-    // Optional options
-    setCommits: userOptions.setCommits,
-    deploy: userOptions.deploy,
-    releaseInjectionTargets: normalizeReleaseInjectionTargets(userOptions.releaseInjectionTargets),
-    dist: userOptions.dist,
     errorHandler: userOptions.errorHandler,
-    configFile: userOptions.configFile
+    telemetry: (_userOptions$telemetr = userOptions.telemetry) !== null && _userOptions$telemetr !== void 0 ? _userOptions$telemetr : true,
+    disable: (_userOptions$disable = userOptions.disable) !== null && _userOptions$disable !== void 0 ? _userOptions$disable : false,
+    sourcemaps: userOptions.sourcemaps,
+    release: _objectSpread2({
+      name: determineReleaseName(),
+      inject: true,
+      create: true,
+      finalize: true,
+      vcsRemote: (_process$env$SENTRY_V = process.env["SENTRY_VSC_REMOTE"]) !== null && _process$env$SENTRY_V !== void 0 ? _process$env$SENTRY_V : "origin",
+      cleanArtifacts: false
+    }, userOptions.release),
+    _experiments: (_userOptions$_experim = userOptions._experiments) !== null && _userOptions$_experim !== void 0 ? _userOptions$_experim : {}
   };
   return options;
 }
-/**
- * Converts the user-facing `releaseInjectionTargets` option to the internal
- * `releaseInjectionTargets` option
- */
-
-function normalizeReleaseInjectionTargets(userReleaseInjectionTargets) {
-  if (userReleaseInjectionTargets === undefined) {
-    return undefined;
-  } else if (typeof userReleaseInjectionTargets === "function") {
-    return userReleaseInjectionTargets;
-  } else {
-    return arrayify(userReleaseInjectionTargets);
-  }
-}
-/**
- * Converts the user-facing `include` option to the internal `include` option,
- * resulting in an array of `InternalIncludeEntry` objects. This later on lets us
- * work with only one type of include data structure instead of multiple.
- *
- * During the process, we hoist top-level include options (e.g. urlPrefix) into each
- * object if they were not alrady specified in an `IncludeEntry`, making every object
- * fully self-contained. This is also the reason why we pass the entire options
- * object and not just `include`.
- *
- * @param userOptions the entire user-facing `options` object
- *
- * @return an array of `InternalIncludeEntry` objects.
- */
-
-
-function normalizeInclude(userOptions) {
-  return arrayify(userOptions.include).map(function (includeItem) {
-    return typeof includeItem === "string" ? {
-      paths: [includeItem]
-    } : includeItem;
-  }).map(function (userIncludeEntry) {
-    return normalizeIncludeEntry(userOptions, userIncludeEntry);
-  });
-}
-/**
- * Besides array-ifying the `ignore` option, this function hoists top level options into the items of the `include`
- * option. This is to simplify the handling of of the `include` items later on.
- */
-
-
-function normalizeIncludeEntry(userOptions, includeEntry) {
-  var _ref3, _includeEntry$ignore, _ref4, _includeEntry$ext, _includeEntry$ignoreF, _includeEntry$urlPref, _includeEntry$urlSuff, _includeEntry$stripPr, _ref5, _includeEntry$stripCo, _ref6, _includeEntry$sourceM, _ref7, _includeEntry$rewrite, _ref8, _includeEntry$validat;
-
-  var ignoreOption = (_ref3 = (_includeEntry$ignore = includeEntry.ignore) !== null && _includeEntry$ignore !== void 0 ? _includeEntry$ignore : userOptions.ignore) !== null && _ref3 !== void 0 ? _ref3 : ["node_modules"];
-  var ignore = Array.isArray(ignoreOption) ? ignoreOption : [ignoreOption]; // We're prefixing all entries in the `ext` option with a `.` (if it isn't already) to align with Node.js' `path.extname()`
-
-  var ext = (_ref4 = (_includeEntry$ext = includeEntry.ext) !== null && _includeEntry$ext !== void 0 ? _includeEntry$ext : userOptions.ext) !== null && _ref4 !== void 0 ? _ref4 : ["js", "map", "jsbundle", "bundle"];
-  var dotPrefixedExt = ext.map(function (extension) {
-    return ".".concat(extension.replace(/^\./, ""));
-  });
-  return {
-    paths: includeEntry.paths,
-    ignore: ignore,
-    ignoreFile: (_includeEntry$ignoreF = includeEntry.ignoreFile) !== null && _includeEntry$ignoreF !== void 0 ? _includeEntry$ignoreF : userOptions.ignoreFile,
-    ext: dotPrefixedExt,
-    urlPrefix: (_includeEntry$urlPref = includeEntry.urlPrefix) !== null && _includeEntry$urlPref !== void 0 ? _includeEntry$urlPref : userOptions.urlPrefix,
-    urlSuffix: (_includeEntry$urlSuff = includeEntry.urlSuffix) !== null && _includeEntry$urlSuff !== void 0 ? _includeEntry$urlSuff : userOptions.urlSuffix,
-    stripPrefix: (_includeEntry$stripPr = includeEntry.stripPrefix) !== null && _includeEntry$stripPr !== void 0 ? _includeEntry$stripPr : userOptions.stripPrefix,
-    stripCommonPrefix: (_ref5 = (_includeEntry$stripCo = includeEntry.stripCommonPrefix) !== null && _includeEntry$stripCo !== void 0 ? _includeEntry$stripCo : userOptions.stripCommonPrefix) !== null && _ref5 !== void 0 ? _ref5 : false,
-    sourceMapReference: (_ref6 = (_includeEntry$sourceM = includeEntry.sourceMapReference) !== null && _includeEntry$sourceM !== void 0 ? _includeEntry$sourceM : userOptions.sourceMapReference) !== null && _ref6 !== void 0 ? _ref6 : true,
-    rewrite: (_ref7 = (_includeEntry$rewrite = includeEntry.rewrite) !== null && _includeEntry$rewrite !== void 0 ? _includeEntry$rewrite : userOptions.rewrite) !== null && _ref7 !== void 0 ? _ref7 : true,
-    validate: (_ref8 = (_includeEntry$validat = includeEntry.validate) !== null && _includeEntry$validat !== void 0 ? _includeEntry$validat : userOptions.validate) !== null && _ref8 !== void 0 ? _ref8 : false
-  };
-}
 /**
  * Validates a few combinations of options that are not checked by Sentry CLI.
  *
@@ -905,14 +719,10 @@ function normalizeIncludeEntry(userOptions, includeEntry) {
  * @returns `true` if the options are valid, `false` otherwise
  */
 
-
 function validateOptions(options, logger) {
-  if (options.injectReleasesMap && !options.org) {
-    logger.error("The `injectReleasesMap` option was set but it is only supported when the `org` option is also specified.", "Please set the `org` option (you can also set the SENTRY_ORG environment variable) or disable the `injectReleasesMap` option.");
-    return false;
-  }
+  var _options$release, _options$release2, _options$release3;
 
-  var setCommits = options.setCommits;
+  var setCommits = (_options$release = options.release) === null || _options$release === void 0 ? void 0 : _options$release.setCommits;
 
   if (setCommits) {
     if (!setCommits.auto && !(setCommits.repo && setCommits.commit)) {
@@ -925,7 +735,7 @@ function validateOptions(options, logger) {
     }
   }
 
-  if (options.deploy && !options.deploy.env) {
+  if ((_options$release2 = options.release) !== null && _options$release2 !== void 0 && _options$release2.deploy && !((_options$release3 = options.release) !== null && _options$release3 !== void 0 && _options$release3.deploy.env)) {
     logger.error("The `deploy` option was specified but is missing the required `env` property.", "Please set the `env` property.");
     return false;
   }
@@ -933,595 +743,502 @@ function validateOptions(options, logger) {
   return true;
 }
 
-var SENTRY_SAAS_HOSTNAME = "sentry.io";
-function makeSentryClient(dsn, allowedToSendTelemetryPromise, userProject) {
-  var client = new node.NodeClient({
-    dsn: dsn,
-    tracesSampleRate: 1,
-    sampleRate: 1,
-    // We're also sending the user project in dist because it is an indexed fieldso we can use this data effectively in
-    // a dashboard.
-    // Yes, this is slightly abusing the purpose of this field.
-    dist: userProject,
-    release: "2.0.0-alpha.0",
-    integrations: [],
-    tracePropagationTargets: ["sentry.io/api"],
-    stackParser: node.defaultStackParser,
-    beforeSend: function beforeSend(event) {
-      var _event$exception, _event$exception$valu;
-
-      (_event$exception = event.exception) === null || _event$exception === void 0 ? void 0 : (_event$exception$valu = _event$exception.values) === null || _event$exception$valu === void 0 ? void 0 : _event$exception$valu.forEach(function (exception) {
-        delete exception.stacktrace;
-      });
-      delete event.server_name; // Server name might contain PII
+function debugIdUploadPlugin(_ref) {
+  var assets = _ref.assets,
+      ignore = _ref.ignore,
+      logger = _ref.logger,
+      releaseName = _ref.releaseName,
+      dist = _ref.dist,
+      handleRecoverableError = _ref.handleRecoverableError,
+      sentryHub = _ref.sentryHub,
+      sentryClient = _ref.sentryClient,
+      sentryCliOptions = _ref.sentryCliOptions;
+  return {
+    name: "sentry-debug-id-upload-plugin",
+    writeBundle: function writeBundle() {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        var folderToCleanUp, cliInstance, tmpUploadFolder, debugIdChunkFilePaths;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                cliInstance = new SentryCli__default["default"](null, sentryCliOptions);
+                _context2.prev = 1;
+                _context2.next = 4;
+                return fs__default["default"].promises.mkdtemp(path__default["default"].join(os__default["default"].tmpdir(), "sentry-bundler-plugin-upload-"));
+
+              case 4:
+                tmpUploadFolder = _context2.sent;
+                folderToCleanUp = tmpUploadFolder;
+                _context2.next = 8;
+                return glob.glob(assets, {
+                  absolute: true,
+                  nodir: true,
+                  ignore: ignore
+                });
 
-      return event;
-    },
-    beforeSendTransaction: function beforeSendTransaction(event) {
-      delete event.server_name; // Server name might contain PII
+              case 8:
+                debugIdChunkFilePaths = _context2.sent.filter(function (debugIdChunkFilePath) {
+                  return debugIdChunkFilePath.endsWith(".js") || debugIdChunkFilePath.endsWith(".mjs") || debugIdChunkFilePath.endsWith(".cjs");
+                });
+                _context2.next = 11;
+                return Promise.all(debugIdChunkFilePaths.map( /*#__PURE__*/function () {
+                  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(chunkFilePath, chunkIndex) {
+                    return _regeneratorRuntime().wrap(function _callee$(_context) {
+                      while (1) {
+                        switch (_context.prev = _context.next) {
+                          case 0:
+                            _context.next = 2;
+                            return prepareBundleForDebugIdUpload(chunkFilePath, tmpUploadFolder, String(chunkIndex), logger);
+
+                          case 2:
+                          case "end":
+                            return _context.stop();
+                        }
+                      }
+                    }, _callee);
+                  }));
+
+                  return function (_x, _x2) {
+                    return _ref2.apply(this, arguments);
+                  };
+                }()));
 
-      return event;
-    },
-    // We create a transport that stalls sending events until we know that we're allowed to (i.e. when Sentry CLI told
-    // us that the upload URL is the Sentry SaaS URL)
-    transport: function transport(nodeTransportOptions) {
-      var nodeTransport = node.makeNodeTransport(nodeTransportOptions);
-      return {
-        flush: function flush(timeout) {
-          return nodeTransport.flush(timeout);
-        },
-        send: function () {
-          var _send = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-            var isAllowedToSend;
-            return _regeneratorRuntime().wrap(function _callee$(_context) {
-              while (1) {
-                switch (_context.prev = _context.next) {
-                  case 0:
-                    _context.next = 2;
-                    return allowedToSendTelemetryPromise;
+              case 11:
+                _context2.next = 13;
+                return cliInstance.releases.uploadSourceMaps(releaseName !== null && releaseName !== void 0 ? releaseName : "", {
+                  include: [{
+                    paths: [tmpUploadFolder],
+                    rewrite: false,
+                    dist: dist
+                  }],
+                  useArtifactBundle: true
+                });
 
-                  case 2:
-                    isAllowedToSend = _context.sent;
+              case 13:
+                _context2.next = 21;
+                break;
 
-                    if (!isAllowedToSend) {
-                      _context.next = 7;
-                      break;
-                    }
+              case 15:
+                _context2.prev = 15;
+                _context2.t0 = _context2["catch"](1);
+                sentryHub.captureException('Error in "debugIdUploadPlugin" writeBundle hook');
+                _context2.next = 20;
+                return sentryClient.flush();
 
-                    return _context.abrupt("return", nodeTransport.send(request));
+              case 20:
+                handleRecoverableError(_context2.t0);
 
-                  case 7:
-                    return _context.abrupt("return", undefined);
+              case 21:
+                _context2.prev = 21;
 
-                  case 8:
-                  case "end":
-                    return _context.stop();
+                if (folderToCleanUp) {
+                  void fs__default["default"].promises.rm(folderToCleanUp, {
+                    recursive: true,
+                    force: true
+                  });
                 }
-              }
-            }, _callee);
-          }));
 
-          function send(_x) {
-            return _send.apply(this, arguments);
-          }
+                return _context2.finish(21);
 
-          return send;
-        }()
-      };
+              case 24:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, null, [[1, 15, 21, 24]]);
+      }))();
     }
-  });
-  var hub = new node.Hub(client);
-  return {
-    sentryClient: client,
-    sentryHub: hub
   };
 }
+function prepareBundleForDebugIdUpload(_x3, _x4, _x5, _x6) {
+  return _prepareBundleForDebugIdUpload.apply(this, arguments);
+}
 /**
- * Adds a span to the passed parentSpan or to the current transaction that's on the passed hub's scope.
+ * Looks for a particular string pattern (`sdbid-[debug ID]`) in the bundle
+ * source and extracts the bundle's debug ID from it.
+ *
+ * The string pattern is injected via the debug ID injection snipped.
  */
 
-function addSpanToTransaction(ctx, op, description) {
-  var _hub$getScope;
-
-  var hub = ctx.hub,
-      parentSpan = ctx.parentSpan;
-  var actualSpan = parentSpan || ((_hub$getScope = hub.getScope()) === null || _hub$getScope === void 0 ? void 0 : _hub$getScope.getTransaction());
-  var span = actualSpan === null || actualSpan === void 0 ? void 0 : actualSpan.startChild({
-    op: op,
-    description: description
-  });
-  hub.configureScope(function (scope) {
-    return scope.setSpan(span);
-  });
-  return span;
-}
-function addPluginOptionInformationToHub(options, hub, bundler) {
-  var org = options.org,
-      project = options.project,
-      cleanArtifacts = options.cleanArtifacts,
-      finalize = options.finalize,
-      setCommits = options.setCommits,
-      injectReleasesMap = options.injectReleasesMap,
-      dryRun = options.dryRun,
-      errorHandler = options.errorHandler,
-      deploy = options.deploy,
-      include = options.include;
-  hub.setTag("include", include.length > 1 ? "multiple-entries" : "single-entry"); // Optional release pipeline steps
-
-  if (cleanArtifacts) {
-    hub.setTag("clean-artifacts", true);
-  }
-
-  if (setCommits) {
-    hub.setTag("set-commits", setCommits.auto === true ? "auto" : "manual");
-  }
-
-  if (finalize) {
-    hub.setTag("finalize-release", true);
-  }
-
-  if (deploy) {
-    hub.setTag("add-deploy", true);
-  } // Miscelaneous options
-
-
-  if (dryRun) {
-    hub.setTag("dry-run", true);
-  }
-
-  if (injectReleasesMap) {
-    hub.setTag("inject-releases-map", true);
-  }
-
-  if (errorHandler) {
-    hub.setTag("error-handler", "custom");
-  }
-
-  hub.setTag("node", process.version);
-  hub.setTags({
-    organization: org,
-    project: project,
-    bundler: bundler
-  });
-  hub.setUser({
-    id: org
-  });
-}
-function shouldSendTelemetry(_x2) {
-  return _shouldSendTelemetry.apply(this, arguments);
-}
-
-function _shouldSendTelemetry() {
-  _shouldSendTelemetry = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(options) {
-    var _cliInfo$split$, _cliInfo$split$$repla;
-
-    var silent, org, project, authToken, url, vcsRemote, headers, telemetry, dryRun, cli, cliInfo, cliInfoUrl;
-    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+function _prepareBundleForDebugIdUpload() {
+  _prepareBundleForDebugIdUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(bundleFilePath, uploadFolder, uniqueUploadName, logger) {
+    var bundleContent, debugId, writeSourceFilePromise, writeSourceMapFilePromise;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
       while (1) {
-        switch (_context2.prev = _context2.next) {
+        switch (_context4.prev = _context4.next) {
           case 0:
-            silent = options.silent, org = options.org, project = options.project, authToken = options.authToken, url = options.url, vcsRemote = options.vcsRemote, headers = options.headers, telemetry = options.telemetry, dryRun = options.dryRun; // `options.telemetry` defaults to true
-
-            if (!(telemetry === false)) {
-              _context2.next = 3;
-              break;
-            }
-
-            return _context2.abrupt("return", false);
+            _context4.prev = 0;
+            _context4.next = 3;
+            return util.promisify(fs__default["default"].readFile)(bundleFilePath, "utf8");
 
           case 3:
-            if (!dryRun) {
-              _context2.next = 5;
-              break;
-            }
-
-            return _context2.abrupt("return", false);
-
-          case 5:
-            if (!(url === SENTRY_SAAS_URL)) {
-              _context2.next = 7;
-              break;
-            }
-
-            return _context2.abrupt("return", true);
-
-          case 7:
-            cli = new SentryCli__default["default"](options.configFile, {
-              url: url,
-              authToken: authToken,
-              org: org,
-              project: project,
-              vcsRemote: vcsRemote,
-              silent: silent,
-              headers: headers
-            });
-            _context2.prev = 8;
-            _context2.next = 11;
-            return cli.execute(["info"], false);
-
-          case 11:
-            cliInfo = _context2.sent;
-            _context2.next = 17;
+            bundleContent = _context4.sent;
+            _context4.next = 10;
             break;
 
-          case 14:
-            _context2.prev = 14;
-            _context2.t0 = _context2["catch"](8);
-            throw new Error('Sentry CLI "info" command failed, make sure you have an auth token configured, and your `url` option is correct.');
+          case 6:
+            _context4.prev = 6;
+            _context4.t0 = _context4["catch"](0);
+            logger.error("Could not read bundle to determine debug ID and source map: ".concat(bundleFilePath), _context4.t0);
+            return _context4.abrupt("return");
 
-          case 17:
-            cliInfoUrl = (_cliInfo$split$ = cliInfo.split(/(\r\n|\n|\r)/)[0]) === null || _cliInfo$split$ === void 0 ? void 0 : (_cliInfo$split$$repla = _cliInfo$split$.replace(/^Sentry Server: /, "")) === null || _cliInfo$split$$repla === void 0 ? void 0 : _cliInfo$split$$repla.trim();
+          case 10:
+            debugId = determineDebugIdFromBundleSource(bundleContent);
 
-            if (!(cliInfoUrl === undefined)) {
-              _context2.next = 20;
+            if (!(debugId === undefined)) {
+              _context4.next = 14;
               break;
             }
 
-            return _context2.abrupt("return", false);
+            logger.warn("Could not determine debug ID from bundle. This can happen if you did not clean your output folder before installing the Sentry plugin. File will not be source mapped: ".concat(bundleFilePath));
+            return _context4.abrupt("return");
 
-          case 20:
-            return _context2.abrupt("return", new URL(cliInfoUrl).hostname === SENTRY_SAAS_HOSTNAME);
+          case 14:
+            bundleContent += "\n//# debugId=".concat(debugId);
+            writeSourceFilePromise = fs__default["default"].promises.writeFile(path__default["default"].join(uploadFolder, "".concat(uniqueUploadName, ".js")), bundleContent, "utf-8");
+            writeSourceMapFilePromise = determineSourceMapPathFromBundle(bundleFilePath, bundleContent, logger).then( /*#__PURE__*/function () {
+              var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(sourceMapPath) {
+                return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                  while (1) {
+                    switch (_context3.prev = _context3.next) {
+                      case 0:
+                        if (!sourceMapPath) {
+                          _context3.next = 4;
+                          break;
+                        }
+
+                        _context3.next = 3;
+                        return prepareSourceMapForDebugIdUpload(sourceMapPath, path__default["default"].join(uploadFolder, "".concat(uniqueUploadName, ".js.map")), debugId, logger);
+
+                      case 3:
+                        return _context3.abrupt("return", _context3.sent);
+
+                      case 4:
+                      case "end":
+                        return _context3.stop();
+                    }
+                  }
+                }, _callee3);
+              }));
+
+              return function (_x14) {
+                return _ref3.apply(this, arguments);
+              };
+            }());
+            return _context4.abrupt("return", Promise.all([writeSourceFilePromise, writeSourceMapFilePromise]));
 
-          case 21:
+          case 18:
           case "end":
-            return _context2.stop();
+            return _context4.stop();
         }
       }
-    }, _callee2, null, [[8, 14]]);
+    }, _callee4, null, [[0, 6]]);
   }));
-  return _shouldSendTelemetry.apply(this, arguments);
-}
-
-function createNewRelease(_x, _x2, _x3) {
-  return _createNewRelease.apply(this, arguments);
+  return _prepareBundleForDebugIdUpload.apply(this, arguments);
 }
 
-function _createNewRelease() {
-  _createNewRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(options, ctx, releaseName) {
-    var span;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            span = addSpanToTransaction(ctx, "function.plugin.create_release");
-            _context.prev = 1;
-            _context.next = 4;
-            return ctx.cli.releases["new"](releaseName);
-
-          case 4:
-            _context.next = 10;
-            break;
+function determineDebugIdFromBundleSource(code) {
+  var match = code.match(/sentry-dbid-([0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12})/);
 
-          case 6:
-            _context.prev = 6;
-            _context.t0 = _context["catch"](1);
-            ctx.hub.captureException(new Error("CLI Error: Creating new release failed"));
-            throw _context.t0;
+  if (match) {
+    return match[1];
+  } else {
+    return undefined;
+  }
+}
+/**
+ * Applies a set of heuristics to find the source map for a particular bundle.
+ *
+ * @returns the path to the bundle's source map or `undefined` if none could be found.
+ */
 
-          case 10:
-            _context.prev = 10;
-            span === null || span === void 0 ? void 0 : span.finish();
-            return _context.finish(10);
-
-          case 13:
-            ctx.hub.addBreadcrumb({
-              level: "info",
-              message: "Successfully created release."
-            });
-            ctx.logger.info("Successfully created release.");
 
-          case 15:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee, null, [[1, 6, 10, 13]]);
-  }));
-  return _createNewRelease.apply(this, arguments);
+function determineSourceMapPathFromBundle(_x7, _x8, _x9) {
+  return _determineSourceMapPathFromBundle.apply(this, arguments);
 }
+/**
+ * Reads a source map, injects debug ID fields, and writes the source map to the target path.
+ */
 
-function cleanArtifacts(_x4, _x5, _x6) {
-  return _cleanArtifacts.apply(this, arguments);
-}
 
-function _cleanArtifacts() {
-  _cleanArtifacts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(options, ctx, releaseName) {
-    var span;
-    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+function _determineSourceMapPathFromBundle() {
+  _determineSourceMapPathFromBundle = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(bundlePath, bundleSource, logger) {
+    var sourceMappingUrlMatch, sourceMappingUrl, adjacentSourceMapFilePath;
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
       while (1) {
-        switch (_context2.prev = _context2.next) {
+        switch (_context5.prev = _context5.next) {
           case 0:
-            if (options.cleanArtifacts) {
-              _context2.next = 3;
+            // 1. try to find source map at `sourceMappingURL` location
+            sourceMappingUrlMatch = bundleSource.match(/^\/\/# sourceMappingURL=(.*)$/);
+
+            if (!sourceMappingUrlMatch) {
+              _context5.next = 8;
               break;
             }
 
-            logger.debug("Skipping artifact cleanup.");
-            return _context2.abrupt("return");
+            sourceMappingUrl = path__default["default"].normalize(sourceMappingUrlMatch[1]);
 
-          case 3:
-            span = addSpanToTransaction(ctx, "function.plugin.clean_artifacts");
-            _context2.prev = 4;
-            _context2.next = 7;
-            return ctx.cli.releases.execute(["releases", "files", releaseName, "delete", "--all"], true);
+            if (!path__default["default"].isAbsolute(sourceMappingUrl)) {
+              _context5.next = 7;
+              break;
+            }
+
+            return _context5.abrupt("return", sourceMappingUrl);
 
           case 7:
-            _context2.next = 13;
-            break;
+            return _context5.abrupt("return", path__default["default"].join(path__default["default"].dirname(bundlePath), sourceMappingUrl));
 
-          case 9:
-            _context2.prev = 9;
-            _context2.t0 = _context2["catch"](4);
-            ctx.hub.captureException(new Error("CLI Error: Deleting release files failed"));
-            throw _context2.t0;
+          case 8:
+            _context5.prev = 8;
+            adjacentSourceMapFilePath = bundlePath + ".map";
+            _context5.next = 12;
+            return util__namespace.promisify(fs__default["default"].access)(adjacentSourceMapFilePath);
 
-          case 13:
-            _context2.prev = 13;
-            span === null || span === void 0 ? void 0 : span.finish();
-            return _context2.finish(13);
+          case 12:
+            return _context5.abrupt("return", adjacentSourceMapFilePath);
 
-          case 16:
-            ctx.hub.addBreadcrumb({
-              level: "info",
-              message: "Successfully cleaned previous artifacts."
-            });
-            ctx.logger.info("Successfully cleaned previous artifacts.");
+          case 15:
+            _context5.prev = 15;
+            _context5.t0 = _context5["catch"](8);
 
-          case 18:
+          case 17:
+            logger.warn("Could not determine source map path for bundle: ".concat(bundlePath));
+            return _context5.abrupt("return", undefined);
+
+          case 19:
           case "end":
-            return _context2.stop();
+            return _context5.stop();
         }
       }
-    }, _callee2, null, [[4, 9, 13, 16]]);
+    }, _callee5, null, [[8, 15]]);
   }));
-  return _cleanArtifacts.apply(this, arguments);
+  return _determineSourceMapPathFromBundle.apply(this, arguments);
 }
 
-function uploadSourceMaps(_x7, _x8, _x9) {
-  return _uploadSourceMaps.apply(this, arguments);
+function prepareSourceMapForDebugIdUpload(_x10, _x11, _x12, _x13) {
+  return _prepareSourceMapForDebugIdUpload.apply(this, arguments);
 }
 
-function _uploadSourceMaps() {
-  _uploadSourceMaps = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(options, ctx, releaseName) {
-    var span;
-    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+function _prepareSourceMapForDebugIdUpload() {
+  _prepareSourceMapForDebugIdUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(sourceMapPath, targetPath, debugId, logger) {
+    var sourceMapFileContent, map;
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
       while (1) {
-        switch (_context3.prev = _context3.next) {
+        switch (_context6.prev = _context6.next) {
           case 0:
-            span = addSpanToTransaction(ctx, "function.plugin.upload_sourcemaps");
-            ctx.logger.info("Uploading Sourcemaps."); // Since our internal include entries contain all top-level sourcemaps options,
-            // we only need to pass the include option here.
-
-            _context3.prev = 2;
-            _context3.next = 5;
-            return ctx.cli.releases.uploadSourceMaps(releaseName, {
-              include: options.include,
-              dist: options.dist
+            _context6.prev = 0;
+            _context6.next = 3;
+            return util__namespace.promisify(fs__default["default"].readFile)(sourceMapPath, {
+              encoding: "utf8"
             });
 
-          case 5:
-            _context3.next = 11;
+          case 3:
+            sourceMapFileContent = _context6.sent;
+            _context6.next = 10;
             break;
 
-          case 7:
-            _context3.prev = 7;
-            _context3.t0 = _context3["catch"](2);
-            ctx.hub.captureException(new Error("CLI Error: Uploading source maps failed"));
-            throw _context3.t0;
+          case 6:
+            _context6.prev = 6;
+            _context6.t0 = _context6["catch"](0);
+            logger.error("Failed to read source map for debug ID upload: ".concat(sourceMapPath), _context6.t0);
+            return _context6.abrupt("return");
 
-          case 11:
-            _context3.prev = 11;
-            span === null || span === void 0 ? void 0 : span.finish();
-            return _context3.finish(11);
+          case 10:
+            _context6.prev = 10;
+            map = JSON.parse(sourceMapFileContent); // For now we write both fields until we know what will become the standard - if ever.
 
-          case 14:
-            ctx.hub.addBreadcrumb({
-              level: "info",
-              message: "Successfully uploaded source maps."
-            });
-            ctx.logger.info("Successfully uploaded source maps.");
+            map["debug_id"] = debugId;
+            map["debugId"] = debugId;
+            _context6.next = 20;
+            break;
 
           case 16:
-          case "end":
-            return _context3.stop();
-        }
-      }
-    }, _callee3, null, [[2, 7, 11, 14]]);
-  }));
-  return _uploadSourceMaps.apply(this, arguments);
-}
-
-function setCommits(_x10, _x11, _x12) {
-  return _setCommits.apply(this, arguments);
-}
-
-function _setCommits() {
-  _setCommits = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(options, ctx, releaseName) {
-    var span, _options$setCommits, auto, repo, commit, previousCommit, ignoreMissing, ignoreEmpty;
-
-    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-      while (1) {
-        switch (_context4.prev = _context4.next) {
-          case 0:
-            if (options.setCommits) {
-              _context4.next = 3;
-              break;
-            }
-
-            logger.debug("Skipping setting commits to release.");
-            return _context4.abrupt("return");
+            _context6.prev = 16;
+            _context6.t1 = _context6["catch"](10);
+            logger.error("Failed to parse source map for debug ID upload: ".concat(sourceMapPath));
+            return _context6.abrupt("return");
 
-          case 3:
-            span = addSpanToTransaction(ctx, "function.plugin.set_commits");
-            _options$setCommits = options.setCommits, auto = _options$setCommits.auto, repo = _options$setCommits.repo, commit = _options$setCommits.commit, previousCommit = _options$setCommits.previousCommit, ignoreMissing = _options$setCommits.ignoreMissing, ignoreEmpty = _options$setCommits.ignoreEmpty;
-            _context4.prev = 5;
-            _context4.next = 8;
-            return ctx.cli.releases.setCommits(releaseName, {
-              commit: commit,
-              previousCommit: previousCommit,
-              repo: repo,
-              auto: auto,
-              ignoreMissing: ignoreMissing,
-              ignoreEmpty: ignoreEmpty
+          case 20:
+            _context6.prev = 20;
+            _context6.next = 23;
+            return util__namespace.promisify(fs__default["default"].writeFile)(targetPath, JSON.stringify(map), {
+              encoding: "utf8"
             });
 
-          case 8:
-            _context4.next = 14;
+          case 23:
+            _context6.next = 29;
             break;
 
-          case 10:
-            _context4.prev = 10;
-            _context4.t0 = _context4["catch"](5);
-            ctx.hub.captureException(new Error("CLI Error: Setting commits failed"));
-            throw _context4.t0;
-
-          case 14:
-            _context4.prev = 14;
-            span === null || span === void 0 ? void 0 : span.finish();
-            return _context4.finish(14);
-
-          case 17:
-            ctx.logger.info("Successfully set commits.");
+          case 25:
+            _context6.prev = 25;
+            _context6.t2 = _context6["catch"](20);
+            logger.error("Failed to prepare source map for debug ID upload: ".concat(sourceMapPath), _context6.t2);
+            return _context6.abrupt("return");
 
-          case 18:
+          case 29:
           case "end":
-            return _context4.stop();
+            return _context6.stop();
         }
       }
-    }, _callee4, null, [[5, 10, 14, 17]]);
+    }, _callee6, null, [[0, 6], [10, 16], [20, 25]]);
   }));
-  return _setCommits.apply(this, arguments);
-}
-
-function finalizeRelease(_x13, _x14, _x15) {
-  return _finalizeRelease.apply(this, arguments);
+  return _prepareSourceMapForDebugIdUpload.apply(this, arguments);
 }
 
-function _finalizeRelease() {
-  _finalizeRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(options, ctx, releaseName) {
-    var span;
-    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-      while (1) {
-        switch (_context5.prev = _context5.next) {
-          case 0:
-            if (options.finalize) {
-              _context5.next = 4;
-              break;
-            }
+function releaseManagementPlugin(_ref) {
+  var releaseName = _ref.releaseName,
+      include = _ref.include,
+      dist = _ref.dist,
+      setCommitsOption = _ref.setCommitsOption,
+      shouldCreateRelease = _ref.shouldCreateRelease,
+      shouldCleanArtifacts = _ref.shouldCleanArtifacts,
+      shouldFinalizeRelease = _ref.shouldFinalizeRelease,
+      deployOptions = _ref.deployOptions,
+      handleRecoverableError = _ref.handleRecoverableError,
+      sentryHub = _ref.sentryHub,
+      sentryClient = _ref.sentryClient,
+      sentryCliOptions = _ref.sentryCliOptions;
+  return {
+    name: "sentry-debug-id-upload-plugin",
+    writeBundle: function writeBundle() {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var cliInstance, normalizedInclude;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.prev = 0;
+                cliInstance = new SentryCli__default["default"](null, sentryCliOptions);
 
-            ctx.hub.addBreadcrumb({
-              level: "info",
-              message: "Skipping release finalization."
-            });
-            logger.debug("Skipping release finalization.");
-            return _context5.abrupt("return");
+                if (!shouldCreateRelease) {
+                  _context.next = 5;
+                  break;
+                }
 
-          case 4:
-            span = addSpanToTransaction(ctx, "function.plugin.finalize_release");
-            _context5.prev = 5;
-            _context5.next = 8;
-            return ctx.cli.releases.finalize(releaseName);
+                _context.next = 5;
+                return cliInstance.releases["new"](releaseName);
 
-          case 8:
-            _context5.next = 14;
-            break;
+              case 5:
+                if (!shouldCleanArtifacts) {
+                  _context.next = 8;
+                  break;
+                }
 
-          case 10:
-            _context5.prev = 10;
-            _context5.t0 = _context5["catch"](5);
-            ctx.hub.captureException(new Error("CLI Error: Finalizing release failed"));
-            throw _context5.t0;
+                _context.next = 8;
+                return cliInstance.releases.execute(["releases", "files", releaseName, "delete", "--all"], true);
 
-          case 14:
-            _context5.prev = 14;
-            span === null || span === void 0 ? void 0 : span.finish();
-            return _context5.finish(14);
+              case 8:
+                if (!include) {
+                  _context.next = 12;
+                  break;
+                }
 
-          case 17:
-            ctx.hub.addBreadcrumb({
-              level: "info",
-              message: "Successfully finalized release."
-            });
-            ctx.logger.info("Successfully finalized release.");
+                normalizedInclude = arrayify(include).map(function (includeItem) {
+                  return typeof includeItem === "string" ? {
+                    paths: [includeItem]
+                  } : includeItem;
+                }).map(function (includeEntry) {
+                  var _includeEntry$validat;
+
+                  return _objectSpread2(_objectSpread2({}, includeEntry), {}, {
+                    validate: (_includeEntry$validat = includeEntry.validate) !== null && _includeEntry$validat !== void 0 ? _includeEntry$validat : false,
+                    ext: includeEntry.ext ? includeEntry.ext.map(function (extension) {
+                      return ".".concat(extension.replace(/^\./, ""));
+                    }) : [".js", ".map", ".jsbundle", ".bundle"],
+                    ignore: includeEntry.ignore ? arrayify(includeEntry.ignore) : undefined
+                  });
+                });
+                _context.next = 12;
+                return cliInstance.releases.uploadSourceMaps(releaseName, {
+                  include: normalizedInclude,
+                  dist: dist
+                });
 
-          case 19:
-          case "end":
-            return _context5.stop();
-        }
-      }
-    }, _callee5, null, [[5, 10, 14, 17]]);
-  }));
-  return _finalizeRelease.apply(this, arguments);
-}
+              case 12:
+                if (!setCommitsOption) {
+                  _context.next = 15;
+                  break;
+                }
 
-function addDeploy(_x16, _x17, _x18) {
-  return _addDeploy.apply(this, arguments);
-}
+                _context.next = 15;
+                return cliInstance.releases.setCommits(releaseName, setCommitsOption);
 
-function _addDeploy() {
-  _addDeploy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(options, ctx, releaseName) {
-    var span, _options$deploy, env, started, finished, time, name, url;
+              case 15:
+                if (!shouldFinalizeRelease) {
+                  _context.next = 18;
+                  break;
+                }
 
-    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
-      while (1) {
-        switch (_context6.prev = _context6.next) {
-          case 0:
-            if (options.deploy) {
-              _context6.next = 4;
-              break;
-            }
+                _context.next = 18;
+                return cliInstance.releases.finalize(releaseName);
 
-            ctx.hub.addBreadcrumb({
-              level: "info",
-              message: "Skipping adding deploy info to release."
-            });
-            logger.debug("Skipping adding deploy info to release.");
-            return _context6.abrupt("return");
+              case 18:
+                if (!deployOptions) {
+                  _context.next = 21;
+                  break;
+                }
 
-          case 4:
-            span = addSpanToTransaction(ctx, "function.plugin.deploy");
-            _options$deploy = options.deploy, env = _options$deploy.env, started = _options$deploy.started, finished = _options$deploy.finished, time = _options$deploy.time, name = _options$deploy.name, url = _options$deploy.url;
-            _context6.prev = 6;
-            _context6.next = 9;
-            return ctx.cli.releases.newDeploy(releaseName, {
-              env: env,
-              started: started,
-              finished: finished,
-              time: time,
-              name: name,
-              url: url
-            });
+                _context.next = 21;
+                return cliInstance.releases.newDeploy(releaseName, deployOptions);
 
-          case 9:
-            _context6.next = 15;
-            break;
+              case 21:
+                _context.next = 29;
+                break;
 
-          case 11:
-            _context6.prev = 11;
-            _context6.t0 = _context6["catch"](6);
-            ctx.hub.captureException(new Error("CLI Error: Adding deploy info failed"));
-            throw _context6.t0;
+              case 23:
+                _context.prev = 23;
+                _context.t0 = _context["catch"](0);
+                sentryHub.captureException('Error in "releaseManagementPlugin" writeBundle hook');
+                _context.next = 28;
+                return sentryClient.flush();
 
-          case 15:
-            _context6.prev = 15;
-            span === null || span === void 0 ? void 0 : span.finish();
-            return _context6.finish(15);
+              case 28:
+                handleRecoverableError(_context.t0);
 
-          case 18:
-            ctx.hub.addBreadcrumb({
-              level: "info",
-              message: "Successfully added deploy."
-            });
-            ctx.logger.info("Successfully added deploy.");
+              case 29:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, null, [[0, 23]]);
+      }))();
+    }
+  };
+}
 
-          case 20:
-          case "end":
-            return _context6.stop();
-        }
-      }
-    }, _callee6, null, [[6, 11, 15, 18]]);
-  }));
-  return _addDeploy.apply(this, arguments);
+function telemetryPlugin(_ref) {
+  var sentryClient = _ref.sentryClient,
+      pluginExecutionTransaction = _ref.pluginExecutionTransaction,
+      shouldSendTelemetry = _ref.shouldSendTelemetry,
+      logger = _ref.logger;
+  return {
+    name: "sentry-telemetry-plugin",
+    buildStart: function buildStart() {
+      void shouldSendTelemetry.then(function () {
+        logger.info("Sending error and performance telemetry data to Sentry. To disable telemetry, set `options.telemetry` to `false`.");
+      });
+      pluginExecutionTransaction.startTimestamp = Date.now() / 1000;
+    },
+    writeBundle: function writeBundle() {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                pluginExecutionTransaction.finish();
+                _context.next = 3;
+                return sentryClient.flush();
+
+              case 3:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }))();
+    }
+  };
 }
 
 function createLogger(options) {
@@ -1577,91 +1294,222 @@ function createLogger(options) {
   };
 }
 
-/**
- * Creates a new Sentry CLI instance.
- *
- * In case, users selected the `dryRun` options, this returns a stub
- * that makes no-ops out of most CLI operations
- */
-function getSentryCli(internalOptions, logger) {
-  var silent = internalOptions.silent,
-      org = internalOptions.org,
-      project = internalOptions.project,
-      authToken = internalOptions.authToken,
-      url = internalOptions.url,
-      vcsRemote = internalOptions.vcsRemote,
-      headers = internalOptions.headers;
-  var cli = new SentryCli__default["default"](internalOptions.configFile, {
-    url: url,
-    authToken: authToken,
-    org: org,
-    project: project,
-    vcsRemote: vcsRemote,
-    silent: silent,
-    headers: headers
+var SENTRY_SAAS_HOSTNAME = "sentry.io";
+function createSentryInstance(options, shouldSendTelemetry, bundler) {
+  var client = new node.NodeClient({
+    dsn: "https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737",
+    tracesSampleRate: 1,
+    sampleRate: 1,
+    release: "2.0.0-alpha.2",
+    integrations: [],
+    tracePropagationTargets: ["sentry.io/api"],
+    stackParser: node.defaultStackParser,
+    beforeSend: function beforeSend(event) {
+      var _event$exception, _event$exception$valu;
+
+      (_event$exception = event.exception) === null || _event$exception === void 0 ? void 0 : (_event$exception$valu = _event$exception.values) === null || _event$exception$valu === void 0 ? void 0 : _event$exception$valu.forEach(function (exception) {
+        delete exception.stacktrace;
+      });
+      delete event.server_name; // Server name might contain PII
+
+      return event;
+    },
+    beforeSendTransaction: function beforeSendTransaction(event) {
+      delete event.server_name; // Server name might contain PII
+
+      return event;
+    },
+    // We create a transport that stalls sending events until we know that we're allowed to (i.e. when Sentry CLI told
+    // us that the upload URL is the Sentry SaaS URL)
+    transport: function transport(nodeTransportOptions) {
+      var nodeTransport = node.makeNodeTransport(nodeTransportOptions);
+      return {
+        flush: function flush(timeout) {
+          return nodeTransport.flush(timeout);
+        },
+        send: function () {
+          var _send = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
+            return _regeneratorRuntime().wrap(function _callee$(_context) {
+              while (1) {
+                switch (_context.prev = _context.next) {
+                  case 0:
+                    _context.next = 2;
+                    return shouldSendTelemetry;
+
+                  case 2:
+                    if (!_context.sent) {
+                      _context.next = 6;
+                      break;
+                    }
+
+                    return _context.abrupt("return", nodeTransport.send(request));
+
+                  case 6:
+                    return _context.abrupt("return", undefined);
+
+                  case 7:
+                  case "end":
+                    return _context.stop();
+                }
+              }
+            }, _callee);
+          }));
+
+          function send(_x) {
+            return _send.apply(this, arguments);
+          }
+
+          return send;
+        }()
+      };
+    }
   });
+  var hub = new node.Hub(client);
+  setTelemetryDataOnHub(options, hub, bundler);
+  return {
+    sentryHub: hub,
+    sentryClient: client
+  };
+}
+function setTelemetryDataOnHub(options, hub, bundler) {
+  var org = options.org,
+      project = options.project,
+      release = options.release,
+      errorHandler = options.errorHandler,
+      sourcemaps = options.sourcemaps;
+
+  if (release.uploadLegacySourcemaps) {
+    hub.setTag("uploadLegacySourcemapsEntries", Array.isArray(release.uploadLegacySourcemaps) ? release.uploadLegacySourcemaps.length : 1);
+  } // Optional release pipeline steps
+
+
+  if (release.cleanArtifacts) {
+    hub.setTag("clean-artifacts", true);
+  }
+
+  if (release.setCommits) {
+    hub.setTag("set-commits", release.setCommits.auto === true ? "auto" : "manual");
+  }
+
+  if (release.finalize) {
+    hub.setTag("finalize-release", true);
+  }
+
+  if (release.deploy) {
+    hub.setTag("add-deploy", true);
+  } // Miscelaneous options
+
 
-  if (internalOptions.dryRun) {
-    logger.info("In DRY RUN Mode");
-    return getDryRunCLI(cli, logger);
+  if (errorHandler) {
+    hub.setTag("error-handler", "custom");
   }
 
-  return cli;
+  if (sourcemaps !== null && sourcemaps !== void 0 && sourcemaps.assets) {
+    hub.setTag("debug-id-upload", true);
+  }
+
+  if (sourcemaps !== null && sourcemaps !== void 0 && sourcemaps.deleteAfterUpload) {
+    hub.setTag("delete-after-upload", true);
+  }
+
+  hub.setTag("node", process.version);
+  hub.setTags({
+    organization: org,
+    project: project,
+    bundler: bundler
+  });
+  hub.setUser({
+    id: org
+  });
+}
+function allowedToSendTelemetry(_x2) {
+  return _allowedToSendTelemetry.apply(this, arguments);
 }
 
-function getDryRunCLI(cli, logger) {
-  return {
-    releases: {
-      proposeVersion: function proposeVersion() {
-        return cli.releases.proposeVersion().then(function (version) {
-          logger.info("Proposed version:\n", version);
-          return version;
-        });
-      },
-      "new": function _new(release) {
-        logger.info("Creating new release:\n", release);
-        return Promise.resolve(release);
-      },
-      uploadSourceMaps: function uploadSourceMaps(release, config) {
-        logger.info("Calling upload-sourcemaps with:\n", config);
-        return Promise.resolve(release);
-      },
-      finalize: function finalize(release) {
-        logger.info("Finalizing release:\n", release);
-        return Promise.resolve(release);
-      },
-      setCommits: function setCommits(release, config) {
-        logger.info("Calling set-commits with:\n", config);
-        return Promise.resolve(release);
-      },
-      newDeploy: function newDeploy(release, config) {
-        logger.info("Calling deploy with:\n", config);
-        return Promise.resolve(release);
-      },
-      execute: function execute(args, live) {
-        logger.info("Executing", args, "live:", live);
-        return Promise.resolve("");
+function _allowedToSendTelemetry() {
+  _allowedToSendTelemetry = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(options) {
+    var _cliInfo$split$, _cliInfo$split$$repla;
+
+    var silent, org, project, authToken, url, headers, telemetry, release, cli, cliInfo, cliInfoUrl;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            silent = options.silent, org = options.org, project = options.project, authToken = options.authToken, url = options.url, headers = options.headers, telemetry = options.telemetry, release = options.release; // `options.telemetry` defaults to true
+
+            if (!(telemetry === false)) {
+              _context2.next = 3;
+              break;
+            }
+
+            return _context2.abrupt("return", false);
+
+          case 3:
+            if (!(url === SENTRY_SAAS_URL)) {
+              _context2.next = 5;
+              break;
+            }
+
+            return _context2.abrupt("return", true);
+
+          case 5:
+            cli = new SentryCli__default["default"](null, {
+              url: url,
+              authToken: authToken,
+              org: org,
+              project: project,
+              vcsRemote: release.vcsRemote,
+              silent: silent,
+              headers: headers
+            });
+            _context2.prev = 6;
+            _context2.next = 9;
+            return cli.execute(["info"], false);
+
+          case 9:
+            cliInfo = _context2.sent;
+            _context2.next = 15;
+            break;
+
+          case 12:
+            _context2.prev = 12;
+            _context2.t0 = _context2["catch"](6);
+            return _context2.abrupt("return", false);
+
+          case 15:
+            cliInfoUrl = (_cliInfo$split$ = cliInfo.split(/(\r\n|\n|\r)/)[0]) === null || _cliInfo$split$ === void 0 ? void 0 : (_cliInfo$split$$repla = _cliInfo$split$.replace(/^Sentry Server: /, "")) === null || _cliInfo$split$$repla === void 0 ? void 0 : _cliInfo$split$$repla.trim();
+
+            if (!(cliInfoUrl === undefined)) {
+              _context2.next = 18;
+              break;
+            }
+
+            return _context2.abrupt("return", false);
+
+          case 18:
+            return _context2.abrupt("return", new URL(cliInfoUrl).hostname === SENTRY_SAAS_HOSTNAME);
+
+          case 19:
+          case "end":
+            return _context2.stop();
+        }
       }
-    },
-    execute: function execute(args, live) {
-      logger.info("Executing", args, "live:", live);
-      return Promise.resolve("Executed");
-    }
-  };
+    }, _callee2, null, [[6, 12]]);
+  }));
+  return _allowedToSendTelemetry.apply(this, arguments);
 }
 
-var ALLOWED_TRANSFORMATION_FILE_ENDINGS = [".js", ".ts", ".jsx", ".tsx", ".mjs"];
 /**
  * The sentry bundler plugin concerns itself with two things:
  * - Release injection
  * - Sourcemaps upload
  *
  * Release injection:
- * Per default the sentry bundler plugin will inject a global `SENTRY_RELEASE` into
- * each JavaScript/TypeScript entrypoint. On a technical level this is done by identifying
- * entrypoints in the `resolveId` hook and prepending user code in the `transform` hook.
- * If a user wants to inject the release into a particular set of modules instead,
- * they can use the `releaseInjectionTargets` option.
+ * Per default the sentry bundler plugin will inject a global `SENTRY_RELEASE` into each JavaScript/TypeScript module
+ * that is part of the bundle. On a technical level this is done by appending an import (`import "sentry-release-injector;"`)
+ * to all entrypoint files of the user code (see `transformInclude` and `transform` hooks). This import is then resolved
+ * by the sentry plugin to a virtual module that sets the global variable (see `resolveId` and `load` hooks).
+ * If a user wants to inject the release into a particular set of modules they can use the `releaseInjectionTargets` option.
  *
  * Source maps upload:
  *
@@ -1678,395 +1526,271 @@ var ALLOWED_TRANSFORMATION_FILE_ENDINGS = [".js", ".ts", ".jsx", ".tsx", ".mjs"]
  *
  * This release creation pipeline relies on Sentry CLI to execute the different steps.
  */
-
-var unplugin = unplugin$1.createUnplugin(function (options, unpluginMetaContext) {
-  var internalOptions = normalizeUserOptions(options);
-  var allowedToSendTelemetryPromise = shouldSendTelemetry(internalOptions);
-
-  var _makeSentryClient = makeSentryClient("https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737", allowedToSendTelemetryPromise, internalOptions.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
-  //      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.
-  //      The ideal solution would be a code change in the JS SDK but it's not a straight-forward fix.
-
-  node.makeMain(sentryHub);
-  var logger = createLogger({
-    prefix: "[sentry-".concat(unpluginMetaContext.framework, "-plugin]"),
-    silent: internalOptions.silent,
-    debug: internalOptions.debug
-  });
-
-  if (!validateOptions(internalOptions, logger)) {
-    handleError(new Error("Options were not set correctly. See output above for more details."), logger, internalOptions.errorHandler);
-  }
-
-  var cli = getSentryCli(internalOptions, logger);
-  var releaseNamePromise = new Promise(function (resolve) {
-    if (options.release) {
-      resolve(options.release);
-    } else {
-      resolve(cli.releases.proposeVersion());
+function sentryUnpluginFactory(_ref) {
+  var releaseInjectionPlugin = _ref.releaseInjectionPlugin,
+      debugIdInjectionPlugin = _ref.debugIdInjectionPlugin;
+  return unplugin.createUnplugin(function (userOptions, unpluginMetaContext) {
+    var options = normalizeUserOptions(userOptions);
+
+    if (unpluginMetaContext.watchMode || options.disable) {
+      return [{
+        name: "sentry-noop-plugin"
+      }];
     }
-  });
-  var transaction;
-  var releaseInjectionSpan;
-  var absolueEntrypointPaths = new Set();
-  return {
-    name: "sentry-plugin",
-    enforce: "pre",
-    // needed for Vite to call resolveId hook
 
-    /**
-     * Responsible for starting the plugin execution transaction and the release injection span
-     */
-    buildStart: function buildStart() {
-      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-        var isAllowedToSendToSendTelemetry, releaseName;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                logger.debug("Called 'buildStart'");
-                _context.next = 3;
-                return allowedToSendTelemetryPromise;
+    var shouldSendTelemetry = allowedToSendTelemetry(options);
 
-              case 3:
-                isAllowedToSendToSendTelemetry = _context.sent;
-
-                if (isAllowedToSendToSendTelemetry) {
-                  logger.info("Sending error and performance telemetry data to Sentry.");
-                  logger.info("To disable telemetry, set `options.telemetry` to `false`.");
-                  sentryHub.addBreadcrumb({
-                    level: "info",
-                    message: "Telemetry enabled."
-                  });
-                } else {
-                  sentryHub.addBreadcrumb({
-                    level: "info",
-                    message: "Telemetry disabled. This should never show up in a Sentry event."
-                  });
-                }
+    var _createSentryInstance = createSentryInstance(options, shouldSendTelemetry, unpluginMetaContext.framework),
+        sentryHub = _createSentryInstance.sentryHub,
+        sentryClient = _createSentryInstance.sentryClient;
 
-                _context.next = 7;
-                return releaseNamePromise;
+    var pluginExecutionTransaction = sentryHub.startTransaction({
+      name: "Sentry Bundler Plugin execution"
+    });
+    sentryHub.getScope().setSpan(pluginExecutionTransaction);
+    var logger = createLogger({
+      prefix: "[sentry-".concat(unpluginMetaContext.framework, "-plugin]"),
+      silent: options.silent,
+      debug: options.debug
+    });
 
-              case 7:
-                releaseName = _context.sent;
+    function handleRecoverableError(unknownError) {
+      pluginExecutionTransaction.setStatus("internal_error");
 
-                // 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);
-                }
+      if (options.errorHandler) {
+        if (unknownError instanceof Error) {
+          options.errorHandler(unknownError);
+        } else {
+          options.errorHandler(new Error("An unknown error occured"));
+        }
+      } else {
+        throw unknownError;
+      }
+    }
 
-                transaction = sentryHub.startTransaction({
-                  op: "function.plugin",
-                  name: "Sentry Bundler Plugin execution"
-                });
-                releaseInjectionSpan = addSpanToTransaction({
-                  hub: sentryHub,
-                  parentSpan: transaction,
-                  logger: logger,
-                  cli: cli
-                }, "function.plugin.inject_release", "Release injection");
+    if (!validateOptions(options, logger)) {
+      handleRecoverableError(new Error("Options were not set correctly. See output above for more details."));
+    }
 
-              case 11:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee);
-      }))();
-    },
+    if (process.cwd().match(/\\node_modules\\|\/node_modules\//)) {
+      logger.warn("Running Sentry plugin from within a `node_modules` folder. Some features may not work.");
+    }
 
-    /**
-     * Responsible for returning the "sentry-release-injector" ID when we encounter it. We return the ID so load is
-     * called and we can "virtually" load the module. See `load` hook for more info on why it's virtual.
-     *
-     * We also record the id (i.e. absolute path) of any non-entrypoint.
-     *
-     * @param id For imports: The absolute path of the module to be imported. For entrypoints: The path the user defined as entrypoint - may also be relative.
-     * @param importer For imports: The absolute path of the module that imported this module. For entrypoints: `undefined`.
-     * @param options Additional information to use for making a resolving decision.
-     * @returns `"sentry-release-injector"` when the imported file is called `"sentry-release-injector"`. Otherwise returns `undefined`.
-     */
-    resolveId: function resolveId(id, importer, _ref) {
-      var isEntry = _ref.isEntry;
-      logger.debug('Called "resolveId":', {
-        id: id,
-        importer: importer,
-        isEntry: isEntry
+    var plugins = [];
+    plugins.push(telemetryPlugin({
+      pluginExecutionTransaction: pluginExecutionTransaction,
+      logger: logger,
+      shouldSendTelemetry: shouldSendTelemetry,
+      sentryClient: sentryClient
+    }));
+
+    if (!options.release.inject) {
+      logger.debug("Release injection disabled via `release.inject` option. Will not inject release.");
+    } else if (!options.release.name) {
+      logger.warn("No release name provided. Will not inject release. Please set the `release.name` option to identifiy your release.");
+    } else {
+      var _injectionCode = generateGlobalInjectorCode({
+        release: options.release.name,
+        injectBuildInformation: options._experiments.injectBuildInformation || false
       });
 
-      if (isEntry) {
-        absolueEntrypointPaths.add(path__default["default"].resolve(path__default["default"].normalize(id)));
-      }
-
-      return undefined;
-    },
+      plugins.push(releaseInjectionPlugin(_injectionCode));
+    }
 
-    /**
-     * This hook determines whether we want to transform a module. In the sentry bundler plugin we want to transform every entrypoint
-     * unless configured otherwise with the `releaseInjectionTargets` option.
-     *
-     * @param id Always the absolute (fully resolved) path to the module.
-     * @returns `true` or `false` depending on whether we want to transform the module. For the sentry bundler plugin we only
-     * want to transform the release injector file.
-     */
-    transformInclude: function transformInclude(id) {
-      logger.debug('Called "transformInclude":', {
-        id: id
-      }); // We normalize the id because vite always passes `id` as a unix style path which causes problems when a user passes
-      // a windows style path to `releaseInjectionTargets`
-
-      var normalizedId = path__default["default"].normalize(id);
-
-      if (internalOptions.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 (!options.release.name) {
+      logger.warn("No release name provided. Will not create release. Please set the `release.name` option to identifiy your release.");
+    } else if (!options.authToken) {
+      logger.warn("No auth token provided. Will not create release. Please set the `authToken` option. You can find information on how to generate a Sentry auth token here: https://docs.sentry.io/api/auth/");
+    } else if (!options.org) {
+      logger.warn("No organization slug provided. Will not create release. Please set the `org` option to your Sentry organization slug.");
+    } else if (!options.project) {
+      logger.warn("No project provided. Will not create release. Please set the `project` option to your Sentry project slug.");
+    } else {
+      plugins.push(releaseManagementPlugin({
+        logger: logger,
+        releaseName: options.release.name,
+        shouldCreateRelease: options.release.create,
+        shouldCleanArtifacts: options.release.cleanArtifacts,
+        shouldFinalizeRelease: options.release.finalize,
+        include: options.release.uploadLegacySourcemaps,
+        setCommitsOption: options.release.setCommits,
+        deployOptions: options.release.deploy,
+        dist: options.release.dist,
+        handleRecoverableError: handleRecoverableError,
+        sentryHub: sentryHub,
+        sentryClient: sentryClient,
+        sentryCliOptions: {
+          authToken: options.authToken,
+          org: options.org,
+          project: options.project,
+          silent: options.silent,
+          url: options.url,
+          vcsRemote: options.release.vcsRemote,
+          headers: options.headers
         }
+      }));
+    }
 
-        return internalOptions.releaseInjectionTargets.some(function (entry) {
-          if (entry instanceof RegExp) {
-            return entry.test(normalizedId);
-          } else {
-            var normalizedEntry = path__default["default"].normalize(entry);
-            return normalizedId === normalizedEntry;
-          }
-        });
-      } else if (absolueEntrypointPaths.has(normalizedId)) {
-        var pathIsOrdinary = !normalizedId.includes("?") && !normalizedId.includes("#");
-        var pathHasAllowedFileEnding = ALLOWED_TRANSFORMATION_FILE_ENDINGS.some(function (allowedFileEnding) {
-          return normalizedId.endsWith(allowedFileEnding);
-        });
-        return pathIsOrdinary && pathHasAllowedFileEnding;
+    if (options.sourcemaps) {
+      if (!options.authToken) {
+        logger.warn("No auth token provided. Will not upload source maps. Please set the `authToken` option. You can find information on how to generate a Sentry auth token here: https://docs.sentry.io/api/auth/");
+      } else if (!options.org) {
+        logger.warn("No org provided. Will not upload source maps. Please set the `org` option to your Sentry organization slug.");
+      } else if (!options.project) {
+        logger.warn("No project provided. Will not upload source maps. Please set the `project` option to your Sentry project slug.");
+      } else if (!options.sourcemaps.assets) {
+        logger.warn("No assets defined. Will not upload source maps. Please provide set the `assets` option to your build-output folder.");
       } else {
-        return false;
+        plugins.push(debugIdInjectionPlugin());
+        plugins.push(debugIdUploadPlugin({
+          assets: options.sourcemaps.assets,
+          ignore: options.sourcemaps.ignore,
+          dist: options.release.dist,
+          releaseName: options.release.name,
+          logger: logger,
+          handleRecoverableError: handleRecoverableError,
+          sentryHub: sentryHub,
+          sentryClient: sentryClient,
+          sentryCliOptions: {
+            authToken: options.authToken,
+            org: options.org,
+            project: options.project,
+            silent: options.silent,
+            url: options.url,
+            vcsRemote: options.release.vcsRemote,
+            headers: options.headers
+          }
+        }));
       }
-    },
+    }
 
-    /**
-     * This hook is responsible for injecting the "sentry release injector" imoprt statement into each entrypoint unless
-     * configured otherwise with the `releaseInjectionTargets` option (logic for that is in the `transformInclude` hook).
-     *
-     * @param code Code of the file to transform.
-     * @param id Always the absolute (fully resolved) path to the module.
-     * @returns transformed code + source map
-     */
-    transform: function transform(code, id) {
-      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
-        var ms;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                logger.debug('Called "transform":', {
-                  id: id
-                }); // The MagicString library allows us to generate sourcemaps for the changes we make to the user code.
-
-                ms = new MagicString__default["default"](code);
-                _context2.t0 = ms;
-                _context2.t1 = generateGlobalInjectorCode;
-                _context2.next = 6;
-                return releaseNamePromise;
-
-              case 6:
-                _context2.t2 = _context2.sent;
-                _context2.t3 = internalOptions.injectReleasesMap;
-                _context2.t4 = internalOptions.org;
-                _context2.t5 = internalOptions.project;
-                _context2.t6 = {
-                  release: _context2.t2,
-                  injectReleasesMap: _context2.t3,
-                  org: _context2.t4,
-                  project: _context2.t5
-                };
-                _context2.t7 = (0, _context2.t1)(_context2.t6);
-
-                _context2.t0.prepend.call(_context2.t0, _context2.t7);
-
-                if (!(unpluginMetaContext.framework === "esbuild")) {
-                  _context2.next = 17;
-                  break;
-                }
+    return plugins;
+  });
+}
+function getBuildInformation() {
+  var packageJson = getPackageJson();
 
-                return _context2.abrupt("return", ms.toString());
+  var _ref2 = packageJson ? getDependencies(packageJson) : {
+    deps: [],
+    depsVersions: {}
+  },
+      deps = _ref2.deps,
+      depsVersions = _ref2.depsVersions;
 
-              case 17:
-                return _context2.abrupt("return", {
-                  code: ms.toString(),
-                  map: ms.generateMap()
-                });
+  return {
+    deps: deps,
+    depsVersions: depsVersions,
+    nodeVersion: parseMajorVersion(process.version)
+  };
+}
+/**
+ * Determines whether the Sentry CLI binary is in its expected location.
+ * This function is useful since `@sentry/cli` installs the binary via a post-install
+ * script and post-install scripts may not always run. E.g. with `npm i --ignore-scripts`.
+ */
 
-              case 18:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2);
-      }))();
+function sentryCliBinaryExists() {
+  return fs__default["default"].existsSync(SentryCli__default["default"].getPath());
+}
+function createRollupReleaseInjectionHooks(injectionCode) {
+  var virtualReleaseInjectionFileId = "\0sentry-release-injection-file";
+  return {
+    resolveId: function resolveId(id) {
+      if (id === virtualReleaseInjectionFileId) {
+        return {
+          id: virtualReleaseInjectionFileId,
+          external: false,
+          moduleSideEffects: true
+        };
+      } else {
+        return null;
+      }
     },
+    load: function load(id) {
+      if (id === virtualReleaseInjectionFileId) {
+        return injectionCode;
+      } else {
+        return null;
+      }
+    },
+    transform: function transform(code, id) {
+      if (id === virtualReleaseInjectionFileId) {
+        return null;
+      }
 
-    /**
-     * Responsible for executing the sentry release creation pipeline (i.e. creating a release on
-     * Sentry.io, uploading sourcemaps, associating commits and deploys and finalizing the release)
-     */
-    writeBundle: function writeBundle() {
-      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
-        var _releaseInjectionSpan;
-
-        var releasePipelineSpan, ctx, releaseName, _transaction, _transaction2, _transaction3;
-
-        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-          while (1) {
-            switch (_context3.prev = _context3.next) {
-              case 0:
-                logger.debug('Called "writeBundle"');
-                (_releaseInjectionSpan = releaseInjectionSpan) === null || _releaseInjectionSpan === void 0 ? void 0 : _releaseInjectionSpan.finish();
-                releasePipelineSpan = transaction && addSpanToTransaction({
-                  hub: sentryHub,
-                  parentSpan: transaction,
-                  logger: logger,
-                  cli: cli
-                }, "function.plugin.release", "Release pipeline");
-                sentryHub.addBreadcrumb({
-                  category: "writeBundle:start",
-                  level: "info"
-                });
-                ctx = {
-                  hub: sentryHub,
-                  parentSpan: releasePipelineSpan,
-                  logger: logger,
-                  cli: cli
-                };
-                _context3.next = 7;
-                return releaseNamePromise;
-
-              case 7:
-                releaseName = _context3.sent;
-                _context3.prev = 8;
-                _context3.next = 11;
-                return createNewRelease(internalOptions, ctx, releaseName);
-
-              case 11:
-                _context3.next = 13;
-                return cleanArtifacts(internalOptions, ctx, releaseName);
-
-              case 13:
-                _context3.next = 15;
-                return uploadSourceMaps(internalOptions, ctx, releaseName);
-
-              case 15:
-                _context3.next = 17;
-                return setCommits(internalOptions, ctx, releaseName);
-
-              case 17:
-                _context3.next = 19;
-                return finalizeRelease(internalOptions, ctx, releaseName);
-
-              case 19:
-                _context3.next = 21;
-                return addDeploy(internalOptions, ctx, releaseName);
-
-              case 21:
-                (_transaction = transaction) === null || _transaction === void 0 ? void 0 : _transaction.setStatus("ok");
-                _context3.next = 29;
-                break;
-
-              case 24:
-                _context3.prev = 24;
-                _context3.t0 = _context3["catch"](8);
-                (_transaction2 = transaction) === null || _transaction2 === void 0 ? void 0 : _transaction2.setStatus("cancelled");
-                sentryHub.addBreadcrumb({
-                  level: "error",
-                  message: "Error during writeBundle"
-                });
-                handleError(_context3.t0, logger, internalOptions.errorHandler);
-
-              case 29:
-                _context3.prev = 29;
-                releasePipelineSpan === null || releasePipelineSpan === void 0 ? void 0 : releasePipelineSpan.finish();
-                (_transaction3 = transaction) === null || _transaction3 === void 0 ? void 0 : _transaction3.finish();
-                _context3.next = 34;
-                return sentryClient.flush().then(null, function () {
-                  logger.warn("Sending of telemetry failed");
-                });
+      if (id.match(/\\node_modules\\|\/node_modules\//)) {
+        return null;
+      }
 
-              case 34:
-                return _context3.finish(29);
+      if (![".js", ".ts", ".jsx", ".tsx", ".mjs"].some(function (ending) {
+        return id.endsWith(ending);
+      })) {
+        return null;
+      }
 
-              case 35:
-                sentryHub.addBreadcrumb({
-                  category: "writeBundle:finish",
-                  level: "info"
-                });
+      var ms = new MagicString__default["default"](code); // Appending instead of prepending has less probability of mucking with user's source maps.
+      // Luckily import statements get hoisted to the top anyways.
 
-              case 36:
-              case "end":
-                return _context3.stop();
-            }
-          }
-        }, _callee3, null, [[8, 24, 29, 35]]);
-      }))();
+      ms.append("\n\n;import \"".concat(virtualReleaseInjectionFileId, "\";"));
+      return {
+        code: ms.toString(),
+        map: ms.generateMap()
+      };
     }
   };
-});
-
-function handleError(unknownError, logger, errorHandler) {
-  if (unknownError instanceof Error) {
-    logger.error(unknownError.message);
-  } else {
-    logger.error(String(unknownError));
-  }
+}
+function createRollupDebugIdInjectionHooks() {
+  return {
+    renderChunk: function renderChunk(code, chunk) {
+      if ([".js", ".mjs", ".cjs"].some(function (ending) {
+        return chunk.fileName.endsWith(ending);
+      }) // chunks could be any file (html, md, ...)
+      ) {
+        var _code$match;
+
+        var debugId = stringToUUID(code); // generate a deterministic debug ID
+
+        var codeToInject = getDebugIdSnippet(debugId);
+        var ms = new MagicString__default["default"](code, {
+          filename: chunk.fileName
+        }); // 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.
+
+        var commentUseStrictRegex = // Note: CodeQL complains that this regex potentially has n^2 runtime. This likely won't affect realistic files.
+        /^(?:\s*|\/\*(?:.|\r|\n)*\*\/|\/\/.*[\n\r])*(?:"[^"]*";|'[^']*';)?/;
+
+        if ((_code$match = code.match(commentUseStrictRegex)) !== null && _code$match !== void 0 && _code$match[0]) {
+          // Add injected code after any comments or "use strict" at the beginning of the bundle.
+          ms.replace(commentUseStrictRegex, function (match) {
+            return "".concat(match).concat(codeToInject);
+          });
+        } else {
+          // ms.replace() doesn't work when there is an empty string match (which happens if
+          // there is neither, a comment, nor a "use strict" at the top of the chunk) so we
+          // need this special case here.
+          ms.prepend(codeToInject);
+        }
 
-  if (errorHandler) {
-    if (unknownError instanceof Error) {
-      errorHandler(unknownError);
-    } else {
-      errorHandler(new Error("An unknown error occured"));
+        return {
+          code: ms.toString(),
+          map: ms.generateMap({
+            file: chunk.fileName
+          })
+        };
+      } else {
+        return null; // returning null means not modifying the chunk at all
+      }
     }
-  } else {
-    throw unknownError;
-  }
+  };
+}
+function getDebugIdSnippet(debugId) {
+  return ";!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]=\"".concat(debugId, "\",e._sentryDebugIdIdentifier=\"sentry-dbid-").concat(debugId, "\")}catch(e){}}();");
 }
-/**
- * Generates code for the "sentry-release-injector" which is responsible for setting the global `SENTRY_RELEASE`
- * variable.
- */
-
-
-function generateGlobalInjectorCode(_ref2) {
-  var release = _ref2.release,
-      injectReleasesMap = _ref2.injectReleasesMap,
-      org = _ref2.org,
-      project = _ref2.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, "\"};");
-
-  if (injectReleasesMap && project) {
-    var key = org ? "".concat(project, "@").concat(org) : project;
-    code += "\n      _global.SENTRY_RELEASES=_global.SENTRY_RELEASES || {};\n      _global.SENTRY_RELEASES[\"".concat(key, "\"]={id:\"").concat(release, "\"};");
-  }
-
-  return code;
-} // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-
-var sentryVitePlugin = unplugin.vite; // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-var sentryRollupPlugin = unplugin.rollup; // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-var sentryWebpackPlugin = unplugin.webpack; // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-var sentryEsbuildPlugin = unplugin.esbuild;
 
-exports.sentryEsbuildPlugin = sentryEsbuildPlugin;
-exports.sentryRollupPlugin = sentryRollupPlugin;
-exports.sentryVitePlugin = sentryVitePlugin;
-exports.sentryWebpackPlugin = sentryWebpackPlugin;
+exports.createRollupDebugIdInjectionHooks = createRollupDebugIdInjectionHooks;
+exports.createRollupReleaseInjectionHooks = createRollupReleaseInjectionHooks;
+exports.getBuildInformation = getBuildInformation;
+exports.getDebugIdSnippet = getDebugIdSnippet;
+exports.sentryCliBinaryExists = sentryCliBinaryExists;
+exports.sentryUnpluginFactory = sentryUnpluginFactory;
 //# sourceMappingURL=index.js.map