msw 2.11.3 → 2.11.5

package/lib/shims/statuses.mjs

@@ -0,0 +1,187 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/codes.json
+var require_codes = __commonJS({
+  "node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/codes.json"(exports, module) {
+    module.exports = {
+      "100": "Continue",
+      "101": "Switching Protocols",
+      "102": "Processing",
+      "103": "Early Hints",
+      "200": "OK",
+      "201": "Created",
+      "202": "Accepted",
+      "203": "Non-Authoritative Information",
+      "204": "No Content",
+      "205": "Reset Content",
+      "206": "Partial Content",
+      "207": "Multi-Status",
+      "208": "Already Reported",
+      "226": "IM Used",
+      "300": "Multiple Choices",
+      "301": "Moved Permanently",
+      "302": "Found",
+      "303": "See Other",
+      "304": "Not Modified",
+      "305": "Use Proxy",
+      "307": "Temporary Redirect",
+      "308": "Permanent Redirect",
+      "400": "Bad Request",
+      "401": "Unauthorized",
+      "402": "Payment Required",
+      "403": "Forbidden",
+      "404": "Not Found",
+      "405": "Method Not Allowed",
+      "406": "Not Acceptable",
+      "407": "Proxy Authentication Required",
+      "408": "Request Timeout",
+      "409": "Conflict",
+      "410": "Gone",
+      "411": "Length Required",
+      "412": "Precondition Failed",
+      "413": "Payload Too Large",
+      "414": "URI Too Long",
+      "415": "Unsupported Media Type",
+      "416": "Range Not Satisfiable",
+      "417": "Expectation Failed",
+      "418": "I'm a Teapot",
+      "421": "Misdirected Request",
+      "422": "Unprocessable Entity",
+      "423": "Locked",
+      "424": "Failed Dependency",
+      "425": "Too Early",
+      "426": "Upgrade Required",
+      "428": "Precondition Required",
+      "429": "Too Many Requests",
+      "431": "Request Header Fields Too Large",
+      "451": "Unavailable For Legal Reasons",
+      "500": "Internal Server Error",
+      "501": "Not Implemented",
+      "502": "Bad Gateway",
+      "503": "Service Unavailable",
+      "504": "Gateway Timeout",
+      "505": "HTTP Version Not Supported",
+      "506": "Variant Also Negotiates",
+      "507": "Insufficient Storage",
+      "508": "Loop Detected",
+      "509": "Bandwidth Limit Exceeded",
+      "510": "Not Extended",
+      "511": "Network Authentication Required"
+    };
+  }
+});
+
+// node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/index.js
+var require_statuses = __commonJS({
+  "node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/index.js"(exports, module) {
+    "use strict";
+    var codes = require_codes();
+    module.exports = status;
+    status.message = codes;
+    status.code = createMessageToStatusCodeMap(codes);
+    status.codes = createStatusCodeList(codes);
+    status.redirect = {
+      300: true,
+      301: true,
+      302: true,
+      303: true,
+      305: true,
+      307: true,
+      308: true
+    };
+    status.empty = {
+      204: true,
+      205: true,
+      304: true
+    };
+    status.retry = {
+      502: true,
+      503: true,
+      504: true
+    };
+    function createMessageToStatusCodeMap(codes2) {
+      var map = {};
+      Object.keys(codes2).forEach(function forEachCode(code) {
+        var message2 = codes2[code];
+        var status2 = Number(code);
+        map[message2.toLowerCase()] = status2;
+      });
+      return map;
+    }
+    function createStatusCodeList(codes2) {
+      return Object.keys(codes2).map(function mapCode(code) {
+        return Number(code);
+      });
+    }
+    function getStatusCode(message2) {
+      var msg = message2.toLowerCase();
+      if (!Object.prototype.hasOwnProperty.call(status.code, msg)) {
+        throw new Error('invalid status message: "' + message2 + '"');
+      }
+      return status.code[msg];
+    }
+    function getStatusMessage(code) {
+      if (!Object.prototype.hasOwnProperty.call(status.message, code)) {
+        throw new Error("invalid status code: " + code);
+      }
+      return status.message[code];
+    }
+    function status(code) {
+      if (typeof code === "number") {
+        return getStatusMessage(code);
+      }
+      if (typeof code !== "string") {
+        throw new TypeError("code must be a number or string");
+      }
+      var n = parseInt(code, 10);
+      if (!isNaN(n)) {
+        return getStatusMessage(n);
+      }
+      return getStatusCode(code);
+    }
+  }
+});
+
+// src/shims/statuses.ts
+var allStatuses = __toESM(require_statuses(), 1);
+var statuses = allStatuses.default || allStatuses;
+var message = statuses.message;
+var statuses_default = statuses;
+export {
+  statuses_default as default,
+  message
+};
+/*! Bundled license information:
+
+statuses/index.js:
+  (*!
+   * statuses
+   * Copyright(c) 2014 Jonathan Ong
+   * Copyright(c) 2016 Douglas Christopher Wilson
+   * MIT Licensed
+   *)
+*/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "2.11.3",
+  "version": "2.11.5",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "type": "commonjs",
   "main": "./lib/core/index.js",
@@ -214,13 +214,11 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@bundled-es-modules/cookie": "^2.0.1",
-    "@bundled-es-modules/statuses": "^1.0.1",
     "@inquirer/confirm": "^5.0.0",
     "@mswjs/interceptors": "^0.39.1",
     "@open-draft/deferred-promise": "^2.2.0",
-    "@types/cookie": "^0.6.0",
     "@types/statuses": "^2.0.4",
+    "cookie": "^1.0.2",
     "graphql": "^16.8.1",
     "headers-polyfill": "^4.0.2",
     "is-node-process": "^1.2.0",
@@ -228,6 +226,7 @@
     "path-to-regexp": "^6.3.0",
     "picocolors": "^1.1.1",
     "rettime": "^0.7.0",
+    "statuses": "^2.0.2",
     "strict-event-emitter": "^0.5.1",
     "tough-cookie": "^6.0.0",
     "type-fest": "^4.26.1",
@@ -242,7 +241,7 @@
     "@fastify/websocket": "^8.3.1",
     "@graphql-typed-document-node/core": "^3.2.0",
     "@open-draft/test-server": "^0.4.2",
-    "@ossjs/release": "^0.8.1",
+    "@ossjs/release": "^0.10.0",
     "@playwright/test": "^1.48.0",
     "@swc/core": "^1.13.5",
     "@types/eslint__js": "^8.42.3",
@@ -287,7 +286,7 @@
     "vitest-environment-miniflare": "^2.14.4",
     "webpack": "^5.95.0",
     "webpack-http-server": "^0.5.0",
-    "msw": "2.11.3"
+    "msw": "2.11.5"
   },
   "peerDependencies": {
     "typescript": ">= 4.8.x"

package/src/browser/setupWorker/glossary.ts

@@ -1,4 +1,5 @@
 import { Emitter } from 'strict-event-emitter'
+import type { HttpRequestEventMap, Interceptor } from '@mswjs/interceptors'
 import type { DeferredPromise } from '@open-draft/deferred-promise'
 import {
   LifeCycleEventEmitter,
@@ -6,7 +7,6 @@ import {
   SharedOptions,
 } from '~/core/sharedOptions'
 import { RequestHandler } from '~/core/handlers/RequestHandler'
-import type { HttpRequestEventMap, Interceptor } from '@mswjs/interceptors'
 import type { RequiredDeep } from '~/core/typeUtils'
 import type { WebSocketHandler } from '~/core/handlers/WebSocketHandler'
 import type { WorkerChannel } from '../utils/workerChannel'
@@ -25,10 +25,6 @@ export type SetupWorkerInternalContext = {
   emitter: Emitter<LifeCycleEventsMap>
   keepAliveInterval?: number
   workerChannel: WorkerChannel
-  supports: {
-    serviceWorkerApi: boolean
-    readableStreamTransfer: boolean
-  }
   fallbackInterceptor?: Interceptor<HttpRequestEventMap>
 }
 

package/src/browser/setupWorker/setupWorker.ts

@@ -1,5 +1,6 @@
 import { invariant } from 'outvariant'
 import { isNodeProcess } from 'is-node-process'
+import { DeferredPromise } from '@open-draft/deferred-promise'
 import type {
   SetupWorkerInternalContext,
   StartReturnType,
@@ -14,15 +15,14 @@ import { SetupApi } from '~/core/SetupApi'
 import { mergeRight } from '~/core/utils/internal/mergeRight'
 import type { LifeCycleEventsMap } from '~/core/sharedOptions'
 import type { WebSocketHandler } from '~/core/handlers/WebSocketHandler'
-import { supportsReadableStreamTransfer } from '../utils/supportsReadableStreamTransfer'
 import { webSocketInterceptor } from '~/core/ws/webSocketInterceptor'
 import { handleWebSocketEvent } from '~/core/ws/handleWebSocketEvent'
 import { attachWebSocketLogger } from '~/core/ws/utils/attachWebSocketLogger'
 import { WorkerChannel } from '../utils/workerChannel'
-import { DeferredPromise } from '@open-draft/deferred-promise'
 import { createFallbackRequestListener } from './start/createFallbackRequestListener'
 import { printStartMessage } from './start/utils/printStartMessage'
 import { printStopMessage } from './stop/utils/printStopMessage'
+import { supportsServiceWorker } from '../utils/supports'
 
 export class SetupWorkerApi
   extends SetupApi<LifeCycleEventsMap>
@@ -60,11 +60,6 @@ export class SetupWorkerApi
       workerChannel: new WorkerChannel({
         worker: workerPromise,
       }),
-      supports: {
-        serviceWorkerApi:
-          'serviceWorker' in navigator && location.protocol !== 'file:',
-        readableStreamTransfer: supportsReadableStreamTransfer(),
-      },
     }
   }
 
@@ -117,7 +112,7 @@ export class SetupWorkerApi
 
     // Use a fallback interception algorithm in the environments
     // where the Service Worker API isn't supported.
-    if (!this.context.supports.serviceWorkerApi) {
+    if (!supportsServiceWorker()) {
       const fallbackInterceptor = createFallbackRequestListener(
         this.context,
         this.context.startOptions,
@@ -159,7 +154,7 @@ export class SetupWorkerApi
     this.context.workerStoppedAt = Date.now()
     this.context.emitter.removeAllListeners()
 
-    if (this.context.supports.serviceWorkerApi) {
+    if (supportsServiceWorker()) {
       this.context.workerChannel.removeAllListeners('RESPONSE')
       window.clearInterval(this.context.keepAliveInterval)
     }

package/src/browser/setupWorker/start/createRequestListener.ts

@@ -1,6 +1,7 @@
 import { Emitter } from 'rettime'
 import { StartOptions, SetupWorkerInternalContext } from '../glossary'
 import { deserializeRequest } from '../../utils/deserializeRequest'
+import { supportsReadableStreamTransfer } from '../../utils/supports'
 import { RequestHandler } from '~/core/handlers/RequestHandler'
 import { handleRequest } from '~/core/utils/handleRequest'
 import { RequiredDeep } from '~/core/typeUtils'
@@ -8,6 +9,8 @@ import { devUtils } from '~/core/utils/internal/devUtils'
 import { toResponseInit } from '~/core/utils/toResponseInit'
 import { isHandlerKind } from '~/core/utils/internal/isHandlerKind'
 
+const SUPPORTS_READABLE_STREAM_TRANSFER = supportsReadableStreamTransfer()
+
 export const createRequestListener = (
   context: SetupWorkerInternalContext,
   options: RequiredDeep<StartOptions>,
@@ -58,7 +61,7 @@ export const createRequestListener = (
              * @note Safari doesn't support transferring a "ReadableStream".
              * Check that the browser supports that before sending it to the worker.
              */
-            if (context.supports.readableStreamTransfer) {
+            if (SUPPORTS_READABLE_STREAM_TRANSFER) {
               const responseStreamOrNull = response.body
 
               event.postMessage(

package/src/browser/utils/{supportsReadableStreamTransfer.ts → supports.ts}

@@ -1,3 +1,16 @@
+/**
+ * Checks if the Service Worker API is supproted and available
+ * in the current browsing context.
+ */
+export function supportsServiceWorker(): boolean {
+  return (
+    typeof navigator !== 'undefined' &&
+    'serviceWorker' in navigator &&
+    typeof location !== 'undefined' &&
+    location.protocol !== 'file:'
+  )
+}
+
 /**
  * Returns a boolean indicating whether the current browser
  * supports `ReadableStream` as a `Transferable` when posting

package/src/browser/utils/workerChannel.ts

@@ -1,6 +1,8 @@
+import { invariant } from 'outvariant'
 import { Emitter, TypedEvent } from 'rettime'
 import { isObject } from '~/core/utils/internal/isObject'
 import type { StringifiedResponse } from '../setupWorker/glossary'
+import { supportsServiceWorker } from '../utils/supports'
 
 export interface WorkerChannelOptions {
   worker: Promise<ServiceWorker>
@@ -65,6 +67,8 @@ export type WorkerEventResponse = {
   PASSTHROUGH: []
 }
 
+const SUPPORTS_SERVICE_WORKER = supportsServiceWorker()
+
 export class WorkerEvent<
   DataType,
   ReturnType = any,
@@ -121,6 +125,10 @@ export class WorkerChannel extends Emitter<WorkerChannelEventMap> {
   constructor(protected readonly options: WorkerChannelOptions) {
     super()
 
+    if (!SUPPORTS_SERVICE_WORKER) {
+      return
+    }
+
     navigator.serviceWorker.addEventListener('message', async (event) => {
       const worker = await this.options.worker
 
@@ -139,6 +147,11 @@ export class WorkerChannel extends Emitter<WorkerChannelEventMap> {
    * This triggers the `message` event listener on ServiceWorkerGlobalScope.
    */
   public postMessage(type: OutgoingWorkerEvents): void {
+    invariant(
+      SUPPORTS_SERVICE_WORKER,
+      'Failed to post message on a WorkerChannel: the Service Worker API is unavailable in this context. This is likely an issue with MSW. Please report it on GitHub: https://github.com/mswjs/msw/issues',
+    )
+
     this.options.worker.then((worker) => {
       worker.postMessage(type)
     })

package/src/core/HttpResponse.ts

@@ -17,6 +17,7 @@ export type DefaultUnsafeFetchResponse = Response & {
 
 export interface StrictRequest<BodyType extends JsonBodyType> extends Request {
   json(): Promise<BodyType>
+  clone(): StrictRequest<BodyType>
 }
 
 /**

package/src/core/handlers/HttpHandler.ts

@@ -13,7 +13,7 @@ import {
 } from '../utils/matching/matchRequestUrl'
 import { toPublicUrl } from '../utils/request/toPublicUrl'
 import { getAllRequestCookies } from '../utils/request/getRequestCookies'
-import { cleanUrl, getSearchParams } from '../utils/url/cleanUrl'
+import { cleanUrl } from '../utils/url/cleanUrl'
 import {
   RequestHandler,
   RequestHandlerDefaultInfo,
@@ -115,13 +115,6 @@ export class HttpHandler extends RequestHandler<
       return
     }
 
-    const searchParams = getSearchParams(path)
-    const queryParams: Array<string> = []
-
-    searchParams.forEach((_, paramName) => {
-      queryParams.push(paramName)
-    })
-
     devUtils.warn(
       `Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead and access query parameters using "new URL(request.url).searchParams" instead. Learn more: https://mswjs.io/docs/http/intercepting-requests#querysearch-parameters`,
     )

package/src/core/index.ts

@@ -20,6 +20,11 @@ export {
 /* Utils */
 export { matchRequestUrl } from './utils/matching/matchRequestUrl'
 export * from './utils/handleRequest'
+export {
+  onUnhandledRequest,
+  type UnhandledRequestStrategy,
+  type UnhandledRequestCallback,
+} from './utils/request/onUnhandledRequest'
 export { getResponse } from './getResponse'
 export { cleanUrl } from './utils/url/cleanUrl'
 

package/src/core/utils/HttpResponse/decorators.ts

@@ -1,4 +1,4 @@
-import statuses from '@bundled-es-modules/statuses'
+import statuses from '../../../shims/statuses'
 import { Headers as HeadersPolyfill } from 'headers-polyfill'
 import type { HttpResponseInit } from '../../HttpResponse'
 

package/src/core/utils/logging/serializeResponse.ts

@@ -1,4 +1,4 @@
-import statuses from '@bundled-es-modules/statuses'
+import statuses from '../../../shims/statuses'
 
 const { message } = statuses
 

package/src/core/utils/request/getRequestCookies.ts

@@ -1,8 +1,11 @@
-import cookieUtils from '@bundled-es-modules/cookie'
+import {
+  parse as parseCookie,
+  serialize as serializeCookie,
+} from '../../../shims/cookie'
 import { cookieStore } from '../cookieStore'
 
 function parseCookies(input: string): Record<string, string> {
-  const parsedCookies = cookieUtils.parse(input)
+  const parsedCookies = parseCookie(input)
   const cookies: Record<string, string> = {}
 
   for (const cookieName in parsedCookies) {
@@ -62,7 +65,7 @@ export function getAllRequestCookies(request: Request): Record<string, string> {
   for (const name in cookiesFromDocument) {
     request.headers.append(
       'cookie',
-      cookieUtils.serialize(name, cookiesFromDocument[name]),
+      serializeCookie(name, cookiesFromDocument[name]),
     )
   }
 

package/src/core/utils/url/cleanUrl.ts

@@ -1,9 +1,5 @@
 const REDUNDANT_CHARACTERS_EXP = /[?|#].*$/g
 
-export function getSearchParams(path: string) {
-  return new URL(`/${path}`, 'http://localhost').searchParams
-}
-
 /**
  * Removes search parameters and the fragment
  * from a given URL string.

package/src/core/ws/WebSocketIndexedDBClientStore.ts

@@ -1,5 +1,5 @@
 import { DeferredPromise } from '@open-draft/deferred-promise'
-import { WebSocketClientConnectionProtocol } from '@mswjs/interceptors/lib/browser/interceptors/WebSocket'
+import { WebSocketClientConnectionProtocol } from '@mswjs/interceptors/WebSocket'
 import {
   type SerializedWebSocketClient,
   WebSocketClientStore,

package/src/core/ws/WebSocketMemoryClientStore.ts

@@ -1,4 +1,4 @@
-import { WebSocketClientConnectionProtocol } from '@mswjs/interceptors/lib/browser/interceptors/WebSocket'
+import { WebSocketClientConnectionProtocol } from '@mswjs/interceptors/WebSocket'
 import {
   SerializedWebSocketClient,
   WebSocketClientStore,

package/src/core/ws/handleWebSocketEvent.ts

@@ -1,4 +1,4 @@
-import type { WebSocketConnectionData } from '@mswjs/interceptors/lib/browser/interceptors/WebSocket'
+import type { WebSocketConnectionData } from '@mswjs/interceptors/WebSocket'
 import { RequestHandler } from '../handlers/RequestHandler'
 import { WebSocketHandler } from '../handlers/WebSocketHandler'
 import { webSocketInterceptor } from './webSocketInterceptor'

package/src/core/ws/utils/getMessageLength.ts

@@ -1,4 +1,4 @@
-import type { WebSocketData } from '@mswjs/interceptors/lib/browser/interceptors/WebSocket'
+import type { WebSocketData } from '@mswjs/interceptors/WebSocket'
 
 /**
  * Returns the byte length of the given WebSocket message.

package/src/mockServiceWorker.js

@@ -205,6 +205,7 @@ async function resolveMainClient(event) {
  * @param {FetchEvent} event
  * @param {Client | undefined} client
  * @param {string} requestId
+ * @param {number} requestInterceptedAt
  * @returns {Promise<Response>}
  */
 async function getResponse(event, client, requestId, requestInterceptedAt) {

package/src/shims/cookie.ts

@@ -0,0 +1,7 @@
+import * as allCookie from 'cookie'
+const cookie = (allCookie as any).default || allCookie
+
+export const parse = cookie.parse as typeof import('cookie').parse
+export const serialize = cookie.serialize as typeof import('cookie').serialize
+
+export default cookie

package/src/shims/statuses.ts

@@ -0,0 +1,6 @@
+import * as allStatuses from 'statuses'
+const statuses = (allStatuses as any).default || allStatuses
+
+export const message = statuses.message as typeof import('statuses').message
+
+export default statuses

package/src/tsconfig.src.json

@@ -3,12 +3,7 @@
   // living in the "src" directory.
   "extends": "../tsconfig.base.json",
   "compilerOptions": {
-    "composite": true,
-    "baseUrl": "./",
-    "paths": {
-      "~/core": ["core"],
-      "~/core/*": ["core/*"]
-    }
+    "composite": true
   },
   "include": ["../global.d.ts", "./**/*.ts"],
   "exclude": ["./**/*.test.ts"]

package/src/browser/utils/deferNetworkRequestsUntil.test.ts

@@ -1,48 +0,0 @@
-/**
- * @vitest-environment jsdom
- */
-import { deferNetworkRequestsUntil } from './deferNetworkRequestsUntil'
-
-beforeAll(() => {
-  // Stubs native `fetch` function to remove any external
-  // asynchronicity from this test suite.
-  window.fetch = vi.fn().mockImplementation(() => {
-    return Promise.resolve({
-      json: () => ({
-        response: 'body',
-      }),
-    })
-  })
-})
-
-afterAll(() => {
-  vi.restoreAllMocks()
-})
-
-test('defers any requests that happen while a given promise is pending', async () => {
-  const events: string[] = []
-
-  // Emulate a Service Worker registration Promise.
-  const workerPromise = new Promise<null>((resolve) => {
-    setTimeout(resolve, 1000)
-  })
-
-  workerPromise.then(() => {
-    events.push('promise resolved')
-  })
-
-  // Calling this functions intercepts all requests that happen while
-  // the given promise is pending, and defers their execution
-  // until the promise is resolved.
-  deferNetworkRequestsUntil(workerPromise)
-
-  // Perform a request.
-  const requestPromise = fetch('/user').then(() => {
-    events.push('response received')
-  })
-
-  await Promise.all([workerPromise, requestPromise])
-
-  // Assert the order of resolved events.
-  expect(events).toEqual(['promise resolved', 'response received'])
-})

package/src/browser/utils/deferNetworkRequestsUntil.ts

@@ -1,29 +0,0 @@
-import { until } from 'until-async'
-
-/**
- * Intercepts and defers any requests on the page
- * until the Service Worker instance is ready.
- * Must only be used in a browser.
- */
-export function deferNetworkRequestsUntil(predicatePromise: Promise<any>) {
-  // Defer any `XMLHttpRequest` requests until the Service Worker is ready.
-  const originalXhrSend = window.XMLHttpRequest.prototype.send
-  window.XMLHttpRequest.prototype.send = function (
-    ...args: Parameters<XMLHttpRequest['send']>
-  ) {
-    // Keep this function synchronous to comply with `XMLHttpRequest.prototype.send`,
-    // because that method is always synchronous.
-    until(() => predicatePromise).then(() => {
-      window.XMLHttpRequest.prototype.send = originalXhrSend
-      this.send(...args)
-    })
-  }
-
-  // Defer any `fetch` requests until the Service Worker is ready.
-  const originalFetch = window.fetch
-  window.fetch = async (...args) => {
-    await until(() => predicatePromise)
-    window.fetch = originalFetch
-    return window.fetch(...args)
-  }
-}