@zimic/interceptor 0.15.0-canary.0 → 0.15.0-canary.1

package/dist/http.js

@@ -427,10 +427,10 @@ var DEFAULT_NUMBER_OF_REQUEST_LIMITS = Object.freeze({
   max: Infinity
 });
 var HttpRequestHandlerClient = class {
-  constructor(interceptor, _method, _path, handler) {
+  constructor(interceptor, method, path, handler) {
     this.interceptor = interceptor;
-    this._method = _method;
-    this._path = _path;
+    this.method = method;
+    this.path = path;
     this.handler = handler;
   }
   static {
@@ -443,14 +443,8 @@ var HttpRequestHandlerClient = class {
   timesDeclarationPointer;
   numberOfMatchedRequests = 0;
   unmatchedRequestGroups = [];
-  interceptedRequests = [];
+  _requests = [];
   createResponseDeclaration;
-  method() {
-    return this._method;
-  }
-  path() {
-    return this._path;
-  }
   with(restriction) {
     this.restrictions.push(restriction);
     return this;
@@ -460,7 +454,7 @@ var HttpRequestHandlerClient = class {
     newThis.createResponseDeclaration = this.isResponseDeclarationFactory(declaration) ? declaration : () => declaration;
     newThis.numberOfMatchedRequests = 0;
     newThis.unmatchedRequestGroups.length = 0;
-    newThis.interceptedRequests.length = 0;
+    newThis._requests.length = 0;
     this.interceptor.registerRequestHandler(this.handler);
     return newThis;
   }
@@ -484,7 +478,7 @@ var HttpRequestHandlerClient = class {
         declarationPointer: this.timesDeclarationPointer,
         unmatchedRequestGroups: this.unmatchedRequestGroups,
         hasRestrictions: this.restrictions.length > 0,
-        hasSavedRequests: this.interceptor.shouldSaveRequests()
+        hasSavedRequests: this.interceptor.shouldSaveRequests
       });
     }
   }
@@ -496,7 +490,7 @@ var HttpRequestHandlerClient = class {
     this.timesDeclarationPointer = void 0;
     this.numberOfMatchedRequests = 0;
     this.unmatchedRequestGroups.length = 0;
-    this.interceptedRequests.length = 0;
+    this._requests.length = 0;
     this.createResponseDeclaration = void 0;
     return this;
   }
@@ -509,7 +503,7 @@ var HttpRequestHandlerClient = class {
     if (restrictionsMatch.value) {
       this.numberOfMatchedRequests++;
     } else {
-      const shouldSaveUnmatchedGroup = this.interceptor.shouldSaveRequests() && this.restrictions.length > 0 && this.timesDeclarationPointer !== void 0;
+      const shouldSaveUnmatchedGroup = this.interceptor.shouldSaveRequests && this.restrictions.length > 0 && this.timesDeclarationPointer !== void 0;
       if (shouldSaveUnmatchedGroup) {
         this.unmatchedRequestGroups.push({ request, diff: restrictionsMatch.diff });
       }
@@ -642,7 +636,7 @@ var HttpRequestHandlerClient = class {
   }
   saveInterceptedRequest(request, response) {
     const interceptedRequest = this.createInterceptedRequest(request, response);
-    this.interceptedRequests.push(interceptedRequest);
+    this._requests.push(interceptedRequest);
   }
   createInterceptedRequest(request, response) {
     const interceptedRequest = request;
@@ -654,13 +648,11 @@ var HttpRequestHandlerClient = class {
     });
     return interceptedRequest;
   }
-  requests() {
-    if (!this.interceptor.shouldSaveRequests()) {
+  get requests() {
+    if (!this.interceptor.shouldSaveRequests) {
       throw new DisabledRequestSavingError_default();
     }
-    const interceptedRequestsCopy = [...this.interceptedRequests];
-    Object.freeze(interceptedRequestsCopy);
-    return interceptedRequestsCopy;
+    return this._requests;
   }
 };
 var HttpRequestHandlerClient_default = HttpRequestHandlerClient;
@@ -671,50 +663,47 @@ var LocalHttpRequestHandler = class {
     __name(this, "LocalHttpRequestHandler");
   }
   type = "local";
-  _client;
+  client;
   constructor(interceptor, method, path) {
-    this._client = new HttpRequestHandlerClient_default(interceptor, method, path, this);
-  }
-  client() {
-    return this._client;
+    this.client = new HttpRequestHandlerClient_default(interceptor, method, path, this);
   }
-  method() {
-    return this._client.method();
+  get method() {
+    return this.client.method;
   }
-  path() {
-    return this._client.path();
+  get path() {
+    return this.client.path;
   }
   with(restriction) {
-    this._client.with(restriction);
+    this.client.with(restriction);
     return this;
   }
   respond(declaration) {
-    this._client.respond(declaration);
+    this.client.respond(declaration);
     const newThis = this;
     return newThis;
   }
   times(minNumberOfRequests, maxNumberOfRequests) {
-    this._client.times(minNumberOfRequests, maxNumberOfRequests);
+    this.client.times(minNumberOfRequests, maxNumberOfRequests);
     return this;
   }
   checkTimes() {
-    this._client.checkTimes();
+    this.client.checkTimes();
   }
   clear() {
-    this._client.clear();
+    this.client.clear();
     return this;
   }
-  requests() {
-    return this._client.requests();
+  get requests() {
+    return this.client.requests;
   }
   matchesRequest(request) {
-    return this._client.matchesRequest(request);
+    return this.client.matchesRequest(request);
   }
   async applyResponseDeclaration(request) {
-    return this._client.applyResponseDeclaration(request);
+    return this.client.applyResponseDeclaration(request);
   }
   saveInterceptedRequest(request, response) {
-    this._client.saveInterceptedRequest(request, response);
+    this.client.saveInterceptedRequest(request, response);
   }
 };
 var LocalHttpRequestHandler_default = LocalHttpRequestHandler;
@@ -850,26 +839,14 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
   static {
     __name(this, "HttpInterceptorWorker");
   }
-  _platform = null;
-  _isRunning = false;
+  platform = null;
+  isRunning = false;
   startingPromise;
   stoppingPromise;
   store = new HttpInterceptorWorkerStore_default();
   runningInterceptors = [];
-  platform() {
-    return this._platform;
-  }
-  setPlatform(platform) {
-    this._platform = platform;
-  }
-  isRunning() {
-    return this._isRunning;
-  }
-  setIsRunning(isRunning) {
-    this._isRunning = isRunning;
-  }
   async sharedStart(internalStart) {
-    if (this.isRunning()) {
+    if (this.isRunning) {
       return;
     }
     if (this.startingPromise) {
@@ -888,7 +865,7 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
     }
   }
   async sharedStop(internalStop) {
-    if (!this.isRunning()) {
+    if (!this.isRunning) {
       return;
     }
     if (this.stoppingPromise) {
@@ -953,8 +930,7 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
   }
   findInterceptorByRequestBaseURL(request) {
     const interceptor = this.runningInterceptors.findLast((interceptor2) => {
-      const baseURL = interceptor2.baseURL();
-      return request.url.startsWith(baseURL);
+      return request.url.startsWith(interceptor2.baseURLAsString);
     });
     return interceptor;
   }
@@ -970,12 +946,11 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
     return defaultStrategyOrFactory;
   }
   async getInterceptorUnhandledRequestStrategy(request, interceptor) {
-    const interceptorStrategyOrFactory = interceptor.onUnhandledRequest();
-    if (typeof interceptorStrategyOrFactory === "function") {
+    if (typeof interceptor.onUnhandledRequest === "function") {
       const parsedRequest = await _HttpInterceptorWorker.parseRawUnhandledRequest(request);
-      return interceptorStrategyOrFactory(parsedRequest);
+      return interceptor.onUnhandledRequest(parsedRequest);
     }
-    return interceptorStrategyOrFactory;
+    return interceptor.onUnhandledRequest;
   }
   static createResponseFromDeclaration(request, declaration) {
     const headers = new http.HttpHeaders(declaration.headers);
@@ -1288,7 +1263,7 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     __name(this, "LocalHttpInterceptorWorker");
   }
   type;
-  _internalWorker;
+  internalWorker;
   defaultHttpHandler;
   httpHandlerGroups = [];
   constructor(options) {
@@ -1299,17 +1274,17 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       return this.bypassOrRejectUnhandledRequest(request);
     });
   }
-  internalWorkerOrThrow() {
-    if (!this._internalWorker) {
+  get internalWorkerOrThrow() {
+    if (!this.internalWorker) {
       throw new NotStartedHttpInterceptorError_default();
     }
-    return this._internalWorker;
+    return this.internalWorker;
   }
-  internalWorkerOrCreate() {
-    if (!this._internalWorker) {
-      this._internalWorker = this.createInternalWorker();
+  get internalWorkerOrCreate() {
+    if (!this.internalWorker) {
+      this.internalWorker = this.createInternalWorker();
     }
-    return this._internalWorker;
+    return this.internalWorker;
   }
   createInternalWorker() {
     if (isServerSide() && "setupServer" in mswNode__namespace) {
@@ -1322,18 +1297,18 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   }
   async start() {
     await super.sharedStart(async () => {
-      const internalWorker = this.internalWorkerOrCreate();
+      const internalWorker = this.internalWorkerOrCreate;
       const sharedOptions = {
         onUnhandledRequest: "bypass"
       };
       if (this.isInternalBrowserWorker(internalWorker)) {
-        super.setPlatform("browser");
+        this.platform = "browser";
         await this.startInBrowser(internalWorker, sharedOptions);
       } else {
-        super.setPlatform("node");
+        this.platform = "node";
         this.startInNode(internalWorker, sharedOptions);
       }
-      super.setIsRunning(true);
+      this.isRunning = true;
     });
   }
   async startInBrowser(internalWorker, sharedOptions) {
@@ -1354,15 +1329,15 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   }
   async stop() {
     await super.sharedStop(() => {
-      const internalWorker = this.internalWorkerOrCreate();
+      const internalWorker = this.internalWorkerOrCreate;
       if (this.isInternalBrowserWorker(internalWorker)) {
         this.stopInBrowser(internalWorker);
       } else {
         this.stopInNode(internalWorker);
       }
       this.clearHandlers();
-      this._internalWorker = void 0;
-      super.setIsRunning(false);
+      this.internalWorker = void 0;
+      this.isRunning = false;
     });
   }
   stopInBrowser(internalWorker) {
@@ -1375,13 +1350,12 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     return "start" in worker && "stop" in worker;
   }
   hasInternalBrowserWorker() {
-    return this.isInternalBrowserWorker(this.internalWorkerOrThrow());
+    return this.isInternalBrowserWorker(this.internalWorkerOrThrow);
   }
   hasInternalNodeWorker() {
     return !this.hasInternalBrowserWorker();
   }
   use(interceptor, method, rawURL, createResponse) {
-    const internalWorker = this.internalWorkerOrThrow();
     const lowercaseMethod = method.toLowerCase();
     const url = new URL(rawURL);
     excludeURLParams_default(url);
@@ -1407,7 +1381,7 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       }
       return response;
     });
-    internalWorker.use(httpHandler);
+    this.internalWorkerOrThrow.use(httpHandler);
     this.httpHandlerGroups.push({ interceptor, httpHandler });
   }
   async bypassOrRejectUnhandledRequest(request) {
@@ -1421,20 +1395,18 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     }
   }
   clearHandlers() {
-    const internalWorker = this.internalWorkerOrThrow();
-    internalWorker.resetHandlers();
+    this.internalWorkerOrThrow.resetHandlers();
     this.httpHandlerGroups = [];
   }
   clearInterceptorHandlers(interceptor) {
-    const internalWorker = this.internalWorkerOrThrow();
     const groupToRemoveIndex = this.httpHandlerGroups.findIndex((group) => group.interceptor === interceptor);
     removeArrayIndex(this.httpHandlerGroups, groupToRemoveIndex);
-    internalWorker.resetHandlers();
+    this.internalWorkerOrThrow.resetHandlers();
     for (const { httpHandler } of this.httpHandlerGroups) {
-      internalWorker.use(httpHandler);
+      this.internalWorkerOrThrow.use(httpHandler);
     }
   }
-  interceptorsWithHandlers() {
+  get interceptorsWithHandlers() {
     return this.httpHandlerGroups.map((group) => group.interceptor);
   }
 };
@@ -1447,12 +1419,12 @@ var RemoteHttpRequestHandler = class {
     __name(this, "RemoteHttpRequestHandler");
   }
   type = "remote";
-  _client;
+  client;
   syncPromises = [];
   unsynced;
   synced;
   constructor(interceptor, method, path) {
-    this._client = new HttpRequestHandlerClient_default(interceptor, method, path, this);
+    this.client = new HttpRequestHandlerClient_default(interceptor, method, path, this);
     this.unsynced = this;
     this.synced = this.createSyncedProxy();
   }
@@ -1475,32 +1447,29 @@ var RemoteHttpRequestHandler = class {
   isHiddenPropertyWhenSynced(property) {
     return PENDING_PROPERTIES.has(property);
   }
-  client() {
-    return this._client;
-  }
-  method() {
-    return this._client.method();
+  get method() {
+    return this.client.method;
   }
-  path() {
-    return this._client.path();
+  get path() {
+    return this.client.path;
   }
   with(restriction) {
-    this._client.with(restriction);
+    this.client.with(restriction);
     return this.unsynced;
   }
   respond(declaration) {
     const newUnsyncedThis = this.unsynced;
-    newUnsyncedThis._client.respond(declaration);
+    newUnsyncedThis.client.respond(declaration);
     return newUnsyncedThis;
   }
   times(minNumberOfRequests, maxNumberOfRequests) {
-    this._client.times(minNumberOfRequests, maxNumberOfRequests);
+    this.client.times(minNumberOfRequests, maxNumberOfRequests);
     return this;
   }
   async checkTimes() {
     return new Promise((resolve, reject) => {
       try {
-        this._client.checkTimes();
+        this.client.checkTimes();
         resolve();
       } catch (error) {
         reject(error);
@@ -1508,38 +1477,32 @@ var RemoteHttpRequestHandler = class {
     });
   }
   clear() {
-    this._client.clear();
+    this.client.clear();
     return this.unsynced;
   }
-  requests() {
-    return new Promise((resolve, reject) => {
-      try {
-        resolve(this._client.requests());
-      } catch (error) {
-        reject(error);
-      }
-    });
+  get requests() {
+    return this.client.requests;
   }
   matchesRequest(request) {
-    return this._client.matchesRequest(request);
+    return this.client.matchesRequest(request);
   }
   async applyResponseDeclaration(request) {
-    return this._client.applyResponseDeclaration(request);
+    return this.client.applyResponseDeclaration(request);
   }
   saveInterceptedRequest(request, response) {
-    this._client.saveInterceptedRequest(request, response);
+    this.client.saveInterceptedRequest(request, response);
   }
   registerSyncPromise(promise) {
     this.syncPromises.push(promise);
   }
-  isSynced() {
+  get isSynced() {
     return this.syncPromises.length === 0;
   }
   then(onFulfilled, onRejected) {
     const promisesToWait = new Set(this.syncPromises);
     return Promise.all(promisesToWait).then(() => {
       this.syncPromises = this.syncPromises.filter((promise) => !promisesToWait.has(promise));
-      return this.isSynced() ? this.synced : this.unsynced;
+      return this.isSynced ? this.synced : this.unsynced;
     }).then(onFulfilled, onRejected);
   }
   catch(onRejected) {
@@ -1560,9 +1523,9 @@ var HttpInterceptorClient = class {
   worker;
   store;
   _baseURL;
-  _isRunning = false;
-  _onUnhandledRequest;
-  _shouldSaveRequests = false;
+  isRunning = false;
+  onUnhandledRequest;
+  shouldSaveRequests = false;
   Handler;
   handlerClientsByMethod = {
     GET: /* @__PURE__ */ new Map(),
@@ -1578,27 +1541,18 @@ var HttpInterceptorClient = class {
     this.store = options.store;
     this._baseURL = options.baseURL;
     this.Handler = options.Handler;
-    this._onUnhandledRequest = options.onUnhandledRequest;
-    this._shouldSaveRequests = options.saveRequests ?? false;
+    this.onUnhandledRequest = options.onUnhandledRequest;
+    this.shouldSaveRequests = options.saveRequests ?? false;
   }
-  baseURL() {
+  get baseURLAsString() {
     const baseURL = this._baseURL;
     if (baseURL.href === `${baseURL.origin}/`) {
       return baseURL.origin;
     }
-    return baseURL.toString();
-  }
-  platform() {
-    return this.worker.platform();
-  }
-  onUnhandledRequest() {
-    return this._onUnhandledRequest;
-  }
-  isRunning() {
-    return this.worker.isRunning() && this._isRunning;
+    return baseURL.href;
   }
-  shouldSaveRequests() {
-    return this._shouldSaveRequests;
+  get platform() {
+    return this.worker.platform;
   }
   async start() {
     await this.worker.start();
@@ -1619,11 +1573,11 @@ var HttpInterceptorClient = class {
     } else {
       this.store.markRemoteInterceptorAsRunning(this, isRunning, this._baseURL);
     }
-    this._isRunning = isRunning;
+    this.isRunning = isRunning;
   }
   numberOfRunningInterceptors() {
     if (this.worker instanceof LocalHttpInterceptorWorker_default) {
-      return this.store.numberOfRunningLocalInterceptors();
+      return this.store.numberOfRunningLocalInterceptors;
     } else {
       return this.store.numberOfRunningRemoteInterceptors(this._baseURL);
     }
@@ -1650,7 +1604,7 @@ var HttpInterceptorClient = class {
     return this.createHttpRequestHandler("OPTIONS", path);
   }
   createHttpRequestHandler(method, path) {
-    if (!this.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedHttpInterceptorError_default();
     }
     const handler = new this.Handler(this, method, path);
@@ -1658,24 +1612,24 @@ var HttpInterceptorClient = class {
     return handler;
   }
   registerRequestHandler(handler) {
-    const handlerClients = this.handlerClientsByMethod[handler.method()].get(handler.path()) ?? [];
-    const isAlreadyRegistered = handlerClients.includes(handler.client());
+    const handlerClients = this.handlerClientsByMethod[handler.method].get(handler.path) ?? [];
+    const isAlreadyRegistered = handlerClients.includes(handler.client);
     if (isAlreadyRegistered) {
       return;
     }
-    handlerClients.push(handler.client());
+    handlerClients.push(handler.client);
     const isFirstHandlerForMethodPath = handlerClients.length === 1;
     if (!isFirstHandlerForMethodPath) {
       return;
     }
-    this.handlerClientsByMethod[handler.method()].set(handler.path(), handlerClients);
-    const url = joinURL_default(this.baseURL(), handler.path());
+    this.handlerClientsByMethod[handler.method].set(handler.path, handlerClients);
+    const url = joinURL_default(this.baseURLAsString, handler.path);
     const urlRegex = createRegExpFromURL_default(url);
-    const registrationResult = this.worker.use(this, handler.method(), url, async (context) => {
+    const registrationResult = this.worker.use(this, handler.method, url, async (context) => {
       const response = await this.handleInterceptedRequest(
         urlRegex,
-        handler.method(),
-        handler.path(),
+        handler.method,
+        handler.path,
         context
       );
       return response;
@@ -1694,7 +1648,7 @@ var HttpInterceptorClient = class {
     }
     const responseDeclaration = await matchedHandler.applyResponseDeclaration(parsedRequest);
     const response = HttpInterceptorWorker_default.createResponseFromDeclaration(request, responseDeclaration);
-    if (this.shouldSaveRequests()) {
+    if (this.shouldSaveRequests) {
       const responseClone = response.clone();
       const parsedResponse = await HttpInterceptorWorker_default.parseRawResponse(responseClone);
       matchedHandler.saveInterceptedRequest(parsedRequest, parsedResponse);
@@ -1722,7 +1676,7 @@ var HttpInterceptorClient = class {
     }
   }
   clear(options = {}) {
-    if (!this.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedHttpInterceptorError_default();
     }
     const clearResults = [];
@@ -1946,24 +1900,18 @@ var WebSocketHandler = class {
     __name(this, "WebSocketHandler");
   }
   sockets = /* @__PURE__ */ new Set();
-  _socketTimeout;
-  _messageTimeout;
+  socketTimeout;
+  messageTimeout;
   channelListeners = {};
   socketListeners = {
     messageAbort: /* @__PURE__ */ new Map()
   };
   constructor(options) {
-    this._socketTimeout = options.socketTimeout ?? DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT;
-    this._messageTimeout = options.messageTimeout ?? DEFAULT_WEB_SOCKET_MESSAGE_TIMEOUT;
-  }
-  socketTimeout() {
-    return this._socketTimeout;
-  }
-  messageTimeout() {
-    return this._messageTimeout;
+    this.socketTimeout = options.socketTimeout ?? DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT;
+    this.messageTimeout = options.messageTimeout ?? DEFAULT_WEB_SOCKET_MESSAGE_TIMEOUT;
   }
   async registerSocket(socket) {
-    const openPromise = waitForOpenClientSocket(socket, { timeout: this._socketTimeout });
+    const openPromise = waitForOpenClientSocket(socket, { timeout: this.socketTimeout });
     const handleSocketMessage = /* @__PURE__ */ __name(async (rawMessage) => {
       await this.handleSocketMessage(socket, rawMessage);
     }, "handleSocketMessage");
@@ -2050,7 +1998,7 @@ var WebSocketHandler = class {
   }
   async closeClientSockets(sockets = this.sockets) {
     const closingPromises = Array.from(sockets, async (socket) => {
-      await closeClientSocket(socket, { timeout: this._socketTimeout });
+      await closeClientSocket(socket, { timeout: this.socketTimeout });
     });
     await Promise.all(closingPromises);
   }
@@ -2082,9 +2030,9 @@ var WebSocketHandler = class {
       const replyTimeout = setTimeout(() => {
         this.offReply(channel, replyListener);
         this.offAbortSocketMessages(sockets, abortListener);
-        const timeoutError = new WebSocketMessageTimeoutError(this._messageTimeout);
+        const timeoutError = new WebSocketMessageTimeoutError(this.messageTimeout);
         reject(timeoutError);
-      }, this._messageTimeout);
+      }, this.messageTimeout);
       const abortListener = this.onAbortSocketMessages(sockets, (error) => {
         clearTimeout(replyTimeout);
         this.offReply(channel, replyListener);
@@ -2106,7 +2054,7 @@ var WebSocketHandler = class {
   }
   async reply(request, replyData, options) {
     const reply = await this.createReplyMessage(request, replyData);
-    if (this.isRunning()) {
+    if (this.isRunning) {
       this.sendMessage(reply, options.sockets);
     }
   }
@@ -2121,7 +2069,7 @@ var WebSocketHandler = class {
     return replyMessage;
   }
   sendMessage(message, sockets = this.sockets) {
-    if (!this.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedWebSocketHandlerError_default();
     }
     const stringifiedMessage = JSON.stringify(message);
@@ -2202,7 +2150,7 @@ var WebSocketClient = class extends WebSocketHandler_default {
     this.url = new URL(options.url);
     validateURLProtocol_default(this.url, SUPPORTED_WEB_SOCKET_PROTOCOLS);
   }
-  isRunning() {
+  get isRunning() {
     return this.socket !== void 0 && this.socket.readyState === this.socket.OPEN;
   }
   async start() {
@@ -2230,13 +2178,13 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     __name(this, "RemoteHttpInterceptorWorker");
   }
   type;
-  _webSocketClient;
+  webSocketClient;
   httpHandlers = /* @__PURE__ */ new Map();
   constructor(options) {
     super();
     this.type = options.type;
     const webSocketServerURL = this.deriveWebSocketServerURL(options.serverURL);
-    this._webSocketClient = new WebSocketClient_default({
+    this.webSocketClient = new WebSocketClient_default({
       url: webSocketServerURL.toString()
     });
   }
@@ -2245,17 +2193,13 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     webSocketServerURL.protocol = serverURL.protocol.replace(/^http(s)?:$/, "ws$1:");
     return webSocketServerURL;
   }
-  webSocketClient() {
-    return this._webSocketClient;
-  }
   async start() {
     await super.sharedStart(async () => {
-      await this._webSocketClient.start();
-      this._webSocketClient.onEvent("interceptors/responses/create", this.createResponse);
-      this._webSocketClient.onEvent("interceptors/responses/unhandled", this.handleUnhandledServerRequest);
-      const platform = this.readPlatform();
-      super.setPlatform(platform);
-      super.setIsRunning(true);
+      await this.webSocketClient.start();
+      this.webSocketClient.onEvent("interceptors/responses/create", this.createResponse);
+      this.webSocketClient.onEvent("interceptors/responses/unhandled", this.handleUnhandledServerRequest);
+      this.platform = this.readPlatform();
+      this.isRunning = true;
     });
   }
   createResponse = /* @__PURE__ */ __name(async (message) => {
@@ -2294,14 +2238,14 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   async stop() {
     await super.sharedStop(async () => {
       await this.clearHandlers();
-      this._webSocketClient.offEvent("interceptors/responses/create", this.createResponse);
-      this._webSocketClient.offEvent("interceptors/responses/unhandled", this.handleUnhandledServerRequest);
-      await this._webSocketClient.stop();
-      super.setIsRunning(false);
+      this.webSocketClient.offEvent("interceptors/responses/create", this.createResponse);
+      this.webSocketClient.offEvent("interceptors/responses/unhandled", this.handleUnhandledServerRequest);
+      await this.webSocketClient.stop();
+      this.isRunning = false;
     });
   }
   async use(interceptor, method, rawURL, createResponse) {
-    if (!super.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedHttpInterceptorError_default();
     }
     const crypto = await importCrypto();
@@ -2311,7 +2255,7 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     const handler = {
       id: crypto.randomUUID(),
       url: {
-        base: interceptor.baseURL(),
+        base: interceptor.baseURLAsString,
         full: url.toString()
       },
       method,
@@ -2322,23 +2266,23 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       }
     };
     this.httpHandlers.set(handler.id, handler);
-    await this._webSocketClient.request("interceptors/workers/use/commit", {
+    await this.webSocketClient.request("interceptors/workers/use/commit", {
       id: handler.id,
       url: handler.url,
       method
     });
   }
   async clearHandlers() {
-    if (!super.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedHttpInterceptorError_default();
     }
     this.httpHandlers.clear();
-    if (this._webSocketClient.isRunning()) {
-      await this._webSocketClient.request("interceptors/workers/use/reset", void 0);
+    if (this.webSocketClient.isRunning) {
+      await this.webSocketClient.request("interceptors/workers/use/reset", void 0);
     }
   }
   async clearInterceptorHandlers(interceptor) {
-    if (!super.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedHttpInterceptorError_default();
     }
     for (const handler of this.httpHandlers.values()) {
@@ -2346,16 +2290,16 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
         this.httpHandlers.delete(handler.id);
       }
     }
-    if (this._webSocketClient.isRunning()) {
+    if (this.webSocketClient.isRunning) {
       const groupsToRecommit = Array.from(this.httpHandlers.values(), (handler) => ({
         id: handler.id,
         url: handler.url,
         method: handler.method
       }));
-      await this._webSocketClient.request("interceptors/workers/use/reset", groupsToRecommit);
+      await this.webSocketClient.request("interceptors/workers/use/reset", groupsToRecommit);
     }
   }
-  interceptorsWithHandlers() {
+  get interceptorsWithHandlers() {
     const interceptors = Array.from(this.httpHandlers.values(), (handler) => handler.interceptor);
     return interceptors;
   }
@@ -2382,13 +2326,13 @@ var HttpInterceptorStore = class _HttpInterceptorStore {
   static remoteWorkers = /* @__PURE__ */ new Map();
   static runningRemoteInterceptors = /* @__PURE__ */ new Map();
   class = _HttpInterceptorStore;
-  localWorker() {
+  get localWorker() {
     return this.class._localWorker;
   }
   remoteWorker(baseURL) {
     return this.class.remoteWorkers.get(baseURL.origin);
   }
-  numberOfRunningLocalInterceptors() {
+  get numberOfRunningLocalInterceptors() {
     return this.class.runningLocalInterceptors.size;
   }
   numberOfRunningRemoteInterceptors(baseURL) {
@@ -2449,14 +2393,14 @@ var LocalHttpInterceptor = class {
   }
   type;
   store = new HttpInterceptorStore_default();
-  _client;
+  client;
   constructor(options) {
     this.type = options.type;
     const baseURL = new URL(options.baseURL);
     validateURLProtocol_default(baseURL, SUPPORTED_BASE_URL_PROTOCOLS);
     excludeURLParams_default(baseURL);
     const worker = this.store.getOrCreateLocalWorker({});
-    this._client = new HttpInterceptorClient_default({
+    this.client = new HttpInterceptorClient_default({
       worker,
       store: this.store,
       baseURL,
@@ -2465,57 +2409,54 @@ var LocalHttpInterceptor = class {
       saveRequests: options.saveRequests
     });
   }
-  client() {
-    return this._client;
+  get baseURL() {
+    return this.client.baseURLAsString;
   }
-  baseURL() {
-    return this._client.baseURL();
+  get platform() {
+    return this.client.platform;
   }
-  platform() {
-    return this._client.platform();
-  }
-  isRunning() {
-    return this._client.isRunning();
+  get isRunning() {
+    return this.client.isRunning;
   }
   async start() {
-    if (this.isRunning()) {
+    if (this.isRunning) {
       return;
     }
-    await this._client.start();
+    await this.client.start();
   }
   async stop() {
-    if (!this.isRunning()) {
+    if (!this.isRunning) {
       return;
     }
     this.clear();
-    await this._client.stop();
+    await this.client.stop();
   }
   get = /* @__PURE__ */ __name((path) => {
-    return this._client.get(path);
+    return this.client.get(path);
   }, "get");
   post = /* @__PURE__ */ __name((path) => {
-    return this._client.post(path);
+    return this.client.post(path);
   }, "post");
   patch = /* @__PURE__ */ __name((path) => {
-    return this._client.patch(path);
+    return this.client.patch(path);
   }, "patch");
   put = /* @__PURE__ */ __name((path) => {
-    return this._client.put(path);
+    return this.client.put(path);
   }, "put");
   delete = /* @__PURE__ */ __name((path) => {
-    return this._client.delete(path);
+    return this.client.delete(path);
   }, "delete");
   head = /* @__PURE__ */ __name((path) => {
-    return this._client.head(path);
+    return this.client.head(path);
   }, "head");
   options = /* @__PURE__ */ __name((path) => {
-    return this._client.options(path);
+    return this.client.options(path);
   }, "options");
   checkTimes() {
-    this._client.checkTimes();
+    this.client.checkTimes();
   }
   clear() {
-    this._client.clear();
+    this.client.clear();
   }
 };
 var LocalHttpInterceptor_default = LocalHttpInterceptor;
@@ -2527,7 +2468,7 @@ var RemoteHttpInterceptor = class {
   }
   type;
   store = new HttpInterceptorStore_default();
-  _client;
+  client;
   constructor(options) {
     this.type = options.type;
     const baseURL = new URL(options.baseURL);
@@ -2535,7 +2476,7 @@ var RemoteHttpInterceptor = class {
     excludeURLParams_default(baseURL);
     const serverURL = new URL(baseURL.origin);
     const worker = this.store.getOrCreateRemoteWorker({ serverURL });
-    this._client = new HttpInterceptorClient_default({
+    this.client = new HttpInterceptorClient_default({
       worker,
       store: this.store,
       baseURL,
@@ -2544,56 +2485,53 @@ var RemoteHttpInterceptor = class {
       saveRequests: options.saveRequests
     });
   }
-  client() {
-    return this._client;
-  }
-  baseURL() {
-    return this._client.baseURL();
+  get baseURL() {
+    return this.client.baseURLAsString;
   }
-  platform() {
-    return this._client.platform();
+  get platform() {
+    return this.client.platform;
   }
-  isRunning() {
-    return this._client.isRunning();
+  get isRunning() {
+    return this.client.isRunning;
   }
   async start() {
-    if (this.isRunning()) {
+    if (this.isRunning) {
       return;
     }
-    await this._client.start();
+    await this.client.start();
   }
   async stop() {
-    if (!this.isRunning()) {
+    if (!this.isRunning) {
       return;
     }
     await this.clear();
-    await this._client.stop();
+    await this.client.stop();
   }
   get = /* @__PURE__ */ __name((path) => {
-    return this._client.get(path);
+    return this.client.get(path);
   }, "get");
   post = /* @__PURE__ */ __name((path) => {
-    return this._client.post(path);
+    return this.client.post(path);
   }, "post");
   patch = /* @__PURE__ */ __name((path) => {
-    return this._client.patch(path);
+    return this.client.patch(path);
   }, "patch");
   put = /* @__PURE__ */ __name((path) => {
-    return this._client.put(path);
+    return this.client.put(path);
   }, "put");
   delete = /* @__PURE__ */ __name((path) => {
-    return this._client.delete(path);
+    return this.client.delete(path);
   }, "delete");
   head = /* @__PURE__ */ __name((path) => {
-    return this._client.head(path);
+    return this.client.head(path);
   }, "head");
   options = /* @__PURE__ */ __name((path) => {
-    return this._client.options(path);
+    return this.client.options(path);
   }, "options");
   checkTimes() {
     return new Promise((resolve, reject) => {
       try {
-        this._client.checkTimes();
+        this.client.checkTimes();
         resolve();
       } catch (error) {
         reject(error);
@@ -2602,7 +2540,7 @@ var RemoteHttpInterceptor = class {
   }
   async clear() {
     await new Promise((resolve, reject) => {
-      this._client.clear({
+      this.client.clear({
         onCommitSuccess: resolve,
         onCommitError: reject
       });