msw 1.3.1 → 2.0.0

package/lib/browser/index.mjs

@@ -0,0 +1,733 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/browser/setupWorker/setupWorker.ts
+import { invariant } from "outvariant";
+import { isNodeProcess } from "is-node-process";
+
+// src/browser/setupWorker/start/createStartHandler.ts
+import { until as until3 } from "@open-draft/until";
+import { devUtils as devUtils6 } from '../core/utils/internal/devUtils.mjs';
+
+// src/browser/setupWorker/start/utils/getWorkerInstance.ts
+import { until } from "@open-draft/until";
+import { devUtils } from '../core/utils/internal/devUtils.mjs';
+
+// src/browser/utils/getAbsoluteWorkerUrl.ts
+function getAbsoluteWorkerUrl(workerUrl) {
+  return new URL(workerUrl, location.href).href;
+}
+
+// src/browser/setupWorker/start/utils/getWorkerByRegistration.ts
+function getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker) {
+  const allStates = [
+    registration.active,
+    registration.installing,
+    registration.waiting
+  ];
+  const relevantStates = allStates.filter((state) => {
+    return state != null;
+  });
+  const worker = relevantStates.find((worker2) => {
+    return findWorker(worker2.scriptURL, absoluteWorkerUrl);
+  });
+  return worker || null;
+}
+
+// src/browser/setupWorker/start/utils/getWorkerInstance.ts
+var getWorkerInstance = (_0, ..._1) => __async(void 0, [_0, ..._1], function* (url, options = {}, findWorker) {
+  const absoluteWorkerUrl = getAbsoluteWorkerUrl(url);
+  const mockRegistrations = yield navigator.serviceWorker.getRegistrations().then(
+    (registrations) => registrations.filter(
+      (registration) => getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker)
+    )
+  );
+  if (!navigator.serviceWorker.controller && mockRegistrations.length > 0) {
+    location.reload();
+  }
+  const [existingRegistration] = mockRegistrations;
+  if (existingRegistration) {
+    return existingRegistration.update().then(() => {
+      return [
+        getWorkerByRegistration(
+          existingRegistration,
+          absoluteWorkerUrl,
+          findWorker
+        ),
+        existingRegistration
+      ];
+    });
+  }
+  const registrationResult = yield until(
+    () => __async(void 0, null, function* () {
+      const registration = yield navigator.serviceWorker.register(url, options);
+      return [
+        // Compare existing worker registration by its worker URL,
+        // to prevent irrelevant workers to resolve here (such as Codesandbox worker).
+        getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker),
+        registration
+      ];
+    })
+  );
+  if (registrationResult.error) {
+    const isWorkerMissing = registrationResult.error.message.includes("(404)");
+    if (isWorkerMissing) {
+      const scopeUrl = new URL((options == null ? void 0 : options.scope) || "/", location.href);
+      throw new Error(
+        devUtils.formatMessage(`Failed to register a Service Worker for scope ('${scopeUrl.href}') with script ('${absoluteWorkerUrl}'): Service Worker script does not exist at the given path.
+
+Did you forget to run "npx msw init <PUBLIC_DIR>"?
+
+Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/init`)
+      );
+    }
+    throw new Error(
+      devUtils.formatMessage(
+        "Failed to register the Service Worker:\n\n%s",
+        registrationResult.error.message
+      )
+    );
+  }
+  return registrationResult.data;
+});
+
+// src/browser/setupWorker/start/utils/enableMocking.ts
+import { devUtils as devUtils3 } from '../core/utils/internal/devUtils.mjs';
+
+// src/browser/setupWorker/start/utils/printStartMessage.ts
+import { devUtils as devUtils2 } from '../core/utils/internal/devUtils.mjs';
+function printStartMessage(args = {}) {
+  if (args.quiet) {
+    return;
+  }
+  const message = args.message || "Mocking enabled.";
+  console.groupCollapsed(
+    `%c${devUtils2.formatMessage(message)}`,
+    "color:orangered;font-weight:bold;"
+  );
+  console.log(
+    "%cDocumentation: %chttps://mswjs.io/docs",
+    "font-weight:bold",
+    "font-weight:normal"
+  );
+  console.log("Found an issue? https://github.com/mswjs/msw/issues");
+  if (args.workerUrl) {
+    console.log("Worker script URL:", args.workerUrl);
+  }
+  if (args.workerScope) {
+    console.log("Worker scope:", args.workerScope);
+  }
+  console.groupEnd();
+}
+
+// src/browser/setupWorker/start/utils/enableMocking.ts
+function enableMocking(context, options) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    context.workerChannel.send("MOCK_ACTIVATE");
+    yield context.events.once("MOCKING_ENABLED");
+    if (context.isMockingEnabled) {
+      devUtils3.warn(
+        `Found a redundant "worker.start()" call. Note that starting the worker while mocking is already enabled will have no effect. Consider removing this "worker.start()" call.`
+      );
+      return;
+    }
+    context.isMockingEnabled = true;
+    printStartMessage({
+      quiet: options.quiet,
+      workerScope: (_a = context.registration) == null ? void 0 : _a.scope,
+      workerUrl: (_b = context.worker) == null ? void 0 : _b.scriptURL
+    });
+  });
+}
+
+// src/browser/setupWorker/start/utils/createMessageChannel.ts
+var WorkerChannel = class {
+  constructor(port) {
+    this.port = port;
+  }
+  postMessage(event, ...rest) {
+    const [data, transfer] = rest;
+    this.port.postMessage(
+      { type: event, data },
+      {
+        // @ts-ignore ReadableStream can be transferred
+        // but TypeScript doesn't acknowledge that.
+        transfer
+      }
+    );
+  }
+};
+
+// src/browser/utils/pruneGetRequestBody.ts
+function pruneGetRequestBody(request) {
+  if (["HEAD", "GET"].includes(request.method)) {
+    return void 0;
+  }
+  return request.body;
+}
+
+// src/browser/utils/parseWorkerRequest.ts
+function parseWorkerRequest(incomingRequest) {
+  return new Request(incomingRequest.url, __spreadProps(__spreadValues({}, incomingRequest), {
+    body: pruneGetRequestBody(incomingRequest)
+  }));
+}
+
+// src/browser/setupWorker/start/createRequestListener.ts
+import { handleRequest } from '../core/utils/handleRequest.mjs';
+import { devUtils as devUtils4 } from '../core/utils/internal/devUtils.mjs';
+import { toResponseInit } from '../core/utils/toResponseInit.mjs';
+var createRequestListener = (context, options) => {
+  return (event, message) => __async(void 0, null, function* () {
+    var _b;
+    const messageChannel = new WorkerChannel(event.ports[0]);
+    const requestId = message.payload.id;
+    const request = parseWorkerRequest(message.payload);
+    const requestCloneForLogs = request.clone();
+    try {
+      let _a;
+      yield handleRequest(
+        request,
+        requestId,
+        context.requestHandlers,
+        options,
+        context.emitter,
+        {
+          onPassthroughResponse() {
+            messageChannel.postMessage("NOT_FOUND");
+          },
+          onMockedResponse(_0, _1) {
+            return __async(this, arguments, function* (response, { handler, parsedResult }) {
+              const responseClone = response.clone();
+              const responseInit = toResponseInit(response);
+              if (context.supports.readableStreamTransfer) {
+                const responseStream = response.body;
+                messageChannel.postMessage(
+                  "MOCK_RESPONSE",
+                  __spreadProps(__spreadValues({}, responseInit), {
+                    body: responseStream
+                  }),
+                  responseStream ? [responseStream] : void 0
+                );
+              } else {
+                const responseBuffer = yield responseClone.arrayBuffer();
+                messageChannel.postMessage("MOCK_RESPONSE", __spreadProps(__spreadValues({}, responseInit), {
+                  body: responseBuffer
+                }));
+              }
+              if (!options.quiet) {
+                context.emitter.once("response:mocked", ({ response: response2 }) => {
+                  handler.log({
+                    request: requestCloneForLogs,
+                    response: response2,
+                    parsedResult
+                  });
+                });
+              }
+            });
+          }
+        }
+      );
+    } catch (error) {
+      if (error instanceof Error) {
+        devUtils4.error(
+          `Uncaught exception in the request handler for "%s %s":
+
+%s
+
+This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error, as it indicates a mistake in your code. If you wish to mock an error response, please see this guide: https://mswjs.io/docs/recipes/mocking-error-responses`,
+          request.method,
+          request.url,
+          (_b = error.stack) != null ? _b : error
+        );
+        messageChannel.postMessage("MOCK_RESPONSE", {
+          status: 500,
+          statusText: "Request Handler Error",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+          })
+        });
+      }
+    }
+  });
+};
+
+// src/browser/utils/requestIntegrityCheck.ts
+function requestIntegrityCheck(context, serviceWorker) {
+  return __async(this, null, function* () {
+    context.workerChannel.send("INTEGRITY_CHECK_REQUEST");
+    const { payload: actualChecksum } = yield context.events.once(
+      "INTEGRITY_CHECK_RESPONSE"
+    );
+    if (actualChecksum !== "0877fcdc026242810f5bfde0d7178db4") {
+      throw new Error(
+        `Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"0877fcdc026242810f5bfde0d7178db4"}).`
+      );
+    }
+    return serviceWorker;
+  });
+}
+
+// src/browser/utils/deferNetworkRequestsUntil.ts
+import { until as until2 } from "@open-draft/until";
+function deferNetworkRequestsUntil(predicatePromise) {
+  const originalXhrSend = window.XMLHttpRequest.prototype.send;
+  window.XMLHttpRequest.prototype.send = function(...args) {
+    until2(() => predicatePromise).then(() => {
+      window.XMLHttpRequest.prototype.send = originalXhrSend;
+      this.send(...args);
+    });
+  };
+  const originalFetch = window.fetch;
+  window.fetch = (...args) => __async(this, null, function* () {
+    yield until2(() => predicatePromise);
+    window.fetch = originalFetch;
+    return window.fetch(...args);
+  });
+}
+
+// src/browser/setupWorker/start/createResponseListener.ts
+function createResponseListener(context) {
+  return (_, message) => {
+    var _a;
+    const { payload: responseJson } = message;
+    if ((_a = responseJson.type) == null ? void 0 : _a.includes("opaque")) {
+      return;
+    }
+    const response = responseJson.status === 0 ? Response.error() : new Response(responseJson.body, responseJson);
+    context.emitter.emit(
+      responseJson.isMockedResponse ? "response:mocked" : "response:bypass",
+      {
+        response,
+        /**
+         * @todo @fixme In this context, we don't know anything about
+         * the request.
+         */
+        request: null,
+        requestId: responseJson.requestId
+      }
+    );
+  };
+}
+
+// src/browser/setupWorker/start/utils/validateWorkerScope.ts
+import { devUtils as devUtils5 } from '../core/utils/internal/devUtils.mjs';
+function validateWorkerScope(registration, options) {
+  if (!(options == null ? void 0 : options.quiet) && !location.href.startsWith(registration.scope)) {
+    devUtils5.warn(
+      `Cannot intercept requests on this page because it's outside of the worker's scope ("${registration.scope}"). If you wish to mock API requests on this page, you must resolve this scope issue.
+
+- (Recommended) Register the worker at the root level ("/") of your application.
+- Set the "Service-Worker-Allowed" response header to allow out-of-scope workers.`
+    );
+  }
+}
+
+// src/browser/setupWorker/start/createStartHandler.ts
+var createStartHandler = (context) => {
+  return function start(options, customOptions) {
+    const startWorkerInstance = () => __async(this, null, function* () {
+      context.events.removeAllListeners();
+      context.workerChannel.on(
+        "REQUEST",
+        createRequestListener(context, options)
+      );
+      context.workerChannel.on("RESPONSE", createResponseListener(context));
+      const instance = yield getWorkerInstance(
+        options.serviceWorker.url,
+        options.serviceWorker.options,
+        options.findWorker
+      );
+      const [worker, registration] = instance;
+      if (!worker) {
+        const missingWorkerMessage = (customOptions == null ? void 0 : customOptions.findWorker) ? devUtils6.formatMessage(
+          `Failed to locate the Service Worker registration using a custom "findWorker" predicate.
+
+Please ensure that the custom predicate properly locates the Service Worker registration at "%s".
+More details: https://mswjs.io/docs/api/setup-worker/start#findworker
+`,
+          options.serviceWorker.url
+        ) : devUtils6.formatMessage(
+          `Failed to locate the Service Worker registration.
+
+This most likely means that the worker script URL "%s" cannot resolve against the actual public hostname (%s). This may happen if your application runs behind a proxy, or has a dynamic hostname.
+
+Please consider using a custom "serviceWorker.url" option to point to the actual worker script location, or a custom "findWorker" option to resolve the Service Worker registration manually. More details: https://mswjs.io/docs/api/setup-worker/start`,
+          options.serviceWorker.url,
+          location.host
+        );
+        throw new Error(missingWorkerMessage);
+      }
+      context.worker = worker;
+      context.registration = registration;
+      context.events.addListener(window, "beforeunload", () => {
+        if (worker.state !== "redundant") {
+          context.workerChannel.send("CLIENT_CLOSED");
+        }
+        window.clearInterval(context.keepAliveInterval);
+      });
+      const integrityCheckResult = yield until3(
+        () => requestIntegrityCheck(context, worker)
+      );
+      if (integrityCheckResult.error) {
+        devUtils6.error(`Detected outdated Service Worker: ${integrityCheckResult.error.message}
+
+The mocking is still enabled, but it's highly recommended that you update your Service Worker by running:
+
+$ npx msw init <PUBLIC_DIR>
+
+This is necessary to ensure that the Service Worker is in sync with the library to guarantee its stability.
+If this message still persists after updating, please report an issue: https://github.com/open-draft/msw/issues      `);
+      }
+      context.keepAliveInterval = window.setInterval(
+        () => context.workerChannel.send("KEEPALIVE_REQUEST"),
+        5e3
+      );
+      validateWorkerScope(registration, context.startOptions);
+      return registration;
+    });
+    const workerRegistration = startWorkerInstance().then(
+      (registration) => __async(this, null, function* () {
+        const pendingInstance = registration.installing || registration.waiting;
+        if (pendingInstance) {
+          yield new Promise((resolve) => {
+            pendingInstance.addEventListener("statechange", () => {
+              if (pendingInstance.state === "activated") {
+                return resolve();
+              }
+            });
+          });
+        }
+        yield enableMocking(context, options).catch((error) => {
+          throw new Error(`Failed to enable mocking: ${error == null ? void 0 : error.message}`);
+        });
+        return registration;
+      })
+    );
+    if (options.waitUntilReady) {
+      deferNetworkRequestsUntil(workerRegistration);
+    }
+    return workerRegistration;
+  };
+};
+
+// src/browser/setupWorker/stop/createStop.ts
+import { devUtils as devUtils8 } from '../core/utils/internal/devUtils.mjs';
+
+// src/browser/setupWorker/stop/utils/printStopMessage.ts
+import { devUtils as devUtils7 } from '../core/utils/internal/devUtils.mjs';
+function printStopMessage(args = {}) {
+  if (args.quiet) {
+    return;
+  }
+  console.log(
+    `%c${devUtils7.formatMessage("Mocking disabled.")}`,
+    "color:orangered;font-weight:bold;"
+  );
+}
+
+// src/browser/setupWorker/stop/createStop.ts
+var createStop = (context) => {
+  return function stop() {
+    var _a;
+    if (!context.isMockingEnabled) {
+      devUtils8.warn(
+        'Found a redundant "worker.stop()" call. Note that stopping the worker while mocking already stopped has no effect. Consider removing this "worker.stop()" call.'
+      );
+      return;
+    }
+    context.workerChannel.send("MOCK_DEACTIVATE");
+    context.isMockingEnabled = false;
+    window.clearInterval(context.keepAliveInterval);
+    printStopMessage({ quiet: (_a = context.startOptions) == null ? void 0 : _a.quiet });
+  };
+};
+
+// src/browser/setupWorker/start/utils/prepareStartHandler.ts
+import { mergeRight } from '../core/utils/internal/mergeRight.mjs';
+var DEFAULT_START_OPTIONS = {
+  serviceWorker: {
+    url: "/mockServiceWorker.js",
+    options: null
+  },
+  quiet: false,
+  waitUntilReady: true,
+  onUnhandledRequest: "warn",
+  findWorker(scriptURL, mockServiceWorkerUrl) {
+    return scriptURL === mockServiceWorkerUrl;
+  }
+};
+
+// src/browser/setupWorker/start/createFallbackRequestListener.ts
+import {
+  BatchInterceptor
+} from "@mswjs/interceptors";
+import { FetchInterceptor } from "@mswjs/interceptors/fetch";
+import { XMLHttpRequestInterceptor } from "@mswjs/interceptors/XMLHttpRequest";
+import { handleRequest as handleRequest2 } from '../core/utils/handleRequest.mjs';
+function createFallbackRequestListener(context, options) {
+  const interceptor = new BatchInterceptor({
+    name: "fallback",
+    interceptors: [new FetchInterceptor(), new XMLHttpRequestInterceptor()]
+  });
+  interceptor.on("request", (_0) => __async(this, [_0], function* ({ request, requestId }) {
+    const requestCloneForLogs = request.clone();
+    const response = yield handleRequest2(
+      request,
+      requestId,
+      context.requestHandlers,
+      options,
+      context.emitter,
+      {
+        onMockedResponse(_, { handler, parsedResult }) {
+          if (!options.quiet) {
+            context.emitter.once("response:mocked", ({ response: response2 }) => {
+              handler.log({
+                request: requestCloneForLogs,
+                response: response2,
+                parsedResult
+              });
+            });
+          }
+        }
+      }
+    );
+    if (response) {
+      request.respondWith(response);
+    }
+  }));
+  interceptor.on(
+    "response",
+    ({ response, isMockedResponse, request, requestId }) => {
+      context.emitter.emit(
+        isMockedResponse ? "response:mocked" : "response:bypass",
+        {
+          response,
+          request,
+          requestId
+        }
+      );
+    }
+  );
+  interceptor.apply();
+  return interceptor;
+}
+
+// src/browser/setupWorker/start/createFallbackStart.ts
+function createFallbackStart(context) {
+  return function start(options) {
+    return __async(this, null, function* () {
+      context.fallbackInterceptor = createFallbackRequestListener(
+        context,
+        options
+      );
+      printStartMessage({
+        message: "Mocking enabled (fallback mode).",
+        quiet: options.quiet
+      });
+      return void 0;
+    });
+  };
+}
+
+// src/browser/setupWorker/stop/createFallbackStop.ts
+function createFallbackStop(context) {
+  return function stop() {
+    var _a, _b;
+    (_a = context.fallbackInterceptor) == null ? void 0 : _a.dispose();
+    printStopMessage({ quiet: (_b = context.startOptions) == null ? void 0 : _b.quiet });
+  };
+}
+
+// src/browser/setupWorker/setupWorker.ts
+import { devUtils as devUtils9 } from '../core/utils/internal/devUtils.mjs';
+import { SetupApi } from '../core/SetupApi.mjs';
+import { mergeRight as mergeRight2 } from '../core/utils/internal/mergeRight.mjs';
+
+// src/browser/utils/supportsReadableStreamTransfer.ts
+function supportsReadableStreamTransfer() {
+  try {
+    const stream = new ReadableStream({
+      start: (controller) => controller.close()
+    });
+    const message = new MessageChannel();
+    message.port1.postMessage(stream, [stream]);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+// src/browser/setupWorker/setupWorker.ts
+var SetupWorkerApi = class extends SetupApi {
+  constructor(...handlers) {
+    super(...handlers);
+    this.startHandler = null;
+    this.stopHandler = null;
+    invariant(
+      !isNodeProcess(),
+      devUtils9.formatMessage(
+        "Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead."
+      )
+    );
+    this.listeners = [];
+    this.context = this.createWorkerContext();
+  }
+  createWorkerContext() {
+    const context = {
+      // Mocking is not considered enabled until the worker
+      // signals back the successful activation event.
+      isMockingEnabled: false,
+      startOptions: null,
+      worker: null,
+      registration: null,
+      requestHandlers: this.currentHandlers,
+      emitter: this.emitter,
+      workerChannel: {
+        on: (eventType, callback) => {
+          this.context.events.addListener(navigator.serviceWorker, "message", (event) => {
+            if (event.source !== this.context.worker) {
+              return;
+            }
+            const message = event.data;
+            if (!message) {
+              return;
+            }
+            if (message.type === eventType) {
+              callback(event, message);
+            }
+          });
+        },
+        send: (type) => {
+          var _a;
+          (_a = this.context.worker) == null ? void 0 : _a.postMessage(type);
+        }
+      },
+      events: {
+        addListener: (target, eventType, callback) => {
+          target.addEventListener(eventType, callback);
+          this.listeners.push({
+            eventType,
+            target,
+            callback
+          });
+          return () => {
+            target.removeEventListener(eventType, callback);
+          };
+        },
+        removeAllListeners: () => {
+          for (const { target, eventType, callback } of this.listeners) {
+            target.removeEventListener(eventType, callback);
+          }
+          this.listeners = [];
+        },
+        once: (eventType) => {
+          const bindings = [];
+          return new Promise((resolve, reject) => {
+            const handleIncomingMessage = (event) => {
+              try {
+                const message = event.data;
+                if (message.type === eventType) {
+                  resolve(message);
+                }
+              } catch (error) {
+                reject(error);
+              }
+            };
+            bindings.push(
+              this.context.events.addListener(
+                navigator.serviceWorker,
+                "message",
+                handleIncomingMessage
+              ),
+              this.context.events.addListener(
+                navigator.serviceWorker,
+                "messageerror",
+                reject
+              )
+            );
+          }).finally(() => {
+            bindings.forEach((unbind) => unbind());
+          });
+        }
+      },
+      supports: {
+        serviceWorkerApi: !("serviceWorker" in navigator) || location.protocol === "file:",
+        readableStreamTransfer: supportsReadableStreamTransfer()
+      }
+    };
+    Object.defineProperties(context, {
+      requestHandlers: {
+        get: () => this.currentHandlers
+      }
+    });
+    this.startHandler = context.supports.serviceWorkerApi ? createFallbackStart(context) : createStartHandler(context);
+    this.stopHandler = context.supports.serviceWorkerApi ? createFallbackStop(context) : createStop(context);
+    return context;
+  }
+  start() {
+    return __async(this, arguments, function* (options = {}) {
+      this.context.startOptions = mergeRight2(
+        DEFAULT_START_OPTIONS,
+        options
+      );
+      return yield this.startHandler(this.context.startOptions, options);
+    });
+  }
+  stop() {
+    super.dispose();
+    this.context.events.removeAllListeners();
+    this.context.emitter.removeAllListeners();
+    this.stopHandler();
+  }
+};
+function setupWorker(...handlers) {
+  return new SetupWorkerApi(...handlers);
+}
+export {
+  SetupWorkerApi,
+  setupWorker
+};