@sentry/bundler-plugin-core 0.0.1-alpha.0

package/dist/cjs/index.js

@@ -0,0 +1,1550 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var unplugin$1 = require('unplugin');
+var MagicString = require('magic-string');
+var child_process = require('child_process');
+var axios = require('axios');
+var FormData = require('form-data');
+var node = require('@sentry/node');
+var path = require('path');
+var fs = require('fs');
+require('@sentry/tracing');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+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 MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
+var child_process__namespace = /*#__PURE__*/_interopNamespace(child_process);
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+var FormData__default = /*#__PURE__*/_interopDefaultLegacy(FormData);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+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 */
+
+  _regeneratorRuntime = function () {
+    return exports;
+  };
+
+  var exports = {},
+      Op = Object.prototype,
+      hasOwn = Op.hasOwnProperty,
+      $Symbol = "function" == typeof Symbol ? Symbol : {},
+      iteratorSymbol = $Symbol.iterator || "@@iterator",
+      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  function define(obj, key, value) {
+    return Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), obj[key];
+  }
+
+  try {
+    define({}, "");
+  } catch (err) {
+    define = function (obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+        generator = Object.create(protoGenerator.prototype),
+        context = new Context(tryLocsList || []);
+    return generator._invoke = function (innerFn, self, context) {
+      var state = "suspendedStart";
+      return function (method, arg) {
+        if ("executing" === state) throw new Error("Generator is already running");
+
+        if ("completed" === state) {
+          if ("throw" === method) throw arg;
+          return doneResult();
+        }
+
+        for (context.method = method, context.arg = arg;;) {
+          var delegate = context.delegate;
+
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+
+          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+            if ("suspendedStart" === state) throw state = "completed", context.arg;
+            context.dispatchException(context.arg);
+          } else "return" === context.method && context.abrupt("return", context.arg);
+          state = "executing";
+          var record = tryCatch(innerFn, self, context);
+
+          if ("normal" === record.type) {
+            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          }
+
+          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+        }
+      };
+    }(innerFn, self, context), generator;
+  }
+
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+
+  exports.wrap = wrap;
+  var ContinueSentinel = {};
+
+  function Generator() {}
+
+  function GeneratorFunction() {}
+
+  function GeneratorFunctionPrototype() {}
+
+  var IteratorPrototype = {};
+  define(IteratorPrototype, iteratorSymbol, function () {
+    return this;
+  });
+  var getProto = Object.getPrototypeOf,
+      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      define(prototype, method, function (arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+
+      if ("throw" !== record.type) {
+        var result = record.arg,
+            value = result.value;
+        return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+          invoke("next", value, resolve, reject);
+        }, function (err) {
+          invoke("throw", err, resolve, reject);
+        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped, resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+
+      reject(record.arg);
+    }
+
+    var previousPromise;
+
+    this._invoke = function (method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    };
+  }
+
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+
+    if (undefined === method) {
+      if (context.delegate = null, "throw" === context.method) {
+        if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
+        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+      }
+
+      return ContinueSentinel;
+    }
+
+    var record = tryCatch(method, delegate.iterator, context.arg);
+    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+    var info = record.arg;
+    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+  }
+
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal", delete record.arg, entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+  }
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) return iteratorMethod.call(iterable);
+      if ("function" == typeof iterable.next) return iterable;
+
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+            next = function next() {
+          for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+
+          return next.value = undefined, next.done = !0, next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    return {
+      next: doneResult
+    };
+  }
+
+  function doneResult() {
+    return {
+      value: undefined,
+      done: !0
+    };
+  }
+
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+    var ctor = "function" == typeof genFun && genFun.constructor;
+    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+  }, exports.mark = function (genFun) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+  }, exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    void 0 === PromiseImpl && (PromiseImpl = Promise);
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+    return this;
+  }), define(Gp, "toString", function () {
+    return "[object Generator]";
+  }), exports.keys = function (object) {
+    var keys = [];
+
+    for (var key in object) keys.push(key);
+
+    return keys.reverse(), function next() {
+      for (; keys.length;) {
+        var key = keys.pop();
+        if (key in object) return next.value = key, next.done = !1, next;
+      }
+
+      return next.done = !0, next;
+    };
+  }, exports.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (skipTempReset) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+    },
+    stop: function () {
+      this.done = !0;
+      var rootRecord = this.tryEntries[0].completion;
+      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      return this.rval;
+    },
+    dispatchException: function (exception) {
+      if (this.done) throw exception;
+      var context = this;
+
+      function handle(loc, caught) {
+        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i],
+            record = entry.completion;
+        if ("root" === entry.tryLoc) return handle("end");
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc"),
+              hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+          } else {
+            if (!hasFinally) throw new Error("try statement without catch or finally");
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+      var record = finallyEntry ? finallyEntry.completion : {};
+      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+    },
+    complete: function (record, afterLoc) {
+      if ("throw" === record.type) throw record.arg;
+      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+    },
+    finish: function (finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+      }
+    },
+    catch: function (tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+
+          if ("throw" === record.type) {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+
+          return thrown;
+        }
+      }
+
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (iterable, resultName, nextLoc) {
+      return this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+    }
+  }, exports;
+}
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+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;
+  }
+
+  return obj;
+}
+
+function getGitBranchHead() {
+  try {
+    return child_process__namespace.execSync("git rev-parse HEAD").toString().trim();
+  } catch (e) {
+    // no git installed
+    return undefined;
+  }
+}
+
+function getReleaseName(releaseName) {
+  if (releaseName) {
+    return releaseName;
+  } // Env var SENTRY_RELEASE takes presendace over other env vars listed below
+  // this is why we are looking for it before proceeding with others
+
+
+  if (process.env["SENTRY_RELEASE"]) {
+    return process.env["SENTRY_RELEASE"];
+  }
+
+  var ENV_VARS = ["SOURCE_VERSION", // Heroku #1 https://devcenter.heroku.com/changelog-items/630
+  "HEROKU_SLUG_COMMIT", // Heroku #2: https://docs.sentry.io/product/integrations/deployment/heroku/#configure-releases
+  "CODEBUILD_RESOLVED_SOURCE_VERSION", // AWS CodeBuild: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html
+  "CIRCLE_SHA1", // CircleCI: https://circleci.com/docs/2.0/env-vars/
+  "VERCEL_GIT_COMMIT_SHA" // Vercel docs: https://vercel.com/docs/concepts/projects/environment-variables#system-environment-variables
+  ];
+  var releaseFromEnvironmentVar = ENV_VARS.find(function (key) {
+    return Object.keys(process.env).includes(key);
+  });
+
+  if (releaseFromEnvironmentVar) {
+    return process.env[releaseFromEnvironmentVar];
+  }
+
+  var gitBranchHead = getGitBranchHead();
+
+  if (gitBranchHead) {
+    return gitBranchHead;
+  } else {
+    throw new Error("Could not return a release name");
+  }
+}
+
+function makeSentryClient(dsn, telemetryEnabled, org) {
+  var client = new node.NodeClient({
+    dsn: dsn,
+    enabled: telemetryEnabled,
+    tracesSampleRate: telemetryEnabled ? 1.0 : 0.0,
+    sampleRate: telemetryEnabled ? 1.0 : 0.0,
+    release: "0.0.1-alpha.0",
+    integrations: [new node.Integrations.Http({
+      tracing: true
+    })],
+    tracePropagationTargets: ["sentry.io/api"],
+    stackParser: node.defaultStackParser,
+    transport: node.makeNodeTransport,
+    debug: true
+  });
+  var hub = new node.Hub(client);
+  hub.configureScope(function (scope) {
+    if (org) {
+      scope.setTag("org", org);
+    }
+  }); //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(hub);
+  return {
+    client: client,
+    hub: hub
+  };
+}
+/**
+ * Adds a span to the passed parentSpan or to the current transaction that's on the passed hub's scope.
+ */
+
+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 captureMinimalError(error, hub) {
+  var isAxiosError = error instanceof axios.AxiosError;
+  var sentryError = error instanceof Error ? {
+    name: "".concat(isAxiosError && error.status ? error.status : "", ": ").concat(error.name),
+    message: error.message,
+    stack: error.stack
+  } : {};
+  hub.captureException(sentryError);
+}
+
+var API_PATH = "/api/0";
+var USER_AGENT = "sentry-bundler-plugin/".concat("0.0.1-alpha.0");
+
+var sentryApiAxiosInstance = function sentryApiAxiosInstance(_ref) {
+  var authToken = _ref.authToken,
+      customHeaders = _ref.customHeaders;
+  return axios__default["default"].create({
+    headers: _objectSpread2(_objectSpread2({}, customHeaders), {}, {
+      "User-Agent": USER_AGENT,
+      Authorization: "Bearer ".concat(authToken)
+    })
+  });
+};
+
+function createRelease(_x) {
+  return _createRelease.apply(this, arguments);
+}
+
+function _createRelease() {
+  _createRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref2) {
+    var org, project, release, authToken, sentryUrl, sentryHub, customHeaders, requestUrl, releasePayload;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            org = _ref2.org, project = _ref2.project, release = _ref2.release, authToken = _ref2.authToken, sentryUrl = _ref2.sentryUrl, sentryHub = _ref2.sentryHub, customHeaders = _ref2.customHeaders;
+            requestUrl = "".concat(sentryUrl).concat(API_PATH, "/organizations/").concat(org, "/releases/");
+            releasePayload = {
+              version: release,
+              projects: [project],
+              // we currently only support creating releases for a single project
+              dateStarted: new Date(),
+              dateReleased: new Date() //TODO: figure out if these dates are set correctly
+
+            };
+            _context.prev = 3;
+            _context.next = 6;
+            return sentryApiAxiosInstance({
+              authToken: authToken,
+              customHeaders: customHeaders
+            }).post(requestUrl, releasePayload, {
+              headers: {
+                Authorization: "Bearer ".concat(authToken)
+              }
+            });
+
+          case 6:
+            _context.next = 12;
+            break;
+
+          case 8:
+            _context.prev = 8;
+            _context.t0 = _context["catch"](3);
+            captureMinimalError(_context.t0, sentryHub);
+            throw _context.t0;
+
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[3, 8]]);
+  }));
+  return _createRelease.apply(this, arguments);
+}
+
+function deleteAllReleaseArtifacts(_x2) {
+  return _deleteAllReleaseArtifacts.apply(this, arguments);
+}
+
+function _deleteAllReleaseArtifacts() {
+  _deleteAllReleaseArtifacts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref3) {
+    var org, project, release, authToken, sentryUrl, sentryHub, customHeaders, requestUrl;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            org = _ref3.org, project = _ref3.project, release = _ref3.release, authToken = _ref3.authToken, sentryUrl = _ref3.sentryUrl, sentryHub = _ref3.sentryHub, customHeaders = _ref3.customHeaders;
+            requestUrl = "".concat(sentryUrl).concat(API_PATH, "/projects/").concat(org, "/").concat(project, "/files/source-maps/?name=").concat(release);
+            _context2.prev = 2;
+            _context2.next = 5;
+            return sentryApiAxiosInstance({
+              authToken: authToken,
+              customHeaders: customHeaders
+            })["delete"](requestUrl, {
+              headers: {
+                Authorization: "Bearer ".concat(authToken)
+              }
+            });
+
+          case 5:
+            _context2.next = 11;
+            break;
+
+          case 7:
+            _context2.prev = 7;
+            _context2.t0 = _context2["catch"](2);
+            captureMinimalError(_context2.t0, sentryHub);
+            throw _context2.t0;
+
+          case 11:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[2, 7]]);
+  }));
+  return _deleteAllReleaseArtifacts.apply(this, arguments);
+}
+
+function updateRelease(_x3) {
+  return _updateRelease.apply(this, arguments);
+}
+
+function _updateRelease() {
+  _updateRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref4) {
+    var release, org, authToken, sentryUrl, project, sentryHub, customHeaders, requestUrl, releasePayload;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            release = _ref4.release, org = _ref4.org, authToken = _ref4.authToken, sentryUrl = _ref4.sentryUrl, project = _ref4.project, sentryHub = _ref4.sentryHub, customHeaders = _ref4.customHeaders;
+            requestUrl = "".concat(sentryUrl).concat(API_PATH, "/projects/").concat(org, "/").concat(project, "/releases/").concat(release, "/");
+            releasePayload = {
+              dateReleased: new Date().toISOString()
+            };
+            _context3.prev = 3;
+            _context3.next = 6;
+            return sentryApiAxiosInstance({
+              authToken: authToken,
+              customHeaders: customHeaders
+            }).put(requestUrl, releasePayload, {
+              headers: {
+                Authorization: "Bearer ".concat(authToken)
+              }
+            });
+
+          case 6:
+            _context3.next = 12;
+            break;
+
+          case 8:
+            _context3.prev = 8;
+            _context3.t0 = _context3["catch"](3);
+            captureMinimalError(_context3.t0, sentryHub);
+            throw _context3.t0;
+
+          case 12:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[3, 8]]);
+  }));
+  return _updateRelease.apply(this, arguments);
+}
+
+function uploadReleaseFile(_x4) {
+  return _uploadReleaseFile.apply(this, arguments);
+}
+
+function _uploadReleaseFile() {
+  _uploadReleaseFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref5) {
+    var org, project, release, authToken, sentryUrl, filename, fileContent, sentryHub, customHeaders, requestUrl, form;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            org = _ref5.org, project = _ref5.project, release = _ref5.release, authToken = _ref5.authToken, sentryUrl = _ref5.sentryUrl, filename = _ref5.filename, fileContent = _ref5.fileContent, sentryHub = _ref5.sentryHub, customHeaders = _ref5.customHeaders;
+            requestUrl = "".concat(sentryUrl).concat(API_PATH, "/projects/").concat(org, "/").concat(project, "/releases/").concat(release, "/files/");
+            form = new FormData__default["default"]();
+            form.append("name", filename);
+            form.append("file", Buffer.from(fileContent, "utf-8"), {
+              filename: filename
+            });
+            _context4.prev = 5;
+            _context4.next = 8;
+            return sentryApiAxiosInstance({
+              authToken: authToken,
+              customHeaders: customHeaders
+            }).post(requestUrl, form, {
+              headers: {
+                Authorization: "Bearer ".concat(authToken),
+                "Content-Type": "multipart/form-data"
+              }
+            });
+
+          case 8:
+            _context4.next = 14;
+            break;
+
+          case 10:
+            _context4.prev = 10;
+            _context4.t0 = _context4["catch"](5);
+            captureMinimalError(_context4.t0, sentryHub);
+            throw _context4.t0;
+
+          case 14:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[5, 10]]);
+  }));
+  return _uploadReleaseFile.apply(this, arguments);
+}
+
+function getFiles(path, allowedExtensions) {
+  var includedFiles = getAllIncludedFileNames(path, allowedExtensions, []);
+  return includedFiles.map(function (filename) {
+    var content = fs__default["default"].readFileSync(filename, {
+      encoding: "utf-8"
+    });
+    return {
+      name: "~" + filename.replace(new RegExp("^".concat(path)), ""),
+      content: content
+    };
+  });
+}
+
+function getAllIncludedFileNames(dirPath, allowedExtensions, accFiles) {
+  var files = fs__default["default"].readdirSync(dirPath);
+  files.map(function (file) {
+    return path__default["default"].join(dirPath, "/", file);
+  }).forEach(function (file) {
+    if (fs__default["default"].statSync(file).isDirectory()) {
+      accFiles = accFiles.concat(getAllIncludedFileNames(file, allowedExtensions, accFiles));
+    } else {
+      if (allowedExtensions.some(function (e) {
+        return file.endsWith(e);
+      })) {
+        accFiles.push(file);
+      }
+    }
+  });
+  return accFiles;
+}
+
+function createNewRelease(_x, _x2, _x3) {
+  return _createNewRelease.apply(this, arguments);
+}
+
+function _createNewRelease() {
+  _createNewRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(release, options, ctx) {
+    var span;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            span = addSpanToTransaction(ctx, "function.plugin.create_release"); // TODO: pull these checks out of here and simplify them
+
+            if (!(options.authToken === undefined)) {
+              _context.next = 6;
+              break;
+            }
+
+            ctx.logger.warn('Missing "authToken" option. Will not create release.');
+            return _context.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 6:
+            if (!(options.org === undefined)) {
+              _context.next = 11;
+              break;
+            }
+
+            ctx.logger.warn('Missing "org" option. Will not create release.');
+            return _context.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 11:
+            if (!(options.url === undefined)) {
+              _context.next = 16;
+              break;
+            }
+
+            ctx.logger.warn('Missing "url" option. Will not create release.');
+            return _context.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 16:
+            if (!(options.project === undefined)) {
+              _context.next = 19;
+              break;
+            }
+
+            ctx.logger.warn('Missing "project" option. Will not create release.');
+            return _context.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 19:
+            _context.next = 21;
+            return createRelease({
+              release: release,
+              authToken: options.authToken,
+              org: options.org,
+              project: options.project,
+              sentryUrl: options.url,
+              sentryHub: ctx.hub,
+              customHeaders: options.customHeaders
+            });
+
+          case 21:
+            ctx.logger.info("Successfully created release.");
+            span === null || span === void 0 ? void 0 : span.finish();
+            return _context.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 24:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _createNewRelease.apply(this, arguments);
+}
+
+function uploadSourceMaps(_x4, _x5, _x6) {
+  return _uploadSourceMaps.apply(this, arguments);
+}
+
+function _uploadSourceMaps() {
+  _uploadSourceMaps = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(release, options, ctx) {
+    var span, include, ext, org, project, authToken, url, fileExtensions, files;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            span = addSpanToTransaction(ctx, "function.plugin.upload_sourcemaps"); // This is what Sentry CLI does:
+            //  TODO: 0. Preprocess source maps
+            //           - (Out of scope for now)
+            //           - For rewriting source maps see https://github.com/getsentry/rust-sourcemap/blob/master/src/types.rs#L763
+            //  TODO: 1. Creates a new release to make sure it exists
+            //           - can we assume that the release will exist b/c we don't give unplugin users the
+            //           option to skip this step?
+            //  TODO: 2. download already uploaded files and get their checksums
+            //  TODO: 3. identify new or changed files (by comparing checksums)
+            //  TODO: 4. upload new and changed files
+            //           - CLI asks API for chunk options https://github.com/getsentry/sentry-cli/blob/7b8466885d9cfd51aee6fdc041eca9f645026303/src/utils/file_upload.rs#L106-L112
+            //           - WTF?
+            //           - don't upload more than 20k files
+            //           - upload files concurrently
+            //           - 2 options: chunked upload (multiple files per chunk) or single file upload
+
+            include = options.include, ext = options.ext, org = options.org, project = options.project, authToken = options.authToken, url = options.url; // TODO: pull these checks out of here and simplify them
+
+            if (!(authToken === undefined)) {
+              _context2.next = 7;
+              break;
+            }
+
+            ctx.logger.warn('Missing "authToken" option. Will not create release.');
+            return _context2.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 7:
+            if (!(org === undefined)) {
+              _context2.next = 12;
+              break;
+            }
+
+            ctx.logger.warn('Missing "org" option. Will not create release.');
+            return _context2.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 12:
+            if (!(url === undefined)) {
+              _context2.next = 17;
+              break;
+            }
+
+            ctx.logger.warn('Missing "url" option. Will not create release.');
+            return _context2.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 17:
+            if (!(project === undefined)) {
+              _context2.next = 20;
+              break;
+            }
+
+            ctx.logger.warn('Missing "project" option. Will not create release.');
+            return _context2.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 20:
+            ctx.logger.info("Uploading Sourcemaps."); //TODO: Remove this once we have internal options. this property must always be present
+
+            fileExtensions = ext || [];
+            files = getFiles(include, fileExtensions);
+            ctx.logger.info("Found ".concat(files.length, " files to upload."));
+            return _context2.abrupt("return", Promise.all(files.map(function (file) {
+              return uploadReleaseFile({
+                org: org,
+                project: project,
+                release: release,
+                authToken: authToken,
+                sentryUrl: url,
+                filename: file.name,
+                fileContent: file.content,
+                sentryHub: ctx.hub,
+                customHeaders: options.customHeaders
+              });
+            })).then(function () {
+              ctx.logger.info("Successfully uploaded sourcemaps.");
+              span === null || span === void 0 ? void 0 : span.finish();
+              return "done";
+            }));
+
+          case 25:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _uploadSourceMaps.apply(this, arguments);
+}
+
+function finalizeRelease(_x7, _x8, _x9) {
+  return _finalizeRelease.apply(this, arguments);
+}
+
+function _finalizeRelease() {
+  _finalizeRelease = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(release, options, ctx) {
+    var span, authToken, org, url, project;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            span = addSpanToTransaction(ctx, "function.plugin.finalize_release");
+
+            if (!options.finalize) {
+              _context3.next = 9;
+              break;
+            }
+
+            authToken = options.authToken, org = options.org, url = options.url, project = options.project;
+
+            if (!(!authToken || !org || !url || !project)) {
+              _context3.next = 6;
+              break;
+            }
+
+            ctx.logger.warn("Missing required option. Will not clean existing artifacts.");
+            return _context3.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 6:
+            _context3.next = 8;
+            return updateRelease({
+              authToken: authToken,
+              org: org,
+              release: release,
+              sentryUrl: url,
+              project: project,
+              sentryHub: ctx.hub,
+              customHeaders: options.customHeaders
+            });
+
+          case 8:
+            ctx.logger.info("Successfully finalized release.");
+
+          case 9:
+            span === null || span === void 0 ? void 0 : span.finish();
+            return _context3.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 11:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _finalizeRelease.apply(this, arguments);
+}
+
+function cleanArtifacts(_x10, _x11, _x12) {
+  return _cleanArtifacts.apply(this, arguments);
+} // TODO: Stuff we worry about later:
+
+function _cleanArtifacts() {
+  _cleanArtifacts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(release, options, ctx) {
+    var span;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            span = addSpanToTransaction(ctx, "function.plugin.clean_artifacts");
+
+            if (!options.cleanArtifacts) {
+              _context4.next = 23;
+              break;
+            }
+
+            if (!(options.authToken === undefined)) {
+              _context4.next = 7;
+              break;
+            }
+
+            ctx.logger.warn('Missing "authToken" option. Will not clean existing artifacts.');
+            return _context4.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 7:
+            if (!(options.org === undefined)) {
+              _context4.next = 12;
+              break;
+            }
+
+            ctx.logger.warn('Missing "org" option. Will not clean existing artifacts.');
+            return _context4.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 12:
+            if (!(options.url === undefined)) {
+              _context4.next = 17;
+              break;
+            }
+
+            ctx.logger.warn('Missing "url" option. Will not clean existing artifacts.');
+            return _context4.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 17:
+            if (!(options.project === undefined)) {
+              _context4.next = 20;
+              break;
+            }
+
+            ctx.logger.warn('Missing "project" option. Will not clean existing artifacts.');
+            return _context4.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 20:
+            _context4.next = 22;
+            return deleteAllReleaseArtifacts({
+              authToken: options.authToken,
+              org: options.org,
+              release: release,
+              sentryUrl: options.url,
+              project: options.project,
+              sentryHub: ctx.hub,
+              customHeaders: options.customHeaders
+            });
+
+          case 22:
+            ctx.logger.info("Successfully cleaned previous artifacts.");
+
+          case 23:
+            span === null || span === void 0 ? void 0 : span.finish();
+            return _context4.abrupt("return", Promise.resolve("nothing to do here"));
+
+          case 25:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _cleanArtifacts.apply(this, arguments);
+}
+
+function setCommits(_x13) {
+  return _setCommits.apply(this, arguments);
+}
+
+function _setCommits() {
+  _setCommits = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(
+  /* version: string, */
+  ctx) {
+    var span;
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            span = addSpanToTransaction(ctx, "function.plugin.set_commits");
+            span === null || span === void 0 ? void 0 : span.finish();
+            return _context5.abrupt("return", Promise.resolve("Noop"));
+
+          case 3:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _setCommits.apply(this, arguments);
+}
+
+function addDeploy(_x14) {
+  return _addDeploy.apply(this, arguments);
+}
+
+function _addDeploy() {
+  _addDeploy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(
+  /* version: string, */
+  ctx) {
+    var span;
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            span = addSpanToTransaction(ctx, "function.plugin.add_deploy");
+            span === null || span === void 0 ? void 0 : span.finish();
+            return _context6.abrupt("return", Promise.resolve("Noop"));
+
+          case 3:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+  return _addDeploy.apply(this, arguments);
+}
+
+function createLogger(options) {
+  function addBreadcrumb(level, message) {
+    options.hub.addBreadcrumb({
+      category: "logger",
+      level: level,
+      message: message
+    });
+  }
+
+  return {
+    info: function info(message) {
+      if (!(options !== null && options !== void 0 && options.silent)) {
+        // eslint-disable-next-line no-console
+        console.log("".concat(options.prefix, " ").concat(message));
+      }
+
+      addBreadcrumb("info", message);
+    },
+    warn: function warn(message) {
+      if (!(options !== null && options !== void 0 && options.silent)) {
+        // eslint-disable-next-line no-console
+        console.log("".concat(options.prefix, " Warning! ").concat(message));
+      }
+
+      addBreadcrumb("warning", message);
+    },
+    error: function error(message) {
+      if (!(options !== null && options !== void 0 && options.silent)) {
+        // eslint-disable-next-line no-console
+        console.log("".concat(options.prefix, " Error: ").concat(message));
+      }
+
+      addBreadcrumb("error", message);
+    }
+  };
+}
+
+var defaultOptions = {
+  //TODO: add default options here as we port over options from the webpack plugin
+  // validate: false
+  debug: false,
+  cleanArtifacts: false,
+  finalize: true,
+  url: "https://sentry.io",
+  ext: ["js", "map", "jsbundle", "bundle"],
+  telemetry: true
+}; // We prefix the polyfill id with \0 to tell other plugins not to try to load or transform it.
+// This hack is taken straight from https://rollupjs.org/guide/en/#resolveid.
+// This probably doesn't work for all bundlers but for rollup it does.
+
+var RELEASE_INJECTOR_ID = "\0sentry-release-injector";
+/**
+ * The sentry-unplugin concerns itself with two things:
+ * - Release injection
+ * - Sourcemaps upload
+ *
+ * Release injection:
+ *
+ * Per default the sentry-unpugin will inject a global `SENTRY_RELEASE` variable into the entrypoint of all bundles. 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-unplugin
+ * to a virtual module that sets the global variable (see `resolveId` and `load` hooks).
+ *
+ * The resulting output approximately looks like this:
+ *
+ * ```text
+ *                               entrypoint1.js (user file)
+ *  ┌───────────────────┐        ┌─────────────────────────────────────────────────┐
+ *  │                   │        │  import { myFunction } from "./my-library.js";  │
+ *  │  sentry-unplugin  │        │                                                 │
+ *  │                   │        │  const myResult = myFunction();                 │
+ *  └---------│---------┘        │  export { myResult };                           │
+ *            │                  │                                                 │
+ *            │      injects     │  // injected by sentry-unplugin                 │
+ *            ├───────────────────► import "sentry-release-injector"; ─────────────────────┐
+ *            │                  └─────────────────────────────────────────────────┘       │
+ *            │                                                                            │
+ *            │                                                                            │
+ *            │                  entrypoint2.js (user file)                                │
+ *            │                  ┌─────────────────────────────────────────────────┐       │
+ *            │                  │  export function myFunction() {                 │       │
+ *            │                  │    return "Hello world!";                       │       │
+ *            │                  │  }                                              │       │
+ *            │                  │                                                 │       │
+ *            │      injects     │  // injected by sentry-unplugin                 │       │
+ *            └───────────────────► import "sentry-release-injector"; ─────────────────────┤
+ *                               └─────────────────────────────────────────────────┘       │
+ *                                                                                         │
+ *                                                                                         │
+ *                               sentry-release-injector                                   │
+ *                               ┌──────────────────────────────────┐                      │
+ *                               │                                  │    is resolved       │
+ *                               │  global.SENTRY_RELEASE = { ... } │    by unplugin       │
+ *                               │  // + a little more logic        │<─────────────────────┘
+ *                               │                                  │    (only once)
+ *                               └──────────────────────────────────┘
+ * ```
+ *
+ * Source maps upload:
+ *
+ * The sentry-unplugin will also take care of uploading source maps to Sentry. This is all done in the `buildEnd` hook.
+ * TODO: elaborate a bit on how sourcemaps upload works
+ */
+
+var unplugin = unplugin$1.createUnplugin(function (originalOptions, unpluginMetaContext) {
+  var options = _objectSpread2(_objectSpread2({}, defaultOptions), originalOptions); //TODO: We can get rid of this variable once we have internal plugin options
+
+
+  var telemetryEnabled = options.telemetry === true;
+
+  var _makeSentryClient = makeSentryClient("https://4c2bae7d9fbc413e8f7385f55c515d51@o1.ingest.sentry.io/6690737", telemetryEnabled, options.org),
+      sentryHub = _makeSentryClient.hub;
+
+  var logger = createLogger({
+    hub: sentryHub,
+    prefix: "[sentry-".concat(unpluginMetaContext.framework, "-plugin]"),
+    silent: options.silent
+  });
+
+  if (telemetryEnabled) {
+    logger.info("Sending error and performance telemetry data to Sentry.");
+    logger.info("To disable telemetry, set `options.telemetry` to `false`.");
+  }
+
+  sentryHub.setTags({
+    organization: options.org,
+    project: options.project,
+    bundler: unpluginMetaContext.framework
+  });
+  sentryHub.setUser({
+    id: options.org
+  }); // This is `nonEntrypointSet` instead of `entrypointSet` because this set is filled in the `resolveId` hook and there
+  // we don't have guaranteed access to *absolute* paths of files if they're entrypoints. For non-entrypoints we're
+  // guaranteed to have absolute paths - we're then using the paths in later hooks to make decisions about whether a
+  // file is an entrypoint or a non-entrypoint.
+
+  var nonEntrypointSet = new Set();
+  var transaction;
+  var releaseInjectionSpan;
+  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() {
+      transaction = sentryHub.startTransaction({
+        op: "function.plugin",
+        name: "Sentry Bundler Plugin execution"
+      });
+      releaseInjectionSpan = addSpanToTransaction({
+        hub: sentryHub,
+        parentSpan: transaction,
+        logger: logger
+      }, "function.plugin.inject_release", "Release injection");
+    },
+
+    /**
+     * 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;
+      sentryHub.addBreadcrumb({
+        category: "resolveId",
+        message: "isEntry: ".concat(String(isEntry)),
+        level: "info"
+      });
+
+      if (!isEntry) {
+        nonEntrypointSet.add(id);
+      }
+
+      if (id === RELEASE_INJECTOR_ID) {
+        return RELEASE_INJECTOR_ID;
+      } else {
+        return undefined;
+      }
+    },
+    loadInclude: function loadInclude(id) {
+      logger.info("Called \"loadInclude\": ".concat(JSON.stringify({
+        id: id
+      })));
+      return id === RELEASE_INJECTOR_ID;
+    },
+
+    /**
+     * Responsible for "virtually" loading the "sentry-release-injector" module. "Virtual" means that the module is not
+     * read from somewhere on disk but rather just returned via a string.
+     *
+     * @param id Always the absolute (fully resolved) path to the module.
+     * @returns The global injector code when we load the "sentry-release-injector" module. Otherwise returns `undefined`.
+     */
+    load: function load(id) {
+      sentryHub.addBreadcrumb({
+        category: "load",
+        level: "info"
+      });
+
+      if (id === RELEASE_INJECTOR_ID) {
+        return generateGlobalInjectorCode({
+          release: getReleaseName(options.release)
+        });
+      } else {
+        return undefined;
+      }
+    },
+
+    /**
+     * This hook determines whether we want to transform a module. In the unplugin we want to transform every entrypoint
+     * unless configured otherwise with the `entries` 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-unplugin we only
+     * want to transform the release injector file.
+     */
+    transformInclude: function transformInclude(id) {
+      sentryHub.addBreadcrumb({
+        category: "transformInclude",
+        level: "info"
+      });
+
+      if (options.entries) {
+        // If there's an `entries` option transform (ie. inject the release varible) when the file path matches the option.
+        if (typeof options.entries === "function") {
+          return options.entries(id);
+        }
+
+        var arrayifiedEntriesOption = Array.isArray(options.entries) ? options.entries : [options.entries];
+        return arrayifiedEntriesOption.some(function (entry) {
+          if (entry instanceof RegExp) {
+            return entry.test(id);
+          } else {
+            return id === entry;
+          }
+        });
+      } // We want to transform (release injection) every module except for "sentry-release-injector".
+
+
+      return id !== RELEASE_INJECTOR_ID && !nonEntrypointSet.has(id);
+    },
+
+    /**
+     * This hook is responsible for injecting the "sentry release injector" imoprt statement into each entrypoint unless
+     * configured otherwise with the `entries` 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) {
+      sentryHub.addBreadcrumb({
+        category: "transform",
+        level: "info"
+      }); // The MagicString library allows us to generate sourcemaps for the changes we make to the user code.
+
+      var ms = new MagicString__default["default"](code); // Very stupid author's note: For some absurd reason, when we add a JSDoc to this hook, the TS language server starts complaining about `ms` and adding a type annotation helped so that's why it's here. (┛ಠ_ಠ)┛彡┻━┻
+      // appending instead of prepending has less probability of mucking with user'sadly
+      // source maps and import statements get to the top anyways
+
+      ms.append("import \"".concat(RELEASE_INJECTOR_ID, "\";"));
+
+      if (unpluginMetaContext.framework === "esbuild") {
+        // esbuild + unplugin is buggy at the moment when we return an object with a `map` (sourcemap) property.
+        // Currently just returning a string here seems to work and even correctly sourcemaps the code we generate.
+        // However, other bundlers need the `map` property
+        return ms.toString();
+      } else {
+        return {
+          code: ms.toString(),
+          map: ms.generateMap()
+        };
+      }
+    },
+
+    /**
+     * 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)
+     */
+    buildEnd: function buildEnd() {
+      var _releaseInjectionSpan;
+
+      (_releaseInjectionSpan = releaseInjectionSpan) === null || _releaseInjectionSpan === void 0 ? void 0 : _releaseInjectionSpan.finish();
+      var releasePipelineSpan = transaction && addSpanToTransaction({
+        hub: sentryHub,
+        parentSpan: transaction,
+        logger: logger
+      }, "function.plugin.release", "Release pipeline");
+      var release = getReleaseName(options.release);
+      sentryHub.addBreadcrumb({
+        category: "buildEnd:start",
+        level: "info"
+      }); //TODO:
+      //  1. validate options to see if we get a valid include property, release name, etc.
+      //  2. normalize the include property: Users can pass string | string [] | IncludeEntry[].
+      //     That's good for them but a hassle for us. Let's try to normalize this into one data type
+      //     (I vote IncludeEntry[]) and continue with that down the line
+
+      var ctx = {
+        hub: sentryHub,
+        parentSpan: releasePipelineSpan,
+        logger: logger
+      };
+      createNewRelease(release, options, ctx).then(function () {
+        return cleanArtifacts(release, options, ctx);
+      }).then(function () {
+        return uploadSourceMaps(release, options, ctx);
+      }).then(function () {
+        return setCommits(ctx);
+      }) // this is a noop for now
+      .then(function () {
+        return finalizeRelease(release, options, ctx);
+      }).then(function () {
+        return addDeploy(ctx);
+      }) // this is a noop for now
+      .then(function () {
+        var _transaction;
+
+        (_transaction = transaction) === null || _transaction === void 0 ? void 0 : _transaction.setStatus("ok");
+      })["catch"](function (e) {
+        var _transaction2;
+
+        captureMinimalError(e, sentryHub);
+        (_transaction2 = transaction) === null || _transaction2 === void 0 ? void 0 : _transaction2.setStatus("cancelled");
+        logger.error(e.message);
+
+        if (options.errorHandler) {
+          options.errorHandler(e);
+        } else {
+          throw e;
+        }
+      })["finally"](function () {
+        var _transaction3;
+
+        sentryHub.addBreadcrumb({
+          category: "buildEnd:finish",
+          level: "info"
+        });
+        releasePipelineSpan === null || releasePipelineSpan === void 0 ? void 0 : releasePipelineSpan.finish();
+        (_transaction3 = transaction) === null || _transaction3 === void 0 ? void 0 : _transaction3.finish();
+      });
+    }
+  };
+});
+/**
+ * Generates code for the "sentry-release-injector" which is responsible for setting the global `SENTRY_RELEASE`
+ * variable.
+ */
+
+function generateGlobalInjectorCode(_ref2) {
+  var release = _ref2.release;
+  // 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.)
+  return "\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, "\"};");
+} // 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;
+//# sourceMappingURL=index.js.map