@metamask-previews/notification-services-controller 0.1.0-preview-caf274f8 → 0.1.0-preview-ed5d0223

package/dist/chunk-4KZO4UUC.js

@@ -0,0 +1,4300 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkUPVIT75Fjs = require('./chunk-UPVIT75F.js');
+
+
+var _chunk232HZSEVjs = require('./chunk-232HZSEV.js');
+
+
+
+var _chunkYRWUXGL3js = require('./chunk-YRWUXGL3.js');
+
+
+var _chunkZMNXLHACjs = require('./chunk-ZMNXLHAC.js');
+
+
+
+
+var _chunkVOZ7Y2OOjs = require('./chunk-VOZ7Y2OO.js');
+
+
+var _chunkPIZCE3JDjs = require('./chunk-PIZCE3JD.js');
+
+
+var _chunkCQ6CGSKZjs = require('./chunk-CQ6CGSKZ.js');
+
+
+var _chunkTLX5QQK5js = require('./chunk-TLX5QQK5.js');
+
+
+
+
+
+var _chunkV46WVGWNjs = require('./chunk-V46WVGWN.js');
+
+// ../../node_modules/ms/index.js
+var require_ms = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/ms/index.js"(exports, module) {
+    "use strict";
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return plural(ms, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms, msAbs, s, "second");
+      }
+      return ms + " ms";
+    }
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// ../../node_modules/debug/src/common.js
+var require_common = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/debug/src/common.js"(exports, module) {
+    "use strict";
+    function setup(env) {
+      createDebug.debug = createDebug;
+      createDebug.default = createDebug;
+      createDebug.coerce = coerce;
+      createDebug.disable = disable;
+      createDebug.enable = enable;
+      createDebug.enabled = enabled;
+      createDebug.humanize = require_ms();
+      createDebug.destroy = destroy;
+      Object.keys(env).forEach((key) => {
+        createDebug[key] = env[key];
+      });
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          hash |= 0;
+        }
+        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+      }
+      createDebug.selectColor = selectColor;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug(...args) {
+          if (!debug.enabled) {
+            return;
+          }
+          const self = debug;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self.diff = ms;
+          self.prev = prevTime;
+          self.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug.formatArgs.call(self, args);
+          const logFn = self.log || createDebug.log;
+          logFn.apply(self, args);
+        }
+        debug.namespace = namespace;
+        debug.useColors = createDebug.useColors();
+        debug.color = createDebug.selectColor(namespace);
+        debug.extend = extend;
+        debug.destroy = createDebug.destroy;
+        Object.defineProperty(debug, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug.init === "function") {
+          createDebug.init(debug);
+        }
+        return debug;
+      }
+      function extend(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        let i;
+        const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+        const len = split.length;
+        for (i = 0; i < len; i++) {
+          if (!split[i]) {
+            continue;
+          }
+          namespaces = split[i].replace(/\*/g, ".*?");
+          if (namespaces[0] === "-") {
+            createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
+          } else {
+            createDebug.names.push(new RegExp("^" + namespaces + "$"));
+          }
+        }
+      }
+      function disable() {
+        const namespaces = [
+          ...createDebug.names.map(toNamespace),
+          ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      function enabled(name) {
+        if (name[name.length - 1] === "*") {
+          return true;
+        }
+        let i;
+        let len;
+        for (i = 0, len = createDebug.skips.length; i < len; i++) {
+          if (createDebug.skips[i].test(name)) {
+            return false;
+          }
+        }
+        for (i = 0, len = createDebug.names.length; i < len; i++) {
+          if (createDebug.names[i].test(name)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function toNamespace(regexp) {
+        return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
+      }
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      createDebug.enable(createDebug.load());
+      return createDebug;
+    }
+    module.exports = setup;
+  }
+});
+
+// ../../node_modules/debug/src/browser.js
+var require_browser = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/debug/src/browser.js"(exports, module) {
+    "use strict";
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  }
+});
+
+// ../../node_modules/nock/lib/common.js
+var require_common2 = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/lib/common.js"(exports, module) {
+    "use strict";
+    var debug = require_browser()("nock.common");
+    var timers = _chunkV46WVGWNjs.__require.call(void 0, "timers");
+    var url = _chunkV46WVGWNjs.__require.call(void 0, "url");
+    var util = _chunkV46WVGWNjs.__require.call(void 0, "util");
+    function normalizeRequestOptions(options) {
+      options.proto = options.proto || "http";
+      options.port = options.port || (options.proto === "http" ? 80 : 443);
+      if (options.host) {
+        debug("options.host:", options.host);
+        if (!options.hostname) {
+          if (options.host.split(":").length === 2) {
+            options.hostname = options.host.split(":")[0];
+          } else {
+            options.hostname = options.host;
+          }
+        }
+      }
+      debug("options.hostname in the end: %j", options.hostname);
+      options.host = `${options.hostname || "localhost"}:${options.port}`;
+      debug("options.host in the end: %j", options.host);
+      ["hostname", "host"].forEach(function(attr) {
+        if (options[attr]) {
+          options[attr] = options[attr].toLowerCase();
+        }
+      });
+      return options;
+    }
+    function isUtf8Representable(buffer) {
+      const utfEncodedBuffer = buffer.toString("utf8");
+      const reconstructedBuffer = Buffer.from(utfEncodedBuffer, "utf8");
+      return reconstructedBuffer.equals(buffer);
+    }
+    var requestOverrides = {};
+    function overrideRequests(newRequest) {
+      debug("overriding requests");
+      ["http", "https"].forEach(function(proto) {
+        debug("- overriding request for", proto);
+        const moduleName = proto;
+        const module2 = _chunkV46WVGWNjs.__require.call(void 0, proto);
+        const overriddenRequest = module2.request;
+        const overriddenGet = module2.get;
+        if (requestOverrides[moduleName]) {
+          throw new Error(
+            `Module's request already overridden for ${moduleName} protocol.`
+          );
+        }
+        requestOverrides[moduleName] = {
+          module: module2,
+          request: overriddenRequest,
+          get: overriddenGet
+        };
+        module2.request = function(input, options, callback) {
+          return newRequest(proto, overriddenRequest.bind(module2), [
+            input,
+            options,
+            callback
+          ]);
+        };
+        module2.get = function(input, options, callback) {
+          const req = newRequest(proto, overriddenGet.bind(module2), [
+            input,
+            options,
+            callback
+          ]);
+          req.end();
+          return req;
+        };
+        debug("- overridden request for", proto);
+      });
+    }
+    function restoreOverriddenRequests() {
+      debug("restoring requests");
+      Object.entries(requestOverrides).forEach(
+        ([proto, { module: module2, request, get }]) => {
+          debug("- restoring request for", proto);
+          module2.request = request;
+          module2.get = get;
+          debug("- restored request for", proto);
+        }
+      );
+      requestOverrides = {};
+    }
+    function normalizeOrigin(proto, host, port) {
+      const hostHasPort = host.includes(":");
+      const portIsStandard = proto === "http" && (port === 80 || port === "80") || proto === "https" && (port === 443 || port === "443");
+      const portStr = hostHasPort || portIsStandard ? "" : `:${port}`;
+      return `${proto}://${host}${portStr}`;
+    }
+    function stringifyRequest(options, body) {
+      const { method = "GET", path = "", port } = options;
+      const origin = normalizeOrigin(options.proto, options.hostname, port);
+      const log = {
+        method,
+        url: `${origin}${path}`,
+        headers: options.headers
+      };
+      if (body) {
+        log.body = body;
+      }
+      return JSON.stringify(log, null, 2);
+    }
+    function isContentEncoded(headers) {
+      const contentEncoding2 = headers["content-encoding"];
+      return typeof contentEncoding2 === "string" && contentEncoding2 !== "";
+    }
+    function contentEncoding(headers, encoder) {
+      const contentEncoding2 = headers["content-encoding"];
+      return contentEncoding2 !== void 0 && contentEncoding2.toString() === encoder;
+    }
+    function isJSONContent(headers) {
+      const contentType = String(headers["content-type"] || "").toLowerCase();
+      return contentType.startsWith("application/json");
+    }
+    function headersFieldNamesToLowerCase(headers, throwOnDuplicate) {
+      if (!isPlainObject(headers)) {
+        throw Error("Headers must be provided as an object");
+      }
+      const lowerCaseHeaders = {};
+      Object.entries(headers).forEach(([fieldName, fieldValue]) => {
+        const key = fieldName.toLowerCase();
+        if (lowerCaseHeaders[key] !== void 0) {
+          if (throwOnDuplicate) {
+            throw Error(
+              `Failed to convert header keys to lower case due to field name conflict: ${key}`
+            );
+          } else {
+            debug(
+              `Duplicate header provided in request: ${key}. Only the last value can be matched.`
+            );
+          }
+        }
+        lowerCaseHeaders[key] = fieldValue;
+      });
+      return lowerCaseHeaders;
+    }
+    var headersFieldsArrayToLowerCase = (headers) => [
+      ...new Set(headers.map((fieldName) => fieldName.toLowerCase()))
+    ];
+    function headersInputToRawArray(headers) {
+      if (headers === void 0) {
+        return [];
+      }
+      if (Array.isArray(headers)) {
+        if (headers.length % 2) {
+          throw new Error(
+            `Raw headers must be provided as an array with an even number of items. [fieldName, value, ...]`
+          );
+        }
+        return [...headers];
+      }
+      if (util.types.isMap(headers)) {
+        return [].concat(...Array.from(headers, ([k, v]) => [k.toString(), v]));
+      }
+      if (isPlainObject(headers)) {
+        return [].concat(...Object.entries(headers));
+      }
+      throw new Error(
+        `Headers must be provided as an array of raw values, a Map, or a plain Object. ${headers}`
+      );
+    }
+    function headersArrayToObject(rawHeaders) {
+      if (!Array.isArray(rawHeaders)) {
+        throw Error("Expected a header array");
+      }
+      const accumulator = {};
+      forEachHeader(rawHeaders, (value, fieldName) => {
+        addHeaderLine(accumulator, fieldName, value);
+      });
+      return accumulator;
+    }
+    var noDuplicatesHeaders = /* @__PURE__ */ new Set([
+      "age",
+      "authorization",
+      "content-length",
+      "content-type",
+      "etag",
+      "expires",
+      "from",
+      "host",
+      "if-modified-since",
+      "if-unmodified-since",
+      "last-modified",
+      "location",
+      "max-forwards",
+      "proxy-authorization",
+      "referer",
+      "retry-after",
+      "user-agent"
+    ]);
+    function addHeaderLine(headers, name, value) {
+      let values;
+      if (typeof value === "function") {
+        values = [value.name];
+      } else if (Array.isArray(value)) {
+        values = value.map(String);
+      } else {
+        values = [String(value)];
+      }
+      const key = name.toLowerCase();
+      if (key === "set-cookie") {
+        if (headers["set-cookie"] === void 0) {
+          headers["set-cookie"] = values;
+        } else {
+          headers["set-cookie"].push(...values);
+        }
+      } else if (noDuplicatesHeaders.has(key)) {
+        if (headers[key] === void 0) {
+          headers[key] = values[0];
+        }
+      } else {
+        if (headers[key] !== void 0) {
+          values = [headers[key], ...values];
+        }
+        const separator = key === "cookie" ? "; " : ", ";
+        headers[key] = values.join(separator);
+      }
+    }
+    function deleteHeadersField(headers, fieldNameToDelete) {
+      if (!isPlainObject(headers)) {
+        throw Error("headers must be an object");
+      }
+      if (typeof fieldNameToDelete !== "string") {
+        throw Error("field name must be a string");
+      }
+      const lowerCaseFieldNameToDelete = fieldNameToDelete.toLowerCase();
+      Object.keys(headers).filter((fieldName) => fieldName.toLowerCase() === lowerCaseFieldNameToDelete).forEach((fieldName) => delete headers[fieldName]);
+    }
+    function forEachHeader(rawHeaders, callback) {
+      for (let i = 0; i < rawHeaders.length; i += 2) {
+        callback(rawHeaders[i + 1], rawHeaders[i], i);
+      }
+    }
+    function percentDecode(str) {
+      try {
+        return decodeURIComponent(str.replace(/\+/g, " "));
+      } catch (e) {
+        return str;
+      }
+    }
+    function percentEncode(str) {
+      return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
+        return `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
+      });
+    }
+    function matchStringOrRegexp(target, pattern) {
+      const targetStr = target === void 0 || target === null ? "" : String(target);
+      if (pattern instanceof RegExp) {
+        pattern.lastIndex = 0;
+        return pattern.test(targetStr);
+      }
+      return targetStr === String(pattern);
+    }
+    function formatQueryValue(key, value, stringFormattingFn) {
+      switch (true) {
+        case typeof value === "number":
+        case typeof value === "boolean":
+          value = value.toString();
+          break;
+        case value === null:
+        case value === void 0:
+          value = "";
+          break;
+        case typeof value === "string":
+          if (stringFormattingFn) {
+            value = stringFormattingFn(value);
+          }
+          break;
+        case value instanceof RegExp:
+          break;
+        case Array.isArray(value): {
+          value = value.map(function(val, idx) {
+            return formatQueryValue(idx, val, stringFormattingFn)[1];
+          });
+          break;
+        }
+        case typeof value === "object": {
+          value = Object.entries(value).reduce(function(acc, [subKey, subVal]) {
+            const subPair = formatQueryValue(subKey, subVal, stringFormattingFn);
+            acc[subPair[0]] = subPair[1];
+            return acc;
+          }, {});
+          break;
+        }
+      }
+      if (stringFormattingFn)
+        key = stringFormattingFn(key);
+      return [key, value];
+    }
+    function isStream(obj) {
+      return obj && typeof obj !== "string" && !Buffer.isBuffer(obj) && typeof obj.setEncoding === "function";
+    }
+    function normalizeClientRequestArgs(input, options, cb) {
+      if (typeof input === "string") {
+        input = urlToOptions(new url.URL(input));
+      } else if (input instanceof url.URL) {
+        input = urlToOptions(input);
+      } else {
+        cb = options;
+        options = input;
+        input = null;
+      }
+      if (typeof options === "function") {
+        cb = options;
+        options = input || {};
+      } else {
+        options = Object.assign(input || {}, options);
+      }
+      return { options, callback: cb };
+    }
+    function urlToOptions(url2) {
+      const options = {
+        protocol: url2.protocol,
+        hostname: typeof url2.hostname === "string" && url2.hostname.startsWith("[") ? url2.hostname.slice(1, -1) : url2.hostname,
+        hash: url2.hash,
+        search: url2.search,
+        pathname: url2.pathname,
+        path: `${url2.pathname}${url2.search || ""}`,
+        href: url2.href
+      };
+      if (url2.port !== "") {
+        options.port = Number(url2.port);
+      }
+      if (url2.username || url2.password) {
+        options.auth = `${url2.username}:${url2.password}`;
+      }
+      return options;
+    }
+    var dataEqual = (expected, actual) => {
+      if (isPlainObject(expected)) {
+        expected = expand(expected);
+      }
+      if (isPlainObject(actual)) {
+        actual = expand(actual);
+      }
+      return deepEqual(expected, actual);
+    };
+    function deepEqual(expected, actual) {
+      debug("deepEqual comparing", typeof expected, expected, typeof actual, actual);
+      if (expected instanceof RegExp) {
+        return expected.test(actual);
+      }
+      if (Array.isArray(expected) && Array.isArray(actual)) {
+        if (expected.length !== actual.length) {
+          return false;
+        }
+        return expected.every((expVal, idx) => deepEqual(expVal, actual[idx]));
+      }
+      if (isPlainObject(expected) && isPlainObject(actual)) {
+        const allKeys = Array.from(
+          new Set(Object.keys(expected).concat(Object.keys(actual)))
+        );
+        return allKeys.every((key) => deepEqual(expected[key], actual[key]));
+      }
+      return expected === actual;
+    }
+    var timeouts = [];
+    var intervals = [];
+    var immediates = [];
+    var wrapTimer = (timer, ids) => (...args) => {
+      const id = timer(...args);
+      ids.push(id);
+      return id;
+    };
+    var setTimeout = wrapTimer(timers.setTimeout, timeouts);
+    var setInterval = wrapTimer(timers.setInterval, intervals);
+    var setImmediate = wrapTimer(timers.setImmediate, immediates);
+    function clearTimer(clear, ids) {
+      while (ids.length) {
+        clear(ids.shift());
+      }
+    }
+    function removeAllTimers() {
+      clearTimer(clearTimeout, timeouts);
+      clearTimer(clearInterval, intervals);
+      clearTimer(clearImmediate, immediates);
+    }
+    function isRequestDestroyed(req) {
+      return !!(req.destroyed === true || req.aborted || req.socket && req.socket.destroyed);
+    }
+    function isPlainObject(value) {
+      if (typeof value !== "object" || value === null)
+        return false;
+      if (Object.prototype.toString.call(value) !== "[object Object]")
+        return false;
+      const proto = Object.getPrototypeOf(value);
+      if (proto === null)
+        return true;
+      const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+      return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
+    }
+    var prototypePollutionBlockList = ["__proto__", "prototype", "constructor"];
+    var blocklistFilter = function(part) {
+      return prototypePollutionBlockList.indexOf(part) === -1;
+    };
+    var expand = (input) => {
+      if (input === void 0 || input === null) {
+        return input;
+      }
+      const keys = Object.keys(input);
+      const result = {};
+      let resultPtr = result;
+      for (let path of keys) {
+        const originalPath = path;
+        if (path.indexOf("[") >= 0) {
+          path = path.replace(/\[/g, ".").replace(/]/g, "");
+        }
+        const parts = path.split(".");
+        const check = parts.filter(blocklistFilter);
+        if (check.length !== parts.length) {
+          return void 0;
+        }
+        resultPtr = result;
+        const lastIndex = parts.length - 1;
+        for (let i = 0; i < parts.length; ++i) {
+          const part = parts[i];
+          if (i === lastIndex) {
+            if (Array.isArray(resultPtr)) {
+              resultPtr[+part] = input[originalPath];
+            } else {
+              resultPtr[part] = input[originalPath];
+            }
+          } else {
+            if (resultPtr[part] === void 0 || resultPtr[part] === null) {
+              const nextPart = parts[i + 1];
+              if (/^\d+$/.test(nextPart)) {
+                resultPtr[part] = [];
+              } else {
+                resultPtr[part] = {};
+              }
+            }
+            resultPtr = resultPtr[part];
+          }
+        }
+      }
+      return result;
+    };
+    module.exports = {
+      contentEncoding,
+      dataEqual,
+      deleteHeadersField,
+      expand,
+      forEachHeader,
+      formatQueryValue,
+      headersArrayToObject,
+      headersFieldNamesToLowerCase,
+      headersFieldsArrayToLowerCase,
+      headersInputToRawArray,
+      isContentEncoded,
+      isJSONContent,
+      isPlainObject,
+      isRequestDestroyed,
+      isStream,
+      isUtf8Representable,
+      matchStringOrRegexp,
+      normalizeClientRequestArgs,
+      normalizeOrigin,
+      normalizeRequestOptions,
+      overrideRequests,
+      percentDecode,
+      percentEncode,
+      removeAllTimers,
+      restoreOverriddenRequests,
+      setImmediate,
+      setInterval,
+      setTimeout,
+      stringifyRequest
+    };
+  }
+});
+
+// ../../node_modules/propagate/index.js
+var require_propagate = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/propagate/index.js"(exports, module) {
+    "use strict";
+    function propagate(events, source, dest) {
+      if (arguments.length < 3) {
+        dest = source;
+        source = events;
+        events = void 0;
+      }
+      const eventsIsObject = typeof events === "object";
+      if (events && !eventsIsObject)
+        events = [events];
+      if (eventsIsObject) {
+        return explicitPropagate(events, source, dest);
+      }
+      const shouldPropagate = (eventName) => events === void 0 || events.includes(eventName);
+      const oldEmit = source.emit;
+      source.emit = (eventName, ...args) => {
+        const oldEmitHadListeners = oldEmit.call(source, eventName, ...args);
+        let destEmitHadListeners = false;
+        if (shouldPropagate(eventName)) {
+          destEmitHadListeners = dest.emit(eventName, ...args);
+        }
+        return oldEmitHadListeners || destEmitHadListeners;
+      };
+      function end() {
+        source.emit = oldEmit;
+      }
+      return {
+        end
+      };
+    }
+    module.exports = propagate;
+    function explicitPropagate(events, source, dest) {
+      let eventsIn;
+      let eventsOut;
+      if (Array.isArray(events)) {
+        eventsIn = events;
+        eventsOut = events;
+      } else {
+        eventsIn = Object.keys(events);
+        eventsOut = eventsIn.map(function(key) {
+          return events[key];
+        });
+      }
+      const listeners = eventsOut.map(function(event) {
+        return function() {
+          const args = Array.prototype.slice.call(arguments);
+          args.unshift(event);
+          dest.emit.apply(dest, args);
+        };
+      });
+      listeners.forEach(register);
+      return {
+        end
+      };
+      function register(listener, i) {
+        source.on(eventsIn[i], listener);
+      }
+      function unregister(listener, i) {
+        source.removeListener(eventsIn[i], listener);
+      }
+      function end() {
+        listeners.forEach(unregister);
+      }
+    }
+  }
+});
+
+// ../../node_modules/nock/lib/global_emitter.js
+var require_global_emitter = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/lib/global_emitter.js"(exports, module) {
+    "use strict";
+    var { EventEmitter } = _chunkV46WVGWNjs.__require.call(void 0, "events");
+    module.exports = new EventEmitter();
+  }
+});
+
+// ../../node_modules/nock/lib/socket.js
+var require_socket = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/lib/socket.js"(exports, module) {
+    "use strict";
+    var { EventEmitter } = _chunkV46WVGWNjs.__require.call(void 0, "events");
+    var debug = require_browser()("nock.socket");
+    module.exports = class Socket extends EventEmitter {
+      constructor(options) {
+        super();
+        if (options.proto === "https") {
+          this.authorized = true;
+          this.encrypted = true;
+        }
+        this.bufferSize = 0;
+        this.writableLength = 0;
+        this.writable = true;
+        this.readable = true;
+        this.pending = false;
+        this.destroyed = false;
+        this.connecting = true;
+        this._hadError = false;
+        this.timeout = 0;
+        const ipv6 = options.family === 6;
+        this.remoteFamily = ipv6 ? "IPv6" : "IPv4";
+        this.localAddress = this.remoteAddress = ipv6 ? "::1" : "127.0.0.1";
+        this.localPort = this.remotePort = parseInt(options.port);
+      }
+      setNoDelay() {
+      }
+      setKeepAlive() {
+      }
+      resume() {
+      }
+      ref() {
+      }
+      unref() {
+      }
+      write() {
+      }
+      address() {
+        return {
+          port: this.remotePort,
+          family: this.remoteFamily,
+          address: this.remoteAddress
+        };
+      }
+      setTimeout(timeoutMs, fn) {
+        this.timeout = timeoutMs;
+        if (fn) {
+          this.once("timeout", fn);
+        }
+        return this;
+      }
+      /**
+       * Artificial delay that will trip socket timeouts when appropriate.
+       *
+       * Doesn't actually wait for time to pass.
+       * Timeout events don't necessarily end the request.
+       * While many clients choose to abort the request upon a timeout, Node itself does not.
+       */
+      applyDelay(delayMs) {
+        if (this.timeout && delayMs > this.timeout) {
+          debug("socket timeout");
+          this.emit("timeout");
+        }
+      }
+      getPeerCertificate() {
+        return Buffer.from(
+          (Math.random() * 1e4 + Date.now()).toString()
+        ).toString("base64");
+      }
+      /**
+       * Denotes that no more I/O activity should happen on this socket.
+       *
+       * The implementation in Node if far more complex as it juggles underlying async streams.
+       * For the purposes of Nock, we just need it to set some flags and on the first call
+       * emit a 'close' and optional 'error' event. Both events propagate through the request object.
+       */
+      destroy(err) {
+        if (this.destroyed) {
+          return this;
+        }
+        debug("socket destroy");
+        this.destroyed = true;
+        this.readable = this.writable = false;
+        this.readableEnded = this.writableFinished = true;
+        process.nextTick(() => {
+          if (err) {
+            this._hadError = true;
+            this.emit("error", err);
+          }
+          this.emit("close");
+        });
+        return this;
+      }
+    };
+  }
+});
+
+// ../../node_modules/nock/lib/playback_interceptor.js
+var require_playback_interceptor = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/lib/playback_interceptor.js"(exports, module) {
+    "use strict";
+    var stream = _chunkV46WVGWNjs.__require.call(void 0, "stream");
+    var util = _chunkV46WVGWNjs.__require.call(void 0, "util");
+    var zlib = _chunkV46WVGWNjs.__require.call(void 0, "zlib");
+    var debug = require_browser()("nock.playback_interceptor");
+    var common = require_common2();
+    function parseJSONRequestBody(req, requestBody) {
+      if (!requestBody || !common.isJSONContent(req.headers)) {
+        return requestBody;
+      }
+      if (common.contentEncoding(req.headers, "gzip")) {
+        requestBody = String(zlib.gunzipSync(Buffer.from(requestBody, "hex")));
+      } else if (common.contentEncoding(req.headers, "deflate")) {
+        requestBody = String(zlib.inflateSync(Buffer.from(requestBody, "hex")));
+      }
+      return JSON.parse(requestBody);
+    }
+    function parseFullReplyResult(response, fullReplyResult) {
+      debug("full response from callback result: %j", fullReplyResult);
+      if (!Array.isArray(fullReplyResult)) {
+        throw Error("A single function provided to .reply MUST return an array");
+      }
+      if (fullReplyResult.length > 3) {
+        throw Error(
+          "The array returned from the .reply callback contains too many values"
+        );
+      }
+      const [status, body = "", headers] = fullReplyResult;
+      if (!Number.isInteger(status)) {
+        throw new Error(`Invalid ${typeof status} value for status code`);
+      }
+      response.statusCode = status;
+      response.rawHeaders.push(...common.headersInputToRawArray(headers));
+      debug("response.rawHeaders after reply: %j", response.rawHeaders);
+      return body;
+    }
+    function selectDefaultHeaders(existingHeaders, defaultHeaders) {
+      if (!defaultHeaders.length) {
+        return [];
+      }
+      const definedHeaders = /* @__PURE__ */ new Set();
+      const result = [];
+      common.forEachHeader(existingHeaders, (_, fieldName) => {
+        definedHeaders.add(fieldName.toLowerCase());
+      });
+      common.forEachHeader(defaultHeaders, (value, fieldName) => {
+        if (!definedHeaders.has(fieldName.toLowerCase())) {
+          result.push(fieldName, value);
+        }
+      });
+      return result;
+    }
+    var ReadableBuffers = class extends stream.Readable {
+      constructor(buffers, opts = {}) {
+        super(opts);
+        this.buffers = buffers;
+      }
+      _read(_size) {
+        while (this.buffers.length) {
+          if (!this.push(this.buffers.shift())) {
+            return;
+          }
+        }
+        this.push(null);
+      }
+    };
+    function convertBodyToStream(body) {
+      if (common.isStream(body)) {
+        return body;
+      }
+      if (body === void 0) {
+        return new ReadableBuffers([]);
+      }
+      if (Buffer.isBuffer(body)) {
+        return new ReadableBuffers([body]);
+      }
+      if (typeof body !== "string") {
+        body = JSON.stringify(body);
+      }
+      return new ReadableBuffers([Buffer.from(body)]);
+    }
+    function playbackInterceptor({
+      req,
+      socket,
+      options,
+      requestBodyString,
+      requestBodyIsUtf8Representable,
+      response,
+      interceptor
+    }) {
+      const { logger } = interceptor.scope;
+      function start() {
+        req.headers = req.getHeaders();
+        interceptor.scope.emit("request", req, interceptor, requestBodyString);
+        if (typeof interceptor.errorMessage !== "undefined") {
+          let error;
+          if (typeof interceptor.errorMessage === "object") {
+            error = interceptor.errorMessage;
+          } else {
+            error = new Error(interceptor.errorMessage);
+          }
+          const delay = interceptor.delayBodyInMs + interceptor.delayConnectionInMs;
+          common.setTimeout(() => req.destroy(error), delay);
+          return;
+        }
+        response.statusCode = interceptor.statusCode;
+        response.rawHeaders = [...interceptor.rawHeaders];
+        logger("response.rawHeaders:", response.rawHeaders);
+        interceptor.req = req;
+        if (interceptor.replyFunction) {
+          const parsedRequestBody = parseJSONRequestBody(req, requestBodyString);
+          let fn = interceptor.replyFunction;
+          if (fn.length === 3) {
+            fn = util.promisify(fn);
+          }
+          Promise.resolve(fn.call(interceptor, options.path, parsedRequestBody)).then(continueWithResponseBody).catch((err) => req.destroy(err));
+          return;
+        }
+        if (interceptor.fullReplyFunction) {
+          const parsedRequestBody = parseJSONRequestBody(req, requestBodyString);
+          let fn = interceptor.fullReplyFunction;
+          if (fn.length === 3) {
+            fn = util.promisify(fn);
+          }
+          Promise.resolve(fn.call(interceptor, options.path, parsedRequestBody)).then(continueWithFullResponse).catch((err) => req.destroy(err));
+          return;
+        }
+        if (common.isContentEncoded(interceptor.headers) && !common.isStream(interceptor.body)) {
+          const bufferData = Array.isArray(interceptor.body) ? interceptor.body : [interceptor.body];
+          const responseBuffers = bufferData.map((data) => Buffer.from(data, "hex"));
+          const responseBody2 = new ReadableBuffers(responseBuffers);
+          continueWithResponseBody(responseBody2);
+          return;
+        }
+        let responseBody = interceptor.body;
+        if (!requestBodyIsUtf8Representable && typeof responseBody === "string") {
+          responseBody = Buffer.from(responseBody, "hex");
+          if (!responseBody || interceptor.body.length > 0 && responseBody.length === 0) {
+            responseBody = Buffer.from(interceptor.body, "utf8");
+          }
+        }
+        return continueWithResponseBody(responseBody);
+      }
+      function continueWithFullResponse(fullReplyResult) {
+        let responseBody;
+        try {
+          responseBody = parseFullReplyResult(response, fullReplyResult);
+        } catch (err) {
+          req.destroy(err);
+          return;
+        }
+        continueWithResponseBody(responseBody);
+      }
+      function prepareResponseHeaders(body) {
+        const defaultHeaders = [...interceptor.scope._defaultReplyHeaders];
+        const isJSON = body !== void 0 && typeof body !== "string" && !Buffer.isBuffer(body) && !common.isStream(body);
+        if (isJSON) {
+          defaultHeaders.push("Content-Type", "application/json");
+        }
+        response.rawHeaders.push(
+          ...selectDefaultHeaders(response.rawHeaders, defaultHeaders)
+        );
+        common.forEachHeader(response.rawHeaders, (value, fieldName, i) => {
+          if (typeof value === "function") {
+            response.rawHeaders[i + 1] = value(req, response, body);
+          }
+        });
+        response.headers = common.headersArrayToObject(response.rawHeaders);
+      }
+      function continueWithResponseBody(rawBody) {
+        prepareResponseHeaders(rawBody);
+        const bodyAsStream = convertBodyToStream(rawBody);
+        bodyAsStream.pause();
+        bodyAsStream.on("data", function(chunk) {
+          response.push(chunk);
+        });
+        bodyAsStream.on("end", function() {
+          response.complete = true;
+          response.push(null);
+          interceptor.scope.emit("replied", req, interceptor);
+        });
+        bodyAsStream.on("error", function(err) {
+          response.emit("error", err);
+        });
+        const { delayBodyInMs, delayConnectionInMs } = interceptor;
+        function respond() {
+          if (common.isRequestDestroyed(req)) {
+            return;
+          }
+          req.res = response;
+          response.req = req;
+          logger("emitting response");
+          req.emit("response", response);
+          common.setTimeout(() => bodyAsStream.resume(), delayBodyInMs);
+        }
+        socket.applyDelay(delayConnectionInMs);
+        common.setTimeout(respond, delayConnectionInMs);
+      }
+      common.setImmediate(() => {
+        if (!common.isRequestDestroyed(req)) {
+          start();
+        }
+      });
+    }
+    module.exports = { playbackInterceptor };
+  }
+});
+
+// ../../node_modules/nock/lib/intercepted_request_router.js
+var require_intercepted_request_router = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/lib/intercepted_request_router.js"(exports, module) {
+    "use strict";
+    var debug = require_browser()("nock.request_overrider");
+    var {
+      IncomingMessage,
+      ClientRequest,
+      request: originalHttpRequest
+    } = _chunkV46WVGWNjs.__require.call(void 0, "http");
+    var { request: originalHttpsRequest } = _chunkV46WVGWNjs.__require.call(void 0, "https");
+    var propagate = require_propagate();
+    var common = require_common2();
+    var globalEmitter = require_global_emitter();
+    var Socket = require_socket();
+    var { playbackInterceptor } = require_playback_interceptor();
+    function socketOnClose(req) {
+      debug("socket close");
+      if (!req.res && !req.socket._hadError) {
+        req.socket._hadError = true;
+        const err = new Error("socket hang up");
+        err.code = "ECONNRESET";
+        req.emit("error", err);
+      }
+      req.emit("close");
+    }
+    var InterceptedRequestRouter = class {
+      constructor({ req, options, interceptors }) {
+        this.req = req;
+        this.options = {
+          // We may be changing the options object and we don't want those changes
+          // affecting the user so we use a clone of the object.
+          ...options,
+          // We use lower-case header field names throughout Nock.
+          headers: common.headersFieldNamesToLowerCase(
+            options.headers || {},
+            false
+          )
+        };
+        this.interceptors = interceptors;
+        this.socket = new Socket(options);
+        const timeout = options.timeout || options.agent && options.agent.options && options.agent.options.timeout;
+        if (timeout) {
+          this.socket.setTimeout(timeout);
+        }
+        this.response = new IncomingMessage(this.socket);
+        this.requestBodyBuffers = [];
+        this.playbackStarted = false;
+        this.readyToStartPlaybackOnSocketEvent = false;
+        this.attachToReq();
+        process.nextTick(() => this.connectSocket());
+      }
+      attachToReq() {
+        const { req, options } = this;
+        for (const [name, val] of Object.entries(options.headers)) {
+          req.setHeader(name.toLowerCase(), val);
+        }
+        if (options.auth && !options.headers.authorization) {
+          req.setHeader(
+            // We use lower-case header field names throughout Nock.
+            "authorization",
+            `Basic ${Buffer.from(options.auth).toString("base64")}`
+          );
+        }
+        req.path = options.path;
+        req.method = options.method;
+        req.write = (...args) => this.handleWrite(...args);
+        req.end = (...args) => this.handleEnd(...args);
+        req.flushHeaders = (...args) => this.handleFlushHeaders(...args);
+        if (options.headers.expect === "100-continue") {
+          common.setImmediate(() => {
+            debug("continue");
+            req.emit("continue");
+          });
+        }
+      }
+      connectSocket() {
+        const { req, socket } = this;
+        if (common.isRequestDestroyed(req)) {
+          return;
+        }
+        req.socket = req.connection = socket;
+        propagate(["error", "timeout"], socket, req);
+        socket.on("close", () => socketOnClose(req));
+        socket.connecting = false;
+        req.emit("socket", socket);
+        socket.emit("connect");
+        if (socket.authorized) {
+          socket.emit("secureConnect");
+        }
+        if (this.readyToStartPlaybackOnSocketEvent) {
+          this.maybeStartPlayback();
+        }
+      }
+      // from docs: When write function is called with empty string or buffer, it does nothing and waits for more input.
+      // However, actually implementation checks the state of finished and aborted before checking if the first arg is empty.
+      handleWrite(...args) {
+        debug("request write");
+        let [buffer, encoding] = args;
+        const { req } = this;
+        if (req.finished) {
+          const err = new Error("write after end");
+          err.code = "ERR_STREAM_WRITE_AFTER_END";
+          process.nextTick(() => req.emit("error", err));
+          return true;
+        }
+        if (req.socket && req.socket.destroyed) {
+          return false;
+        }
+        if (!buffer) {
+          return true;
+        }
+        if (!Buffer.isBuffer(buffer)) {
+          buffer = Buffer.from(buffer, encoding);
+        }
+        this.requestBodyBuffers.push(buffer);
+        const callback = args.length > 1 ? args[args.length - 1] : void 0;
+        if (typeof callback === "function") {
+          callback();
+        }
+        common.setImmediate(function() {
+          req.emit("drain");
+        });
+        return false;
+      }
+      handleEnd(chunk, encoding, callback) {
+        debug("request end");
+        const { req } = this;
+        if (typeof chunk === "function") {
+          callback = chunk;
+          chunk = null;
+        } else if (typeof encoding === "function") {
+          callback = encoding;
+          encoding = null;
+        }
+        if (typeof callback === "function") {
+          req.once("finish", callback);
+        }
+        if (chunk) {
+          req.write(chunk, encoding);
+        }
+        req.finished = true;
+        this.maybeStartPlayback();
+        return req;
+      }
+      handleFlushHeaders() {
+        debug("request flushHeaders");
+        this.maybeStartPlayback();
+      }
+      /**
+       * Set request headers of the given request. This is needed both during the
+       * routing phase, in case header filters were specified, and during the
+       * interceptor-playback phase, to correctly pass mocked request headers.
+       * TODO There are some problems with this; see https://github.com/nock/nock/issues/1718
+       */
+      setHostHeaderUsingInterceptor(interceptor) {
+        const { req, options } = this;
+        const HOST_HEADER = "host";
+        if (interceptor.__nock_filteredScope && interceptor.__nock_scopeHost) {
+          options.headers[HOST_HEADER] = interceptor.__nock_scopeHost;
+          req.setHeader(HOST_HEADER, interceptor.__nock_scopeHost);
+        } else {
+          if (options.host && !req.getHeader(HOST_HEADER)) {
+            let hostHeader = options.host;
+            if (options.port === 80 || options.port === 443) {
+              hostHeader = hostHeader.split(":")[0];
+            }
+            req.setHeader(HOST_HEADER, hostHeader);
+          }
+        }
+      }
+      maybeStartPlayback() {
+        const { req, socket, playbackStarted } = this;
+        if (socket.connecting) {
+          this.readyToStartPlaybackOnSocketEvent = true;
+          return;
+        }
+        if (!common.isRequestDestroyed(req) && !playbackStarted) {
+          this.startPlayback();
+        }
+      }
+      startPlayback() {
+        debug("ending");
+        this.playbackStarted = true;
+        const { req, response, socket, options, interceptors } = this;
+        Object.assign(options, {
+          // Re-update `options` with the current value of `req.path` because badly
+          // behaving agents like superagent like to change `req.path` mid-flight.
+          path: req.path,
+          // Similarly, node-http-proxy will modify headers in flight, so we have
+          // to put the headers back into options.
+          // https://github.com/nock/nock/pull/1484
+          headers: req.getHeaders(),
+          // Fixes https://github.com/nock/nock/issues/976
+          protocol: `${options.proto}:`
+        });
+        interceptors.forEach((interceptor) => {
+          this.setHostHeaderUsingInterceptor(interceptor);
+        });
+        const requestBodyBuffer = Buffer.concat(this.requestBodyBuffers);
+        const requestBodyIsUtf8Representable = common.isUtf8Representable(requestBodyBuffer);
+        const requestBodyString = requestBodyBuffer.toString(
+          requestBodyIsUtf8Representable ? "utf8" : "hex"
+        );
+        const matchedInterceptor = interceptors.find(
+          (i) => i.match(req, options, requestBodyString)
+        );
+        if (matchedInterceptor) {
+          matchedInterceptor.scope.logger(
+            "interceptor identified, starting mocking"
+          );
+          matchedInterceptor.markConsumed();
+          req.emit("finish");
+          playbackInterceptor({
+            req,
+            socket,
+            options,
+            requestBodyString,
+            requestBodyIsUtf8Representable,
+            response,
+            interceptor: matchedInterceptor
+          });
+        } else {
+          globalEmitter.emit("no match", req, options, requestBodyString);
+          const allowUnmocked = interceptors.some(
+            (i) => i.matchHostName(options) && i.options.allowUnmocked
+          );
+          if (allowUnmocked && req instanceof ClientRequest) {
+            const newReq = options.proto === "https" ? originalHttpsRequest(options) : originalHttpRequest(options);
+            propagate(newReq, req);
+            newReq.end(requestBodyBuffer);
+          } else {
+            const reqStr = common.stringifyRequest(options, requestBodyString);
+            const err = new Error(`Nock: No match for request ${reqStr}`);
+            err.code = "ERR_NOCK_NO_MATCH";
+            err.statusCode = err.status = 404;
+            req.destroy(err);
+          }
+        }
+      }
+    };
+    module.exports = { InterceptedRequestRouter };
+  }
+});
+
+// ../../node_modules/json-stringify-safe/stringify.js
+var require_stringify = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/json-stringify-safe/stringify.js"(exports, module) {
+    "use strict";
+    exports = module.exports = stringify;
+    exports.getSerialize = serializer;
+    function stringify(obj, replacer, spaces, cycleReplacer) {
+      return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
+    }
+    function serializer(replacer, cycleReplacer) {
+      var stack = [], keys = [];
+      if (cycleReplacer == null)
+        cycleReplacer = function(key, value) {
+          if (stack[0] === value)
+            return "[Circular ~]";
+          return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
+        };
+      return function(key, value) {
+        if (stack.length > 0) {
+          var thisPos = stack.indexOf(this);
+          ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+          ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+          if (~stack.indexOf(value))
+            value = cycleReplacer.call(this, key, value);
+        } else
+          stack.push(value);
+        return replacer == null ? value : replacer.call(this, key, value);
+      };
+    }
+  }
+});
+
+// ../../node_modules/nock/lib/match_body.js
+var require_match_body = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/lib/match_body.js"(exports, module) {
+    "use strict";
+    var querystring = _chunkV46WVGWNjs.__require.call(void 0, "querystring");
+    var common = require_common2();
+    module.exports = function matchBody(options, spec, body) {
+      if (spec instanceof RegExp) {
+        return spec.test(body);
+      }
+      if (Buffer.isBuffer(spec)) {
+        const encoding = common.isUtf8Representable(spec) ? "utf8" : "hex";
+        spec = spec.toString(encoding);
+      }
+      const contentType = (options.headers && (options.headers["Content-Type"] || options.headers["content-type"]) || "").toString();
+      const isMultipart = contentType.includes("multipart");
+      const isUrlencoded = contentType.includes("application/x-www-form-urlencoded");
+      let json;
+      if (typeof spec === "object" || typeof spec === "function") {
+        try {
+          json = JSON.parse(body);
+        } catch (err) {
+        }
+        if (json !== void 0) {
+          body = json;
+        } else if (isUrlencoded) {
+          body = querystring.parse(body);
+        }
+      }
+      if (typeof spec === "function") {
+        return spec.call(options, body);
+      }
+      if (!isMultipart && typeof body === "string") {
+        body = body.replace(/\r?\n|\r/g, "");
+      }
+      if (!isMultipart && typeof spec === "string") {
+        spec = spec.replace(/\r?\n|\r/g, "");
+      }
+      if (isUrlencoded) {
+        spec = mapValuesDeep(spec, (val) => val instanceof RegExp ? val : `${val}`);
+      }
+      return common.dataEqual(spec, body);
+    };
+    function mapValues(object, cb) {
+      const keys = Object.keys(object);
+      for (const key of keys) {
+        object[key] = cb(object[key], key, object);
+      }
+      return object;
+    }
+    function mapValuesDeep(obj, cb) {
+      if (Array.isArray(obj)) {
+        return obj.map((v) => mapValuesDeep(v, cb));
+      }
+      if (common.isPlainObject(obj)) {
+        return mapValues(obj, (v) => mapValuesDeep(v, cb));
+      }
+      return cb(obj);
+    }
+  }
+});
+
+// ../../node_modules/nock/lib/interceptor.js
+var require_interceptor = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/lib/interceptor.js"(exports, module) {
+    "use strict";
+    var stringify = require_stringify();
+    var querystring = _chunkV46WVGWNjs.__require.call(void 0, "querystring");
+    var { URL, URLSearchParams } = _chunkV46WVGWNjs.__require.call(void 0, "url");
+    var common = require_common2();
+    var { remove } = require_intercept();
+    var matchBody = require_match_body();
+    var fs;
+    try {
+      fs = _chunkV46WVGWNjs.__require.call(void 0, "fs");
+    } catch (err) {
+    }
+    module.exports = class Interceptor {
+      /**
+       *
+       * Valid argument types for `uri`:
+       *  - A string used for strict comparisons with pathname.
+       *    The search portion of the URI may also be postfixed, in which case the search params
+       *    are striped and added via the `query` method.
+       *  - A RegExp instance that tests against only the pathname of requests.
+       *  - A synchronous function bound to this Interceptor instance. It's provided the pathname
+       *    of requests and must return a boolean denoting if the request is considered a match.
+       */
+      constructor(scope, uri, method, requestBody, interceptorOptions) {
+        const uriIsStr = typeof uri === "string";
+        if (uriIsStr && !scope.scopeOptions.filteringScope && !scope.basePathname && !uri.startsWith("/") && !uri.startsWith("*")) {
+          throw Error(
+            `Non-wildcard URL path strings must begin with a slash (otherwise they won't match anything) (got: ${uri})`
+          );
+        }
+        if (!method) {
+          throw new Error(
+            'The "method" parameter is required for an intercept call.'
+          );
+        }
+        this.scope = scope;
+        this.interceptorMatchHeaders = [];
+        this.method = method.toUpperCase();
+        this.uri = uri;
+        this._key = `${this.method} ${scope.basePath}${scope.basePathname}${uriIsStr ? "" : "/"}${uri}`;
+        this.basePath = this.scope.basePath;
+        this.path = uriIsStr ? scope.basePathname + uri : uri;
+        this.queries = null;
+        this.options = interceptorOptions || {};
+        this.counter = 1;
+        this._requestBody = requestBody;
+        this.reqheaders = common.headersFieldNamesToLowerCase(
+          scope.scopeOptions.reqheaders || {},
+          true
+        );
+        this.badheaders = common.headersFieldsArrayToLowerCase(
+          scope.scopeOptions.badheaders || []
+        );
+        this.delayBodyInMs = 0;
+        this.delayConnectionInMs = 0;
+        this.optional = false;
+        if (uriIsStr && uri.includes("?")) {
+          const parsedURL = new URL(this.path, "http://localhost");
+          this.path = parsedURL.pathname;
+          this.query(parsedURL.searchParams);
+          this._key = `${this.method} ${scope.basePath}${this.path}`;
+        }
+      }
+      optionally(flag = true) {
+        if (typeof flag !== "boolean") {
+          throw new Error("Invalid arguments: argument should be a boolean");
+        }
+        this.optional = flag;
+        return this;
+      }
+      replyWithError(errorMessage) {
+        this.errorMessage = errorMessage;
+        this.options = {
+          ...this.scope.scopeOptions,
+          ...this.options
+        };
+        this.scope.add(this._key, this);
+        return this.scope;
+      }
+      reply(statusCode, body, rawHeaders) {
+        if (typeof statusCode === "function") {
+          if (arguments.length > 1) {
+            throw Error(
+              "Invalid arguments. When providing a function for the first argument, .reply does not accept other arguments."
+            );
+          }
+          this.statusCode = null;
+          this.fullReplyFunction = statusCode;
+        } else {
+          if (statusCode !== void 0 && !Number.isInteger(statusCode)) {
+            throw new Error(`Invalid ${typeof statusCode} value for status code`);
+          }
+          this.statusCode = statusCode || 200;
+          if (typeof body === "function") {
+            this.replyFunction = body;
+            body = null;
+          }
+        }
+        this.options = {
+          ...this.scope.scopeOptions,
+          ...this.options
+        };
+        this.rawHeaders = common.headersInputToRawArray(rawHeaders);
+        if (this.scope.date) {
+          this.rawHeaders.push("Date", this.scope.date.toUTCString());
+        }
+        this.headers = common.headersArrayToObject(
+          this.rawHeaders.concat(this.scope._defaultReplyHeaders)
+        );
+        if (body && typeof body !== "string" && !Buffer.isBuffer(body) && !common.isStream(body) && !common.isContentEncoded(this.headers)) {
+          try {
+            body = stringify(body);
+          } catch (err) {
+            throw new Error("Error encoding response body into JSON");
+          }
+          if (!this.headers["content-type"]) {
+            this.rawHeaders.push("Content-Type", "application/json");
+          }
+        }
+        if (this.scope.contentLen) {
+          if (typeof body === "string") {
+            this.rawHeaders.push("Content-Length", body.length);
+          } else if (Buffer.isBuffer(body)) {
+            this.rawHeaders.push("Content-Length", body.byteLength);
+          }
+        }
+        this.scope.logger("reply.headers:", this.headers);
+        this.scope.logger("reply.rawHeaders:", this.rawHeaders);
+        this.body = body;
+        this.scope.add(this._key, this);
+        return this.scope;
+      }
+      replyWithFile(statusCode, filePath, headers) {
+        if (!fs) {
+          throw new Error("No fs");
+        }
+        this.filePath = filePath;
+        return this.reply(
+          statusCode,
+          () => {
+            const readStream = fs.createReadStream(filePath);
+            readStream.pause();
+            return readStream;
+          },
+          headers
+        );
+      }
+      // Also match request headers
+      // https://github.com/nock/nock/issues/163
+      reqheaderMatches(options, key) {
+        const reqHeader = this.reqheaders[key];
+        let header = options.headers[key];
+        if (header && typeof header !== "string" && header.toString) {
+          header = header.toString();
+        }
+        if (key === "host" && (header === void 0 || reqHeader === void 0)) {
+          return true;
+        }
+        if (reqHeader !== void 0 && header !== void 0) {
+          if (typeof reqHeader === "function") {
+            return reqHeader(header);
+          } else if (common.matchStringOrRegexp(header, reqHeader)) {
+            return true;
+          }
+        }
+        this.scope.logger(
+          "request header field doesn't match:",
+          key,
+          header,
+          reqHeader
+        );
+        return false;
+      }
+      match(req, options, body) {
+        if (this.scope.logger.enabled) {
+          this.scope.logger(
+            "attempting match %s, body = %s",
+            stringify(options),
+            stringify(body)
+          );
+        }
+        const method = (options.method || "GET").toUpperCase();
+        let { path = "/" } = options;
+        let matches;
+        let matchKey;
+        const { proto } = options;
+        if (this.method !== method) {
+          this.scope.logger(
+            `Method did not match. Request ${method} Interceptor ${this.method}`
+          );
+          return false;
+        }
+        if (this.scope.transformPathFunction) {
+          path = this.scope.transformPathFunction(path);
+        }
+        const requestMatchesFilter = ({ name, value: predicate }) => {
+          const headerValue = req.getHeader(name);
+          if (typeof predicate === "function") {
+            return predicate(headerValue);
+          } else {
+            return common.matchStringOrRegexp(headerValue, predicate);
+          }
+        };
+        if (!this.scope.matchHeaders.every(requestMatchesFilter) || !this.interceptorMatchHeaders.every(requestMatchesFilter)) {
+          this.scope.logger("headers don't match");
+          return false;
+        }
+        const reqHeadersMatch = Object.keys(this.reqheaders).every(
+          (key) => this.reqheaderMatches(options, key)
+        );
+        if (!reqHeadersMatch) {
+          this.scope.logger("headers don't match");
+          return false;
+        }
+        if (this.scope.scopeOptions.conditionally && !this.scope.scopeOptions.conditionally()) {
+          this.scope.logger(
+            "matching failed because Scope.conditionally() did not validate"
+          );
+          return false;
+        }
+        const badHeaders = this.badheaders.filter(
+          (header) => header in options.headers
+        );
+        if (badHeaders.length) {
+          this.scope.logger("request contains bad headers", ...badHeaders);
+          return false;
+        }
+        if (this.queries === null) {
+          this.scope.logger("query matching skipped");
+        } else {
+          const [pathname, search] = path.split("?");
+          const matchQueries = this.matchQuery({ search });
+          this.scope.logger(
+            matchQueries ? "query matching succeeded" : "query matching failed"
+          );
+          if (!matchQueries) {
+            return false;
+          }
+          path = pathname;
+        }
+        if (this.__nock_filteredScope) {
+          matchKey = this.__nock_filteredScope;
+        } else {
+          matchKey = common.normalizeOrigin(proto, options.host, options.port);
+        }
+        if (typeof this.uri === "function") {
+          matches = common.matchStringOrRegexp(matchKey, this.basePath) && // This is a false positive, as `uri` is not bound to `this`.
+          // eslint-disable-next-line no-useless-call
+          this.uri.call(this, path);
+        } else {
+          matches = common.matchStringOrRegexp(matchKey, this.basePath) && common.matchStringOrRegexp(path, this.path);
+        }
+        this.scope.logger(`matching ${matchKey}${path} to ${this._key}: ${matches}`);
+        if (matches && this._requestBody !== void 0) {
+          if (this.scope.transformRequestBodyFunction) {
+            body = this.scope.transformRequestBodyFunction(body, this._requestBody);
+          }
+          matches = matchBody(options, this._requestBody, body);
+          if (!matches) {
+            this.scope.logger(
+              "bodies don't match: \n",
+              this._requestBody,
+              "\n",
+              body
+            );
+          }
+        }
+        return matches;
+      }
+      /**
+       * Return true when the interceptor's method, protocol, host, port, and path
+       * match the provided options.
+       */
+      matchOrigin(options) {
+        const isPathFn = typeof this.path === "function";
+        const isRegex = this.path instanceof RegExp;
+        const isRegexBasePath = this.scope.basePath instanceof RegExp;
+        const method = (options.method || "GET").toUpperCase();
+        let { path } = options;
+        const { proto } = options;
+        if (!isRegex) {
+          path = path ? path.split("?")[0] : "";
+        }
+        if (this.scope.transformPathFunction) {
+          path = this.scope.transformPathFunction(path);
+        }
+        const comparisonKey = isPathFn || isRegex ? this.__nock_scopeKey : this._key;
+        const matchKey = `${method} ${proto}://${options.host}${path}`;
+        if (isPathFn) {
+          return !!(matchKey.match(comparisonKey) && this.path(path));
+        }
+        if (isRegex && !isRegexBasePath) {
+          return !!matchKey.match(comparisonKey) && this.path.test(path);
+        }
+        if (isRegexBasePath) {
+          return this.scope.basePath.test(matchKey) && !!path.match(this.path);
+        }
+        return comparisonKey === matchKey;
+      }
+      matchHostName(options) {
+        const { basePath } = this.scope;
+        if (basePath instanceof RegExp) {
+          return basePath.test(options.hostname);
+        }
+        return options.hostname === this.scope.urlParts.hostname;
+      }
+      matchQuery(options) {
+        if (this.queries === true) {
+          return true;
+        }
+        const reqQueries = querystring.parse(options.search);
+        this.scope.logger("Interceptor queries: %j", this.queries);
+        this.scope.logger("    Request queries: %j", reqQueries);
+        if (typeof this.queries === "function") {
+          return this.queries(reqQueries);
+        }
+        return common.dataEqual(this.queries, reqQueries);
+      }
+      filteringPath(...args) {
+        this.scope.filteringPath(...args);
+        return this;
+      }
+      // TODO filtering by path is valid on the intercept level, but not filtering
+      // by request body?
+      markConsumed() {
+        this.interceptionCounter++;
+        remove(this);
+        if (!this.scope.shouldPersist() && this.counter < 1) {
+          this.scope.remove(this._key, this);
+        }
+      }
+      matchHeader(name, value) {
+        this.interceptorMatchHeaders.push({ name, value });
+        return this;
+      }
+      basicAuth({ user, pass = "" }) {
+        const encoded = Buffer.from(`${user}:${pass}`).toString("base64");
+        this.matchHeader("authorization", `Basic ${encoded}`);
+        return this;
+      }
+      /**
+       * Set query strings for the interceptor
+       * @name query
+       * @param queries Object of query string name,values (accepts regexp values)
+       * @public
+       * @example
+       * // Will match 'http://zombo.com/?q=t'
+       * nock('http://zombo.com').get('/').query({q: 't'});
+       */
+      query(queries) {
+        if (this.queries !== null) {
+          throw Error(`Query parameters have already been defined`);
+        }
+        if (queries === true) {
+          this.queries = queries;
+          return this;
+        }
+        if (typeof queries === "function") {
+          this.queries = queries;
+          return this;
+        }
+        let strFormattingFn;
+        if (this.scope.scopeOptions.encodedQueryParams) {
+          strFormattingFn = common.percentDecode;
+        }
+        if (queries instanceof URLSearchParams || typeof queries === "string") {
+          queries = querystring.parse(queries.toString());
+        } else if (!common.isPlainObject(queries)) {
+          throw Error(`Argument Error: ${queries}`);
+        }
+        this.queries = {};
+        for (const [key, value] of Object.entries(queries)) {
+          const formatted = common.formatQueryValue(key, value, strFormattingFn);
+          const [formattedKey, formattedValue] = formatted;
+          this.queries[formattedKey] = formattedValue;
+        }
+        return this;
+      }
+      /**
+       * Set number of times will repeat the interceptor
+       * @name times
+       * @param newCounter Number of times to repeat (should be > 0)
+       * @public
+       * @example
+       * // Will repeat mock 5 times for same king of request
+       * nock('http://zombo.com).get('/').times(5).reply(200, 'Ok');
+       */
+      times(newCounter) {
+        if (newCounter < 1) {
+          return this;
+        }
+        this.counter = newCounter;
+        return this;
+      }
+      /**
+       * An sugar syntax for times(1)
+       * @name once
+       * @see {@link times}
+       * @public
+       * @example
+       * nock('http://zombo.com).get('/').once().reply(200, 'Ok');
+       */
+      once() {
+        return this.times(1);
+      }
+      /**
+       * An sugar syntax for times(2)
+       * @name twice
+       * @see {@link times}
+       * @public
+       * @example
+       * nock('http://zombo.com).get('/').twice().reply(200, 'Ok');
+       */
+      twice() {
+        return this.times(2);
+      }
+      /**
+       * An sugar syntax for times(3).
+       * @name thrice
+       * @see {@link times}
+       * @public
+       * @example
+       * nock('http://zombo.com).get('/').thrice().reply(200, 'Ok');
+       */
+      thrice() {
+        return this.times(3);
+      }
+      /**
+       * Delay the response by a certain number of ms.
+       *
+       * @param {(integer|object)} opts - Number of milliseconds to wait, or an object
+       * @param {integer} [opts.head] - Number of milliseconds to wait before response is sent
+       * @param {integer} [opts.body] - Number of milliseconds to wait before response body is sent
+       * @return {Interceptor} - the current interceptor for chaining
+       */
+      delay(opts) {
+        let headDelay;
+        let bodyDelay;
+        if (typeof opts === "number") {
+          headDelay = opts;
+          bodyDelay = 0;
+        } else if (typeof opts === "object") {
+          headDelay = opts.head || 0;
+          bodyDelay = opts.body || 0;
+        } else {
+          throw new Error(`Unexpected input opts ${opts}`);
+        }
+        return this.delayConnection(headDelay).delayBody(bodyDelay);
+      }
+      /**
+       * Delay the response body by a certain number of ms.
+       *
+       * @param {integer} ms - Number of milliseconds to wait before response is sent
+       * @return {Interceptor} - the current interceptor for chaining
+       */
+      delayBody(ms) {
+        this.delayBodyInMs = ms;
+        return this;
+      }
+      /**
+       * Delay the connection by a certain number of ms.
+       *
+       * @param  {integer} ms - Number of milliseconds to wait
+       * @return {Interceptor} - the current interceptor for chaining
+       */
+      delayConnection(ms) {
+        this.delayConnectionInMs = ms;
+        return this;
+      }
+    };
+  }
+});
+
+// ../../node_modules/nock/lib/intercept.js
+var require_intercept = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/lib/intercept.js"(exports, module) {
+    "use strict";
+    var { InterceptedRequestRouter } = require_intercepted_request_router();
+    var common = require_common2();
+    var { inherits } = _chunkV46WVGWNjs.__require.call(void 0, "util");
+    var http = _chunkV46WVGWNjs.__require.call(void 0, "http");
+    var debug = require_browser()("nock.intercept");
+    var globalEmitter = require_global_emitter();
+    function NetConnectNotAllowedError(host, path) {
+      Error.call(this);
+      this.name = "NetConnectNotAllowedError";
+      this.code = "ENETUNREACH";
+      this.message = `Nock: Disallowed net connect for "${host}${path}"`;
+      Error.captureStackTrace(this, this.constructor);
+    }
+    inherits(NetConnectNotAllowedError, Error);
+    var allInterceptors = {};
+    var allowNetConnect;
+    function enableNetConnect(matcher) {
+      if (typeof matcher === "string") {
+        allowNetConnect = new RegExp(matcher);
+      } else if (matcher instanceof RegExp) {
+        allowNetConnect = matcher;
+      } else if (typeof matcher === "function") {
+        allowNetConnect = { test: matcher };
+      } else {
+        allowNetConnect = /.*/;
+      }
+    }
+    function isEnabledForNetConnect(options) {
+      common.normalizeRequestOptions(options);
+      const enabled = allowNetConnect && allowNetConnect.test(options.host);
+      debug("Net connect", enabled ? "" : "not", "enabled for", options.host);
+      return enabled;
+    }
+    function disableNetConnect() {
+      allowNetConnect = void 0;
+    }
+    function isOn() {
+      return !isOff();
+    }
+    function isOff() {
+      return process.env.NOCK_OFF === "true";
+    }
+    function addInterceptor(key, interceptor, scope, scopeOptions, host) {
+      if (!(key in allInterceptors)) {
+        allInterceptors[key] = { key, interceptors: [] };
+      }
+      interceptor.__nock_scope = scope;
+      interceptor.__nock_scopeKey = key;
+      interceptor.__nock_scopeOptions = scopeOptions;
+      interceptor.__nock_scopeHost = host;
+      interceptor.interceptionCounter = 0;
+      if (scopeOptions.allowUnmocked)
+        allInterceptors[key].allowUnmocked = true;
+      allInterceptors[key].interceptors.push(interceptor);
+    }
+    function remove(interceptor) {
+      if (interceptor.__nock_scope.shouldPersist() || --interceptor.counter > 0) {
+        return;
+      }
+      const { basePath } = interceptor;
+      const interceptors = allInterceptors[basePath] && allInterceptors[basePath].interceptors || [];
+      interceptors.some(function(thisInterceptor, i) {
+        return thisInterceptor === interceptor ? interceptors.splice(i, 1) : false;
+      });
+    }
+    function removeAll() {
+      Object.keys(allInterceptors).forEach(function(key) {
+        allInterceptors[key].interceptors.forEach(function(interceptor) {
+          interceptor.scope.keyedInterceptors = {};
+        });
+      });
+      allInterceptors = {};
+    }
+    function interceptorsFor(options) {
+      common.normalizeRequestOptions(options);
+      debug("interceptors for %j", options.host);
+      const basePath = `${options.proto}://${options.host}`;
+      debug("filtering interceptors for basepath", basePath);
+      for (const { key, interceptors, allowUnmocked } of Object.values(
+        allInterceptors
+      )) {
+        for (const interceptor of interceptors) {
+          const { filteringScope } = interceptor.__nock_scopeOptions;
+          if (filteringScope && filteringScope(basePath)) {
+            interceptor.scope.logger("found matching scope interceptor");
+            interceptors.forEach((ic) => {
+              ic.__nock_filteredScope = ic.__nock_scopeKey;
+            });
+            return interceptors;
+          }
+        }
+        if (common.matchStringOrRegexp(basePath, key)) {
+          if (allowUnmocked && interceptors.length === 0) {
+            debug("matched base path with allowUnmocked (no matching interceptors)");
+            return [
+              {
+                options: { allowUnmocked: true },
+                matchOrigin() {
+                  return false;
+                }
+              }
+            ];
+          } else {
+            debug(
+              `matched base path (${interceptors.length} interceptor${interceptors.length > 1 ? "s" : ""})`
+            );
+            return interceptors;
+          }
+        }
+      }
+      return void 0;
+    }
+    function removeInterceptor(options) {
+      const Interceptor = require_interceptor();
+      let baseUrl, key, method, proto;
+      if (options instanceof Interceptor) {
+        baseUrl = options.basePath;
+        key = options._key;
+      } else {
+        proto = options.proto ? options.proto : "http";
+        common.normalizeRequestOptions(options);
+        baseUrl = `${proto}://${options.host}`;
+        method = options.method && options.method.toUpperCase() || "GET";
+        key = `${method} ${baseUrl}${options.path || "/"}`;
+      }
+      if (allInterceptors[baseUrl] && allInterceptors[baseUrl].interceptors.length > 0) {
+        for (let i = 0; i < allInterceptors[baseUrl].interceptors.length; i++) {
+          const interceptor = allInterceptors[baseUrl].interceptors[i];
+          if (options instanceof Interceptor ? interceptor === options : interceptor._key === key) {
+            allInterceptors[baseUrl].interceptors.splice(i, 1);
+            interceptor.scope.remove(key, interceptor);
+            break;
+          }
+        }
+        return true;
+      }
+      return false;
+    }
+    var originalClientRequest;
+    function ErroringClientRequest(error) {
+      http.OutgoingMessage.call(this);
+      process.nextTick(
+        function() {
+          this.emit("error", error);
+        }.bind(this)
+      );
+    }
+    inherits(ErroringClientRequest, http.ClientRequest);
+    function overrideClientRequest() {
+      debug("Overriding ClientRequest");
+      function OverriddenClientRequest(...args) {
+        const { options, callback } = common.normalizeClientRequestArgs(...args);
+        if (Object.keys(options).length === 0) {
+          throw Error(
+            "Creating a ClientRequest with empty `options` is not supported in Nock"
+          );
+        }
+        http.OutgoingMessage.call(this);
+        const interceptors = interceptorsFor(options);
+        if (isOn() && interceptors) {
+          debug("using", interceptors.length, "interceptors");
+          const overrider = new InterceptedRequestRouter({
+            req: this,
+            options,
+            interceptors
+          });
+          Object.assign(this, overrider);
+          if (callback) {
+            this.once("response", callback);
+          }
+        } else {
+          debug("falling back to original ClientRequest");
+          if (isOff() || isEnabledForNetConnect(options)) {
+            originalClientRequest.apply(this, arguments);
+          } else {
+            common.setImmediate(
+              function() {
+                const error = new NetConnectNotAllowedError(
+                  options.host,
+                  options.path
+                );
+                this.emit("error", error);
+              }.bind(this)
+            );
+          }
+        }
+      }
+      inherits(OverriddenClientRequest, http.ClientRequest);
+      originalClientRequest = http.ClientRequest;
+      http.ClientRequest = OverriddenClientRequest;
+      debug("ClientRequest overridden");
+    }
+    function restoreOverriddenClientRequest() {
+      debug("restoring overridden ClientRequest");
+      if (!originalClientRequest) {
+        debug("- ClientRequest was not overridden");
+      } else {
+        http.ClientRequest = originalClientRequest;
+        originalClientRequest = void 0;
+        debug("- ClientRequest restored");
+      }
+    }
+    function isActive() {
+      return originalClientRequest !== void 0;
+    }
+    function interceptorScopes() {
+      const nestedInterceptors = Object.values(allInterceptors).map(
+        (i) => i.interceptors
+      );
+      const scopes = new Set([].concat(...nestedInterceptors).map((i) => i.scope));
+      return [...scopes];
+    }
+    function isDone() {
+      return interceptorScopes().every((scope) => scope.isDone());
+    }
+    function pendingMocks() {
+      return [].concat(...interceptorScopes().map((scope) => scope.pendingMocks()));
+    }
+    function activeMocks() {
+      return [].concat(...interceptorScopes().map((scope) => scope.activeMocks()));
+    }
+    function activate() {
+      if (originalClientRequest) {
+        throw new Error("Nock already active");
+      }
+      common.overrideRequests(function(proto, overriddenRequest, args) {
+        const { options, callback } = common.normalizeClientRequestArgs(...args);
+        if (Object.keys(options).length === 0) {
+          throw Error(
+            "Making a request with empty `options` is not supported in Nock"
+          );
+        }
+        options.proto = proto;
+        const interceptors = interceptorsFor(options);
+        if (isOn() && interceptors) {
+          const matches = interceptors.some(
+            (interceptor) => interceptor.matchOrigin(options)
+          );
+          const allowUnmocked = interceptors.some(
+            (interceptor) => interceptor.options.allowUnmocked
+          );
+          if (!matches && allowUnmocked) {
+            let req;
+            if (proto === "https") {
+              const { ClientRequest } = http;
+              http.ClientRequest = originalClientRequest;
+              req = overriddenRequest(options, callback);
+              http.ClientRequest = ClientRequest;
+            } else {
+              req = overriddenRequest(options, callback);
+            }
+            globalEmitter.emit("no match", req);
+            return req;
+          }
+          return new http.ClientRequest(options, callback);
+        } else {
+          globalEmitter.emit("no match", options);
+          if (isOff() || isEnabledForNetConnect(options)) {
+            return overriddenRequest(options, callback);
+          } else {
+            const error = new NetConnectNotAllowedError(options.host, options.path);
+            return new ErroringClientRequest(error);
+          }
+        }
+      });
+      overrideClientRequest();
+    }
+    module.exports = {
+      addInterceptor,
+      remove,
+      removeAll,
+      removeInterceptor,
+      isOn,
+      activate,
+      isActive,
+      isDone,
+      pendingMocks,
+      activeMocks,
+      enableNetConnect,
+      disableNetConnect,
+      restoreOverriddenClientRequest,
+      abortPendingRequests: common.removeAllTimers
+    };
+  }
+});
+
+// ../../node_modules/nock/lib/recorder.js
+var require_recorder = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/lib/recorder.js"(exports, module) {
+    "use strict";
+    var debug = require_browser()("nock.recorder");
+    var querystring = _chunkV46WVGWNjs.__require.call(void 0, "querystring");
+    var { inspect } = _chunkV46WVGWNjs.__require.call(void 0, "util");
+    var common = require_common2();
+    var { restoreOverriddenClientRequest } = require_intercept();
+    var SEPARATOR = "\n<<<<<<-- cut here -->>>>>>\n";
+    var recordingInProgress = false;
+    var outputs = [];
+    function getScope(options) {
+      const { proto, host, port } = common.normalizeRequestOptions(options);
+      return common.normalizeOrigin(proto, host, port);
+    }
+    function getMethod(options) {
+      return options.method || "GET";
+    }
+    function getBodyFromChunks(chunks, headers) {
+      if (headers && common.isContentEncoded(headers)) {
+        return {
+          body: chunks.map((chunk) => chunk.toString("hex"))
+        };
+      }
+      const mergedBuffer = Buffer.concat(chunks);
+      const isUtf8Representable = common.isUtf8Representable(mergedBuffer);
+      if (isUtf8Representable) {
+        const maybeStringifiedJson = mergedBuffer.toString("utf8");
+        try {
+          return {
+            isUtf8Representable,
+            body: JSON.parse(maybeStringifiedJson)
+          };
+        } catch (err) {
+          return {
+            isUtf8Representable,
+            body: maybeStringifiedJson
+          };
+        }
+      } else {
+        return {
+          isUtf8Representable,
+          body: mergedBuffer.toString("hex")
+        };
+      }
+    }
+    function generateRequestAndResponseObject({
+      req,
+      bodyChunks,
+      options,
+      res,
+      dataChunks,
+      reqheaders
+    }) {
+      const { body, isUtf8Representable } = getBodyFromChunks(
+        dataChunks,
+        res.headers
+      );
+      options.path = req.path;
+      return {
+        scope: getScope(options),
+        method: getMethod(options),
+        path: options.path,
+        // Is it deliberate that `getBodyFromChunks()` is called a second time?
+        body: getBodyFromChunks(bodyChunks).body,
+        status: res.statusCode,
+        response: body,
+        rawHeaders: res.rawHeaders,
+        reqheaders: reqheaders || void 0,
+        // When content-encoding is enabled, isUtf8Representable is `undefined`,
+        // so we explicitly check for `false`.
+        responseIsBinary: isUtf8Representable === false
+      };
+    }
+    function generateRequestAndResponse({
+      req,
+      bodyChunks,
+      options,
+      res,
+      dataChunks,
+      reqheaders
+    }) {
+      const requestBody = getBodyFromChunks(bodyChunks).body;
+      const responseBody = getBodyFromChunks(dataChunks, res.headers).body;
+      let { path } = options;
+      const queryIndex = req.path.indexOf("?");
+      let queryObj = {};
+      if (queryIndex !== -1) {
+        path = path.substring(0, queryIndex);
+        const queryStr = req.path.slice(queryIndex + 1);
+        queryObj = querystring.parse(queryStr);
+      }
+      path = path.replace(/'/g, `\\'`);
+      const encodedQueryObj = {};
+      for (const key in queryObj) {
+        const formattedPair = common.formatQueryValue(
+          key,
+          queryObj[key],
+          common.percentEncode
+        );
+        encodedQueryObj[formattedPair[0]] = formattedPair[1];
+      }
+      const lines = [];
+      lines.push("");
+      const scope = getScope(options);
+      lines.push(`nock('${scope}', {"encodedQueryParams":true})`);
+      const methodName = getMethod(options).toLowerCase();
+      if (requestBody) {
+        lines.push(`  .${methodName}('${path}', ${JSON.stringify(requestBody)})`);
+      } else {
+        lines.push(`  .${methodName}('${path}')`);
+      }
+      Object.entries(reqheaders || {}).forEach(([fieldName, fieldValue]) => {
+        const safeName = JSON.stringify(fieldName);
+        const safeValue = JSON.stringify(fieldValue);
+        lines.push(`  .matchHeader(${safeName}, ${safeValue})`);
+      });
+      if (queryIndex !== -1) {
+        lines.push(`  .query(${JSON.stringify(encodedQueryObj)})`);
+      }
+      const statusCode = res.statusCode.toString();
+      const stringifiedResponseBody = JSON.stringify(responseBody);
+      const headers = inspect(res.rawHeaders);
+      lines.push(`  .reply(${statusCode}, ${stringifiedResponseBody}, ${headers});`);
+      return lines.join("\n");
+    }
+    var currentRecordingId = 0;
+    var defaultRecordOptions = {
+      dont_print: false,
+      enable_reqheaders_recording: false,
+      logging: console.log,
+      // eslint-disable-line no-console
+      output_objects: false,
+      use_separator: true
+    };
+    function record(recOptions) {
+      if (recordingInProgress) {
+        throw new Error("Nock recording already in progress");
+      }
+      recordingInProgress = true;
+      currentRecordingId = currentRecordingId + 1;
+      const thisRecordingId = currentRecordingId;
+      if (typeof recOptions === "boolean") {
+        recOptions = { dont_print: recOptions };
+      }
+      recOptions = { ...defaultRecordOptions, ...recOptions };
+      debug("start recording", thisRecordingId, recOptions);
+      const {
+        dont_print: dontPrint,
+        enable_reqheaders_recording: enableReqHeadersRecording,
+        logging,
+        output_objects: outputObjects,
+        use_separator: useSeparator
+      } = recOptions;
+      debug(thisRecordingId, "restoring overridden requests before new overrides");
+      common.restoreOverriddenRequests();
+      restoreOverriddenClientRequest();
+      common.overrideRequests(function(proto, overriddenRequest, rawArgs) {
+        const { options, callback } = common.normalizeClientRequestArgs(...rawArgs);
+        const bodyChunks = [];
+        if (options._recording) {
+          return overriddenRequest(options, callback);
+        }
+        options._recording = true;
+        const req = overriddenRequest(options, function(res) {
+          debug(thisRecordingId, "intercepting", proto, "request to record");
+          res.once("end", function() {
+            debug(thisRecordingId, proto, "intercepted request ended");
+            let reqheaders;
+            if (enableReqHeadersRecording) {
+              reqheaders = req.getHeaders();
+              common.deleteHeadersField(reqheaders, "user-agent");
+            }
+            const generateFn = outputObjects ? generateRequestAndResponseObject : generateRequestAndResponse;
+            let out = generateFn({
+              req,
+              bodyChunks,
+              options,
+              res,
+              dataChunks,
+              reqheaders
+            });
+            debug("out:", out);
+            if (thisRecordingId !== currentRecordingId) {
+              debug("skipping recording of an out-of-order request", out);
+              return;
+            }
+            outputs.push(out);
+            if (!dontPrint) {
+              if (useSeparator) {
+                if (typeof out !== "string") {
+                  out = JSON.stringify(out, null, 2);
+                }
+                logging(SEPARATOR + out + SEPARATOR);
+              } else {
+                logging(out);
+              }
+            }
+          });
+          let encoding;
+          const { setEncoding } = res;
+          res.setEncoding = function(newEncoding) {
+            encoding = newEncoding;
+            return setEncoding.apply(this, arguments);
+          };
+          const dataChunks = [];
+          const origResPush = res.push;
+          res.push = function(data) {
+            if (data) {
+              if (encoding) {
+                data = Buffer.from(data, encoding);
+              }
+              dataChunks.push(data);
+            }
+            return origResPush.call(res, data);
+          };
+          if (callback) {
+            callback(res, options, callback);
+          }
+          debug("finished setting up intercepting");
+          if (proto === "https") {
+            options.proto = "https";
+          }
+        });
+        const recordChunk = (chunk, encoding) => {
+          debug(thisRecordingId, "new", proto, "body chunk");
+          if (!Buffer.isBuffer(chunk)) {
+            chunk = Buffer.from(chunk, encoding);
+          }
+          bodyChunks.push(chunk);
+        };
+        const oldWrite = req.write;
+        req.write = function(chunk, encoding) {
+          if (typeof chunk !== "undefined") {
+            recordChunk(chunk, encoding);
+            oldWrite.apply(req, arguments);
+          } else {
+            throw new Error("Data was undefined.");
+          }
+        };
+        const oldEnd = req.end;
+        req.end = function(chunk, encoding, callback2) {
+          debug("req.end");
+          if (typeof chunk === "function") {
+            callback2 = chunk;
+            chunk = null;
+          } else if (typeof encoding === "function") {
+            callback2 = encoding;
+            encoding = null;
+          }
+          if (chunk) {
+            recordChunk(chunk, encoding);
+          }
+          oldEnd.call(req, chunk, encoding, callback2);
+        };
+        return req;
+      });
+    }
+    function restore() {
+      debug(
+        currentRecordingId,
+        "restoring all the overridden http/https properties"
+      );
+      common.restoreOverriddenRequests();
+      restoreOverriddenClientRequest();
+      recordingInProgress = false;
+    }
+    function clear() {
+      outputs = [];
+    }
+    module.exports = {
+      record,
+      outputs: () => outputs,
+      restore,
+      clear
+    };
+  }
+});
+
+// ../../node_modules/nock/lib/scope.js
+var require_scope = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/lib/scope.js"(exports, module) {
+    "use strict";
+    var { addInterceptor, isOn } = require_intercept();
+    var common = require_common2();
+    var assert = _chunkV46WVGWNjs.__require.call(void 0, "assert");
+    var url = _chunkV46WVGWNjs.__require.call(void 0, "url");
+    var debug = require_browser()("nock.scope");
+    var { EventEmitter } = _chunkV46WVGWNjs.__require.call(void 0, "events");
+    var Interceptor = require_interceptor();
+    var { URL, Url: LegacyUrl } = url;
+    var fs;
+    try {
+      fs = _chunkV46WVGWNjs.__require.call(void 0, "fs");
+    } catch (err) {
+    }
+    function normalizeUrl(u) {
+      if (!(u instanceof URL)) {
+        if (u instanceof LegacyUrl) {
+          return normalizeUrl(new URL(url.format(u)));
+        }
+        return normalizeUrl(new URL(u));
+      }
+      if (!/https?:/.test(u.protocol)) {
+        throw new TypeError(
+          `Protocol '${u.protocol}' not recognized. This commonly occurs when a hostname and port are included without a protocol, producing a URL that is valid but confusing, and probably not what you want.`
+        );
+      }
+      return {
+        href: u.href,
+        origin: u.origin,
+        protocol: u.protocol,
+        username: u.username,
+        password: u.password,
+        host: u.host,
+        hostname: (
+          // strip brackets from IPv6
+          typeof u.hostname === "string" && u.hostname.startsWith("[") ? u.hostname.slice(1, -1) : u.hostname
+        ),
+        port: u.port || (u.protocol === "http:" ? 80 : 443),
+        pathname: u.pathname,
+        search: u.search,
+        searchParams: u.searchParams,
+        hash: u.hash
+      };
+    }
+    var Scope = class _Scope extends EventEmitter {
+      constructor(basePath, options) {
+        super();
+        this.keyedInterceptors = {};
+        this.interceptors = [];
+        this.transformPathFunction = null;
+        this.transformRequestBodyFunction = null;
+        this.matchHeaders = [];
+        this.scopeOptions = options || {};
+        this.urlParts = {};
+        this._persist = false;
+        this.contentLen = false;
+        this.date = null;
+        this.basePath = basePath;
+        this.basePathname = "";
+        this.port = null;
+        this._defaultReplyHeaders = [];
+        let logNamespace = String(basePath);
+        if (!(basePath instanceof RegExp)) {
+          this.urlParts = normalizeUrl(basePath);
+          this.port = this.urlParts.port;
+          this.basePathname = this.urlParts.pathname.replace(/\/$/, "");
+          this.basePath = `${this.urlParts.protocol}//${this.urlParts.hostname}:${this.port}`;
+          logNamespace = this.urlParts.host;
+        }
+        this.logger = debug.extend(logNamespace);
+      }
+      add(key, interceptor) {
+        if (!(key in this.keyedInterceptors)) {
+          this.keyedInterceptors[key] = [];
+        }
+        this.keyedInterceptors[key].push(interceptor);
+        addInterceptor(
+          this.basePath,
+          interceptor,
+          this,
+          this.scopeOptions,
+          this.urlParts.hostname
+        );
+      }
+      remove(key, interceptor) {
+        if (this._persist) {
+          return;
+        }
+        const arr = this.keyedInterceptors[key];
+        if (arr) {
+          arr.splice(arr.indexOf(interceptor), 1);
+          if (arr.length === 0) {
+            delete this.keyedInterceptors[key];
+          }
+        }
+      }
+      intercept(uri, method, requestBody, interceptorOptions) {
+        const ic = new Interceptor(
+          this,
+          uri,
+          method,
+          requestBody,
+          interceptorOptions
+        );
+        this.interceptors.push(ic);
+        return ic;
+      }
+      get(uri, requestBody, options) {
+        return this.intercept(uri, "GET", requestBody, options);
+      }
+      post(uri, requestBody, options) {
+        return this.intercept(uri, "POST", requestBody, options);
+      }
+      put(uri, requestBody, options) {
+        return this.intercept(uri, "PUT", requestBody, options);
+      }
+      head(uri, requestBody, options) {
+        return this.intercept(uri, "HEAD", requestBody, options);
+      }
+      patch(uri, requestBody, options) {
+        return this.intercept(uri, "PATCH", requestBody, options);
+      }
+      merge(uri, requestBody, options) {
+        return this.intercept(uri, "MERGE", requestBody, options);
+      }
+      delete(uri, requestBody, options) {
+        return this.intercept(uri, "DELETE", requestBody, options);
+      }
+      options(uri, requestBody, options) {
+        return this.intercept(uri, "OPTIONS", requestBody, options);
+      }
+      // Returns the list of keys for non-optional Interceptors that haven't been completed yet.
+      // TODO: This assumes that completed mocks are removed from the keyedInterceptors list
+      // (when persistence is off). We should change that (and this) in future.
+      pendingMocks() {
+        return this.activeMocks().filter(
+          (key) => this.keyedInterceptors[key].some(({ interceptionCounter, optional }) => {
+            const persistedAndUsed = this._persist && interceptionCounter > 0;
+            return !persistedAndUsed && !optional;
+          })
+        );
+      }
+      // Returns all keyedInterceptors that are active.
+      // This includes incomplete interceptors, persisted but complete interceptors, and
+      // optional interceptors, but not non-persisted and completed interceptors.
+      activeMocks() {
+        return Object.keys(this.keyedInterceptors);
+      }
+      isDone() {
+        if (!isOn()) {
+          return true;
+        }
+        return this.pendingMocks().length === 0;
+      }
+      done() {
+        assert.ok(
+          this.isDone(),
+          `Mocks not yet satisfied:
+${this.pendingMocks().join("\n")}`
+        );
+      }
+      buildFilter() {
+        const filteringArguments = arguments;
+        if (arguments[0] instanceof RegExp) {
+          return function(candidate) {
+            if (typeof candidate !== "string") {
+              throw Error(
+                `Nock internal assertion failed: typeof candidate is ${typeof candidate}. If you encounter this error, please report it as a bug.`
+              );
+            }
+            return candidate.replace(filteringArguments[0], filteringArguments[1]);
+          };
+        } else if (typeof arguments[0] === "function") {
+          return arguments[0];
+        }
+      }
+      filteringPath() {
+        this.transformPathFunction = this.buildFilter.apply(this, arguments);
+        if (!this.transformPathFunction) {
+          throw new Error(
+            "Invalid arguments: filtering path should be a function or a regular expression"
+          );
+        }
+        return this;
+      }
+      filteringRequestBody() {
+        this.transformRequestBodyFunction = this.buildFilter.apply(this, arguments);
+        if (!this.transformRequestBodyFunction) {
+          throw new Error(
+            "Invalid arguments: filtering request body should be a function or a regular expression"
+          );
+        }
+        return this;
+      }
+      matchHeader(name, value) {
+        this.matchHeaders.push({ name: name.toLowerCase(), value });
+        return this;
+      }
+      defaultReplyHeaders(headers) {
+        this._defaultReplyHeaders = common.headersInputToRawArray(headers);
+        return this;
+      }
+      persist(flag = true) {
+        if (typeof flag !== "boolean") {
+          throw new Error("Invalid arguments: argument should be a boolean");
+        }
+        this._persist = flag;
+        return this;
+      }
+      /**
+       * @private
+       * @returns {boolean}
+       */
+      shouldPersist() {
+        return this._persist;
+      }
+      replyContentLength() {
+        this.contentLen = true;
+        return this;
+      }
+      replyDate(d) {
+        this.date = d || /* @__PURE__ */ new Date();
+        return this;
+      }
+      clone() {
+        return new _Scope(this.basePath, this.scopeOptions);
+      }
+    };
+    function loadDefs(path) {
+      if (!fs) {
+        throw new Error("No fs");
+      }
+      const contents = fs.readFileSync(path);
+      return JSON.parse(contents);
+    }
+    function load(path) {
+      return define(loadDefs(path));
+    }
+    function getStatusFromDefinition(nockDef) {
+      if (nockDef.reply !== void 0) {
+        const parsedReply = parseInt(nockDef.reply, 10);
+        if (isNaN(parsedReply)) {
+          throw Error("`reply`, when present, must be a numeric string");
+        }
+        return parsedReply;
+      }
+      const DEFAULT_STATUS_OK = 200;
+      return nockDef.status || DEFAULT_STATUS_OK;
+    }
+    function getScopeFromDefinition(nockDef) {
+      if (nockDef.port !== void 0) {
+        const options = url.parse(nockDef.scope);
+        if (options.port === null) {
+          return `${nockDef.scope}:${nockDef.port}`;
+        } else {
+          if (parseInt(options.port) !== parseInt(nockDef.port)) {
+            throw new Error(
+              "Mismatched port numbers in scope and port properties of nock definition."
+            );
+          }
+        }
+      }
+      return nockDef.scope;
+    }
+    function tryJsonParse(string) {
+      try {
+        return JSON.parse(string);
+      } catch (err) {
+        return string;
+      }
+    }
+    function define(nockDefs) {
+      const scopes = [];
+      nockDefs.forEach(function(nockDef) {
+        const nscope = getScopeFromDefinition(nockDef);
+        const npath = nockDef.path;
+        if (!nockDef.method) {
+          throw Error("Method is required");
+        }
+        const method = nockDef.method.toLowerCase();
+        const status = getStatusFromDefinition(nockDef);
+        const rawHeaders = nockDef.rawHeaders || [];
+        const reqheaders = nockDef.reqheaders || {};
+        const badheaders = nockDef.badheaders || [];
+        const options = { ...nockDef.options };
+        options.reqheaders = reqheaders;
+        options.badheaders = badheaders;
+        let response;
+        if (!nockDef.response) {
+          response = "";
+        } else if (nockDef.responseIsBinary) {
+          response = Buffer.from(nockDef.response, "hex");
+        } else {
+          response = typeof nockDef.response === "string" ? tryJsonParse(nockDef.response) : nockDef.response;
+        }
+        const scope = new Scope(nscope, options);
+        Object.entries(reqheaders).forEach(([fieldName, value]) => {
+          scope.matchHeader(fieldName, value);
+        });
+        const acceptableFilters = ["filteringRequestBody", "filteringPath"];
+        acceptableFilters.forEach((filter) => {
+          if (nockDef[filter]) {
+            scope[filter](nockDef[filter]);
+          }
+        });
+        scope.intercept(npath, method, nockDef.body).reply(status, response, rawHeaders);
+        scopes.push(scope);
+      });
+      return scopes;
+    }
+    module.exports = {
+      Scope,
+      load,
+      loadDefs,
+      define
+    };
+  }
+});
+
+// ../../node_modules/nock/lib/back.js
+var require_back = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/lib/back.js"(exports, module) {
+    "use strict";
+    var assert = _chunkV46WVGWNjs.__require.call(void 0, "assert");
+    var recorder = require_recorder();
+    var {
+      activate,
+      disableNetConnect,
+      enableNetConnect,
+      removeAll: cleanAll
+    } = require_intercept();
+    var { loadDefs, define } = require_scope();
+    var { format } = _chunkV46WVGWNjs.__require.call(void 0, "util");
+    var path = _chunkV46WVGWNjs.__require.call(void 0, "path");
+    var debug = require_browser()("nock.back");
+    var _mode = null;
+    var fs;
+    try {
+      fs = _chunkV46WVGWNjs.__require.call(void 0, "fs");
+    } catch (err) {
+    }
+    function Back(fixtureName, options, nockedFn) {
+      if (!Back.fixtures) {
+        throw new Error(
+          "Back requires nock.back.fixtures to be set\nEx:\n	require(nock).back.fixtures = '/path/to/fixtures/'"
+        );
+      }
+      if (typeof fixtureName !== "string") {
+        throw new Error("Parameter fixtureName must be a string");
+      }
+      if (arguments.length === 1) {
+        options = {};
+      } else if (arguments.length === 2) {
+        if (typeof options === "function") {
+          nockedFn = options;
+          options = {};
+        }
+      }
+      _mode.setup();
+      const fixture = path.join(Back.fixtures, fixtureName);
+      const context = _mode.start(fixture, options);
+      const nockDone = function() {
+        _mode.finish(fixture, options, context);
+      };
+      debug("context:", context);
+      if (typeof nockedFn === "function") {
+        nockedFn.call(context, nockDone);
+      } else {
+        return Promise.resolve({ nockDone, context });
+      }
+    }
+    var wild = {
+      setup: function() {
+        cleanAll();
+        recorder.restore();
+        activate();
+        enableNetConnect();
+      },
+      start: function() {
+        return load();
+      },
+      finish: function() {
+      }
+    };
+    var dryrun = {
+      setup: function() {
+        recorder.restore();
+        cleanAll();
+        activate();
+        enableNetConnect();
+      },
+      start: function(fixture, options) {
+        const contexts = load(fixture, options);
+        enableNetConnect();
+        return contexts;
+      },
+      finish: function() {
+      }
+    };
+    var record = {
+      setup: function() {
+        recorder.restore();
+        recorder.clear();
+        cleanAll();
+        activate();
+        disableNetConnect();
+      },
+      start: function(fixture, options) {
+        if (!fs) {
+          throw new Error("no fs");
+        }
+        const context = load(fixture, options);
+        if (!context.isLoaded) {
+          recorder.record({
+            dont_print: true,
+            output_objects: true,
+            ...options.recorder
+          });
+          context.isRecording = true;
+        }
+        return context;
+      },
+      finish: function(fixture, options, context) {
+        if (context.isRecording) {
+          let outputs = recorder.outputs();
+          if (typeof options.afterRecord === "function") {
+            outputs = options.afterRecord(outputs);
+          }
+          outputs = typeof outputs === "string" ? outputs : JSON.stringify(outputs, null, 4);
+          debug("recorder outputs:", outputs);
+          fs.mkdirSync(path.dirname(fixture), { recursive: true });
+          fs.writeFileSync(fixture, outputs);
+        }
+      }
+    };
+    var update = {
+      setup: function() {
+        recorder.restore();
+        recorder.clear();
+        cleanAll();
+        activate();
+        disableNetConnect();
+      },
+      start: function(fixture, options) {
+        if (!fs) {
+          throw new Error("no fs");
+        }
+        const context = removeFixture(fixture);
+        recorder.record({
+          dont_print: true,
+          output_objects: true,
+          ...options.recorder
+        });
+        context.isRecording = true;
+        return context;
+      },
+      finish: function(fixture, options, context) {
+        let outputs = recorder.outputs();
+        if (typeof options.afterRecord === "function") {
+          outputs = options.afterRecord(outputs);
+        }
+        outputs = typeof outputs === "string" ? outputs : JSON.stringify(outputs, null, 4);
+        debug("recorder outputs:", outputs);
+        fs.mkdirSync(path.dirname(fixture), { recursive: true });
+        fs.writeFileSync(fixture, outputs);
+      }
+    };
+    var lockdown = {
+      setup: function() {
+        recorder.restore();
+        recorder.clear();
+        cleanAll();
+        activate();
+        disableNetConnect();
+      },
+      start: function(fixture, options) {
+        return load(fixture, options);
+      },
+      finish: function() {
+      }
+    };
+    function load(fixture, options) {
+      const context = {
+        scopes: [],
+        assertScopesFinished: function() {
+          assertScopes(this.scopes, fixture);
+        },
+        query: function() {
+          const nested = this.scopes.map(
+            (scope) => scope.interceptors.map((interceptor) => ({
+              method: interceptor.method,
+              uri: interceptor.uri,
+              basePath: interceptor.basePath,
+              path: interceptor.path,
+              queries: interceptor.queries,
+              counter: interceptor.counter,
+              body: interceptor.body,
+              statusCode: interceptor.statusCode,
+              optional: interceptor.optional
+            }))
+          );
+          return [].concat.apply([], nested);
+        }
+      };
+      if (fixture && fixtureExists(fixture)) {
+        let scopes = loadDefs(fixture);
+        applyHook(scopes, options.before);
+        scopes = define(scopes);
+        applyHook(scopes, options.after);
+        context.scopes = scopes;
+        context.isLoaded = true;
+      }
+      return context;
+    }
+    function removeFixture(fixture, options) {
+      const context = {
+        scopes: [],
+        assertScopesFinished: function() {
+        }
+      };
+      if (fixture && fixtureExists(fixture)) {
+        fs.rmSync ? fs.rmSync(fixture) : fs.unlinkSync(fixture);
+      }
+      context.isLoaded = false;
+      return context;
+    }
+    function applyHook(scopes, fn) {
+      if (!fn) {
+        return;
+      }
+      if (typeof fn !== "function") {
+        throw new Error("processing hooks must be a function");
+      }
+      scopes.forEach(fn);
+    }
+    function fixtureExists(fixture) {
+      if (!fs) {
+        throw new Error("no fs");
+      }
+      return fs.existsSync(fixture);
+    }
+    function assertScopes(scopes, fixture) {
+      const pending = scopes.filter((scope) => !scope.isDone()).map((scope) => scope.pendingMocks());
+      if (pending.length) {
+        assert.fail(
+          format(
+            "%j was not used, consider removing %s to rerecord fixture",
+            [].concat(...pending),
+            fixture
+          )
+        );
+      }
+    }
+    var Modes = {
+      wild,
+      // all requests go out to the internet, dont replay anything, doesnt record anything
+      dryrun,
+      // use recorded nocks, allow http calls, doesnt record anything, useful for writing new tests (default)
+      record,
+      // use recorded nocks, record new nocks
+      update,
+      // allow http calls, record all nocks, don't use recorded nocks
+      lockdown
+      // use recorded nocks, disables all http calls even when not nocked, doesnt record
+    };
+    Back.setMode = function(mode) {
+      if (!(mode in Modes)) {
+        throw new Error(`Unknown mode: ${mode}`);
+      }
+      Back.currentMode = mode;
+      debug("New nock back mode:", Back.currentMode);
+      _mode = Modes[mode];
+      _mode.setup();
+    };
+    Back.fixtures = null;
+    Back.currentMode = null;
+    module.exports = Back;
+  }
+});
+
+// ../../node_modules/nock/index.js
+var require_nock = _chunkV46WVGWNjs.__commonJS.call(void 0, {
+  "../../node_modules/nock/index.js"(exports, module) {
+    "use strict";
+    var back = require_back();
+    var emitter = require_global_emitter();
+    var {
+      activate,
+      isActive,
+      isDone,
+      isOn,
+      pendingMocks,
+      activeMocks,
+      removeInterceptor,
+      disableNetConnect,
+      enableNetConnect,
+      removeAll,
+      abortPendingRequests
+    } = require_intercept();
+    var recorder = require_recorder();
+    var { Scope, load, loadDefs, define } = require_scope();
+    module.exports = (basePath, options) => new Scope(basePath, options);
+    Object.assign(module.exports, {
+      activate,
+      isActive,
+      isDone,
+      pendingMocks,
+      activeMocks,
+      removeInterceptor,
+      disableNetConnect,
+      enableNetConnect,
+      cleanAll: removeAll,
+      abortPendingRequests,
+      load,
+      loadDefs,
+      define,
+      emitter,
+      recorder: {
+        rec: recorder.record,
+        clear: recorder.clear,
+        play: recorder.outputs
+      },
+      restore: recorder.restore,
+      back
+    });
+    if (isOn()) {
+      back.setMode(process.env.NOCK_BACK_MODE || "dryrun");
+    }
+  }
+});
+
+// src/NotificationServicesController/index.ts
+var NotificationServicesController_exports = {};
+_chunkV46WVGWNjs.__export.call(void 0, NotificationServicesController_exports, {
+  Constants: () => _chunkCQ6CGSKZjs.constants_exports,
+  Controller: () => _chunkYRWUXGL3js.NotificationServicesController,
+  Mocks: () => fixtures_exports,
+  Processors: () => _chunkUPVIT75Fjs.processors_exports,
+  Types: () => _chunk232HZSEVjs.types_exports,
+  defaultState: () => _chunkYRWUXGL3js.defaultState
+});
+
+// src/NotificationServicesController/__fixtures__/index.ts
+var fixtures_exports = {};
+_chunkV46WVGWNjs.__export.call(void 0, fixtures_exports, {
+  CONTENTFUL_RESPONSE: () => CONTENTFUL_RESPONSE,
+  MOCK_RAW_ON_CHAIN_NOTIFICATIONS: () => MOCK_RAW_ON_CHAIN_NOTIFICATIONS,
+  MOCK_USER_STORAGE_ACCOUNT: () => MOCK_USER_STORAGE_ACCOUNT,
+  MOCK_USER_STORAGE_CHAIN: () => MOCK_USER_STORAGE_CHAIN,
+  createMockFeatureAnnouncementAPIResult: () => createMockFeatureAnnouncementAPIResult,
+  createMockFeatureAnnouncementRaw: () => createMockFeatureAnnouncementRaw,
+  createMockFullUserStorage: () => createMockFullUserStorage,
+  createMockNotificationERC1155Received: () => createMockNotificationERC1155Received,
+  createMockNotificationERC1155Sent: () => createMockNotificationERC1155Sent,
+  createMockNotificationERC20Received: () => createMockNotificationERC20Received,
+  createMockNotificationERC20Sent: () => createMockNotificationERC20Sent,
+  createMockNotificationERC721Received: () => createMockNotificationERC721Received,
+  createMockNotificationERC721Sent: () => createMockNotificationERC721Sent,
+  createMockNotificationEthReceived: () => createMockNotificationEthReceived,
+  createMockNotificationEthSent: () => createMockNotificationEthSent,
+  createMockNotificationLidoReadyToBeWithdrawn: () => createMockNotificationLidoReadyToBeWithdrawn,
+  createMockNotificationLidoStakeCompleted: () => createMockNotificationLidoStakeCompleted,
+  createMockNotificationLidoWithdrawalCompleted: () => createMockNotificationLidoWithdrawalCompleted,
+  createMockNotificationLidoWithdrawalRequested: () => createMockNotificationLidoWithdrawalRequested,
+  createMockNotificationMetaMaskSwapsCompleted: () => createMockNotificationMetaMaskSwapsCompleted,
+  createMockNotificationRocketPoolStakeCompleted: () => createMockNotificationRocketPoolStakeCompleted,
+  createMockNotificationRocketPoolUnStakeCompleted: () => createMockNotificationRocketPoolUnStakeCompleted,
+  createMockNotificationTrigger: () => createMockNotificationTrigger,
+  createMockRawOnChainNotifications: () => createMockRawOnChainNotifications,
+  createMockUserStorage: () => createMockUserStorage,
+  createMockUserStorageWithTriggers: () => createMockUserStorageWithTriggers,
+  getMockBatchCreateTriggersResponse: () => getMockBatchCreateTriggersResponse,
+  getMockBatchDeleteTriggersResponse: () => getMockBatchDeleteTriggersResponse,
+  getMockFeatureAnnouncementResponse: () => getMockFeatureAnnouncementResponse,
+  getMockListNotificationsResponse: () => getMockListNotificationsResponse,
+  getMockMarkNotificationsAsReadResponse: () => getMockMarkNotificationsAsReadResponse,
+  mockBatchCreateTriggers: () => mockBatchCreateTriggers,
+  mockBatchDeleteTriggers: () => mockBatchDeleteTriggers,
+  mockFetchFeatureAnnouncementNotifications: () => mockFetchFeatureAnnouncementNotifications,
+  mockListNotifications: () => mockListNotifications,
+  mockMarkNotificationsAsRead: () => mockMarkNotificationsAsRead
+});
+
+// src/NotificationServicesController/__fixtures__/mock-feature-announcements.ts
+function createMockFeatureAnnouncementAPIResult() {
+  return {
+    sys: {
+      type: "Array"
+    },
+    total: 17,
+    skip: 0,
+    limit: 1,
+    items: [
+      {
+        metadata: {
+          tags: []
+        },
+        sys: {
+          space: {
+            sys: {
+              type: "Link",
+              linkType: "Space",
+              id: "jdkgyfmyd9sw"
+            }
+          },
+          id: "1ABRmHaNCgmxROKXXLXsMu",
+          type: "Entry",
+          createdAt: "2024-04-09T13:24:01.872Z",
+          updatedAt: "2024-04-09T13:24:01.872Z",
+          environment: {
+            sys: {
+              id: "master",
+              type: "Link",
+              linkType: "Environment"
+            }
+          },
+          revision: 1,
+          contentType: {
+            sys: {
+              type: "Link",
+              linkType: "ContentType",
+              id: "productAnnouncement"
+            }
+          },
+          locale: "en-US"
+        },
+        fields: {
+          title: "Don\u2019t miss out on airdrops and new NFT mints!",
+          id: "dont-miss-out-on-airdrops-and-new-nft-mints",
+          category: "ANNOUNCEMENT",
+          shortDescription: "Check your airdrop eligibility and see trending NFT drops. Head over to the Explore tab to get started. ",
+          image: {
+            sys: {
+              type: "Link",
+              linkType: "Asset",
+              id: "5jqq8sFeLc6XEoeWlpI3aB"
+            }
+          },
+          longDescription: {
+            data: {},
+            content: [
+              {
+                data: {},
+                content: [
+                  {
+                    data: {},
+                    marks: [],
+                    value: "You can now verify if any of your connected addresses are eligible for airdrops and other ERC-20 claims in a secure and convenient way. We\u2019ve also added trending NFT mints based on creators you\u2019ve minted from before or other tokens you hold. Head over to the Explore tab to get started. \n",
+                    nodeType: "text"
+                  }
+                ],
+                nodeType: "paragraph"
+              }
+            ],
+            nodeType: "document"
+          },
+          link: {
+            sys: {
+              type: "Link",
+              linkType: "Entry",
+              id: "62xKYM2ydo4F1mS5q97K5q"
+            }
+          }
+        }
+      }
+    ],
+    includes: {
+      Entry: [
+        {
+          metadata: {
+            tags: []
+          },
+          sys: {
+            space: {
+              sys: {
+                type: "Link",
+                linkType: "Space",
+                id: "jdkgyfmyd9sw"
+              }
+            },
+            id: "62xKYM2ydo4F1mS5q97K5q",
+            type: "Entry",
+            createdAt: "2024-04-09T13:23:03.636Z",
+            updatedAt: "2024-04-09T13:23:03.636Z",
+            environment: {
+              sys: {
+                id: "master",
+                type: "Link",
+                linkType: "Environment"
+              }
+            },
+            revision: 1,
+            contentType: {
+              sys: {
+                type: "Link",
+                linkType: "ContentType",
+                id: "link"
+              }
+            },
+            locale: "en-US"
+          },
+          fields: {
+            extensionLinkText: "Try now",
+            extensionLinkRoute: "home.html"
+          }
+        }
+      ],
+      Asset: [
+        {
+          metadata: {
+            tags: []
+          },
+          sys: {
+            space: {
+              sys: {
+                type: "Link",
+                linkType: "Space",
+                id: "jdkgyfmyd9sw"
+              }
+            },
+            id: "5jqq8sFeLc6XEoeWlpI3aB",
+            type: "Asset",
+            createdAt: "2024-04-09T13:23:13.327Z",
+            updatedAt: "2024-04-09T13:23:13.327Z",
+            environment: {
+              sys: {
+                id: "master",
+                type: "Link",
+                linkType: "Environment"
+              }
+            },
+            revision: 1,
+            locale: "en-US"
+          },
+          fields: {
+            title: "PDAPP notification image Airdrops & NFT mints",
+            description: "",
+            file: {
+              url: "//images.ctfassets.net/jdkgyfmyd9sw/5jqq8sFeLc6XEoeWlpI3aB/73ee0f1afa9916c3a7538b0bbee09c26/PDAPP_notification_image_Airdrops___NFT_mints.png",
+              details: {
+                size: 797731,
+                image: {
+                  width: 2880,
+                  height: 1921
+                }
+              },
+              fileName: "PDAPP notification image_Airdrops & NFT mints.png",
+              contentType: "image/png"
+            }
+          }
+        }
+      ]
+    }
+  };
+}
+function createMockFeatureAnnouncementRaw() {
+  return {
+    type: "features_announcement" /* FEATURES_ANNOUNCEMENT */,
+    createdAt: "2999-04-09T13:24:01.872Z",
+    data: {
+      id: "dont-miss-out-on-airdrops-and-new-nft-mints",
+      category: "ANNOUNCEMENT",
+      title: "Don\u2019t miss out on airdrops and new NFT mints!",
+      longDescription: `<p>You can now verify if any of your connected addresses are eligible for airdrops and other ERC-20 claims in a secure and convenient way. We\u2019ve also added trending NFT mints based on creators you\u2019ve minted from before or other tokens you hold. Head over to the Explore tab to get started.</p>`,
+      shortDescription: "Check your airdrop eligibility and see trending NFT drops. Head over to the Explore tab to get started.",
+      image: {
+        title: "PDAPP notification image Airdrops & NFT mints",
+        description: "",
+        url: "//images.ctfassets.net/jdkgyfmyd9sw/5jqq8sFeLc6XEoeWlpI3aB/73ee0f1afa9916c3a7538b0bbee09c26/PDAPP_notification_image_Airdrops___NFT_mints.png"
+      },
+      extensionLink: {
+        extensionLinkText: "Try now",
+        extensionLinkRoute: "home.html"
+      }
+    }
+  };
+}
+
+// src/NotificationServicesController/__fixtures__/mock-notification-trigger.ts
+var _uuid = require('uuid');
+function createMockNotificationTrigger(override) {
+  return {
+    id: _uuid.v4.call(void 0, ),
+    address: "0xFAKE_ADDRESS",
+    chainId: "1",
+    kind: "eth_sent",
+    enabled: true,
+    ...override
+  };
+}
+
+// src/NotificationServicesController/__fixtures__/mock-notification-user-storage.ts
+var MOCK_USER_STORAGE_ACCOUNT = "0x0000000000000000000000000000000000000000";
+var MOCK_USER_STORAGE_CHAIN = "1";
+function createMockUserStorage(override) {
+  return {
+    [_chunkTLX5QQK5js.USER_STORAGE_VERSION_KEY]: "1",
+    [MOCK_USER_STORAGE_ACCOUNT]: {
+      [MOCK_USER_STORAGE_CHAIN]: {
+        "111-111-111-111": {
+          k: "erc20_received" /* ERC20_RECEIVED */,
+          e: true
+        },
+        "222-222-222-222": {
+          k: "erc20_sent" /* ERC20_SENT */,
+          e: true
+        }
+      }
+    },
+    ...override
+  };
+}
+function createMockUserStorageWithTriggers(triggers) {
+  const userStorage = {
+    [_chunkTLX5QQK5js.USER_STORAGE_VERSION_KEY]: "1",
+    [MOCK_USER_STORAGE_ACCOUNT]: {
+      [MOCK_USER_STORAGE_CHAIN]: {}
+    }
+  };
+  triggers.forEach((t) => {
+    let tId;
+    let e;
+    let k;
+    if (typeof t === "string") {
+      tId = t;
+      e = true;
+      k = "erc20_received" /* ERC20_RECEIVED */;
+    } else {
+      tId = t.id;
+      e = t.e;
+      k = t.k ?? "erc20_received" /* ERC20_RECEIVED */;
+    }
+    userStorage[MOCK_USER_STORAGE_ACCOUNT][MOCK_USER_STORAGE_CHAIN][tId] = {
+      k,
+      e
+    };
+  });
+  return userStorage;
+}
+function createMockFullUserStorage(props = {}) {
+  return _chunkPIZCE3JDjs.initializeUserStorage.call(void 0, 
+    [{ address: props.address ?? MOCK_USER_STORAGE_ACCOUNT }],
+    props.triggersEnabled ?? true
+  );
+}
+
+// src/NotificationServicesController/__fixtures__/mock-raw-notifications.ts
+function createMockNotificationEthSent() {
+  const mockNotification = {
+    type: "eth_sent" /* ETH_SENT */,
+    id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+    trigger_id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+    chain_id: 1,
+    block_number: 17485840,
+    block_timestamp: "2022-03-01T00:00:00Z",
+    tx_hash: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    unread: true,
+    created_at: "2022-03-01T00:00:00Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      kind: "eth_sent",
+      network_fee: {
+        gas_price: "207806259583",
+        native_token_price_in_usd: "0.83"
+      },
+      from: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+      to: "0x881D40237659C251811CEC9c364ef91dC08D300D",
+      amount: {
+        usd: "670.64",
+        eth: "0.005"
+      }
+    }
+  };
+  return mockNotification;
+}
+function createMockNotificationEthReceived() {
+  const mockNotification = {
+    type: "eth_received" /* ETH_RECEIVED */,
+    id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+    trigger_id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+    chain_id: 1,
+    block_number: 17485840,
+    block_timestamp: "2022-03-01T00:00:00Z",
+    tx_hash: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    unread: true,
+    created_at: "2022-03-01T00:00:00Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      kind: "eth_received",
+      network_fee: {
+        gas_price: "207806259583",
+        native_token_price_in_usd: "0.83"
+      },
+      from: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+      to: "0x881D40237659C251811CEC9c364ef91dC08D300D",
+      amount: {
+        usd: "670.64",
+        eth: "808.000000000000000000"
+      }
+    }
+  };
+  return mockNotification;
+}
+function createMockNotificationERC20Sent() {
+  const mockNotification = {
+    type: "erc20_sent" /* ERC20_SENT */,
+    id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+    trigger_id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+    chain_id: 1,
+    block_number: 17485840,
+    block_timestamp: "2022-03-01T00:00:00Z",
+    tx_hash: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    unread: true,
+    created_at: "2022-03-01T00:00:00Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      kind: "erc20_sent",
+      network_fee: {
+        gas_price: "207806259583",
+        native_token_price_in_usd: "0.83"
+      },
+      to: "0xecc19e177d24551aa7ed6bc6fe566eca726cc8a9",
+      from: "0x1231deb6f5749ef6ce6943a275a1d3e7486f4eae",
+      token: {
+        usd: "1.00",
+        name: "USDC",
+        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/usdc.svg",
+        amount: "4956250000",
+        symbol: "USDC",
+        address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+        decimals: "6"
+      }
+    }
+  };
+  return mockNotification;
+}
+function createMockNotificationERC20Received() {
+  const mockNotification = {
+    type: "erc20_received" /* ERC20_RECEIVED */,
+    id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+    trigger_id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+    chain_id: 1,
+    block_number: 17485840,
+    block_timestamp: "2022-03-01T00:00:00Z",
+    tx_hash: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    unread: true,
+    created_at: "2022-03-01T00:00:00Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      kind: "erc20_received",
+      network_fee: {
+        gas_price: "207806259583",
+        native_token_price_in_usd: "0.83"
+      },
+      to: "0xeae7380dd4cef6fbd1144f49e4d1e6964258a4f4",
+      from: "0x51c72848c68a965f66fa7a88855f9f7784502a7f",
+      token: {
+        usd: "0.00",
+        name: "SHIBA INU",
+        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/shib.svg",
+        amount: "8382798736999999457296646144",
+        symbol: "SHIB",
+        address: "0x95ad61b0a150d79219dcf64e1e6cc01f0b64c4ce",
+        decimals: "18"
+      }
+    }
+  };
+  return mockNotification;
+}
+function createMockNotificationERC721Sent() {
+  const mockNotification = {
+    type: "erc721_sent" /* ERC721_SENT */,
+    block_number: 18576643,
+    block_timestamp: "1700043467",
+    chain_id: 1,
+    created_at: "2023-11-15T11:08:17.895407Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      to: "0xf47f628fe3bd2595e9ab384bfffc3859b448e451",
+      nft: {
+        name: "Captainz #8680",
+        image: "https://i.seadn.io/s/raw/files/ae0fc06714ff7fb40217340d8a242c0e.gif?w=500&auto=format",
+        token_id: "8680",
+        collection: {
+          name: "The Captainz",
+          image: "https://i.seadn.io/gcs/files/6df4d75778066bce740050615bc84e21.png?w=500&auto=format",
+          symbol: "Captainz",
+          address: "0x769272677fab02575e84945f03eca517acc544cc"
+        }
+      },
+      from: "0x24a0bb54b7e7a8e406e9b28058a9fd6c49e6df4f",
+      kind: "erc721_sent",
+      network_fee: {
+        gas_price: "24550653274",
+        native_token_price_in_usd: "1986.61"
+      }
+    },
+    id: "a4193058-9814-537e-9df4-79dcac727fb6",
+    trigger_id: "028485be-b994-422b-a93b-03fcc01ab715",
+    tx_hash: "0x0833c69fb41cf972a0f031fceca242939bc3fcf82b964b74606649abcad371bd",
+    unread: true
+  };
+  return mockNotification;
+}
+function createMockNotificationERC721Received() {
+  const mockNotification = {
+    type: "erc721_received" /* ERC721_RECEIVED */,
+    block_number: 18571446,
+    block_timestamp: "1699980623",
+    chain_id: 1,
+    created_at: "2023-11-14T17:40:52.319281Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      to: "0xba7f3daa8adfdad686574406ab9bd5d2f0a49d2e",
+      nft: {
+        name: "The Plague #2722",
+        image: "https://i.seadn.io/s/raw/files/a96f90ec8ebf55a2300c66a0c46d6a16.png?w=500&auto=format",
+        token_id: "2722",
+        collection: {
+          name: "The Plague NFT",
+          image: "https://i.seadn.io/gcs/files/4577987a5ca45ca5118b2e31559ee4d1.jpg?w=500&auto=format",
+          symbol: "FROG",
+          address: "0xc379e535caff250a01caa6c3724ed1359fe5c29b"
+        }
+      },
+      from: "0x24a0bb54b7e7a8e406e9b28058a9fd6c49e6df4f",
+      kind: "erc721_received",
+      network_fee: {
+        gas_price: "53701898538",
+        native_token_price_in_usd: "2047.01"
+      }
+    },
+    id: "00a79d24-befa-57ed-a55a-9eb8696e1654",
+    trigger_id: "d24ac26a-8579-49ec-9947-d04d63592ebd",
+    tx_hash: "0xe554c9e29e6eeca8ba94da4d047334ba08b8eb9ca3b801dd69cec08dfdd4ae43",
+    unread: true
+  };
+  return mockNotification;
+}
+function createMockNotificationERC1155Sent() {
+  const mockNotification = {
+    type: "erc1155_sent" /* ERC1155_SENT */,
+    block_number: 18615206,
+    block_timestamp: "1700510003",
+    chain_id: 1,
+    created_at: "2023-11-20T20:44:10.110706Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      to: "0x15bd77ccacf2da39b84f0c31fee2e451225bb190",
+      nft: {
+        name: "IlluminatiNFT DAO",
+        image: "https://i.seadn.io/gcs/files/79a77cb37c7b2f1069f752645d29fea7.jpg?w=500&auto=format",
+        token_id: "1",
+        collection: {
+          name: "IlluminatiNFT DAO",
+          image: "https://i.seadn.io/gae/LTKz3om2eCQfn3M6PkqEmY7KhLtdMCOm0QVch2318KJq7-KyToCH7NBTMo4UuJ0AZI-oaBh1HcgrAEIEWYbXY3uMcYpuGXunaXEh?w=500&auto=format",
+          symbol: "TRUTH",
+          address: "0xe25f0fe686477f9df3c2876c4902d3b85f75f33a"
+        }
+      },
+      from: "0x0000000000000000000000000000000000000000",
+      kind: "erc1155_sent",
+      network_fee: {
+        gas_price: "33571446596",
+        native_token_price_in_usd: "2038.88"
+      }
+    },
+    id: "a09ff9d1-623a-52ab-a3d4-c7c8c9a58362",
+    trigger_id: "e2130f7d-78b8-4c34-999a-3f3d3bb5b03c",
+    tx_hash: "0x03381aba290facbaf71c123e263c8dc3dd550aac00ef589cce395182eaeff76f",
+    unread: true
+  };
+  return mockNotification;
+}
+function createMockNotificationERC1155Received() {
+  const mockNotification = {
+    type: "erc1155_received" /* ERC1155_RECEIVED */,
+    block_number: 18615206,
+    block_timestamp: "1700510003",
+    chain_id: 1,
+    created_at: "2023-11-20T20:44:10.110706Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      to: "0x15bd77ccacf2da39b84f0c31fee2e451225bb190",
+      nft: {
+        name: "IlluminatiNFT DAO",
+        image: "https://i.seadn.io/gcs/files/79a77cb37c7b2f1069f752645d29fea7.jpg?w=500&auto=format",
+        token_id: "1",
+        collection: {
+          name: "IlluminatiNFT DAO",
+          image: "https://i.seadn.io/gae/LTKz3om2eCQfn3M6PkqEmY7KhLtdMCOm0QVch2318KJq7-KyToCH7NBTMo4UuJ0AZI-oaBh1HcgrAEIEWYbXY3uMcYpuGXunaXEh?w=500&auto=format",
+          symbol: "TRUTH",
+          address: "0xe25f0fe686477f9df3c2876c4902d3b85f75f33a"
+        }
+      },
+      from: "0x0000000000000000000000000000000000000000",
+      kind: "erc1155_received",
+      network_fee: {
+        gas_price: "33571446596",
+        native_token_price_in_usd: "2038.88"
+      }
+    },
+    id: "b6b93c84-e8dc-54ed-9396-7ea50474843a",
+    trigger_id: "710c8abb-43a9-42a5-9d86-9dd258726c82",
+    tx_hash: "0x03381aba290facbaf71c123e263c8dc3dd550aac00ef589cce395182eaeff76f",
+    unread: true
+  };
+  return mockNotification;
+}
+function createMockNotificationMetaMaskSwapsCompleted() {
+  const mockNotification = {
+    type: "metamask_swap_completed" /* METAMASK_SWAP_COMPLETED */,
+    block_number: 18377666,
+    block_timestamp: "1697637275",
+    chain_id: 1,
+    created_at: "2023-10-18T13:58:49.854596Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      kind: "metamask_swap_completed",
+      rate: "1558.27",
+      token_in: {
+        usd: "1576.73",
+        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
+        amount: "9000000000000000",
+        symbol: "ETH",
+        address: "0x0000000000000000000000000000000000000000",
+        decimals: "18",
+        name: "Ethereum"
+      },
+      token_out: {
+        usd: "1.00",
+        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/usdt.svg",
+        amount: "14024419",
+        symbol: "USDT",
+        address: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+        decimals: "6",
+        name: "USDT"
+      },
+      network_fee: {
+        gas_price: "15406129273",
+        native_token_price_in_usd: "1576.73"
+      }
+    },
+    id: "7ddfe6a1-ac52-5ffe-aa40-f04242db4b8b",
+    trigger_id: "d2eaa2eb-2e6e-4fd5-8763-b70ea571b46c",
+    tx_hash: "0xf69074290f3aa11bce567aabc9ca0df7a12559dfae1b80ba1a124e9dfe19ecc5",
+    unread: true
+  };
+  return mockNotification;
+}
+function createMockNotificationRocketPoolStakeCompleted() {
+  const mockNotification = {
+    type: "rocketpool_stake_completed" /* ROCKETPOOL_STAKE_COMPLETED */,
+    block_number: 18585057,
+    block_timestamp: "1700145059",
+    chain_id: 1,
+    created_at: "2023-11-20T12:02:48.796824Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      kind: "rocketpool_stake_completed",
+      stake_in: {
+        usd: "2031.86",
+        name: "Ethereum",
+        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
+        amount: "190690478063438272",
+        symbol: "ETH",
+        address: "0x0000000000000000000000000000000000000000",
+        decimals: "18"
+      },
+      stake_out: {
+        usd: "2226.49",
+        name: "Rocket Pool ETH",
+        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/rETH.svg",
+        amount: "175024360778165879",
+        symbol: "RETH",
+        address: "0xae78736Cd615f374D3085123A210448E74Fc6393",
+        decimals: "18"
+      },
+      network_fee: {
+        gas_price: "36000000000",
+        native_token_price_in_usd: "2031.86"
+      }
+    },
+    id: "c2a2f225-b2fb-5d6c-ba56-e27a5c71ffb9",
+    trigger_id: "5110ff97-acff-40c0-83b4-11d487b8c7b0",
+    tx_hash: "0xcfc0693bf47995907b0f46ef0644cf16dd9a0de797099b2e00fd481e1b2117d3",
+    unread: true
+  };
+  return mockNotification;
+}
+function createMockNotificationRocketPoolUnStakeCompleted() {
+  const mockNotification = {
+    type: "rocketpool_unstake_completed" /* ROCKETPOOL_UNSTAKE_COMPLETED */,
+    block_number: 18384336,
+    block_timestamp: "1697718011",
+    chain_id: 1,
+    created_at: "2023-10-19T13:11:10.623042Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      kind: "rocketpool_unstake_completed",
+      stake_in: {
+        usd: "1686.34",
+        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/rETH.svg",
+        amount: "66608041413696770",
+        symbol: "RETH",
+        address: "0xae78736Cd615f374D3085123A210448E74Fc6393",
+        decimals: "18",
+        name: "Rocketpool Eth"
+      },
+      stake_out: {
+        usd: "1553.75",
+        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
+        amount: "72387843427700824",
+        symbol: "ETH",
+        address: "0x0000000000000000000000000000000000000000",
+        decimals: "18",
+        name: "Ethereum"
+      },
+      network_fee: {
+        gas_price: "5656322987",
+        native_token_price_in_usd: "1553.75"
+      }
+    },
+    id: "d8c246e7-a0a4-5f1d-b079-2b1707665fbc",
+    trigger_id: "291ec897-f569-4837-b6c0-21001b198dff",
+    tx_hash: "0xc7972a7e409abfc62590ec90e633acd70b9b74e76ad02305be8bf133a0e22d5f",
+    unread: true
+  };
+  return mockNotification;
+}
+function createMockNotificationLidoStakeCompleted() {
+  const mockNotification = {
+    type: "lido_stake_completed" /* LIDO_STAKE_COMPLETED */,
+    block_number: 18487118,
+    block_timestamp: "1698961091",
+    chain_id: 1,
+    created_at: "2023-11-02T22:28:49.970865Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      kind: "lido_stake_completed",
+      stake_in: {
+        usd: "1806.33",
+        name: "Ethereum",
+        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
+        amount: "330303634023928032",
+        symbol: "ETH",
+        address: "0x0000000000000000000000000000000000000000",
+        decimals: "18"
+      },
+      stake_out: {
+        usd: "1801.30",
+        name: "Liquid staked Ether 2.0",
+        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/stETH.svg",
+        amount: "330303634023928032",
+        symbol: "STETH",
+        address: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
+        decimals: "18"
+      },
+      network_fee: {
+        gas_price: "26536359866",
+        native_token_price_in_usd: "1806.33"
+      }
+    },
+    id: "9d9b1467-b3ee-5492-8ca2-22382657b690",
+    trigger_id: "ec10d66a-f78f-461f-83c9-609aada8cc50",
+    tx_hash: "0x8cc0fa805f7c3b1743b14f3b91c6b824113b094f26d4ccaf6a71ad8547ce6a0f",
+    unread: true
+  };
+  return mockNotification;
+}
+function createMockNotificationLidoWithdrawalRequested() {
+  const mockNotification = {
+    type: "lido_withdrawal_requested" /* LIDO_WITHDRAWAL_REQUESTED */,
+    block_number: 18377760,
+    block_timestamp: "1697638415",
+    chain_id: 1,
+    created_at: "2023-10-18T15:04:02.482526Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      kind: "lido_withdrawal_requested",
+      stake_in: {
+        usd: "1568.54",
+        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/stETH.svg",
+        amount: "97180668792218669859",
+        symbol: "STETH",
+        address: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
+        decimals: "18",
+        name: "Staked Eth"
+      },
+      stake_out: {
+        usd: "1576.73",
+        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
+        amount: "97180668792218669859",
+        symbol: "ETH",
+        address: "0x0000000000000000000000000000000000000000",
+        decimals: "18",
+        name: "Ethereum"
+      },
+      network_fee: {
+        gas_price: "11658906980",
+        native_token_price_in_usd: "1576.73"
+      }
+    },
+    id: "29ddc718-78c6-5f91-936f-2bef13a605f0",
+    trigger_id: "ef003925-3379-4ba7-9e2d-8218690cadc8",
+    tx_hash: "0x58b5f82e084cb750ea174e02b20fbdfd2ba8d78053deac787f34fc38e5d427aa",
+    unread: true
+  };
+  return mockNotification;
+}
+function createMockNotificationLidoWithdrawalCompleted() {
+  const mockNotification = {
+    type: "lido_withdrawal_completed" /* LIDO_WITHDRAWAL_COMPLETED */,
+    block_number: 18378208,
+    block_timestamp: "1697643851",
+    chain_id: 1,
+    created_at: "2023-10-18T16:35:03.147606Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      kind: "lido_withdrawal_completed",
+      stake_in: {
+        usd: "1570.23",
+        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/stETH.svg",
+        amount: "35081997661451346",
+        symbol: "STETH",
+        address: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
+        decimals: "18",
+        name: "Staked Eth"
+      },
+      stake_out: {
+        usd: "1571.74",
+        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
+        amount: "35081997661451346",
+        symbol: "ETH",
+        address: "0x0000000000000000000000000000000000000000",
+        decimals: "18",
+        name: "Ethereum"
+      },
+      network_fee: {
+        gas_price: "12699495150",
+        native_token_price_in_usd: "1571.74"
+      }
+    },
+    id: "f4ef0b7f-5612-537f-9144-0b5c63ae5391",
+    trigger_id: "d73df14d-ce73-4f38-bad3-ab028154042c",
+    tx_hash: "0xe6d210d2e601ef3dd1075c48e71452cf35f2daae3886911e964e3babad8ac657",
+    unread: true
+  };
+  return mockNotification;
+}
+function createMockNotificationLidoReadyToBeWithdrawn() {
+  const mockNotification = {
+    type: "lido_stake_ready_to_be_withdrawn" /* LIDO_STAKE_READY_TO_BE_WITHDRAWN */,
+    block_number: 18378208,
+    block_timestamp: "1697643851",
+    chain_id: 1,
+    created_at: "2023-10-18T16:35:03.147606Z",
+    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
+    data: {
+      kind: "lido_stake_ready_to_be_withdrawn",
+      request_id: "123456789",
+      staked_eth: {
+        address: "0x881D40237659C251811CEC9c364ef91dC08D300F",
+        symbol: "ETH",
+        name: "Ethereum",
+        amount: "2.5",
+        decimals: "18",
+        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
+        usd: "10000.00"
+      }
+    },
+    id: "f4ef0b7f-5612-537f-9144-0b5c63ae5391",
+    trigger_id: "d73df14d-ce73-4f38-bad3-ab028154042c",
+    tx_hash: "0xe6d210d2e601ef3dd1075c48e71452cf35f2daae3886911e964e3babad8ac657",
+    unread: true
+  };
+  return mockNotification;
+}
+function createMockRawOnChainNotifications() {
+  return [1, 2, 3].map((id) => {
+    const notification = createMockNotificationEthSent();
+    notification.id += `-${id}`;
+    return notification;
+  });
+}
+
+// src/NotificationServicesController/__fixtures__/mockResponses.ts
+var CONTENTFUL_RESPONSE = createMockFeatureAnnouncementAPIResult();
+var getMockFeatureAnnouncementResponse = () => {
+  return {
+    url: _chunkZMNXLHACjs.FEATURE_ANNOUNCEMENT_API,
+    requestMethod: "GET",
+    response: CONTENTFUL_RESPONSE
+  };
+};
+var getMockBatchCreateTriggersResponse = () => {
+  return {
+    url: _chunkVOZ7Y2OOjs.TRIGGER_API_BATCH_ENDPOINT,
+    requestMethod: "POST",
+    response: null
+  };
+};
+var getMockBatchDeleteTriggersResponse = () => {
+  return {
+    url: _chunkVOZ7Y2OOjs.TRIGGER_API_BATCH_ENDPOINT,
+    requestMethod: "DELETE",
+    response: null
+  };
+};
+var MOCK_RAW_ON_CHAIN_NOTIFICATIONS = createMockRawOnChainNotifications();
+var getMockListNotificationsResponse = () => {
+  return {
+    url: _chunkVOZ7Y2OOjs.NOTIFICATION_API_LIST_ENDPOINT,
+    requestMethod: "POST",
+    response: MOCK_RAW_ON_CHAIN_NOTIFICATIONS
+  };
+};
+var getMockMarkNotificationsAsReadResponse = () => {
+  return {
+    url: _chunkVOZ7Y2OOjs.NOTIFICATION_API_MARK_ALL_AS_READ_ENDPOINT,
+    requestMethod: "POST",
+    response: null
+  };
+};
+
+// src/NotificationServicesController/__fixtures__/mockServices.ts
+var import_nock = _chunkV46WVGWNjs.__toESM.call(void 0, require_nock());
+var mockFetchFeatureAnnouncementNotifications = (mockReply) => {
+  const mockResponse = getMockFeatureAnnouncementResponse();
+  const reply = mockReply ?? { status: 200, body: mockResponse.response };
+  const mockEndpoint = (0, import_nock.default)(mockResponse.url).get("").query(true).reply(reply.status, reply.body);
+  return mockEndpoint;
+};
+var mockBatchCreateTriggers = (mockReply) => {
+  const mockResponse = getMockBatchCreateTriggersResponse();
+  const reply = mockReply ?? { status: 204 };
+  const mockEndpoint = (0, import_nock.default)(mockResponse.url).post("").reply(reply.status, reply.body);
+  return mockEndpoint;
+};
+var mockBatchDeleteTriggers = (mockReply) => {
+  const mockResponse = getMockBatchDeleteTriggersResponse();
+  const reply = mockReply ?? { status: 204 };
+  const mockEndpoint = (0, import_nock.default)(mockResponse.url).delete("").reply(reply.status, reply.body);
+  return mockEndpoint;
+};
+var mockListNotifications = (mockReply) => {
+  const mockResponse = getMockListNotificationsResponse();
+  const reply = mockReply ?? { status: 200, body: mockResponse.response };
+  const mockEndpoint = (0, import_nock.default)(mockResponse.url).post("").query(true).reply(reply.status, reply.body);
+  return mockEndpoint;
+};
+var mockMarkNotificationsAsRead = (mockReply) => {
+  const mockResponse = getMockMarkNotificationsAsReadResponse();
+  const reply = mockReply ?? { status: 200 };
+  const mockEndpoint = (0, import_nock.default)(mockResponse.url).post("").reply(reply.status, reply.body);
+  return mockEndpoint;
+};
+
+
+
+
+
+exports.require_nock = require_nock; exports.fixtures_exports = fixtures_exports; exports.NotificationServicesController_exports = NotificationServicesController_exports;
+//# sourceMappingURL=chunk-4KZO4UUC.js.map