msw 0.43.1 → 0.44.0

package/lib/index.d.ts

@@ -1,10 +1,10 @@
-import { R as ResponseTransformer, s as status, a as set, d as delay, f as fetch, b as RequestHandler, S as SetupWorkerApi, D as DefaultContext, c as DefaultBodyType, M as MockedRequest, e as ResponseResolver, g as ResponseResolutionContext, h as SerializedResponse, i as RequestHandlerDefaultInfo, j as MockedResponse, k as ResponseLookupResult, l as SharedOptions, m as ServerLifecycleEventsMap } from './glossary-58eca5a8.js';
-export { A as AsyncResponseResolverReturnType, c as DefaultBodyType, u as DefaultRequestMultipartBody, y as DelayMode, M as MockedRequest, j as MockedResponse, b as RequestHandler, v as ResponseComposition, w as ResponseCompositionOptions, x as ResponseFunction, e as ResponseResolver, t as ResponseResolverReturnType, R as ResponseTransformer, S as SetupWorkerApi, l as SharedOptions, q as StartOptions, o as createResponseComposition, p as defaultContext, n as defaultResponse, r as response } from './glossary-58eca5a8.js';
+import { R as ResponseTransformer, s as status, a as set, d as delay, f as fetch, b as RequestHandler, S as SetupWorkerApi, D as DefaultContext, c as DefaultBodyType, M as MockedRequest, e as ResponseResolver, g as ResponseResolutionContext, h as SerializedResponse, i as RequestHandlerDefaultInfo, j as MockedResponse, k as ResponseLookupResult, l as SharedOptions, m as ServerLifecycleEventsMap } from './glossary-17949ef9.js';
+export { A as AsyncResponseResolverReturnType, c as DefaultBodyType, u as DefaultRequestMultipartBody, y as DelayMode, M as MockedRequest, H as MockedRequestInit, j as MockedResponse, z as RequestCache, E as RequestDestination, b as RequestHandler, B as RequestMode, F as RequestPriority, C as RequestRedirect, G as RequestReferrerPolicy, v as ResponseComposition, w as ResponseCompositionOptions, x as ResponseFunction, e as ResponseResolver, t as ResponseResolverReturnType, R as ResponseTransformer, S as SetupWorkerApi, l as SharedOptions, q as StartOptions, o as createResponseComposition, p as defaultContext, n as defaultResponse, r as response } from './glossary-17949ef9.js';
 import * as cookieUtils from 'cookie';
 import { GraphQLError, OperationTypeNode, DocumentNode } from 'graphql';
 import { StrictEventEmitter } from 'strict-event-emitter';
-import { IsomorphicRequest } from '@mswjs/interceptors';
 import 'type-fest';
+import '@mswjs/interceptors';
 import 'headers-polyfill';
 
 declare type Path = string | RegExp;
@@ -155,10 +155,11 @@ declare const restContext: RestContext;
 declare type RequestQuery = {
     [queryName: string]: string;
 };
-interface RestRequest<BodyType extends DefaultBodyType = DefaultBodyType, ParamsType extends PathParams = PathParams> extends MockedRequest<BodyType> {
-    params: ParamsType;
-}
 declare type ParsedRestRequest = Match;
+declare class RestRequest<RequestBody extends DefaultBodyType = DefaultBodyType, RequestParams extends PathParams = PathParams> extends MockedRequest<RequestBody> {
+    readonly params: RequestParams;
+    constructor(request: MockedRequest<RequestBody>, params: RequestParams);
+}
 /**
  * Request handler for REST API requests.
  * Provides request matching based on method and URL.
@@ -225,8 +226,9 @@ interface GraphQLJsonRequestBody<Variables extends GraphQLVariables> {
     query: string;
     variables?: Variables;
 }
-interface GraphQLRequest<Variables extends GraphQLVariables> extends MockedRequest<GraphQLRequestBody<Variables>> {
-    variables: Variables;
+declare class GraphQLRequest<Variables extends GraphQLVariables> extends MockedRequest<GraphQLRequestBody<Variables>> {
+    readonly variables: Variables;
+    constructor(request: MockedRequest, variables: Variables);
 }
 declare class GraphQLHandler<Request extends GraphQLRequest<any> = GraphQLRequest<any>> extends RequestHandler<GraphQLHandlerInfo, Request, ParsedGraphQLRequest | null, GraphQLRequest<any>> {
     private endpoint;
@@ -349,14 +351,9 @@ interface HandleRequestOptions<ResponseType> {
 }
 declare function handleRequest<ResponseType extends Record<string, any> = MockedResponse<string>>(request: MockedRequest, handlers: RequestHandler[], options: RequiredDeep<SharedOptions>, emitter: StrictEventEmitter<ServerLifecycleEventsMap>, handleRequestOptions?: HandleRequestOptions<ResponseType>): Promise<ResponseType | undefined>;
 
-/**
- * Converts a given isomorphic request to a `MockedRequest` instance.
- */
-declare function parseIsomorphicRequest(request: IsomorphicRequest): MockedRequest;
-
 /**
  * Removes query parameters and hashes from a given URL string.
  */
 declare function cleanUrl(path: string): string;
 
-export { GraphQLContext, GraphQLHandler, GraphQLJsonRequestBody, GraphQLRequest, GraphQLRequestBody, GraphQLVariables, HandleRequestOptions, Match, ParsedGraphQLRequest, ParsedRestRequest, Path, PathParams, RESTMethods, RequestQuery, RestContext, RestHandler, RestRequest, cleanUrl, compose, index as context, graphql, graphqlContext, handleRequest, matchRequestUrl, parseIsomorphicRequest, rest, restContext, setupWorker };
+export { GraphQLContext, GraphQLHandler, GraphQLJsonRequestBody, GraphQLRequest, GraphQLRequestBody, GraphQLVariables, HandleRequestOptions, Match, ParsedGraphQLRequest, ParsedRestRequest, Path, PathParams, RESTMethods, RequestQuery, RestContext, RestHandler, RestRequest, cleanUrl, compose, index as context, graphql, graphqlContext, handleRequest, matchRequestUrl, rest, restContext, setupWorker };

package/lib/index.js

@@ -52,6 +52,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   GraphQLHandler: () => GraphQLHandler,
+  MockedRequest: () => MockedRequest,
   RESTMethods: () => RESTMethods,
   RequestHandler: () => RequestHandler,
   RestHandler: () => RestHandler,
@@ -65,7 +66,6 @@ __export(src_exports, {
   graphqlContext: () => graphqlContext,
   handleRequest: () => handleRequest,
   matchRequestUrl: () => matchRequestUrl,
-  parseIsomorphicRequest: () => parseIsomorphicRequest,
   response: () => response,
   rest: () => rest,
   restContext: () => restContext,
@@ -446,166 +446,15 @@ var NetworkError = class extends Error {
 };
 
 // src/utils/request/parseWorkerRequest.ts
-var import_headers_polyfill6 = require("headers-polyfill");
-
-// src/handlers/RequestHandler.ts
+var import_interceptors2 = require("@mswjs/interceptors");
 var import_headers_polyfill4 = require("headers-polyfill");
 
-// src/response.ts
-var import_headers_polyfill3 = require("headers-polyfill");
-
-// src/utils/internal/compose.ts
-function compose(...fns) {
-  return (...args) => {
-    return fns.reduceRight((leftFn, rightFn) => {
-      return leftFn instanceof Promise ? Promise.resolve(leftFn).then(rightFn) : rightFn(leftFn);
-    }, args[0]);
-  };
-}
-
-// src/response.ts
-var defaultResponse = {
-  status: 200,
-  statusText: "OK",
-  body: null,
-  delay: 0,
-  once: false,
-  passthrough: false
-};
-var defaultResponseTransformers = [];
-function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
-  return async (...transformers) => {
-    const initialResponse = Object.assign({}, defaultResponse, {
-      headers: new import_headers_polyfill3.Headers({
-        "x-powered-by": "msw"
-      })
-    }, responseOverrides);
-    const resolvedTransformers = [
-      ...defaultTransformers,
-      ...transformers
-    ].filter(Boolean);
-    const resolvedResponse = resolvedTransformers.length > 0 ? compose(...resolvedTransformers)(initialResponse) : initialResponse;
-    return resolvedResponse;
-  };
-}
-var response = Object.assign(createResponseComposition(), {
-  once: createResponseComposition({ once: true }),
-  networkError(message) {
-    throw new NetworkError(message);
-  }
-});
-
-// src/utils/internal/getCallFrame.ts
-var SOURCE_FRAME = /\/msw\/src\/(.+)/;
-var BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
-function getCallFrame(error2) {
-  const stack = error2.stack;
-  if (!stack) {
-    return;
-  }
-  const frames = stack.split("\n").slice(1);
-  const declarationFrame = frames.find((frame) => {
-    return !(SOURCE_FRAME.test(frame) || BUILD_FRAME.test(frame));
-  });
-  if (!declarationFrame) {
-    return;
-  }
-  const declarationPath = declarationFrame.replace(/\s*at [^()]*\(([^)]+)\)/, "$1").replace(/^@/, "");
-  return declarationPath;
-}
-
-// src/utils/internal/isIterable.ts
-function isIterable(fn) {
-  if (!fn) {
-    return false;
-  }
-  return typeof fn[Symbol.iterator] == "function";
-}
-
-// src/handlers/RequestHandler.ts
-var defaultContext = {
-  status,
-  set,
-  delay,
-  fetch
-};
-var RequestHandler = class {
-  constructor(options) {
-    this.shouldSkip = false;
-    this.ctx = options.ctx || defaultContext;
-    this.resolver = options.resolver;
-    const callFrame = getCallFrame(new Error());
-    this.info = __spreadProps(__spreadValues({}, options.info), {
-      callFrame
-    });
-  }
-  parse(_request, _resolutionContext) {
-    return null;
-  }
-  test(request, resolutionContext) {
-    return this.predicate(request, this.parse(request, resolutionContext), resolutionContext);
-  }
-  getPublicRequest(request, _parsedResult) {
-    return request;
-  }
-  markAsSkipped(shouldSkip = true) {
-    this.shouldSkip = shouldSkip;
-  }
-  async run(request, resolutionContext) {
-    if (this.shouldSkip) {
-      return null;
-    }
-    const parsedResult = this.parse(request, resolutionContext);
-    const shouldIntercept = this.predicate(request, parsedResult, resolutionContext);
-    if (!shouldIntercept) {
-      return null;
-    }
-    const publicRequest = this.getPublicRequest(request, parsedResult);
-    const executeResolver = this.wrapResolver(this.resolver);
-    const mockedResponse = await executeResolver(publicRequest, response, this.ctx);
-    return this.createExecutionResult(parsedResult, publicRequest, mockedResponse);
-  }
-  wrapResolver(resolver) {
-    return async (req, res, ctx) => {
-      const result = this.resolverGenerator || await resolver(req, res, ctx);
-      if (isIterable(result)) {
-        const { value, done } = result[Symbol.iterator]().next();
-        const nextResponse = await value;
-        if (!nextResponse && done) {
-          return this.resolverGeneratorResult;
-        }
-        if (!this.resolverGenerator) {
-          this.resolverGenerator = result;
-        }
-        this.resolverGeneratorResult = nextResponse;
-        return nextResponse;
-      }
-      return result;
-    };
-  }
-  createExecutionResult(parsedResult, request, response2) {
-    return {
-      handler: this,
-      parsedResult: parsedResult || null,
-      request,
-      response: response2 || null
-    };
-  }
-};
-function passthrough() {
-  return {
-    status: 101,
-    statusText: "Continue",
-    headers: new import_headers_polyfill4.Headers(),
-    body: null,
-    passthrough: true,
-    once: false
-  };
-}
-
-// src/utils/request/setRequestCookies.ts
+// src/utils/request/MockedRequest.ts
 var cookieUtils3 = __toESM(require("cookie"));
 var import_cookies = require("@mswjs/cookies");
+var import_interceptors = require("@mswjs/interceptors");
+var import_bufferUtils = require("@mswjs/interceptors/lib/utils/bufferUtils");
+var import_lib = require("headers-polyfill/lib");
 
 // src/utils/request/getRequestCookies.ts
 var cookieUtils2 = __toESM(require("cookie"));
@@ -629,28 +478,11 @@ function getRequestCookies(request) {
   }
 }
 
-// src/utils/request/setRequestCookies.ts
-function setRequestCookies(request) {
-  var _a;
-  const requestCookiesString = request.headers.get("cookie");
-  import_cookies.store.hydrate();
-  const cookiesFromStore = Array.from((_a = import_cookies.store.get(__spreadProps(__spreadValues({}, request), { url: request.url.toString() }))) == null ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => {
-    return Object.assign(cookies, { [name.trim()]: value });
-  }, {});
-  const cookiesFromDocument = getRequestCookies(request);
-  const forwardedCookies = __spreadValues(__spreadValues({}, cookiesFromDocument), cookiesFromStore);
-  for (const [name, value] of Object.entries(forwardedCookies)) {
-    request.headers.append("cookie", `${name}=${value}`);
-  }
-  const ownCookies = requestCookiesString ? cookieUtils3.parse(requestCookiesString) : {};
-  request.cookies = __spreadValues(__spreadValues(__spreadValues({}, request.cookies), forwardedCookies), ownCookies);
-}
-
 // src/utils/internal/parseMultipartData.ts
-var import_headers_polyfill5 = require("headers-polyfill");
+var import_headers_polyfill3 = require("headers-polyfill");
 function parseContentHeaders(headersString) {
   var _a, _b;
-  const headers = (0, import_headers_polyfill5.stringToHeaders)(headersString);
+  const headers = (0, import_headers_polyfill3.stringToHeaders)(headersString);
   const contentType = headers.get("content-type") || "text/plain";
   const disposition = headers.get("content-disposition");
   if (!disposition) {
@@ -729,39 +561,74 @@ function isStringEqual(actual, expected) {
   return actual.toLowerCase() === expected.toLowerCase();
 }
 
-// src/utils/request/pruneGetRequestBody.ts
-function pruneGetRequestBody(request) {
-  if (request.method && isStringEqual(request.method, "GET") && request.body === "") {
-    return void 0;
+// src/utils/request/MockedRequest.ts
+var MockedRequest = class extends import_interceptors.IsomorphicRequest {
+  constructor(input, init = {}) {
+    var __super = (...args) => {
+      super(...args);
+    };
+    if (input instanceof import_interceptors.IsomorphicRequest) {
+      __super(input);
+    } else {
+      __super(input, init);
+    }
+    if (init.id) {
+      this.id = init.id;
+    }
+    this.cache = init.cache || "default";
+    this.destination = init.destination || "";
+    this.integrity = init.integrity || "";
+    this.keepalive = init.keepalive || false;
+    this.mode = init.mode || "cors";
+    this.priority = init.priority || "auto";
+    this.redirect = init.redirect || "follow";
+    this.referrer = init.referrer || "";
+    this.referrerPolicy = init.referrerPolicy || "no-referrer";
+    this.cookies = init.cookies || this.getCookies();
+  }
+  get body() {
+    const text2 = (0, import_bufferUtils.decodeBuffer)(this["_body"]);
+    const body2 = parseBody(text2, this.headers);
+    if (isStringEqual(this.method, "GET") && body2 === "") {
+      return void 0;
+    }
+    return body2;
   }
-  return request.body;
-}
+  passthrough() {
+    return {
+      status: 101,
+      statusText: "Continue",
+      headers: new import_lib.Headers(),
+      body: null,
+      passthrough: true,
+      once: false
+    };
+  }
+  getCookies() {
+    var _a;
+    const requestCookiesString = this.headers.get("cookie");
+    const ownCookies = requestCookiesString ? cookieUtils3.parse(requestCookiesString) : {};
+    import_cookies.store.hydrate();
+    const cookiesFromStore = Array.from((_a = import_cookies.store.get(__spreadProps(__spreadValues({}, this), { url: this.url.href }))) == null ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => {
+      return Object.assign(cookies, { [name.trim()]: value });
+    }, {});
+    const cookiesFromDocument = getRequestCookies(this);
+    const forwardedCookies = __spreadValues(__spreadValues({}, cookiesFromDocument), cookiesFromStore);
+    for (const [name, value] of Object.entries(forwardedCookies)) {
+      this.headers.append("cookie", `${name}=${value}`);
+    }
+    return __spreadValues(__spreadValues({}, forwardedCookies), ownCookies);
+  }
+};
 
 // src/utils/request/parseWorkerRequest.ts
 function parseWorkerRequest(rawRequest) {
-  const request = {
-    id: rawRequest.id,
-    cache: rawRequest.cache,
-    credentials: rawRequest.credentials,
-    method: rawRequest.method,
-    url: new URL(rawRequest.url),
-    referrer: rawRequest.referrer,
-    referrerPolicy: rawRequest.referrerPolicy,
-    redirect: rawRequest.redirect,
-    mode: rawRequest.mode,
-    params: {},
-    cookies: {},
-    integrity: rawRequest.integrity,
-    keepalive: rawRequest.keepalive,
-    destination: rawRequest.destination,
-    body: pruneGetRequestBody(rawRequest),
-    bodyUsed: rawRequest.bodyUsed,
-    headers: new import_headers_polyfill6.Headers(rawRequest.headers),
-    passthrough
-  };
-  setRequestCookies(request);
-  request.body = parseBody(request.body, request.headers);
-  return request;
+  const url = new URL(rawRequest.url);
+  const headers = new import_headers_polyfill4.Headers(rawRequest.headers);
+  return new MockedRequest(url, __spreadProps(__spreadValues({}, rawRequest), {
+    body: (0, import_interceptors2.encodeBuffer)(rawRequest.body || ""),
+    headers
+  }));
 }
 
 // src/utils/handleRequest.ts
@@ -940,14 +807,15 @@ function getTimestamp() {
 // src/utils/logging/prepareRequest.ts
 function prepareRequest(request) {
   return __spreadProps(__spreadValues({}, request), {
+    body: request.body,
     headers: request.headers.all()
   });
 }
 
 // src/utils/logging/prepareResponse.ts
-var import_headers_polyfill7 = require("headers-polyfill");
+var import_headers_polyfill5 = require("headers-polyfill");
 function prepareResponse(res) {
-  const responseHeaders = (0, import_headers_polyfill7.objectToHeaders)(res.headers);
+  const responseHeaders = (0, import_headers_polyfill5.objectToHeaders)(res.headers);
   return __spreadProps(__spreadValues({}, res), {
     body: parseBody(res.body, responseHeaders)
   });
@@ -1014,6 +882,151 @@ function matchRequestUrl(url, path, baseUrl) {
   };
 }
 
+// src/handlers/RequestHandler.ts
+var import_headers_polyfill7 = require("headers-polyfill");
+
+// src/response.ts
+var import_headers_polyfill6 = require("headers-polyfill");
+
+// src/utils/internal/compose.ts
+function compose(...fns) {
+  return (...args) => {
+    return fns.reduceRight((leftFn, rightFn) => {
+      return leftFn instanceof Promise ? Promise.resolve(leftFn).then(rightFn) : rightFn(leftFn);
+    }, args[0]);
+  };
+}
+
+// src/response.ts
+var defaultResponse = {
+  status: 200,
+  statusText: "OK",
+  body: null,
+  delay: 0,
+  once: false,
+  passthrough: false
+};
+var defaultResponseTransformers = [];
+function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
+  return async (...transformers) => {
+    const initialResponse = Object.assign({}, defaultResponse, {
+      headers: new import_headers_polyfill6.Headers({
+        "x-powered-by": "msw"
+      })
+    }, responseOverrides);
+    const resolvedTransformers = [
+      ...defaultTransformers,
+      ...transformers
+    ].filter(Boolean);
+    const resolvedResponse = resolvedTransformers.length > 0 ? compose(...resolvedTransformers)(initialResponse) : initialResponse;
+    return resolvedResponse;
+  };
+}
+var response = Object.assign(createResponseComposition(), {
+  once: createResponseComposition({ once: true }),
+  networkError(message) {
+    throw new NetworkError(message);
+  }
+});
+
+// src/utils/internal/getCallFrame.ts
+var SOURCE_FRAME = /\/msw\/src\/(.+)/;
+var BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
+function getCallFrame(error2) {
+  const stack = error2.stack;
+  if (!stack) {
+    return;
+  }
+  const frames = stack.split("\n").slice(1);
+  const declarationFrame = frames.find((frame) => {
+    return !(SOURCE_FRAME.test(frame) || BUILD_FRAME.test(frame));
+  });
+  if (!declarationFrame) {
+    return;
+  }
+  const declarationPath = declarationFrame.replace(/\s*at [^()]*\(([^)]+)\)/, "$1").replace(/^@/, "");
+  return declarationPath;
+}
+
+// src/utils/internal/isIterable.ts
+function isIterable(fn) {
+  if (!fn) {
+    return false;
+  }
+  return typeof fn[Symbol.iterator] == "function";
+}
+
+// src/handlers/RequestHandler.ts
+var defaultContext = {
+  status,
+  set,
+  delay,
+  fetch
+};
+var RequestHandler = class {
+  constructor(options) {
+    this.shouldSkip = false;
+    this.ctx = options.ctx || defaultContext;
+    this.resolver = options.resolver;
+    const callFrame = getCallFrame(new Error());
+    this.info = __spreadProps(__spreadValues({}, options.info), {
+      callFrame
+    });
+  }
+  parse(_request, _resolutionContext) {
+    return null;
+  }
+  test(request, resolutionContext) {
+    return this.predicate(request, this.parse(request, resolutionContext), resolutionContext);
+  }
+  getPublicRequest(request, _parsedResult) {
+    return request;
+  }
+  markAsSkipped(shouldSkip = true) {
+    this.shouldSkip = shouldSkip;
+  }
+  async run(request, resolutionContext) {
+    if (this.shouldSkip) {
+      return null;
+    }
+    const parsedResult = this.parse(request, resolutionContext);
+    const shouldIntercept = this.predicate(request, parsedResult, resolutionContext);
+    if (!shouldIntercept) {
+      return null;
+    }
+    const publicRequest = this.getPublicRequest(request, parsedResult);
+    const executeResolver = this.wrapResolver(this.resolver);
+    const mockedResponse = await executeResolver(publicRequest, response, this.ctx);
+    return this.createExecutionResult(parsedResult, publicRequest, mockedResponse);
+  }
+  wrapResolver(resolver) {
+    return async (req, res, ctx) => {
+      const result = this.resolverGenerator || await resolver(req, res, ctx);
+      if (isIterable(result)) {
+        const { value, done } = result[Symbol.iterator]().next();
+        const nextResponse = await value;
+        if (!nextResponse && done) {
+          return this.resolverGeneratorResult;
+        }
+        if (!this.resolverGenerator) {
+          this.resolverGenerator = result;
+        }
+        this.resolverGeneratorResult = nextResponse;
+        return nextResponse;
+      }
+      return result;
+    };
+  }
+  createExecutionResult(parsedResult, request, response2) {
+    return {
+      handler: this,
+      parsedResult: parsedResult || null,
+      request,
+      response: response2 || null
+    };
+  }
+};
+
 // src/handlers/RestHandler.ts
 var RESTMethods = /* @__PURE__ */ ((RESTMethods2) => {
   RESTMethods2["HEAD"] = "HEAD";
@@ -1032,6 +1045,15 @@ var restContext = __spreadProps(__spreadValues({}, defaultContext), {
   json,
   xml
 });
+var RestRequest = class extends MockedRequest {
+  constructor(request, params) {
+    super(request.url, __spreadProps(__spreadValues({}, request), {
+      body: request["_body"]
+    }));
+    this.params = params;
+    this.id = request.id;
+  }
+};
 var RestHandler = class extends RequestHandler {
   constructor(method, path, resolver) {
     super({
@@ -1065,9 +1087,7 @@ var RestHandler = class extends RequestHandler {
     return matchRequestUrl(request.url, this.info.path, resolutionContext == null ? void 0 : resolutionContext.baseUrl);
   }
   getPublicRequest(request, parsedResult) {
-    return __spreadProps(__spreadValues({}, request), {
-      params: parsedResult.params || {}
-    });
+    return new RestRequest(request, parsedResult.params || {});
   }
   predicate(request, parsedResult) {
     const matchesMethod = this.info.method instanceof RegExp ? this.info.method.test(request.method) : isStringEqual(this.info.method, request.method);
@@ -1130,6 +1150,14 @@ function isDocumentNode(value) {
   }
   return typeof value === "object" && "kind" in value && "definitions" in value;
 }
+var GraphQLRequest = class extends MockedRequest {
+  constructor(request, variables) {
+    super(request.url, __spreadProps(__spreadValues({}, request), {
+      body: request["_body"]
+    }));
+    this.variables = variables;
+  }
+};
 var GraphQLHandler = class extends RequestHandler {
   constructor(operationType, operationName, endpoint, resolver) {
     let resolvedOperationName = operationName;
@@ -1159,9 +1187,7 @@ var GraphQLHandler = class extends RequestHandler {
     return tryCatch(() => parseGraphQLRequest(request), (error2) => console.error(error2.message));
   }
   getPublicRequest(request, parsedResult) {
-    return __spreadProps(__spreadValues({}, request), {
-      variables: (parsedResult == null ? void 0 : parsedResult.variables) || {}
-    });
+    return new GraphQLRequest(request, (parsedResult == null ? void 0 : parsedResult.variables) || {});
   }
   predicate(request, parsedResult) {
     if (!parsedResult) {
@@ -1467,8 +1493,8 @@ function transformResponse(response2) {
 async function requestIntegrityCheck(context, serviceWorker) {
   context.workerChannel.send("INTEGRITY_CHECK_REQUEST");
   const { payload: actualChecksum } = await context.events.once("INTEGRITY_CHECK_RESPONSE");
-  if (actualChecksum !== "c9450df6e4dc5e45740c3b0b640727a2") {
-    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"c9450df6e4dc5e45740c3b0b640727a2"}).`);
+  if (actualChecksum !== "df0d85222361310ecbe1792c606e08f2") {
+    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"df0d85222361310ecbe1792c606e08f2"}).`);
   }
   return serviceWorker;
 }
@@ -1646,43 +1672,16 @@ function prepareStartHandler(handler, context) {
 }
 
 // src/setupWorker/start/createFallbackRequestListener.ts
-var import_interceptors = require("@mswjs/interceptors");
+var import_interceptors3 = require("@mswjs/interceptors");
 var import_fetch3 = require("@mswjs/interceptors/lib/interceptors/fetch");
 var import_XMLHttpRequest = require("@mswjs/interceptors/lib/interceptors/XMLHttpRequest");
-
-// src/utils/request/parseIsomorphicRequest.ts
-function parseIsomorphicRequest(request) {
-  const mockedRequest = {
-    id: request.id,
-    url: request.url,
-    method: request.method,
-    body: parseBody(request.body, request.headers),
-    credentials: request.credentials || "same-origin",
-    headers: request.headers,
-    cookies: {},
-    redirect: "manual",
-    referrer: "",
-    keepalive: false,
-    cache: "default",
-    mode: "cors",
-    referrerPolicy: "no-referrer",
-    integrity: "",
-    destination: "document",
-    bodyUsed: false,
-    passthrough
-  };
-  setRequestCookies(mockedRequest);
-  return mockedRequest;
-}
-
-// src/setupWorker/start/createFallbackRequestListener.ts
 function createFallbackRequestListener(context, options) {
-  const interceptor = new import_interceptors.BatchInterceptor({
+  const interceptor = new import_interceptors3.BatchInterceptor({
     name: "fallback",
     interceptors: [new import_fetch3.FetchInterceptor(), new import_XMLHttpRequest.XMLHttpRequestInterceptor()]
   });
   interceptor.on("request", async (request) => {
-    const mockedRequest = parseIsomorphicRequest(request);
+    const mockedRequest = new MockedRequest(request);
     const response2 = await handleRequest(mockedRequest, context.requestHandlers, options, context.emitter, {
       transformResponse(response3) {
         return {
@@ -1767,7 +1766,7 @@ function setupWorker(...requestHandlers) {
           if (event.source !== context.worker) {
             return;
           }
-          const message = jsonParse(event.data);
+          const message = event.data;
           if (!message) {
             return;
           }
@@ -1800,7 +1799,7 @@ function setupWorker(...requestHandlers) {
         return new Promise((resolve, reject) => {
           const handleIncomingMessage = (event) => {
             try {
-              const message = JSON.parse(event.data);
+              const message = event.data;
               if (message.type === eventType) {
                 resolve(message);
               }
@@ -1911,6 +1910,7 @@ var graphql = __spreadProps(__spreadValues({}, standardGraphQLHandlers), {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GraphQLHandler,
+  MockedRequest,
   RESTMethods,
   RequestHandler,
   RestHandler,
@@ -1924,7 +1924,6 @@ var graphql = __spreadProps(__spreadValues({}, standardGraphQLHandlers), {
   graphqlContext,
   handleRequest,
   matchRequestUrl,
-  parseIsomorphicRequest,
   response,
   rest,
   restContext,