@checkly/playwright-core 1.41.2-beta.0

package/lib/utils/isomorphic/stringUtils.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cssEscape = cssEscape;
+exports.escapeForAttributeSelector = escapeForAttributeSelector;
+exports.escapeForTextSelector = escapeForTextSelector;
+exports.escapeWithQuotes = escapeWithQuotes;
+exports.isString = isString;
+exports.normalizeEscapedRegexQuotes = normalizeEscapedRegexQuotes;
+exports.normalizeWhiteSpace = normalizeWhiteSpace;
+exports.quoteCSSAttributeValue = quoteCSSAttributeValue;
+exports.toSnakeCase = toSnakeCase;
+exports.toTitleCase = toTitleCase;
+exports.trimString = trimString;
+exports.trimStringWithEllipsis = trimStringWithEllipsis;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// NOTE: this function should not be used to escape any selectors.
+function escapeWithQuotes(text, char = '\'') {
+  const stringified = JSON.stringify(text);
+  const escapedText = stringified.substring(1, stringified.length - 1).replace(/\\"/g, '"');
+  if (char === '\'') return char + escapedText.replace(/[']/g, '\\\'') + char;
+  if (char === '"') return char + escapedText.replace(/["]/g, '\\"') + char;
+  if (char === '`') return char + escapedText.replace(/[`]/g, '`') + char;
+  throw new Error('Invalid escape char');
+}
+function isString(obj) {
+  return typeof obj === 'string' || obj instanceof String;
+}
+function toTitleCase(name) {
+  return name.charAt(0).toUpperCase() + name.substring(1);
+}
+function toSnakeCase(name) {
+  // E.g. ignoreHTTPSErrors => ignore_https_errors.
+  return name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/([A-Z])([A-Z][a-z])/g, '$1_$2').toLowerCase();
+}
+function cssEscape(s) {
+  let result = '';
+  for (let i = 0; i < s.length; i++) result += cssEscapeOne(s, i);
+  return result;
+}
+function quoteCSSAttributeValue(text) {
+  return `"${cssEscape(text).replace(/\\ /g, ' ')}"`;
+}
+function cssEscapeOne(s, i) {
+  // https://drafts.csswg.org/cssom/#serialize-an-identifier
+  const c = s.charCodeAt(i);
+  if (c === 0x0000) return '\uFFFD';
+  if (c >= 0x0001 && c <= 0x001f || c >= 0x0030 && c <= 0x0039 && (i === 0 || i === 1 && s.charCodeAt(0) === 0x002d)) return '\\' + c.toString(16) + ' ';
+  if (i === 0 && c === 0x002d && s.length === 1) return '\\' + s.charAt(i);
+  if (c >= 0x0080 || c === 0x002d || c === 0x005f || c >= 0x0030 && c <= 0x0039 || c >= 0x0041 && c <= 0x005a || c >= 0x0061 && c <= 0x007a) return s.charAt(i);
+  return '\\' + s.charAt(i);
+}
+function normalizeWhiteSpace(text) {
+  return text.replace(/\u200b/g, '').trim().replace(/\s+/g, ' ');
+}
+function normalizeEscapedRegexQuotes(source) {
+  // This function reverses the effect of escapeRegexForSelector below.
+  // Odd number of backslashes followed by the quote -> remove unneeded backslash.
+  return source.replace(/(^|[^\\])(\\\\)*\\(['"`])/g, '$1$2$3');
+}
+function escapeRegexForSelector(re) {
+  // Unicode mode does not allow "identity character escapes", so we do not escape and
+  // hope that it does not contain quotes and/or >> signs.
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Character_escape
+  // TODO: rework RE usages in internal selectors away from literal representation to json, e.g. {source,flags}.
+  if (re.unicode || re.unicodeSets) return String(re);
+  // Even number of backslashes followed by the quote -> insert a backslash.
+  return String(re).replace(/(^|[^\\])(\\\\)*(["'`])/g, '$1$2\\$3').replace(/>>/g, '\\>\\>');
+}
+function escapeForTextSelector(text, exact) {
+  if (typeof text !== 'string') return escapeRegexForSelector(text);
+  return `${JSON.stringify(text)}${exact ? 's' : 'i'}`;
+}
+function escapeForAttributeSelector(value, exact) {
+  if (typeof value !== 'string') return escapeRegexForSelector(value);
+  // TODO: this should actually be
+  //   cssEscape(value).replace(/\\ /g, ' ')
+  // However, our attribute selectors do not conform to CSS parsing spec,
+  // so we escape them differently.
+  return `"${value.replace(/\\/g, '\\\\').replace(/["]/g, '\\"')}"${exact ? 's' : 'i'}`;
+}
+function trimString(input, cap, suffix = '') {
+  if (input.length <= cap) return input;
+  const chars = [...input];
+  if (chars.length > cap) return chars.slice(0, cap - suffix.length).join('') + suffix;
+  return chars.join('');
+}
+function trimStringWithEllipsis(input, cap) {
+  return trimString(input, cap, '\u2026');
+}

package/lib/utils/isomorphic/traceUtils.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseClientSideCallMetadata = parseClientSideCallMetadata;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function parseClientSideCallMetadata(data) {
+  const result = new Map();
+  const {
+    files,
+    stacks
+  } = data;
+  for (const s of stacks) {
+    const [id, ff] = s;
+    result.set(`call@${id}`, ff.map(f => ({
+      file: files[f[0]],
+      line: f[1],
+      column: f[2],
+      function: f[3]
+    })));
+  }
+  return result;
+}

package/lib/utils/linuxUtils.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLinuxDistributionInfo = getLinuxDistributionInfo;
+exports.getLinuxDistributionInfoSync = getLinuxDistributionInfoSync;
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ * Modifications copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+let didFailToReadOSRelease = false;
+let osRelease;
+async function getLinuxDistributionInfo() {
+  if (process.platform !== 'linux') return undefined;
+  if (!osRelease && !didFailToReadOSRelease) {
+    try {
+      var _fields$get, _fields$get2;
+      // List of /etc/os-release values for different distributions could be
+      // found here: https://gist.github.com/aslushnikov/8ceddb8288e4cf9db3039c02e0f4fb75
+      const osReleaseText = await _fs.default.promises.readFile('/etc/os-release', 'utf8');
+      const fields = parseOSReleaseText(osReleaseText);
+      osRelease = {
+        id: (_fields$get = fields.get('id')) !== null && _fields$get !== void 0 ? _fields$get : '',
+        version: (_fields$get2 = fields.get('version_id')) !== null && _fields$get2 !== void 0 ? _fields$get2 : ''
+      };
+    } catch (e) {
+      didFailToReadOSRelease = true;
+    }
+  }
+  return osRelease;
+}
+function getLinuxDistributionInfoSync() {
+  if (process.platform !== 'linux') return undefined;
+  if (!osRelease && !didFailToReadOSRelease) {
+    try {
+      var _fields$get3, _fields$get4;
+      // List of /etc/os-release values for different distributions could be
+      // found here: https://gist.github.com/aslushnikov/8ceddb8288e4cf9db3039c02e0f4fb75
+      const osReleaseText = _fs.default.readFileSync('/etc/os-release', 'utf8');
+      const fields = parseOSReleaseText(osReleaseText);
+      osRelease = {
+        id: (_fields$get3 = fields.get('id')) !== null && _fields$get3 !== void 0 ? _fields$get3 : '',
+        version: (_fields$get4 = fields.get('version_id')) !== null && _fields$get4 !== void 0 ? _fields$get4 : ''
+      };
+    } catch (e) {
+      didFailToReadOSRelease = true;
+    }
+  }
+  return osRelease;
+}
+function parseOSReleaseText(osReleaseText) {
+  const fields = new Map();
+  for (const line of osReleaseText.split('\n')) {
+    const tokens = line.split('=');
+    const name = tokens.shift();
+    let value = tokens.join('=').trim();
+    if (value.startsWith('"') && value.endsWith('"')) value = value.substring(1, value.length - 1);
+    if (!name) continue;
+    fields.set(name.toLowerCase(), value);
+  }
+  return fields;
+}

package/lib/utils/manualPromise.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ManualPromise = exports.LongStandingScope = void 0;
+var _stackTrace = require("./stackTrace");
+let _Symbol$species, _Symbol$toStringTag;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+_Symbol$species = Symbol.species;
+_Symbol$toStringTag = Symbol.toStringTag;
+class ManualPromise extends Promise {
+  constructor() {
+    let resolve;
+    let reject;
+    super((f, r) => {
+      resolve = f;
+      reject = r;
+    });
+    this._resolve = void 0;
+    this._reject = void 0;
+    this._isDone = void 0;
+    this._isDone = false;
+    this._resolve = resolve;
+    this._reject = reject;
+  }
+  isDone() {
+    return this._isDone;
+  }
+  resolve(t) {
+    this._isDone = true;
+    this._resolve(t);
+  }
+  reject(e) {
+    this._isDone = true;
+    this._reject(e);
+  }
+  static get [_Symbol$species]() {
+    return Promise;
+  }
+  get [_Symbol$toStringTag]() {
+    return 'ManualPromise';
+  }
+}
+exports.ManualPromise = ManualPromise;
+class LongStandingScope {
+  constructor() {
+    this._terminateError = void 0;
+    this._closeError = void 0;
+    this._terminatePromises = new Map();
+    this._isClosed = false;
+  }
+  reject(error) {
+    this._isClosed = true;
+    this._terminateError = error;
+    for (const p of this._terminatePromises.keys()) p.resolve(error);
+  }
+  close(error) {
+    this._isClosed = true;
+    this._closeError = error;
+    for (const [p, frames] of this._terminatePromises) p.resolve(cloneError(error, frames));
+  }
+  isClosed() {
+    return this._isClosed;
+  }
+  static async raceMultiple(scopes, promise) {
+    return Promise.race(scopes.map(s => s.race(promise)));
+  }
+  async race(promise) {
+    return this._race(Array.isArray(promise) ? promise : [promise], false);
+  }
+  async safeRace(promise, defaultValue) {
+    return this._race([promise], true, defaultValue);
+  }
+  async _race(promises, safe, defaultValue) {
+    const terminatePromise = new ManualPromise();
+    const frames = (0, _stackTrace.captureRawStack)();
+    if (this._terminateError) terminatePromise.resolve(this._terminateError);
+    if (this._closeError) terminatePromise.resolve(cloneError(this._closeError, frames));
+    this._terminatePromises.set(terminatePromise, frames);
+    try {
+      return await Promise.race([terminatePromise.then(e => safe ? defaultValue : Promise.reject(e)), ...promises]);
+    } finally {
+      this._terminatePromises.delete(terminatePromise);
+    }
+  }
+}
+exports.LongStandingScope = LongStandingScope;
+function cloneError(error, frames) {
+  const clone = new Error();
+  clone.name = error.name;
+  clone.message = error.message;
+  clone.stack = [error.name + ':' + error.message, ...frames].join('\n');
+  return clone;
+}

package/lib/utils/mimeType.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isJsonMimeType = isJsonMimeType;
+exports.isTextualMimeType = isTextualMimeType;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function isJsonMimeType(mimeType) {
+  return !!mimeType.match(/^(application\/json|application\/.*?\+json|text\/(x-)?json)(;\s*charset=.*)?$/);
+}
+function isTextualMimeType(mimeType) {
+  return !!mimeType.match(/^(text\/.*?|application\/(json|(x-)?javascript|xml.*?|ecmascript|graphql|x-www-form-urlencoded)|image\/svg(\+xml)?|application\/.*?(\+json|\+xml))(;\s*charset=.*)?$/);
+}

package/lib/utils/multimap.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MultiMap = void 0;
+let _Symbol$iterator;
+_Symbol$iterator = Symbol.iterator;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class MultiMap {
+  constructor() {
+    this._map = void 0;
+    this._map = new Map();
+  }
+  set(key, value) {
+    let values = this._map.get(key);
+    if (!values) {
+      values = [];
+      this._map.set(key, values);
+    }
+    values.push(value);
+  }
+  get(key) {
+    return this._map.get(key) || [];
+  }
+  has(key) {
+    return this._map.has(key);
+  }
+  delete(key, value) {
+    const values = this._map.get(key);
+    if (!values) return;
+    if (values.includes(value)) this._map.set(key, values.filter(v => value !== v));
+  }
+  deleteAll(key) {
+    this._map.delete(key);
+  }
+  hasValue(key, value) {
+    const values = this._map.get(key);
+    if (!values) return false;
+    return values.includes(value);
+  }
+  get size() {
+    return this._map.size;
+  }
+  [_Symbol$iterator]() {
+    return this._map[Symbol.iterator]();
+  }
+  keys() {
+    return this._map.keys();
+  }
+  values() {
+    const result = [];
+    for (const key of this.keys()) result.push(...this.get(key));
+    return result;
+  }
+  clear() {
+    this._map.clear();
+  }
+}
+exports.MultiMap = MultiMap;

package/lib/utils/network.js

@@ -0,0 +1,189 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NET_DEFAULT_TIMEOUT = void 0;
+exports.constructURLBasedOnBaseURL = constructURLBasedOnBaseURL;
+exports.createHttpServer = createHttpServer;
+exports.createHttpsServer = createHttpsServer;
+exports.fetchData = fetchData;
+exports.httpRequest = httpRequest;
+exports.isURLAvailable = isURLAvailable;
+exports.urlMatches = urlMatches;
+exports.urlMatchesEqual = urlMatchesEqual;
+var _http = _interopRequireDefault(require("http"));
+var _https = _interopRequireDefault(require("https"));
+var _utilsBundle = require("../utilsBundle");
+var _url = _interopRequireDefault(require("url"));
+var _rtti = require("./rtti");
+var _glob = require("./glob");
+var _happyEyeballs = require("./happy-eyeballs");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const NET_DEFAULT_TIMEOUT = exports.NET_DEFAULT_TIMEOUT = 30_000;
+function httpRequest(params, onResponse, onError) {
+  var _params$timeout;
+  const parsedUrl = _url.default.parse(params.url);
+  let options = {
+    ...parsedUrl,
+    agent: parsedUrl.protocol === 'https:' ? _happyEyeballs.httpsHappyEyeballsAgent : _happyEyeballs.httpHappyEyeballsAgent,
+    method: params.method || 'GET',
+    headers: params.headers
+  };
+  if (params.rejectUnauthorized !== undefined) options.rejectUnauthorized = params.rejectUnauthorized;
+  const timeout = (_params$timeout = params.timeout) !== null && _params$timeout !== void 0 ? _params$timeout : NET_DEFAULT_TIMEOUT;
+  const proxyURL = (0, _utilsBundle.getProxyForUrl)(params.url);
+  if (proxyURL) {
+    const parsedProxyURL = _url.default.parse(proxyURL);
+    if (params.url.startsWith('http:')) {
+      options = {
+        path: parsedUrl.href,
+        host: parsedProxyURL.hostname,
+        port: parsedProxyURL.port,
+        headers: options.headers,
+        method: options.method
+      };
+    } else {
+      parsedProxyURL.secureProxy = parsedProxyURL.protocol === 'https:';
+      options.agent = new _utilsBundle.HttpsProxyAgent(parsedProxyURL);
+      options.rejectUnauthorized = false;
+    }
+  }
+  const requestCallback = res => {
+    const statusCode = res.statusCode || 0;
+    if (statusCode >= 300 && statusCode < 400 && res.headers.location) httpRequest({
+      ...params,
+      url: new URL(res.headers.location, params.url).toString()
+    }, onResponse, onError);else onResponse(res);
+  };
+  const request = options.protocol === 'https:' ? _https.default.request(options, requestCallback) : _http.default.request(options, requestCallback);
+  request.on('error', onError);
+  if (timeout !== undefined) {
+    const rejectOnTimeout = () => {
+      onError(new Error(`Request to ${params.url} timed out after ${timeout}ms`));
+      request.abort();
+    };
+    if (timeout <= 0) {
+      rejectOnTimeout();
+      return;
+    }
+    request.setTimeout(timeout, rejectOnTimeout);
+  }
+  request.end(params.data);
+}
+function fetchData(params, onError) {
+  return new Promise((resolve, reject) => {
+    httpRequest(params, async response => {
+      if (response.statusCode !== 200) {
+        const error = onError ? await onError(params, response) : new Error(`fetch failed: server returned code ${response.statusCode}. URL: ${params.url}`);
+        reject(error);
+        return;
+      }
+      let body = '';
+      response.on('data', chunk => body += chunk);
+      response.on('error', error => reject(error));
+      response.on('end', () => resolve(body));
+    }, reject);
+  });
+}
+function urlMatchesEqual(match1, match2) {
+  if ((0, _rtti.isRegExp)(match1) && (0, _rtti.isRegExp)(match2)) return match1.source === match2.source && match1.flags === match2.flags;
+  return match1 === match2;
+}
+function urlMatches(baseURL, urlString, match) {
+  if (match === undefined || match === '') return true;
+  if ((0, _rtti.isString)(match) && !match.startsWith('*')) match = constructURLBasedOnBaseURL(baseURL, match);
+  if ((0, _rtti.isString)(match)) match = (0, _glob.globToRegex)(match);
+  if ((0, _rtti.isRegExp)(match)) return match.test(urlString);
+  if (typeof match === 'string' && match === urlString) return true;
+  const url = parsedURL(urlString);
+  if (!url) return false;
+  if (typeof match === 'string') return url.pathname === match;
+  if (typeof match !== 'function') throw new Error('url parameter should be string, RegExp or function');
+  return match(url);
+}
+function parsedURL(url) {
+  try {
+    return new URL(url);
+  } catch (e) {
+    return null;
+  }
+}
+function constructURLBasedOnBaseURL(baseURL, givenURL) {
+  try {
+    return new URL(givenURL, baseURL).toString();
+  } catch (e) {
+    return givenURL;
+  }
+}
+function createHttpServer(...args) {
+  const server = _http.default.createServer(...args);
+  decorateServer(server);
+  return server;
+}
+function createHttpsServer(...args) {
+  const server = _https.default.createServer(...args);
+  decorateServer(server);
+  return server;
+}
+async function isURLAvailable(url, ignoreHTTPSErrors, onLog, onStdErr) {
+  let statusCode = await httpStatusCode(url, ignoreHTTPSErrors, onLog, onStdErr);
+  if (statusCode === 404 && url.pathname === '/') {
+    const indexUrl = new URL(url);
+    indexUrl.pathname = '/index.html';
+    statusCode = await httpStatusCode(indexUrl, ignoreHTTPSErrors, onLog, onStdErr);
+  }
+  return statusCode >= 200 && statusCode < 404;
+}
+async function httpStatusCode(url, ignoreHTTPSErrors, onLog, onStdErr) {
+  return new Promise(resolve => {
+    onLog === null || onLog === void 0 || onLog(`HTTP HEAD: ${url}`);
+    httpRequest({
+      method: 'HEAD',
+      url: url.toString(),
+      headers: {
+        Accept: '*/*'
+      },
+      rejectUnauthorized: !ignoreHTTPSErrors
+    }, res => {
+      var _res$statusCode;
+      res.resume();
+      const statusCode = (_res$statusCode = res.statusCode) !== null && _res$statusCode !== void 0 ? _res$statusCode : 0;
+      onLog === null || onLog === void 0 || onLog(`HTTP Status: ${statusCode}`);
+      resolve(statusCode);
+    }, error => {
+      if (error.code === 'DEPTH_ZERO_SELF_SIGNED_CERT') onStdErr === null || onStdErr === void 0 || onStdErr(`[WebServer] Self-signed certificate detected. Try adding ignoreHTTPSErrors: true to config.webServer.`);
+      onLog === null || onLog === void 0 || onLog(`Error while checking if ${url} is available: ${error.message}`);
+      resolve(0);
+    });
+  });
+}
+function decorateServer(server) {
+  const sockets = new Set();
+  server.on('connection', socket => {
+    sockets.add(socket);
+    socket.once('close', () => sockets.delete(socket));
+  });
+  const close = server.close;
+  server.close = callback => {
+    for (const socket of sockets) socket.destroy();
+    sockets.clear();
+    return close.call(server, callback);
+  };
+}