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

package/dist/{chunk-RDMXECNU.mjs → chunk-CSKTIZSC.mjs}

@@ -1,4 +1,3 @@
-import { __name } from './chunk-CGILA3WO.mjs';
 import { HTTP_METHODS, HttpHeaders, HttpSearchParams, HttpFormData } from '@zimic/http';
 import { normalizeNodeRequest, sendNodeResponse } from '@whatwg-node/server';
 import { createServer } from 'http';
@@ -13,9 +12,6 @@ import * as z from 'zod';
 
 // src/server/errors/RunningInterceptorServerError.ts
 var RunningInterceptorServerError = class extends Error {
-  static {
-    __name(this, "RunningInterceptorServerError");
-  }
   constructor(additionalMessage) {
     super(`The interceptor server is running.${additionalMessage}`);
     this.name = "RunningInterceptorServerError";
@@ -25,9 +21,6 @@ var RunningInterceptorServerError_default = RunningInterceptorServerError;
 
 // src/server/errors/NotRunningInterceptorServerError.ts
 var NotRunningInterceptorServerError = class extends Error {
-  static {
-    __name(this, "NotRunningInterceptorServerError");
-  }
   constructor() {
     super("The interceptor server is not running. Did you forget to start it?");
     this.name = "NotRunningInterceptorServerError";
@@ -37,23 +30,14 @@ var NotRunningInterceptorServerError_default = NotRunningInterceptorServerError;
 
 // src/utils/http.ts
 var HttpServerTimeoutError = class extends Error {
-  static {
-    __name(this, "HttpServerTimeoutError");
-  }
 };
 var HttpServerStartTimeoutError = class extends HttpServerTimeoutError {
-  static {
-    __name(this, "HttpServerStartTimeoutError");
-  }
   constructor(reachedTimeout) {
     super(`HTTP server start timed out after ${reachedTimeout}ms.`);
     this.name = "HttpServerStartTimeout";
   }
 };
 var HttpServerStopTimeoutError = class extends HttpServerTimeoutError {
-  static {
-    __name(this, "HttpServerStopTimeoutError");
-  }
   constructor(reachedTimeout) {
     super(`HTTP server stop timed out after ${reachedTimeout}ms.`);
     this.name = "HttpServerStopTimeout";
@@ -67,7 +51,6 @@ async function startHttpServer(server, options = {}) {
       server.off("listening", handleStartSuccess);
       reject(error);
     }
-    __name(handleStartError, "handleStartError");
     const startTimeout = setTimeout(() => {
       const timeoutError = new HttpServerStartTimeoutError(timeoutDuration);
       handleStartError(timeoutError);
@@ -77,12 +60,10 @@ async function startHttpServer(server, options = {}) {
       clearTimeout(startTimeout);
       resolve();
     }
-    __name(handleStartSuccess, "handleStartSuccess");
     server.once("error", handleStartError);
     server.listen(port, hostname, handleStartSuccess);
   });
 }
-__name(startHttpServer, "startHttpServer");
 async function stopHttpServer(server, options = {}) {
   const { timeout: timeoutDuration = DEFAULT_HTTP_SERVER_LIFECYCLE_TIMEOUT } = options;
   if (!server.listening) {
@@ -104,7 +85,6 @@ async function stopHttpServer(server, options = {}) {
     server.closeAllConnections();
   });
 }
-__name(stopHttpServer, "stopHttpServer");
 function getHttpServerPort(server) {
   const address = server.address();
   if (typeof address === "string") {
@@ -113,7 +93,6 @@ function getHttpServerPort(server) {
     return address?.port;
   }
 }
-__name(getHttpServerPort, "getHttpServerPort");
 var HTTP_METHODS_WITH_RESPONSE_BODY = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -125,7 +104,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/webSocket/errors/UnauthorizedWebSocketConnectionError.ts
 var UnauthorizedWebSocketConnectionError = class extends Error {
@@ -134,49 +112,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";
@@ -197,12 +157,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) {
@@ -212,7 +170,6 @@ async function waitForOpenClientSocket(socket, options = {}) {
         handleOpenError(event);
       }
     }
-    __name(handleClose, "handleClose");
     const openTimeout = setTimeout(() => {
       const timeoutError = new WebSocketOpenTimeoutError(timeoutDuration);
       handleOpenError(timeoutError);
@@ -222,14 +179,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 {
@@ -239,7 +194,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;
@@ -251,12 +205,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);
@@ -266,13 +218,11 @@ async function closeClientSocket(socket, options = {}) {
       clearTimeout(closeTimeout);
       resolve();
     }
-    __name(handleClose, "handleClose");
     socket.addEventListener("error", handleError);
     socket.addEventListener("close", handleClose);
     socket.close();
   });
 }
-__name(closeClientSocket, "closeClientSocket");
 async function closeServerSocket(socket, options = {}) {
   const { timeout: timeoutDuration = DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT } = options;
   await new Promise((resolve, reject) => {
@@ -293,7 +243,6 @@ async function closeServerSocket(socket, options = {}) {
     });
   });
 }
-__name(closeServerSocket, "closeServerSocket");
 
 // src/server/constants.ts
 var ALLOWED_ACCESS_CONTROL_HTTP_METHODS = HTTP_METHODS.join(",");
@@ -308,41 +257,25 @@ var DEFAULT_PREFLIGHT_STATUS_CODE = 204;
 var DEFAULT_HOSTNAME = "localhost";
 var DEFAULT_LOG_UNHANDLED_REQUESTS = true;
 
-// ../zimic-utils/dist/chunk-2D3UJWOA.mjs
-var __defProp = Object.defineProperty;
-var __name2 = /* @__PURE__ */ __name((target, value) => __defProp(target, "name", { value, configurable: true }), "__name");
-
-// ../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(path2) {
   const replacedURL = encodeURI(path2).replace(/^\/+/g, "").replace(/\/+$/g, "").replace(getExtraPatternsToEscape(), "\\$1").replace(getURIEncodedBackSlashPattern(), "\\").replace(
     getOptionalRepeatingPathParamPattern(),
@@ -391,8 +324,6 @@ function createParametrizedPathPattern(path2) {
   });
   return new RegExp(`^/?${replacedURL}/?$`);
 }
-__name(createParametrizedPathPattern, "createParametrizedPathPattern");
-__name2(createParametrizedPathPattern, "createParametrizedPathPattern");
 var createParametrizedPathPattern_default = createParametrizedPathPattern;
 
 // ../zimic-utils/dist/url/excludeURLParams.mjs
@@ -403,16 +334,12 @@ function excludeURLParams(url) {
   url.password = "";
   return url;
 }
-__name(excludeURLParams, "excludeURLParams");
-__name2(excludeURLParams, "excludeURLParams");
 var excludeURLParams_default = excludeURLParams;
 
-// ../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;
 
 // src/utils/arrays.ts
@@ -422,39 +349,28 @@ 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");
 
 // src/utils/environment.ts
 function isClientSide() {
   return typeof window !== "undefined" && typeof document !== "undefined";
 }
-__name(isClientSide, "isClientSide");
 
 // ../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 = {}) {
@@ -546,7 +462,6 @@ async function pathExists(path2) {
     return false;
   }
 }
-__name(pathExists, "pathExists");
 
 // src/utils/logging.ts
 var logger = new Logger_default({
@@ -569,7 +484,6 @@ async function formatValueToLog(value, options = {}) {
     sorted: true
   });
 }
-__name(formatValueToLog, "formatValueToLog");
 
 // src/http/requestHandler/types/requests.ts
 var HTTP_INTERCEPTOR_REQUEST_HIDDEN_PROPERTIES = Object.freeze(
@@ -603,9 +517,6 @@ var DEFAULT_UNHANDLED_REQUEST_STRATEGY = Object.freeze({
 
 // 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";
@@ -615,9 +526,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";
@@ -627,9 +535,6 @@ var InvalidJSONError_default = InvalidJSONError;
 
 // src/http/interceptorWorker/HttpInterceptorWorker.ts
 var HttpInterceptorWorker = class _HttpInterceptorWorker {
-  static {
-    __name(this, "HttpInterceptorWorker");
-  }
   platform = null;
   isRunning = false;
   startingPromise;
@@ -960,7 +865,6 @@ function convertArrayBufferToBase64(buffer) {
     return Buffer.from(buffer).toString("base64");
   }
 }
-__name(convertArrayBufferToBase64, "convertArrayBufferToBase64");
 function convertBase64ToArrayBuffer(base64Value) {
   if (isClientSide()) {
     const bufferAsString = atob(base64Value);
@@ -970,18 +874,15 @@ function convertBase64ToArrayBuffer(base64Value) {
     return Buffer.from(base64Value, "base64");
   }
 }
-__name(convertBase64ToArrayBuffer, "convertBase64ToArrayBuffer");
 var HEX_REGEX = /^[a-z0-9]+$/;
 function convertHexLengthToByteLength(hexLength) {
   return Math.ceil(hexLength / 2);
 }
-__name(convertHexLengthToByteLength, "convertHexLengthToByteLength");
 var BASE64URL_REGEX = /^[a-zA-Z0-9-_]+$/;
 function convertHexLengthToBase64urlLength(hexLength) {
   const byteLength = convertHexLengthToByteLength(hexLength);
   return Math.ceil(byteLength * 4 / 3);
 }
-__name(convertHexLengthToBase64urlLength, "convertHexLengthToBase64urlLength");
 
 // src/utils/fetch.ts
 async function serializeRequest(request) {
@@ -1002,7 +903,6 @@ async function serializeRequest(request) {
     body: serializedBody
   };
 }
-__name(serializeRequest, "serializeRequest");
 function deserializeResponse(serializedResponse) {
   const deserializedBody = serializedResponse.body ? convertBase64ToArrayBuffer(serializedResponse.body) : null;
   return new Response(deserializedBody, {
@@ -1011,7 +911,6 @@ function deserializeResponse(serializedResponse) {
     headers: new Headers(serializedResponse.headers)
   });
 }
-__name(deserializeResponse, "deserializeResponse");
 
 // src/utils/crypto.ts
 var importCrypto = createCachedDynamicImport_default(async () => {
@@ -1024,9 +923,6 @@ 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";
@@ -1036,9 +932,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";
@@ -1048,9 +941,6 @@ var NotRunningWebSocketHandlerError_default = NotRunningWebSocketHandlerError;
 
 // src/webSocket/WebSocketHandler.ts
 var WebSocketHandler = class {
-  static {
-    __name(this, "WebSocketHandler");
-  }
   sockets = /* @__PURE__ */ new Set();
   socketTimeout;
   messageTimeout;
@@ -1067,26 +957,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;
@@ -1097,7 +986,7 @@ var WebSocketHandler = class {
     } catch (error) {
       console.error(error);
     }
-  }, "handleSocketMessage");
+  };
   isControlMessageData(messageData) {
     return typeof messageData === "string" && WEB_SOCKET_CONTROL_MESSAGES.includes(messageData);
   }
@@ -1298,9 +1187,6 @@ var WebSocketHandler_default = WebSocketHandler;
 // src/webSocket/WebSocketServer.ts
 var { WebSocketServer: ServerSocket } = ClientSocket;
 var WebSocketServer = class extends WebSocketHandler_default {
-  static {
-    __name(this, "WebSocketServer");
-  }
   webSocketServer;
   httpServer;
   authenticate;
@@ -1356,9 +1242,6 @@ var WebSocketServer_default = WebSocketServer;
 
 // src/server/errors/InvalidInterceptorTokenError.ts
 var InvalidInterceptorTokenError = class extends Error {
-  static {
-    __name(this, "InvalidInterceptorTokenError");
-  }
   constructor(tokenId) {
     super(`Invalid interceptor token: ${tokenId}`);
     this.name = "InvalidInterceptorTokenError";
@@ -1368,9 +1251,6 @@ var InvalidInterceptorTokenError_default = InvalidInterceptorTokenError;
 
 // src/server/errors/InvalidInterceptorTokenFileError.ts
 var InvalidInterceptorTokenFileError = class extends Error {
-  static {
-    __name(this, "InvalidInterceptorTokenFileError");
-  }
   constructor(tokenFilePath, validationErrorMessage) {
     super(`Invalid interceptor token file ${tokenFilePath}: ${validationErrorMessage}`);
     this.name = "InvalidInterceptorTokenFileError";
@@ -1380,9 +1260,6 @@ var InvalidInterceptorTokenFileError_default = InvalidInterceptorTokenFileError;
 
 // src/server/errors/InvalidInterceptorTokenValueError.ts
 var InvalidInterceptorTokenValueError = class extends Error {
-  static {
-    __name(this, "InvalidInterceptorTokenValueError");
-  }
   constructor(tokenValue) {
     super(`Invalid interceptor token value: ${tokenValue}`);
     this.name = "InvalidInterceptorTokenValueError";
@@ -1419,19 +1296,15 @@ async function hashInterceptorToken(plainToken, salt) {
   const hash = hashBuffer.toString("hex");
   return hash;
 }
-__name(hashInterceptorToken, "hashInterceptorToken");
 function createInterceptorTokenId() {
   return crypto.randomUUID().replace(/[^a-z0-9]/g, "");
 }
-__name(createInterceptorTokenId, "createInterceptorTokenId");
 function isValidInterceptorTokenId(tokenId) {
   return tokenId.length === INTERCEPTOR_TOKEN_ID_HEX_LENGTH && HEX_REGEX.test(tokenId);
 }
-__name(isValidInterceptorTokenId, "isValidInterceptorTokenId");
 function isValidInterceptorTokenValue(tokenValue) {
   return tokenValue.length === INTERCEPTOR_TOKEN_VALUE_BASE64URL_LENGTH && BASE64URL_REGEX.test(tokenValue);
 }
-__name(isValidInterceptorTokenValue, "isValidInterceptorTokenValue");
 async function createInterceptorTokensDirectory(tokensDirectory) {
   try {
     const parentTokensDirectory = path.dirname(tokensDirectory);
@@ -1445,7 +1318,6 @@ async function createInterceptorTokensDirectory(tokensDirectory) {
     throw error;
   }
 }
-__name(createInterceptorTokensDirectory, "createInterceptorTokensDirectory");
 var interceptorTokenFileContentSchema = z.object({
   version: z.literal(1),
   token: z.object({
@@ -1479,7 +1351,6 @@ async function saveInterceptorTokenToFile(tokensDirectory, token) {
   });
   return tokeFilePath;
 }
-__name(saveInterceptorTokenToFile, "saveInterceptorTokenToFile");
 async function readInterceptorTokenFromFile(tokenId, options) {
   if (!isValidInterceptorTokenId(tokenId)) {
     throw new InvalidInterceptorTokenError_default(tokenId);
@@ -1496,7 +1367,6 @@ async function readInterceptorTokenFromFile(tokenId, options) {
   }
   return validation.data.token;
 }
-__name(readInterceptorTokenFromFile, "readInterceptorTokenFromFile");
 async function createInterceptorToken(options = {}) {
   const { name, tokensDirectory = DEFAULT_INTERCEPTOR_TOKENS_DIRECTORY } = options;
   const tokensDirectoryExists = await pathExists(tokensDirectory);
@@ -1530,7 +1400,6 @@ async function createInterceptorToken(options = {}) {
   await saveInterceptorTokenToFile(tokensDirectory, token);
   return token;
 }
-__name(createInterceptorToken, "createInterceptorToken");
 async function listInterceptorTokens(options = {}) {
   const { tokensDirectory = DEFAULT_INTERCEPTOR_TOKENS_DIRECTORY } = options;
   const tokensDirectoryExists = await pathExists(tokensDirectory);
@@ -1558,7 +1427,6 @@ async function listInterceptorTokens(options = {}) {
   tokens.sort((token, otherToken) => token.createdAt.getTime() - otherToken.createdAt.getTime());
   return tokens;
 }
-__name(listInterceptorTokens, "listInterceptorTokens");
 async function validateInterceptorToken(tokenValue, options) {
   if (!isValidInterceptorTokenValue(tokenValue)) {
     throw new InvalidInterceptorTokenValueError_default(tokenValue);
@@ -1578,7 +1446,6 @@ async function validateInterceptorToken(tokenValue, options) {
     throw new InvalidInterceptorTokenValueError_default(tokenValue);
   }
 }
-__name(validateInterceptorToken, "validateInterceptorToken");
 async function removeInterceptorToken(tokenId, options = {}) {
   const { tokensDirectory = DEFAULT_INTERCEPTOR_TOKENS_DIRECTORY } = options;
   if (!isValidInterceptorTokenId(tokenId)) {
@@ -1587,7 +1454,6 @@ async function removeInterceptorToken(tokenId, options = {}) {
   const tokenFilePath = path.join(tokensDirectory, tokenId);
   await fs.promises.rm(tokenFilePath, { force: true });
 }
-__name(removeInterceptorToken, "removeInterceptorToken");
 
 // src/server/utils/fetch.ts
 async function getFetchAPI() {
@@ -1616,13 +1482,9 @@ async function getFetchAPI() {
     URLSearchParams
   };
 }
-__name(getFetchAPI, "getFetchAPI");
 
 // src/server/InterceptorServer.ts
 var InterceptorServer = class {
-  static {
-    __name(this, "InterceptorServer");
-  }
   httpServer;
   webSocketServer;
   _hostname;
@@ -1693,7 +1555,7 @@ var InterceptorServer = class {
     });
     this.startWebSocketServer();
   }
-  authenticateWebSocketConnection = /* @__PURE__ */ __name(async (_socket, request) => {
+  authenticateWebSocketConnection = async (_socket, request) => {
     if (!this.tokensDirectory) {
       return { isValid: true };
     }
@@ -1708,7 +1570,7 @@ var InterceptorServer = class {
       console.error(error);
       return { isValid: false, message: "The interceptor token is not valid." };
     }
-  }, "authenticateWebSocketConnection");
+  };
   getWebSocketRequestTokenValue(request) {
     const protocols = request.headers["sec-websocket-protocol"] ?? "";
     const parametersAsString = decodeURIComponent(protocols).split(", ");
@@ -1734,13 +1596,13 @@ var InterceptorServer = class {
     this.webSocketServerOrThrow.onEvent("interceptors/workers/commit", this.commitWorker);
     this.webSocketServerOrThrow.onEvent("interceptors/workers/reset", this.resetWorker);
   }
-  commitWorker = /* @__PURE__ */ __name((message, socket) => {
+  commitWorker = (message, socket) => {
     const commit = message.data;
     this.registerHttpHandler(commit, socket);
     this.registerWorkerSocketIfUnknown(socket);
     return {};
-  }, "commitWorker");
-  resetWorker = /* @__PURE__ */ __name((message, socket) => {
+  };
+  resetWorker = (message, socket) => {
     this.removeHttpHandlersBySocket(socket);
     const handlersToResetTo = message.data;
     const isWorkerNoLongerCommitted = handlersToResetTo === void 0;
@@ -1753,7 +1615,7 @@ var InterceptorServer = class {
     }
     this.registerWorkerSocketIfUnknown(socket);
     return {};
-  }, "resetWorker");
+  };
   registerHttpHandler({ id, baseURL, method, path: path2 }, socket) {
     const handlerGroups = this.httpHandlersByMethod[method];
     handlerGroups.push({
@@ -1797,7 +1659,7 @@ var InterceptorServer = class {
     await this.webSocketServerOrThrow.stop();
     this.webSocketServer = void 0;
   }
-  handleHttpRequest = /* @__PURE__ */ __name(async (nodeRequest, nodeResponse) => {
+  handleHttpRequest = async (nodeRequest, nodeResponse) => {
     const request = normalizeNodeRequest(nodeRequest, await getFetchAPI());
     const serializedRequest = await serializeRequest(request);
     try {
@@ -1826,7 +1688,7 @@ var InterceptorServer = class {
       }
       nodeResponse.destroy();
     }
-  }, "handleHttpRequest");
+  };
   async createResponseForRequest(request) {
     const methodHandlers = this.httpHandlersByMethod[request.method];
     const requestURL = excludeURLParams_default(new URL(request.url));
@@ -1903,7 +1765,6 @@ var InterceptorServer_default = InterceptorServer;
 function createInterceptorServer(options = {}) {
   return new InterceptorServer_default(options);
 }
-__name(createInterceptorServer, "createInterceptorServer");
 /* istanbul ignore next -- @preserve */
 /* istanbul ignore if -- @preserve
  * This is expected not to happen since the servers are not stopped unless they are running. */
@@ -1941,5 +1802,5 @@ __name(createInterceptorServer, "createInterceptorServer");
  * Since simulating this scenario is difficult, we are ignoring this branch fow now. */
 
 export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_INTERCEPTOR_TOKENS_DIRECTORY, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default, RunningInterceptorServerError_default, createCachedDynamicImport_default, createInterceptorServer, createInterceptorToken, listInterceptorTokens, logger, readInterceptorTokenFromFile, removeInterceptorToken };
-//# sourceMappingURL=chunk-RDMXECNU.mjs.map
-//# sourceMappingURL=chunk-RDMXECNU.mjs.map
+//# sourceMappingURL=chunk-CSKTIZSC.mjs.map
+//# sourceMappingURL=chunk-CSKTIZSC.mjs.map