@checkly/playwright-core 1.47.20-alpha → 1.48.10-alpha

package/browsers.json

@@ -3,31 +3,31 @@
   "browsers": [
     {
       "name": "chromium",
-      "revision": "1134",
+      "revision": "1140",
       "installByDefault": true,
-      "browserVersion": "129.0.6668.29"
+      "browserVersion": "130.0.6723.31"
     },
     {
       "name": "chromium-tip-of-tree",
-      "revision": "1256",
+      "revision": "1264",
       "installByDefault": false,
-      "browserVersion": "130.0.6695.0"
+      "browserVersion": "131.0.6740.0"
     },
     {
       "name": "firefox",
-      "revision": "1463",
+      "revision": "1465",
       "installByDefault": true,
-      "browserVersion": "130.0"
+      "browserVersion": "131.0"
     },
     {
       "name": "firefox-beta",
-      "revision": "1462",
+      "revision": "1464",
       "installByDefault": false,
-      "browserVersion": "130.0b2"
+      "browserVersion": "131.0b2"
     },
     {
       "name": "webkit",
-      "revision": "2070",
+      "revision": "2083",
       "installByDefault": true,
       "revisionOverrides": {
         "mac10.14": "1446",
@@ -42,7 +42,11 @@
     {
       "name": "ffmpeg",
       "revision": "1010",
-      "installByDefault": true
+      "installByDefault": true,
+      "revisionOverrides": {
+        "mac12": "1010",
+        "mac12-arm64": "1010"
+      }
     },
     {
       "name": "android",

package/lib/checkly/escapeRegExp.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * Copyright (c) 2009-2020 Lodash.
+ * Taken from: https://github.com/lodash/lodash/blob/main/src/escapeRegExp.ts
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+const reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+const reHasRegExpChar = RegExp(reRegExpChar.source);
+
+/**
+ * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
+ * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
+ *
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to escape.
+ * @returns {string} Returns the escaped string.
+ * @see escape, escapeRegExp, unescape
+ * @example
+ *
+ * escapeRegExp('[lodash](https://lodash.com/)')
+ * // => '\[lodash\]\(https://lodash\.com/\)'
+ */
+function escapeRegExp(string) {
+  return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, '\\$&') : string || '';
+}
+var _default = exports.default = escapeRegExp;

package/lib/checkly/secretsFilter.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.secretsFilter = void 0;
+var _escapeRegExp = _interopRequireDefault(require("./escapeRegExp"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* Copyright Checkly
+*/
+
+const IdentityFunction = s => s;
+const secretsFilter = () => {
+  const disabled = process.env['CHECKLY_INTERNAL_ENABLE_PATCHED_TRACING'] !== 'true';
+  if (disabled) return IdentityFunction;
+  const keys = process.env['CHECKLY_INTERNAL_REPLACE_TRACE_KEYS'] || '[]';
+  const keylist = JSON.parse(keys);
+  if (keylist.length === 0) return IdentityFunction;
+  const escapedList = keylist.map(_escapeRegExp.default);
+  const regex = new RegExp(escapedList.join('|'), 'g');
+  return s => s.replaceAll(regex, '*********');
+};
+exports.secretsFilter = secretsFilter;

package/lib/cli/program.js

@@ -238,13 +238,10 @@ _utilsBundle.program.command('show-trace [trace...]').option('-b, --browser <bro
 Examples:
 
   $ show-trace https://example.com/trace.zip`);
-async function launchContext(options, headless, executablePath) {
+async function launchContext(options, extraOptions) {
   validateOptions(options);
   const browserType = lookupBrowserType(options);
-  const launchOptions = {
-    headless,
-    executablePath
-  };
+  const launchOptions = extraOptions;
   if (options.channel) launchOptions.channel = options.channel;
   launchOptions.handleSIGINT = false;
   const contextOptions =
@@ -256,7 +253,7 @@ async function launchContext(options, headless, executablePath) {
   // In headful mode, use host device scale factor for things to look nice.
   // In headless, keep things the way it works in Playwright by default.
   // Assume high-dpi on MacOS. TODO: this is not perfect.
-  if (!headless) contextOptions.deviceScaleFactor = _os.default.platform() === 'darwin' ? 2 : 1;
+  if (!extraOptions.headless) contextOptions.deviceScaleFactor = _os.default.platform() === 'darwin' ? 2 : 1;
 
   // Work around the WebKit GTK scrolling issue.
   if (browserType.name() === 'webkit' && process.platform === 'linux') {
@@ -281,7 +278,7 @@ async function launchContext(options, headless, executablePath) {
       process.stdout.write(text);
       process.stdout.write('\n-------------8<-------------\n');
       const autoExitCondition = process.env.PWTEST_CLI_AUTO_EXIT_WHEN;
-      if (autoExitCondition && text.includes(autoExitCondition)) Promise.all(context.pages().map(async p => p.close()));
+      if (autoExitCondition && text.includes(autoExitCondition)) closeBrowser();
     };
     // Make sure we exit abnormally when browser crashes.
     const logs = [];
@@ -383,7 +380,7 @@ async function launchContext(options, headless, executablePath) {
       const hasPage = browser.contexts().some(context => context.pages().length > 0);
       if (hasPage) return;
       // Avoid the error when the last page is closed because the browser has been closed.
-      closeBrowser().catch(e => null);
+      closeBrowser().catch(() => {});
     });
   });
   process.on('SIGINT', async () => {
@@ -431,7 +428,10 @@ async function open(options, url, language) {
     context,
     launchOptions,
     contextOptions
-  } = await launchContext(options, !!process.env.PWTEST_CLI_HEADLESS, process.env.PWTEST_CLI_EXECUTABLE_PATH);
+  } = await launchContext(options, {
+    headless: !!process.env.PWTEST_CLI_HEADLESS,
+    executablePath: process.env.PWTEST_CLI_EXECUTABLE_PATH
+  });
   await context._enableRecorder({
     language,
     launchOptions,
@@ -447,11 +447,16 @@ async function codegen(options, url) {
     output: outputFile,
     testIdAttribute: testIdAttributeName
   } = options;
+  const tracesDir = _path.default.join(_os.default.tmpdir(), `playwright-recorder-trace-${Date.now()}`);
   const {
     context,
     launchOptions,
     contextOptions
-  } = await launchContext(options, !!process.env.PWTEST_CLI_HEADLESS, process.env.PWTEST_CLI_EXECUTABLE_PATH);
+  } = await launchContext(options, {
+    headless: !!process.env.PWTEST_CLI_HEADLESS,
+    executablePath: process.env.PWTEST_CLI_EXECUTABLE_PATH,
+    tracesDir
+  });
   _utilsBundle.dotenv.config({
     path: 'playwright.env'
   });
@@ -462,6 +467,7 @@ async function codegen(options, url) {
     device: options.device,
     saveStorage: options.saveStorage,
     mode: 'recording',
+    codegenMode: process.env.PW_RECORDER_IS_TRACE_VIEWER ? 'trace-events' : 'actions',
     testIdAttributeName,
     outputFile: outputFile ? _path.default.resolve(outputFile) : undefined
   });
@@ -480,7 +486,9 @@ async function waitForPage(page, captureOptions) {
 async function screenshot(options, captureOptions, url, path) {
   const {
     context
-  } = await launchContext(options, true);
+  } = await launchContext(options, {
+    headless: true
+  });
   console.log('Navigating to ' + url);
   const page = await openPage(context, url);
   await waitForPage(page, captureOptions);
@@ -499,7 +507,9 @@ async function pdf(options, captureOptions, url, path) {
   } = await launchContext({
     ...options,
     browser: 'chromium'
-  }, true);
+  }, {
+    headless: true
+  });
   console.log('Navigating to ' + url);
   const page = await openPage(context, url);
   await waitForPage(page, captureOptions);

package/lib/client/api.js

@@ -243,6 +243,12 @@ Object.defineProperty(exports, "WebSocket", {
     return _network.WebSocket;
   }
 });
+Object.defineProperty(exports, "WebSocketRoute", {
+  enumerable: true,
+  get: function () {
+    return _network.WebSocketRoute;
+  }
+});
 Object.defineProperty(exports, "Worker", {
   enumerable: true,
   get: function () {

package/lib/client/browserContext.js

@@ -63,6 +63,7 @@ class BrowserContext extends _channelOwner.ChannelOwner {
     super(parent, type, guid, initializer);
     this._pages = new Set();
     this._routes = [];
+    this._webSocketRoutes = [];
     this._browser = null;
     this._browserType = void 0;
     this._bindings = new Map();
@@ -96,6 +97,9 @@ class BrowserContext extends _channelOwner.ChannelOwner {
     this._channel.on('route', ({
       route
     }) => this._onRoute(network.Route.from(route)));
+    this._channel.on('webSocketRoute', ({
+      webSocketRoute
+    }) => this._onWebSocketRoute(network.WebSocketRoute.from(webSocketRoute)));
     this._channel.on('backgroundPage', ({
       page
     }) => {
@@ -215,7 +219,11 @@ class BrowserContext extends _channelOwner.ChannelOwner {
     }
     // If the page is closed or unrouteAll() was called without waiting and interception disabled,
     // the method will throw an error - silence it.
-    await route._innerContinue(true).catch(() => {});
+    await route._innerContinue(true /* isFallback */).catch(() => {});
+  }
+  async _onWebSocketRoute(webSocketRoute) {
+    const routeHandler = this._webSocketRoutes.find(route => route.matches(webSocketRoute.url()));
+    if (routeHandler) await routeHandler.handle(webSocketRoute);else webSocketRoute.connectToServer();
   }
   async _onBinding(bindingCall) {
     const func = this._bindings.get(bindingCall._initializer.name);
@@ -327,6 +335,10 @@ class BrowserContext extends _channelOwner.ChannelOwner {
     this._routes.unshift(new network.RouteHandler(this._options.baseURL, url, handler, options.times));
     await this._updateInterceptionPatterns();
   }
+  async routeWebSocket(url, handler) {
+    this._webSocketRoutes.unshift(new network.WebSocketRouteHandler(this._options.baseURL, url, handler));
+    await this._updateWebSocketInterceptionPatterns();
+  }
   async _recordIntoHAR(har, page, options = {}) {
     var _options$updateConten, _options$updateMode, _options$updateConten2;
     const {
@@ -385,6 +397,12 @@ class BrowserContext extends _channelOwner.ChannelOwner {
       patterns
     });
   }
+  async _updateWebSocketInterceptionPatterns() {
+    const patterns = network.WebSocketRouteHandler.prepareInterceptionPatterns(this._webSocketRoutes);
+    await this._channel.setWebSocketInterceptionPatterns({
+      patterns
+    });
+  }
   _effectiveCloseReason() {
     var _this$_browser3;
     return this._closeReason || ((_this$_browser3 = this._browser) === null || _this$_browser3 === void 0 ? void 0 : _this$_browser3._closeReason);
@@ -470,7 +488,7 @@ class BrowserContext extends _channelOwner.ChannelOwner {
     await this._closedPromise;
   }
   async _enableRecorder(params) {
-    await this._channel.recorderSupplementEnable(params);
+    await this._channel.enableRecorder(params);
   }
 }
 exports.BrowserContext = BrowserContext;

package/lib/client/channelOwner.js

@@ -39,6 +39,7 @@ class ChannelOwner extends _eventEmitter.EventEmitter {
     this._logger = void 0;
     this._instrumentation = void 0;
     this._eventToSubscriptionMapping = new Map();
+    this._isInternalType = false;
     this._wasCollected = false;
     this.setMaxListeners(0);
     this._connection = parent instanceof ChannelOwner ? parent._connection : parent;
@@ -54,6 +55,9 @@ class ChannelOwner extends _eventEmitter.EventEmitter {
     this._channel = this._createChannel(new _eventEmitter.EventEmitter());
     this._initializer = initializer;
   }
+  markAsInternalType() {
+    this._isInternalType = true;
+  }
   _setEventToSubscriptionMapping(mapping) {
     this._eventToSubscriptionMapping = mapping;
   }
@@ -163,7 +167,7 @@ class ChannelOwner extends _eventEmitter.EventEmitter {
     const stackTrace = (0, _stackTrace.captureLibraryStackTrace)();
     let apiName = stackTrace.apiName;
     const frames = stackTrace.frames;
-    isInternal = isInternal || this._type === 'LocalUtils';
+    isInternal = isInternal || this._isInternalType;
     if (isInternal) apiName = undefined;
 
     // Enclosing zone could have provided the apiName and wallTime.
@@ -187,7 +191,6 @@ class ChannelOwner extends _eventEmitter.EventEmitter {
         stepId
       };
       const result = await _zones.zones.run('apiZone', apiZone, async () => await func(apiZone));
-      // @ts-ignore
       csi === null || csi === void 0 || csi.onApiCallEnd(callCookie, null, result);
       logApiCall(logger, `<= ${apiName} succeeded`, isInternal);
       return result;

package/lib/client/connection.js

@@ -315,6 +315,9 @@ class Connection extends _events.EventEmitter {
       case 'WebSocket':
         result = new _network.WebSocket(parent, type, guid, initializer);
         break;
+      case 'WebSocketRoute':
+        result = new _network.WebSocketRoute(parent, type, guid, initializer);
+        break;
       case 'Worker':
         result = new _worker.Worker(parent, type, guid, initializer);
         break;

package/lib/client/fetch.js

@@ -154,8 +154,9 @@ class APIRequestContext extends _channelOwner.ChannelOwner {
       (0, _utils.assert)(options.maxRedirects === undefined || options.maxRedirects >= 0, `'maxRedirects' must be greater than or equal to '0'`);
       (0, _utils.assert)(options.maxRetries === undefined || options.maxRetries >= 0, `'maxRetries' must be greater than or equal to '0'`);
       const url = options.url !== undefined ? options.url : options.request.url();
-      const params = mapParamsToArray(options.params);
       const method = options.method || ((_options$request = options.request) === null || _options$request === void 0 ? void 0 : _options$request.method());
+      let encodedParams = undefined;
+      if (typeof options.params === 'string') encodedParams = options.params;else if (options.params instanceof URLSearchParams) encodedParams = options.params.toString();
       // Cannot call allHeaders() here as the request may be paused inside route handler.
       const headersObj = options.headers || ((_options$request2 = options.request) === null || _options$request2 === void 0 ? void 0 : _options$request2.headers());
       const headers = headersObj ? (0, _utils.headersObjectToArray)(headersObj) : undefined;
@@ -174,7 +175,18 @@ class APIRequestContext extends _channelOwner.ChannelOwner {
           throw new Error(`Unexpected 'data' type`);
         }
       } else if (options.form) {
-        formData = objectToArray(options.form);
+        if (globalThis.FormData && options.form instanceof FormData) {
+          formData = [];
+          for (const [name, value] of options.form.entries()) {
+            if (typeof value !== 'string') throw new Error(`Expected string for options.form["${name}"], found File. Please use options.multipart instead.`);
+            formData.push({
+              name,
+              value
+            });
+          }
+        } else {
+          formData = objectToArray(options.form);
+        }
       } else if (options.multipart) {
         multipartData = [];
         if (globalThis.FormData && options.multipart instanceof FormData) {
@@ -208,7 +220,8 @@ class APIRequestContext extends _channelOwner.ChannelOwner {
       };
       const result = await this._channel.fetch({
         url,
-        params,
+        params: typeof options.params === 'object' ? objectToArray(options.params) : undefined,
+        encodedParams,
         method,
         headers,
         postData: postDataBuffer,

package/lib/client/jsHandle.js

@@ -86,14 +86,6 @@ class JSHandle extends _channelOwner.ChannelOwner {
       throw e;
     }
   }
-  async _objectCount() {
-    return await this._wrapApiCall(async () => {
-      const {
-        count
-      } = await this._channel.objectCount();
-      return count;
-    });
-  }
   toString() {
     return this._preview;
   }

package/lib/client/localUtils.js

@@ -25,6 +25,7 @@ class LocalUtils extends _channelOwner.ChannelOwner {
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
     this.devices = void 0;
+    this.markAsInternalType();
     this.devices = {};
     for (const {
       name,

package/lib/client/network.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.WebSocket = exports.RouteHandler = exports.Route = exports.Response = exports.Request = exports.RawHeaders = void 0;
+exports.WebSocketRouteHandler = exports.WebSocketRoute = exports.WebSocket = exports.RouteHandler = exports.Route = exports.Response = exports.Request = exports.RawHeaders = void 0;
 exports.validateHeaders = validateHeaders;
 var _url = require("url");
 var _channelOwner = require("./channelOwner");
@@ -17,7 +17,7 @@ var _events = require("./events");
 var _waiter = require("./waiter");
 var _fetch = require("./fetch");
 var _errors = require("./errors");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+let _Symbol$asyncDispose;
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -33,7 +33,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class Request extends _channelOwner.ChannelOwner {
   static from(request) {
     return request._object;
@@ -203,6 +203,7 @@ class Route extends _channelOwner.ChannelOwner {
     this._handlingPromise = null;
     this._context = void 0;
     this._didThrow = false;
+    this.markAsInternalType();
   }
   request() {
     return Request.from(this._initializer.request);
@@ -225,7 +226,6 @@ class Route extends _channelOwner.ChannelOwner {
   async abort(errorCode) {
     await this._handleRoute(async () => {
       await this._raceWithTargetClose(this._channel.abort({
-        requestUrl: this.request()._initializer.url,
         errorCode
       }));
     });
@@ -302,7 +302,6 @@ class Route extends _channelOwner.ChannelOwner {
     if (options.contentType) headers['content-type'] = String(options.contentType);else if (options.json) headers['content-type'] = 'application/json';else if (options.path) headers['content-type'] = _utilsBundle.mime.getType(options.path) || 'application/octet-stream';
     if (length && !('content-length' in headers)) headers['content-length'] = String(length);
     await this._raceWithTargetClose(this._channel.fulfill({
-      requestUrl: this.request()._initializer.url,
       status: statusOption || 200,
       headers: (0, _utils.headersObjectToArray)(headers),
       body,
@@ -313,7 +312,7 @@ class Route extends _channelOwner.ChannelOwner {
   async continue(options = {}) {
     await this._handleRoute(async () => {
       this.request()._applyFallbackOverrides(options);
-      await this._innerContinue();
+      await this._innerContinue(false /* isFallback */);
     });
   }
   _checkNotHandled() {
@@ -324,21 +323,180 @@ class Route extends _channelOwner.ChannelOwner {
     this._handlingPromise = null;
     chain.resolve(done);
   }
-  async _innerContinue(internal = false) {
+  async _innerContinue(isFallback) {
     const options = this.request()._fallbackOverridesForContinue();
-    return await this._wrapApiCall(async () => {
-      await this._raceWithTargetClose(this._channel.continue({
-        requestUrl: this.request()._initializer.url,
-        url: options.url,
-        method: options.method,
-        headers: options.headers ? (0, _utils.headersObjectToArray)(options.headers) : undefined,
-        postData: options.postDataBuffer,
-        isFallback: internal
-      }));
-    }, !!internal);
+    return await this._raceWithTargetClose(this._channel.continue({
+      url: options.url,
+      method: options.method,
+      headers: options.headers ? (0, _utils.headersObjectToArray)(options.headers) : undefined,
+      postData: options.postDataBuffer,
+      isFallback
+    }));
   }
 }
 exports.Route = Route;
+_Symbol$asyncDispose = Symbol.asyncDispose;
+class WebSocketRoute extends _channelOwner.ChannelOwner {
+  static from(route) {
+    return route._object;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._onPageMessage = void 0;
+    this._onPageClose = void 0;
+    this._onServerMessage = void 0;
+    this._onServerClose = void 0;
+    this._server = void 0;
+    this._connected = false;
+    this.markAsInternalType();
+    this._server = {
+      onMessage: handler => {
+        this._onServerMessage = handler;
+      },
+      onClose: handler => {
+        this._onServerClose = handler;
+      },
+      connectToServer: () => {
+        throw new Error(`connectToServer must be called on the page-side WebSocketRoute`);
+      },
+      url: () => {
+        return this._initializer.url;
+      },
+      close: async (options = {}) => {
+        await this._channel.closeServer({
+          ...options,
+          wasClean: true
+        }).catch(() => {});
+      },
+      send: message => {
+        if ((0, _utils.isString)(message)) this._channel.sendToServer({
+          message,
+          isBase64: false
+        }).catch(() => {});else this._channel.sendToServer({
+          message: message.toString('base64'),
+          isBase64: true
+        }).catch(() => {});
+      },
+      async [Symbol.asyncDispose]() {
+        await this.close();
+      }
+    };
+    this._channel.on('messageFromPage', ({
+      message,
+      isBase64
+    }) => {
+      if (this._onPageMessage) this._onPageMessage(isBase64 ? Buffer.from(message, 'base64') : message);else if (this._connected) this._channel.sendToServer({
+        message,
+        isBase64
+      }).catch(() => {});
+    });
+    this._channel.on('messageFromServer', ({
+      message,
+      isBase64
+    }) => {
+      if (this._onServerMessage) this._onServerMessage(isBase64 ? Buffer.from(message, 'base64') : message);else this._channel.sendToPage({
+        message,
+        isBase64
+      }).catch(() => {});
+    });
+    this._channel.on('closePage', ({
+      code,
+      reason,
+      wasClean
+    }) => {
+      if (this._onPageClose) this._onPageClose(code, reason);else this._channel.closeServer({
+        code,
+        reason,
+        wasClean
+      }).catch(() => {});
+    });
+    this._channel.on('closeServer', ({
+      code,
+      reason,
+      wasClean
+    }) => {
+      if (this._onServerClose) this._onServerClose(code, reason);else this._channel.closePage({
+        code,
+        reason,
+        wasClean
+      }).catch(() => {});
+    });
+  }
+  url() {
+    return this._initializer.url;
+  }
+  async close(options = {}) {
+    await this._channel.closePage({
+      ...options,
+      wasClean: true
+    }).catch(() => {});
+  }
+  connectToServer() {
+    if (this._connected) throw new Error('Already connected to the server');
+    this._connected = true;
+    this._channel.connect().catch(() => {});
+    return this._server;
+  }
+  send(message) {
+    if ((0, _utils.isString)(message)) this._channel.sendToPage({
+      message,
+      isBase64: false
+    }).catch(() => {});else this._channel.sendToPage({
+      message: message.toString('base64'),
+      isBase64: true
+    }).catch(() => {});
+  }
+  onMessage(handler) {
+    this._onPageMessage = handler;
+  }
+  onClose(handler) {
+    this._onPageClose = handler;
+  }
+  async [_Symbol$asyncDispose]() {
+    await this.close();
+  }
+  async _afterHandle() {
+    if (this._connected) return;
+    // Ensure that websocket is "open" and can send messages without an actual server connection.
+    await this._channel.ensureOpened();
+  }
+}
+exports.WebSocketRoute = WebSocketRoute;
+class WebSocketRouteHandler {
+  constructor(baseURL, url, handler) {
+    this._baseURL = void 0;
+    this.url = void 0;
+    this.handler = void 0;
+    this._baseURL = baseURL;
+    this.url = url;
+    this.handler = handler;
+  }
+  static prepareInterceptionPatterns(handlers) {
+    const patterns = [];
+    let all = false;
+    for (const handler of handlers) {
+      if ((0, _utils.isString)(handler.url)) patterns.push({
+        glob: handler.url
+      });else if ((0, _utils.isRegExp)(handler.url)) patterns.push({
+        regexSource: handler.url.source,
+        regexFlags: handler.url.flags
+      });else all = true;
+    }
+    if (all) return [{
+      glob: '**/*'
+    }];
+    return patterns;
+  }
+  matches(wsURL) {
+    return (0, _utils.urlMatches)(this._baseURL, wsURL, this.url);
+  }
+  async handle(webSocketRoute) {
+    const handler = this.handler;
+    await handler(webSocketRoute);
+    await webSocketRoute._afterHandle();
+  }
+}
+exports.WebSocketRouteHandler = WebSocketRouteHandler;
 class Response extends _channelOwner.ChannelOwner {
   static from(response) {
     return response._object;