@zimic/interceptor 1.1.2-canary.1 → 1.1.2-canary.3

package/dist/http.mjs

@@ -1,18 +1,12 @@
 import color2 from 'picocolors';
-import { HttpHeaders, HttpSearchParams, HttpFormData, HTTP_METHODS } from '@zimic/http';
+import { HTTP_METHODS, HttpHeaders, HttpSearchParams, HttpFormData } from '@zimic/http';
 import { http, passthrough } from 'msw';
 import * as mswBrowser from 'msw/browser';
 import * as mswNode from 'msw/node';
 import ClientSocket from 'isomorphic-ws';
 
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/http/interceptor/errors/RunningHttpInterceptorError.ts
 var RunningHttpInterceptorError = class extends Error {
-  static {
-    __name(this, "RunningHttpInterceptorError");
-  }
   constructor(additionalMessage) {
     super(`The interceptor is running. ${additionalMessage}`);
     this.name = "RunningHttpInterceptorError";
@@ -22,9 +16,6 @@ var RunningHttpInterceptorError_default = RunningHttpInterceptorError;
 
 // src/http/interceptor/errors/NotRunningHttpInterceptorError.ts
 var NotRunningHttpInterceptorError = class extends Error {
-  static {
-    __name(this, "NotRunningHttpInterceptorError");
-  }
   constructor() {
     super("Interceptor is not running. Did you forget to call `await interceptor.start()`?");
     this.name = "NotRunningHttpInterceptorError";
@@ -34,9 +25,6 @@ var NotRunningHttpInterceptorError_default = NotRunningHttpInterceptorError;
 
 // src/http/interceptor/errors/UnknownHttpInterceptorPlatformError.ts
 var UnknownHttpInterceptorPlatformError = class extends Error {
-  static {
-    __name(this, "UnknownHttpInterceptorPlatformError");
-  }
   /* istanbul ignore next -- @preserve
    * Ignoring because checking unknown platforms is currently not possible in our Vitest setup. */
   constructor() {
@@ -48,9 +36,6 @@ var UnknownHttpInterceptorPlatformError_default = UnknownHttpInterceptorPlatform
 
 // src/http/interceptor/errors/UnknownHttpInterceptorTypeError.ts
 var UnknownHttpInterceptorTypeError = class extends TypeError {
-  static {
-    __name(this, "UnknownHttpInterceptorTypeError");
-  }
   constructor(unknownType) {
     super(
       `Unknown HTTP interceptor type: ${unknownType}. The available options are '${"local"}' and '${"remote"}'.`
@@ -62,9 +47,6 @@ var UnknownHttpInterceptorTypeError_default = UnknownHttpInterceptorTypeError;
 
 // src/http/interceptor/errors/RequestSavingSafeLimitExceededError.ts
 var RequestSavingSafeLimitExceededError = class extends TypeError {
-  static {
-    __name(this, "RequestSavingSafeLimitExceededError");
-  }
   constructor(numberOfSavedRequests, safeLimit) {
     super(
       `The number of intercepted requests saved in memory (${numberOfSavedRequests}) exceeded the safe limit of ${safeLimit}. Did you forget to call \`interceptor.clear()\`?
@@ -82,9 +64,6 @@ var RequestSavingSafeLimitExceededError_default = RequestSavingSafeLimitExceeded
 
 // src/http/interceptorWorker/errors/InvalidFormDataError.ts
 var InvalidFormDataError = class extends SyntaxError {
-  static {
-    __name(this, "InvalidFormDataError");
-  }
   constructor(value) {
     super(`Failed to parse value as form data: ${value}`);
     this.name = "InvalidFormDataError";
@@ -94,9 +73,6 @@ var InvalidFormDataError_default = InvalidFormDataError;
 
 // src/http/interceptorWorker/errors/InvalidJSONError.ts
 var InvalidJSONError = class extends SyntaxError {
-  static {
-    __name(this, "InvalidJSONError");
-  }
   constructor(value) {
     super(`Failed to parse value as JSON: ${value}`);
     this.name = "InvalidJSONError";
@@ -109,9 +85,6 @@ var SERVICE_WORKER_FILE_NAME = "mockServiceWorker.js";
 
 // src/http/interceptorWorker/errors/UnregisteredBrowserServiceWorkerError.ts
 var UnregisteredBrowserServiceWorkerError = class extends Error {
-  static {
-    __name(this, "UnregisteredBrowserServiceWorkerError");
-  }
   constructor() {
     super(
       `Failed to register the browser service worker: script '${window.location.origin}/${SERVICE_WORKER_FILE_NAME}' not found.
@@ -130,9 +103,6 @@ var UnregisteredBrowserServiceWorkerError_default = UnregisteredBrowserServiceWo
 
 // src/http/requestHandler/errors/DisabledRequestSavingError.ts
 var DisabledRequestSavingError = class extends TypeError {
-  static {
-    __name(this, "DisabledRequestSavingError");
-  }
   constructor() {
     super(
       "Intercepted requests are not being saved. Did you forget to use `requestSaving.enabled: true` in your interceptor?\n\nLearn more: https://zimic.dev/docs/interceptor/api/create-http-interceptor"
@@ -142,46 +112,30 @@ var DisabledRequestSavingError = class extends TypeError {
 };
 var DisabledRequestSavingError_default = DisabledRequestSavingError;
 
-// ../zimic-utils/dist/chunk-2D3UJWOA.mjs
-var __defProp2 = Object.defineProperty;
-var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
-
-// ../zimic-utils/dist/chunk-WC2DBWWR.mjs
+// ../zimic-utils/dist/chunk-5UH44FTS.mjs
 function isDefined(value) {
   return value !== void 0 && value !== null;
 }
-__name(isDefined, "isDefined");
-__name2(isDefined, "isDefined");
 var isDefined_default = isDefined;
 
 // ../zimic-utils/dist/data/isNonEmpty.mjs
 function isNonEmpty(value) {
   return isDefined_default(value) && value !== "";
 }
-__name(isNonEmpty, "isNonEmpty");
-__name2(isNonEmpty, "isNonEmpty");
 var isNonEmpty_default = isNonEmpty;
 
 // ../zimic-utils/dist/import/createCachedDynamicImport.mjs
 function createCachedDynamicImport(importModuleDynamically) {
   let cachedImportResult;
-  return /* @__PURE__ */ __name2(/* @__PURE__ */ __name(async function importModuleDynamicallyWithCache() {
+  return async function importModuleDynamicallyWithCache() {
     cachedImportResult ??= await importModuleDynamically();
     return cachedImportResult;
-  }, "importModuleDynamicallyWithCache"), "importModuleDynamicallyWithCache");
+  };
 }
-__name(createCachedDynamicImport, "createCachedDynamicImport");
-__name2(createCachedDynamicImport, "createCachedDynamicImport");
 var createCachedDynamicImport_default = createCachedDynamicImport;
 
 // ../zimic-utils/dist/logging/Logger.mjs
 var Logger = class _Logger {
-  static {
-    __name(this, "_Logger");
-  }
-  static {
-    __name2(this, "Logger");
-  }
   prefix;
   raw;
   constructor(options = {}) {
@@ -260,15 +214,12 @@ var Logger_default = Logger;
 function isServerSide() {
   return typeof process !== "undefined" && typeof process.versions !== "undefined";
 }
-__name(isServerSide, "isServerSide");
 function isClientSide() {
   return typeof window !== "undefined" && typeof document !== "undefined";
 }
-__name(isClientSide, "isClientSide");
 function isGlobalFileAvailable() {
   return globalThis.File !== void 0;
 }
-__name(isGlobalFileAvailable, "isGlobalFileAvailable");
 
 // src/utils/logging.ts
 var logger = new Logger_default({
@@ -279,13 +230,12 @@ function stringifyJSONToLog(value) {
     value,
     (_key, value2) => {
       return stringifyValueToLog(value2, {
-        fallback: /* @__PURE__ */ __name((value3) => value3, "fallback")
+        fallback: (value3) => value3
       });
     },
     2
   ).replace(/\n\s*/g, " ").replace(/"(File { name: '.*?', type: '.*?', size: \d*? })"/g, "$1").replace(/"(Blob { type: '.*?', size: \d*? })"/g, "$1");
 }
-__name(stringifyJSONToLog, "stringifyJSONToLog");
 function stringifyValueToLog(value, options = {}) {
   const { fallback = stringifyJSONToLog, includeClassName } = options;
   if (value === null || value === void 0 || typeof value !== "object") {
@@ -309,7 +259,6 @@ function stringifyValueToLog(value, options = {}) {
   }
   return fallback(value);
 }
-__name(stringifyValueToLog, "stringifyValueToLog");
 var importUtil = createCachedDynamicImport_default(() => import('util'));
 async function formatValueToLog(value, options = {}) {
   if (isClientSide()) {
@@ -327,7 +276,6 @@ async function formatValueToLog(value, options = {}) {
     sorted: true
   });
 }
-__name(formatValueToLog, "formatValueToLog");
 
 // src/http/requestHandler/errors/TimesCheckError.ts
 function createMessageHeader({
@@ -355,7 +303,6 @@ Requests evaluated by this handler:
   ${color2.red("+ Received")}`
   ].filter((part) => part !== false).join("");
 }
-__name(createMessageHeader, "createMessageHeader");
 function createMessageDiffs({ requestSaving, unmatchedRequestGroups }) {
   if (!requestSaving.enabled) {
     return "Tip: use `requestSaving.enabled: true` in your interceptor for more details about the unmatched requests.";
@@ -398,22 +345,16 @@ function createMessageDiffs({ requestSaving, unmatchedRequestGroups }) {
     return messageParts.join("\n     ");
   }).join("\n\n");
 }
-__name(createMessageDiffs, "createMessageDiffs");
 function createMessageFooter() {
   return "Learn more: https://zimic.dev/docs/interceptor/api/http-request-handler#handlertimes";
 }
-__name(createMessageFooter, "createMessageFooter");
 function createMessage(options) {
   const messageHeader = createMessageHeader(options);
   const messageDiffs = createMessageDiffs(options);
   const messageFooter = createMessageFooter();
   return [messageHeader, messageDiffs, messageFooter].filter(isNonEmpty_default).join("\n\n");
 }
-__name(createMessage, "createMessage");
 var TimesCheckError = class extends TypeError {
-  static {
-    __name(this, "TimesCheckError");
-  }
   constructor(options) {
     const message = createMessage(options);
     super(message);
@@ -423,7 +364,7 @@ var TimesCheckError = class extends TypeError {
 };
 var TimesCheckError_default = TimesCheckError;
 
-// ../zimic-utils/dist/chunk-F2EXWCVL.mjs
+// ../zimic-utils/dist/chunk-BSG74SVQ.mjs
 async function blobEquals(blob, otherBlob) {
   if (blob.type !== otherBlob.type || blob.size !== otherBlob.size) {
     return false;
@@ -476,16 +417,12 @@ async function blobEquals(blob, otherBlob) {
     otherReader.releaseLock();
   }
 }
-__name(blobEquals, "blobEquals");
-__name2(blobEquals, "blobEquals");
 var blobEquals_default = blobEquals;
 
-// ../zimic-utils/dist/chunk-O7QQJM46.mjs
+// ../zimic-utils/dist/chunk-LBZAJMTR.mjs
 function isPrimitiveJSONValue(value) {
   return typeof value !== "object" || value === null;
 }
-__name(isPrimitiveJSONValue, "isPrimitiveJSONValue");
-__name2(isPrimitiveJSONValue, "isPrimitiveJSONValue");
 
 // ../zimic-utils/dist/data/jsonContains.mjs
 function jsonContains(value, otherValue) {
@@ -527,8 +464,6 @@ function jsonContains(value, otherValue) {
     return jsonContains(subValue, subOtherValue);
   });
 }
-__name(jsonContains, "jsonContains");
-__name2(jsonContains, "jsonContains");
 var jsonContains_default = jsonContains;
 
 // ../zimic-utils/dist/data/jsonEquals.mjs
@@ -562,8 +497,6 @@ function jsonEquals(value, otherValue) {
     return jsonEquals(subValue, subOtherValue);
   });
 }
-__name(jsonEquals, "jsonEquals");
-__name2(jsonEquals, "jsonEquals");
 var jsonEquals_default = jsonEquals;
 
 // src/utils/data.ts
@@ -581,11 +514,9 @@ async function convertReadableStreamToBlob(stream, options) {
   }
   return new Blob(chunks, options);
 }
-__name(convertReadableStreamToBlob, "convertReadableStreamToBlob");
 function convertArrayBufferToBlob(buffer, options) {
   return new Blob([buffer], options);
 }
-__name(convertArrayBufferToBlob, "convertArrayBufferToBlob");
 function convertArrayBufferToBase64(buffer) {
   if (isClientSide()) {
     const bufferBytes = new Uint8Array(buffer);
@@ -600,7 +531,6 @@ function convertArrayBufferToBase64(buffer) {
     return Buffer.from(buffer).toString("base64");
   }
 }
-__name(convertArrayBufferToBase64, "convertArrayBufferToBase64");
 function convertBase64ToArrayBuffer(base64Value) {
   if (isClientSide()) {
     const bufferAsString = atob(base64Value);
@@ -610,13 +540,9 @@ function convertBase64ToArrayBuffer(base64Value) {
     return Buffer.from(base64Value, "base64");
   }
 }
-__name(convertBase64ToArrayBuffer, "convertBase64ToArrayBuffer");
 
 // src/http/requestHandler/errors/NoResponseDefinitionError.ts
 var NoResponseDefinitionError = class extends TypeError {
-  static {
-    __name(this, "NoResponseDefinitionError");
-  }
   constructor() {
     super("Cannot generate a response without a definition. Use .respond() to set a response.");
     this.name = "NoResponseDefinitionError";
@@ -626,9 +552,6 @@ var NoResponseDefinitionError_default = NoResponseDefinitionError;
 
 // src/http/requestHandler/errors/TimesDeclarationPointer.ts
 var TimesDeclarationPointer = class extends Error {
-  static {
-    __name(this, "TimesDeclarationPointer");
-  }
   constructor(minNumberOfRequests, maxNumberOfRequests) {
     super("declared at:");
     this.name = `handler.times(${minNumberOfRequests}${maxNumberOfRequests === void 0 ? "" : `, ${maxNumberOfRequests}`})`;
@@ -648,9 +571,6 @@ var HttpRequestHandlerClient = class {
     this.path = path;
     this.handler = handler;
   }
-  static {
-    __name(this, "HttpRequestHandlerClient");
-  }
   restrictions = [];
   limits = {
     numberOfRequests: DEFAULT_NUMBER_OF_REQUEST_LIMITS
@@ -890,9 +810,6 @@ var HttpRequestHandlerClient_default = HttpRequestHandlerClient;
 
 // src/http/requestHandler/LocalHttpRequestHandler.ts
 var LocalHttpRequestHandler = class {
-  static {
-    __name(this, "LocalHttpRequestHandler");
-  }
   type = "local";
   client;
   constructor(interceptor, method, path) {
@@ -939,37 +856,25 @@ var LocalHttpRequestHandler = class {
 };
 var LocalHttpRequestHandler_default = LocalHttpRequestHandler;
 
-// ../zimic-utils/dist/chunk-FPJJAH7P.mjs
+// ../zimic-utils/dist/chunk-46M3OXFU.mjs
 function getExtraPatternsToEscape() {
   return /([.(){}+$])/g;
 }
-__name(getExtraPatternsToEscape, "getExtraPatternsToEscape");
-__name2(getExtraPatternsToEscape, "getExtraPatternsToEscape");
 function getURIEncodedBackSlashPattern() {
   return /%5C/g;
 }
-__name(getURIEncodedBackSlashPattern, "getURIEncodedBackSlashPattern");
-__name2(getURIEncodedBackSlashPattern, "getURIEncodedBackSlashPattern");
 function getPathParamPattern() {
   return /(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)/gu;
 }
-__name(getPathParamPattern, "getPathParamPattern");
-__name2(getPathParamPattern, "getPathParamPattern");
 function getRepeatingPathParamPattern() {
   return /(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\\+/gu;
 }
-__name(getRepeatingPathParamPattern, "getRepeatingPathParamPattern");
-__name2(getRepeatingPathParamPattern, "getRepeatingPathParamPattern");
 function getOptionalPathParamPattern() {
   return /(?<leadingSlash>\/)?(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\?(?<trailingSlash>\/)?/gu;
 }
-__name(getOptionalPathParamPattern, "getOptionalPathParamPattern");
-__name2(getOptionalPathParamPattern, "getOptionalPathParamPattern");
 function getOptionalRepeatingPathParamPattern() {
   return /(?<leadingSlash>\/)?(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\*(?<trailingSlash>\/)?/gu;
 }
-__name(getOptionalRepeatingPathParamPattern, "getOptionalRepeatingPathParamPattern");
-__name2(getOptionalRepeatingPathParamPattern, "getOptionalRepeatingPathParamPattern");
 function createParametrizedPathPattern(path) {
   const replacedURL = encodeURI(path).replace(/^\/+/g, "").replace(/\/+$/g, "").replace(getExtraPatternsToEscape(), "\\$1").replace(getURIEncodedBackSlashPattern(), "\\").replace(
     getOptionalRepeatingPathParamPattern(),
@@ -1018,8 +923,6 @@ function createParametrizedPathPattern(path) {
   });
   return new RegExp(`^/?${replacedURL}/?$`);
 }
-__name(createParametrizedPathPattern, "createParametrizedPathPattern");
-__name2(createParametrizedPathPattern, "createParametrizedPathPattern");
 var createParametrizedPathPattern_default = createParametrizedPathPattern;
 
 // ../zimic-utils/dist/url/excludeURLParams.mjs
@@ -1030,18 +933,10 @@ function excludeURLParams(url) {
   url.password = "";
   return url;
 }
-__name(excludeURLParams, "excludeURLParams");
-__name2(excludeURLParams, "excludeURLParams");
 var excludeURLParams_default = excludeURLParams;
 
 // ../zimic-utils/dist/url/validateURLProtocol.mjs
 var UnsupportedURLProtocolError = class extends TypeError {
-  static {
-    __name(this, "UnsupportedURLProtocolError");
-  }
-  static {
-    __name2(this, "UnsupportedURLProtocolError");
-  }
   constructor(protocol, availableProtocols) {
     super(
       `Unsupported URL protocol: '${protocol}'. The available options are ${availableProtocols.map((protocol2) => `'${protocol2}'`).join(", ")}`
@@ -1055,8 +950,6 @@ function validateURLProtocol(url, protocols) {
     throw new UnsupportedURLProtocolError(protocol, protocols);
   }
 }
-__name(validateURLProtocol, "validateURLProtocol");
-__name2(validateURLProtocol, "validateURLProtocol");
 var validateURLProtocol_default = validateURLProtocol;
 
 // src/utils/arrays.ts
@@ -1066,12 +959,10 @@ function removeArrayIndex(array, index) {
   }
   return array;
 }
-__name(removeArrayIndex, "removeArrayIndex");
 function removeArrayElement(array, element) {
   const index = array.indexOf(element);
   return removeArrayIndex(array, index);
 }
-__name(removeArrayElement, "removeArrayElement");
 var HTTP_METHODS_WITH_RESPONSE_BODY = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -1083,7 +974,6 @@ var HTTP_METHODS_WITH_RESPONSE_BODY = /* @__PURE__ */ new Set([
 function methodCanHaveResponseBody(method) {
   return HTTP_METHODS_WITH_RESPONSE_BODY.has(method);
 }
-__name(methodCanHaveResponseBody, "methodCanHaveResponseBody");
 
 // src/http/requestHandler/types/requests.ts
 var HTTP_INTERCEPTOR_REQUEST_HIDDEN_PROPERTIES = Object.freeze(
@@ -1117,9 +1007,6 @@ var DEFAULT_UNHANDLED_REQUEST_STRATEGY = Object.freeze({
 
 // src/http/interceptorWorker/HttpInterceptorWorker.ts
 var HttpInterceptorWorker = class _HttpInterceptorWorker {
-  static {
-    __name(this, "HttpInterceptorWorker");
-  }
   platform = null;
   isRunning = false;
   startingPromise;
@@ -1332,8 +1219,13 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
     return HTTP_INTERCEPTOR_RESPONSE_HIDDEN_PROPERTIES.has(property);
   }
   static parseRawPathParams(request, options) {
-    const match = options?.pathPattern.exec(request.url.replace(options.baseURL, ""));
-    return { ...match?.groups };
+    const requestPath = request.url.replace(options?.baseURL ?? "", "");
+    const paramsMatch = options?.pathPattern.exec(requestPath);
+    const params = {};
+    for (const [paramName, paramValue] of Object.entries(paramsMatch?.groups ?? {})) {
+      params[paramName] = typeof paramValue === "string" ? decodeURIComponent(paramValue) : void 0;
+    }
+    return params;
   }
   static async parseRawBody(resource) {
     const contentType = resource.headers.get("content-type");
@@ -1438,9 +1330,6 @@ var HttpInterceptorWorker_default = HttpInterceptorWorker;
 // src/http/requestHandler/RemoteHttpRequestHandler.ts
 var PENDING_PROPERTIES = /* @__PURE__ */ new Set(["then"]);
 var RemoteHttpRequestHandler = class {
-  static {
-    __name(this, "RemoteHttpRequestHandler");
-  }
   type = "remote";
   client;
   syncPromises = [];
@@ -1453,18 +1342,18 @@ var RemoteHttpRequestHandler = class {
   }
   createSyncedProxy() {
     return new Proxy(this, {
-      has: /* @__PURE__ */ __name((target, property) => {
+      has: (target, property) => {
         if (this.isHiddenPropertyWhenSynced(property)) {
           return false;
         }
         return Reflect.has(target, property);
-      }, "has"),
-      get: /* @__PURE__ */ __name((target, property) => {
+      },
+      get: (target, property) => {
         if (this.isHiddenPropertyWhenSynced(property)) {
           return void 0;
         }
         return Reflect.get(target, property);
-      }, "get")
+      }
     });
   }
   isHiddenPropertyWhenSynced(property) {
@@ -1541,9 +1430,6 @@ var RemoteHttpRequestHandler_default = RemoteHttpRequestHandler;
 var SUPPORTED_BASE_URL_PROTOCOLS = Object.freeze(["http", "https"]);
 var DEFAULT_REQUEST_SAVING_SAFE_LIMIT = 1e3;
 var HttpInterceptorClient = class {
-  static {
-    __name(this, "HttpInterceptorClient");
-  }
   store;
   _baseURL;
   createWorker;
@@ -1777,12 +1663,6 @@ var HttpInterceptorClient_default = HttpInterceptorClient;
 
 // ../zimic-utils/dist/url/validatePathParams.mjs
 var DuplicatedPathParamError = class extends Error {
-  static {
-    __name(this, "DuplicatedPathParamError");
-  }
-  static {
-    __name2(this, "DuplicatedPathParamError");
-  }
   constructor(path, paramName) {
     super(
       `The path parameter '${paramName}' appears more than once in '${path}'. This is not supported. Please make sure that each parameter is unique.`
@@ -1804,13 +1684,8 @@ function validatePathParams(path) {
     uniqueParamNames.add(paramName);
   }
 }
-__name(validatePathParams, "validatePathParams");
-__name2(validatePathParams, "validatePathParams");
 var validatePathParams_default = validatePathParams;
 var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
-  static {
-    __name(this, "LocalHttpInterceptorWorker");
-  }
   internalWorker;
   httpHandlersByMethod = {
     GET: [],
@@ -1922,7 +1797,7 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       method,
       pathPattern: createParametrizedPathPattern_default(path),
       interceptor,
-      createResponse: /* @__PURE__ */ __name(async (context) => {
+      createResponse: async (context) => {
         const request = context.request;
         const requestClone = request.clone();
         let response = null;
@@ -1942,7 +1817,7 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
           });
         }
         return response;
-      }, "createResponse")
+      }
     };
     methodHandlers.push(handler);
   }
@@ -2026,7 +1901,6 @@ function deserializeRequest(serializedRequest) {
     body: deserializedBody
   });
 }
-__name(deserializeRequest, "deserializeRequest");
 async function serializeResponse(response) {
   const responseClone = response.clone();
   const serializedBody = responseClone.body ? convertArrayBufferToBase64(await responseClone.arrayBuffer()) : null;
@@ -2037,7 +1911,6 @@ async function serializeResponse(response) {
     body: serializedBody
   };
 }
-__name(serializeResponse, "serializeResponse");
 
 // src/webSocket/errors/UnauthorizedWebSocketConnectionError.ts
 var UnauthorizedWebSocketConnectionError = class extends Error {
@@ -2046,49 +1919,31 @@ var UnauthorizedWebSocketConnectionError = class extends Error {
     this.event = event;
     this.name = "UnauthorizedWebSocketConnectionError";
   }
-  static {
-    __name(this, "UnauthorizedWebSocketConnectionError");
-  }
 };
 var UnauthorizedWebSocketConnectionError_default = UnauthorizedWebSocketConnectionError;
 
 // src/utils/webSocket.ts
 var WebSocketTimeoutError = class extends Error {
-  static {
-    __name(this, "WebSocketTimeoutError");
-  }
 };
 var WebSocketOpenTimeoutError = class extends WebSocketTimeoutError {
-  static {
-    __name(this, "WebSocketOpenTimeoutError");
-  }
   constructor(reachedTimeout) {
     super(`Web socket open timed out after ${reachedTimeout}ms.`);
     this.name = "WebSocketOpenTimeout";
   }
 };
 var WebSocketMessageTimeoutError = class extends WebSocketTimeoutError {
-  static {
-    __name(this, "WebSocketMessageTimeoutError");
-  }
   constructor(reachedTimeout) {
     super(`Web socket message timed out after ${reachedTimeout}ms.`);
     this.name = "WebSocketMessageTimeout";
   }
 };
 var WebSocketMessageAbortError = class extends WebSocketTimeoutError {
-  static {
-    __name(this, "WebSocketMessageAbortError");
-  }
   constructor() {
     super("Web socket message was aborted.");
     this.name = "WebSocketMessageAbortError";
   }
 };
 var WebSocketCloseTimeoutError = class extends WebSocketTimeoutError {
-  static {
-    __name(this, "WebSocketCloseTimeoutError");
-  }
   constructor(reachedTimeout) {
     super(`Web socket close timed out after ${reachedTimeout}ms.`);
     this.name = "WebSocketCloseTimeout";
@@ -2109,12 +1964,10 @@ async function waitForOpenClientSocket(socket, options = {}) {
       socket.removeEventListener("error", handleOpenError);
       socket.removeEventListener("close", handleClose);
     }
-    __name(removeAllSocketListeners, "removeAllSocketListeners");
     function handleOpenError(error) {
       removeAllSocketListeners();
       reject(error);
     }
-    __name(handleOpenError, "handleOpenError");
     function handleClose(event) {
       const isUnauthorized = event.code === 1008;
       if (isUnauthorized) {
@@ -2124,7 +1977,6 @@ async function waitForOpenClientSocket(socket, options = {}) {
         handleOpenError(event);
       }
     }
-    __name(handleClose, "handleClose");
     const openTimeout = setTimeout(() => {
       const timeoutError = new WebSocketOpenTimeoutError(timeoutDuration);
       handleOpenError(timeoutError);
@@ -2134,14 +1986,12 @@ async function waitForOpenClientSocket(socket, options = {}) {
       clearTimeout(openTimeout);
       resolve();
     }
-    __name(handleOpenSuccess, "handleOpenSuccess");
     function handleSocketMessage(message) {
       const hasValidAuth = message.data === "socket:auth:valid";
       if (hasValidAuth) {
         handleOpenSuccess();
       }
     }
-    __name(handleSocketMessage, "handleSocketMessage");
     if (waitForAuthentication) {
       socket.addEventListener("message", handleSocketMessage);
     } else {
@@ -2151,7 +2001,6 @@ async function waitForOpenClientSocket(socket, options = {}) {
     socket.addEventListener("close", handleClose);
   });
 }
-__name(waitForOpenClientSocket, "waitForOpenClientSocket");
 async function closeClientSocket(socket, options = {}) {
   const { timeout: timeoutDuration = DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT } = options;
   const isAlreadyClosed = socket.readyState === socket.CLOSED;
@@ -2163,12 +2012,10 @@ async function closeClientSocket(socket, options = {}) {
       socket.removeEventListener("error", handleError);
       socket.removeEventListener("close", handleClose);
     }
-    __name(removeAllSocketListeners, "removeAllSocketListeners");
     function handleError(error) {
       removeAllSocketListeners();
       reject(error);
     }
-    __name(handleError, "handleError");
     const closeTimeout = setTimeout(() => {
       const timeoutError = new WebSocketCloseTimeoutError(timeoutDuration);
       handleError(timeoutError);
@@ -2178,22 +2025,17 @@ async function closeClientSocket(socket, options = {}) {
       clearTimeout(closeTimeout);
       resolve();
     }
-    __name(handleClose, "handleClose");
     socket.addEventListener("error", handleError);
     socket.addEventListener("close", handleClose);
     socket.close();
   });
 }
-__name(closeClientSocket, "closeClientSocket");
 
 // src/webSocket/constants.ts
 var WEB_SOCKET_CONTROL_MESSAGES = Object.freeze(["socket:auth:valid"]);
 
 // src/webSocket/errors/InvalidWebSocketMessage.ts
 var InvalidWebSocketMessage = class extends Error {
-  static {
-    __name(this, "InvalidWebSocketMessage");
-  }
   constructor(message) {
     super(`Web socket message is invalid and could not be parsed: ${message}`);
     this.name = "InvalidWebSocketMessage";
@@ -2203,9 +2045,6 @@ var InvalidWebSocketMessage_default = InvalidWebSocketMessage;
 
 // src/webSocket/errors/NotRunningWebSocketHandlerError.ts
 var NotRunningWebSocketHandlerError = class extends Error {
-  static {
-    __name(this, "NotRunningWebSocketHandlerError");
-  }
   constructor() {
     super("Web socket handler is not running.");
     this.name = "NotRunningWebSocketHandlerError";
@@ -2215,9 +2054,6 @@ var NotRunningWebSocketHandlerError_default = NotRunningWebSocketHandlerError;
 
 // src/webSocket/WebSocketHandler.ts
 var WebSocketHandler = class {
-  static {
-    __name(this, "WebSocketHandler");
-  }
   sockets = /* @__PURE__ */ new Set();
   socketTimeout;
   messageTimeout;
@@ -2234,26 +2070,25 @@ var WebSocketHandler = class {
       timeout: this.socketTimeout,
       waitForAuthentication: options.waitForAuthentication
     });
-    const handleSocketMessage = /* @__PURE__ */ __name(async (rawMessage) => {
+    const handleSocketMessage = async (rawMessage) => {
       await this.handleSocketMessage(socket, rawMessage);
-    }, "handleSocketMessage");
+    };
     socket.addEventListener("message", handleSocketMessage);
     await openPromise;
     function handleSocketError(error) {
       console.error(error);
     }
-    __name(handleSocketError, "handleSocketError");
     socket.addEventListener("error", handleSocketError);
-    const handleSocketClose = /* @__PURE__ */ __name(() => {
+    const handleSocketClose = () => {
       socket.removeEventListener("message", handleSocketMessage);
       socket.removeEventListener("close", handleSocketClose);
       socket.removeEventListener("error", handleSocketError);
       this.removeSocket(socket);
-    }, "handleSocketClose");
+    };
     socket.addEventListener("close", handleSocketClose);
     this.sockets.add(socket);
   }
-  handleSocketMessage = /* @__PURE__ */ __name(async (socket, rawMessage) => {
+  handleSocketMessage = async (socket, rawMessage) => {
     try {
       if (this.isControlMessageData(rawMessage.data)) {
         return;
@@ -2264,7 +2099,7 @@ var WebSocketHandler = class {
     } catch (error) {
       console.error(error);
     }
-  }, "handleSocketMessage");
+  };
   isControlMessageData(messageData) {
     return typeof messageData === "string" && WEB_SOCKET_CONTROL_MESSAGES.includes(messageData);
   }
@@ -2465,9 +2300,6 @@ var WebSocketHandler_default = WebSocketHandler;
 // src/webSocket/WebSocketClient.ts
 var SUPPORTED_WEB_SOCKET_PROTOCOLS = ["ws", "wss"];
 var WebSocketClient = class extends WebSocketHandler_default {
-  static {
-    __name(this, "WebSocketClient");
-  }
   url;
   socket;
   constructor(options) {
@@ -2503,9 +2335,6 @@ var WebSocketClient_default = WebSocketClient;
 
 // src/http/interceptorWorker/RemoteHttpInterceptorWorker.ts
 var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
-  static {
-    __name(this, "RemoteHttpInterceptorWorker");
-  }
   httpHandlers = /* @__PURE__ */ new Map();
   webSocketClient;
   auth;
@@ -2536,7 +2365,7 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       this.isRunning = true;
     });
   }
-  createResponse = /* @__PURE__ */ __name(async (message) => {
+  createResponse = async (message) => {
     const { handlerId, request: serializedRequest } = message.data;
     const handler = this.httpHandlers.get(handlerId);
     const request = deserializeRequest(serializedRequest);
@@ -2552,14 +2381,14 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     const strategy = await super.getUnhandledRequestStrategy(request, "remote");
     await super.logUnhandledRequestIfNecessary(request, strategy);
     return { response: null };
-  }, "createResponse");
-  handleUnhandledServerRequest = /* @__PURE__ */ __name(async (message) => {
+  };
+  handleUnhandledServerRequest = async (message) => {
     const { request: serializedRequest } = message.data;
     const request = deserializeRequest(serializedRequest);
     const strategy = await super.getUnhandledRequestStrategy(request, "remote");
     const { wasLogged } = await super.logUnhandledRequestIfNecessary(request, strategy);
     return { wasLogged };
-  }, "handleUnhandledServerRequest");
+  };
   readPlatform() {
     if (isServerSide()) {
       return "node";
@@ -2646,13 +2475,9 @@ function createHttpInterceptorWorker(options) {
     return new RemoteHttpInterceptorWorker_default(options);
   }
 }
-__name(createHttpInterceptorWorker, "createHttpInterceptorWorker");
 
 // src/http/interceptor/HttpInterceptorStore.ts
 var HttpInterceptorStore = class _HttpInterceptorStore {
-  static {
-    __name(this, "HttpInterceptorStore");
-  }
   static _localWorker;
   static runningLocalInterceptors = /* @__PURE__ */ new Set();
   static remoteWorkers = /* @__PURE__ */ new Map();
@@ -2729,9 +2554,6 @@ var HttpInterceptorStore_default = HttpInterceptorStore;
 
 // src/http/interceptor/LocalHttpInterceptor.ts
 var LocalHttpInterceptor = class {
-  static {
-    __name(this, "LocalHttpInterceptor");
-  }
   store = new HttpInterceptorStore_default();
   client;
   constructor(options) {
@@ -2739,12 +2561,12 @@ var LocalHttpInterceptor = class {
     this.client = new HttpInterceptorClient_default({
       store: this.store,
       baseURL,
-      createWorker: /* @__PURE__ */ __name(() => {
+      createWorker: () => {
         return this.store.getOrCreateLocalWorker({});
-      }, "createWorker"),
-      deleteWorker: /* @__PURE__ */ __name(() => {
+      },
+      deleteWorker: () => {
         this.store.deleteLocalWorker();
-      }, "deleteWorker"),
+      },
       Handler: LocalHttpRequestHandler_default,
       onUnhandledRequest: options.onUnhandledRequest,
       requestSaving: options.requestSaving
@@ -2790,27 +2612,27 @@ var LocalHttpInterceptor = class {
     this.clear();
     await this.client.stop();
   }
-  get = /* @__PURE__ */ __name((path) => {
+  get = (path) => {
     return this.client.get(path);
-  }, "get");
-  post = /* @__PURE__ */ __name((path) => {
+  };
+  post = (path) => {
     return this.client.post(path);
-  }, "post");
-  patch = /* @__PURE__ */ __name((path) => {
+  };
+  patch = (path) => {
     return this.client.patch(path);
-  }, "patch");
-  put = /* @__PURE__ */ __name((path) => {
+  };
+  put = (path) => {
     return this.client.put(path);
-  }, "put");
-  delete = /* @__PURE__ */ __name((path) => {
+  };
+  delete = (path) => {
     return this.client.delete(path);
-  }, "delete");
-  head = /* @__PURE__ */ __name((path) => {
+  };
+  head = (path) => {
     return this.client.head(path);
-  }, "head");
-  options = /* @__PURE__ */ __name((path) => {
+  };
+  options = (path) => {
     return this.client.options(path);
-  }, "options");
+  };
   checkTimes() {
     this.client.checkTimes();
   }
@@ -2822,9 +2644,6 @@ var LocalHttpInterceptor_default = LocalHttpInterceptor;
 
 // src/http/interceptor/RemoteHttpInterceptor.ts
 var RemoteHttpInterceptor = class {
-  static {
-    __name(this, "RemoteHttpInterceptor");
-  }
   store = new HttpInterceptorStore_default();
   client;
   _auth;
@@ -2834,15 +2653,15 @@ var RemoteHttpInterceptor = class {
     this.client = new HttpInterceptorClient_default({
       store: this.store,
       baseURL,
-      createWorker: /* @__PURE__ */ __name(() => {
+      createWorker: () => {
         return this.store.getOrCreateRemoteWorker({
           serverURL: new URL(baseURL.origin),
           auth: this._auth
         });
-      }, "createWorker"),
-      deleteWorker: /* @__PURE__ */ __name(() => {
+      },
+      deleteWorker: () => {
         this.store.deleteRemoteWorker(baseURL, { auth: options.auth });
-      }, "deleteWorker"),
+      },
       Handler: RemoteHttpRequestHandler_default,
       onUnhandledRequest: options.onUnhandledRequest,
       requestSaving: options.requestSaving
@@ -2876,12 +2695,12 @@ var RemoteHttpInterceptor = class {
       return;
     }
     this._auth = new Proxy(auth, {
-      set: /* @__PURE__ */ __name((target, property, value) => {
+      set: (target, property, value) => {
         if (this.isRunning) {
           throw new RunningHttpInterceptorError_default(cannotChangeAuthWhileRunningMessage);
         }
         return Reflect.set(target, property, value);
-      }, "set")
+      }
     });
   }
   get onUnhandledRequest() {
@@ -2909,27 +2728,27 @@ var RemoteHttpInterceptor = class {
     await this.clear();
     await this.client.stop();
   }
-  get = /* @__PURE__ */ __name((path) => {
+  get = (path) => {
     return this.client.get(path);
-  }, "get");
-  post = /* @__PURE__ */ __name((path) => {
+  };
+  post = (path) => {
     return this.client.post(path);
-  }, "post");
-  patch = /* @__PURE__ */ __name((path) => {
+  };
+  patch = (path) => {
     return this.client.patch(path);
-  }, "patch");
-  put = /* @__PURE__ */ __name((path) => {
+  };
+  put = (path) => {
     return this.client.put(path);
-  }, "put");
-  delete = /* @__PURE__ */ __name((path) => {
+  };
+  delete = (path) => {
     return this.client.delete(path);
-  }, "delete");
-  head = /* @__PURE__ */ __name((path) => {
+  };
+  head = (path) => {
     return this.client.head(path);
-  }, "head");
-  options = /* @__PURE__ */ __name((path) => {
+  };
+  options = (path) => {
     return this.client.options(path);
-  }, "options");
+  };
   checkTimes() {
     return new Promise((resolve, reject) => {
       try {
@@ -2955,11 +2774,9 @@ var RemoteHttpInterceptor_default = RemoteHttpInterceptor;
 function isLocalHttpInterceptorOptions(options) {
   return options.type === void 0 || options.type === "local";
 }
-__name(isLocalHttpInterceptorOptions, "isLocalHttpInterceptorOptions");
 function isRemoteHttpInterceptorOptions(options) {
   return options.type === "remote";
 }
-__name(isRemoteHttpInterceptorOptions, "isRemoteHttpInterceptorOptions");
 function createHttpInterceptor(options) {
   const type = options.type;
   if (isLocalHttpInterceptorOptions(options)) {
@@ -2969,7 +2786,6 @@ function createHttpInterceptor(options) {
   }
   throw new UnknownHttpInterceptorTypeError_default(type);
 }
-__name(createHttpInterceptor, "createHttpInterceptor");
 /* istanbul ignore next -- @preserve
  * Ignoring because there will always be a handler for the given method and path at this point. */
 /* istanbul ignore else -- @preserve */