@checkly/playwright-core 1.41.23 → 1.41.25

package/lib/server/frames.js

@@ -15,7 +15,7 @@ var _browserContext = require("./browserContext");
 var _progress = require("./progress");
 var _utils = require("../utils");
 var _manualPromise = require("../utils/manualPromise");
-var _debugLogger = require("../utils/debugLogger");
+var _debugLogger = require("../common/debugLogger");
 var _instrumentation = require("./instrumentation");
 var _protocolError = require("./protocolError");
 var _selectorParser = require("../utils/isomorphic/selectorParser");
@@ -930,10 +930,9 @@ class Frame extends _instrumentation.SdkObject {
     // Retry upon all other errors.
     return false;
   }
-  async _retryWithProgressIfNotConnected(progress, selector, strict, performLocatorHandlersCheckpoint, action) {
+  async _retryWithProgressIfNotConnected(progress, selector, strict, action) {
     progress.log(`waiting for ${this._asLocator(selector)}`);
     return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
-      if (performLocatorHandlersCheckpoint) await this._page.performLocatorHandlersCheckpoint(progress);
       const resolved = await this.selectors.resolveInjectedForSelector(selector, {
         strict
       });
@@ -986,7 +985,7 @@ class Frame extends _instrumentation.SdkObject {
     });
   }
   async rafrafTimeoutScreenshotElementWithProgress(progress, selector, timeout, options) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, true /* performLocatorHandlersCheckpoint */, async handle => {
+    return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, async handle => {
       await handle._frame.rafrafTimeout(timeout);
       return await this._page._screenshotter.screenshotElement(progress, handle, options);
     });
@@ -994,19 +993,19 @@ class Frame extends _instrumentation.SdkObject {
   async click(metadata, selector, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._click(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._click(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async dblclick(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._dblclick(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._dblclick(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async dragAndDrop(metadata, source, target, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force /* performLocatorHandlersCheckpoint */, async handle => {
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, async handle => {
         return handle._retryPointerAction(progress, 'move and down', false, async point => {
           await this._page.mouse.move(point.x, point.y);
           await this._page.mouse.down();
@@ -1016,8 +1015,7 @@ class Frame extends _instrumentation.SdkObject {
           timeout: progress.timeUntilDeadline()
         });
       }));
-      // Note: do not perform locator handlers checkpoint to avoid moving the mouse in the middle of a drag operation.
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false /* performLocatorHandlersCheckpoint */, async handle => {
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, async handle => {
         return handle._retryPointerAction(progress, 'move and up', false, async point => {
           await this._page.mouse.move(point.x, point.y);
           await this._page.mouse.up();
@@ -1033,25 +1031,25 @@ class Frame extends _instrumentation.SdkObject {
     if (!this._page._browserContext._options.hasTouch) throw new Error('The page does not support tap. Use hasTouch context option to enable touch support.');
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._tap(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._tap(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async fill(metadata, selector, value, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._fill(progress, value, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._fill(progress, value, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async focus(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._focus(progress)));
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._focus(progress)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async blur(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._blur(progress)));
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._blur(progress)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async textContent(metadata, selector, options = {}, scope) {
@@ -1110,11 +1108,6 @@ class Frame extends _instrumentation.SdkObject {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
       progress.log(`  checking visibility of ${this._asLocator(selector)}`);
-      return await this.isVisibleInternal(selector, options, scope);
-    }, this._page._timeoutSettings.timeout({}));
-  }
-  async isVisibleInternal(selector, options = {}, scope) {
-    try {
       const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
       if (!resolved) return false;
       return await resolved.injected.evaluate((injected, {
@@ -1128,10 +1121,10 @@ class Frame extends _instrumentation.SdkObject {
         info: resolved.info,
         root: resolved.frame === this ? scope : undefined
       });
-    } catch (e) {
+    }, this._page._timeoutSettings.timeout({})).catch(e => {
       if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e) || (0, _protocolError.isSessionClosedError)(e)) throw e;
       return false;
-    }
+    });
   }
   async isHidden(metadata, selector, options = {}, scope) {
     return !(await this.isVisible(metadata, selector, options, scope));
@@ -1151,44 +1144,44 @@ class Frame extends _instrumentation.SdkObject {
   async hover(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._hover(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._hover(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async selectOption(metadata, selector, elements, values, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._selectOption(progress, elements, values, options));
+      return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._selectOption(progress, elements, values, options));
     }, this._page._timeoutSettings.timeout(options));
   }
   async setInputFiles(metadata, selector, params) {
     const inputFileItems = await (0, _fileUploadUtils.prepareFilesForUpload)(this, params);
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._setInputFiles(progress, inputFileItems, params)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, handle => handle._setInputFiles(progress, inputFileItems, params)));
     }, this._page._timeoutSettings.timeout(params));
   }
   async type(metadata, selector, text, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._type(progress, text, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._type(progress, text, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async press(metadata, selector, key, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._press(progress, key, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._press(progress, key, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async check(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._setChecked(progress, true, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._setChecked(progress, true, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async uncheck(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._setChecked(progress, false, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._setChecked(progress, false, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async waitForTimeout(metadata, timeout) {
@@ -1198,17 +1191,6 @@ class Frame extends _instrumentation.SdkObject {
     });
   }
   async expect(metadata, selector, options) {
-    const result = await this._expectImpl(metadata, selector, options);
-    // Library mode special case for the expect errors which are return values, not exceptions.
-    if (result.matches === options.isNot) metadata.error = {
-      error: {
-        name: 'Expect',
-        message: 'Expect failed'
-      }
-    };
-    return result;
-  }
-  async _expectImpl(metadata, selector, options) {
     let timeout = this._page._timeoutSettings.timeout(options);
     const start = timeout > 0 ? (0, _utils.monotonicTime)() : 0;
     const lastIntermediateResult = {
@@ -1237,7 +1219,6 @@ class Frame extends _instrumentation.SdkObject {
       }
       return await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1000], async continuePolling => {
         var _info$world;
-        await this._page.performLocatorHandlersCheckpoint(progress);
         const selectorInFrame = await this.selectors.resolveFrameForSelector(selector, {
           strict: true
         });

package/lib/server/helper.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.helper = void 0;
-var _debugLogger = require("../utils/debugLogger");
+var _debugLogger = require("../common/debugLogger");
 var _eventsHelper = require("../utils/eventsHelper");
 /**
  * Copyright 2017 Google Inc. All rights reserved.

package/lib/server/page.js

@@ -17,13 +17,12 @@ var _fileChooser = require("./fileChooser");
 var _progress = require("./progress");
 var _utils = require("../utils");
 var _manualPromise = require("../utils/manualPromise");
-var _debugLogger = require("../utils/debugLogger");
+var _debugLogger = require("../common/debugLogger");
 var _comparators = require("../utils/comparators");
 var _instrumentation = require("./instrumentation");
 var _selectorParser = require("../utils/isomorphic/selectorParser");
 var _utilityScriptSerializers = require("./isomorphic/utilityScriptSerializers");
 var _errors = require("./errors");
-var _locatorGenerators = require("../utils/isomorphic/locatorGenerators");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /**
@@ -77,9 +76,6 @@ class Page extends _instrumentation.SdkObject {
     this._video = null;
     this._opener = void 0;
     this._isServerSideOnly = false;
-    this._locatorHandlers = new Map();
-    this._lastLocatorHandlerUid = 0;
-    this._locatorHandlerRunningCounter = 0;
     // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
     // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
     this._frameThrottler = new FrameThrottler(10, 35, 200);
@@ -143,7 +139,6 @@ class Page extends _instrumentation.SdkObject {
   async resetForReuse(metadata) {
     this.setDefaultNavigationTimeout(undefined);
     this.setDefaultTimeout(undefined);
-    this._locatorHandlers.clear();
     await this._removeExposedBindings();
     await this._removeInitScripts();
     await this.setClientRequestInterceptor(undefined);
@@ -287,43 +282,6 @@ class Page extends _instrumentation.SdkObject {
       return response;
     }), this._timeoutSettings.navigationTimeout(options));
   }
-  registerLocatorHandler(selector) {
-    const uid = ++this._lastLocatorHandlerUid;
-    this._locatorHandlers.set(uid, {
-      selector
-    });
-    return uid;
-  }
-  resolveLocatorHandler(uid) {
-    const handler = this._locatorHandlers.get(uid);
-    if (handler) {
-      var _handler$resolved;
-      (_handler$resolved = handler.resolved) === null || _handler$resolved === void 0 || _handler$resolved.resolve();
-      handler.resolved = undefined;
-    }
-  }
-  async performLocatorHandlersCheckpoint(progress) {
-    // Do not run locator handlers from inside locator handler callbacks to avoid deadlocks.
-    if (this._locatorHandlerRunningCounter) return;
-    for (const [uid, handler] of this._locatorHandlers) {
-      if (!handler.resolved) {
-        if (await this.mainFrame().isVisibleInternal(handler.selector, {
-          strict: true
-        })) {
-          handler.resolved = new _manualPromise.ManualPromise();
-          this.emit(Page.Events.LocatorHandlerTriggered, uid);
-        }
-      }
-      if (handler.resolved) {
-        ++this._locatorHandlerRunningCounter;
-        progress.log(`  found ${(0, _locatorGenerators.asLocator)(this.attribution.playwright.options.sdkLanguage, handler.selector)}, intercepting action to run the handler`);
-        await this.openScope.race(handler.resolved).finally(() => --this._locatorHandlerRunningCounter);
-        // Avoid side-effects after long-running operation.
-        progress.throwIfAborted();
-        progress.log(`  interception handler has finished, continuing`);
-      }
-    }
-  }
   async emulateMedia(options) {
     if (options.media !== undefined) this._emulatedMedia.media = options.media;
     if (options.colorScheme !== undefined) this._emulatedMedia.colorScheme = options.colorScheme;
@@ -389,11 +347,10 @@ class Page extends _instrumentation.SdkObject {
   async expectScreenshot(metadata, options = {}) {
     const locator = options.locator;
     const rafrafScreenshot = locator ? async (progress, timeout) => {
-      return await locator.frame.rafrafTimeoutScreenshotElementWithProgress(progress, locator.selector, timeout, options || {});
+      return await locator.frame.rafrafTimeoutScreenshotElementWithProgress(progress, locator.selector, timeout, options.screenshotOptions || {});
     } : async (progress, timeout) => {
-      await this.performLocatorHandlersCheckpoint(progress);
       await this.mainFrame().rafrafTimeout(timeout);
-      return await this._screenshotter.screenshotPage(progress, options || {});
+      return await this._screenshotter.screenshotPage(progress, options.screenshotOptions || {});
     };
     const comparator = (0, _comparators.getComparator)('image/png');
     const controller = new _progress.ProgressController(metadata, this);
@@ -401,7 +358,7 @@ class Page extends _instrumentation.SdkObject {
       errorMessage: '"not" matcher requires expected result'
     };
     try {
-      const format = (0, _screenshotter.validateScreenshotOptions)(options || {});
+      const format = (0, _screenshotter.validateScreenshotOptions)(options.screenshotOptions || {});
       if (format !== 'png') throw new Error('Only PNG screenshots are supported');
     } catch (error) {
       return {
@@ -410,7 +367,7 @@ class Page extends _instrumentation.SdkObject {
     }
     let intermediateResult = undefined;
     const areEqualScreenshots = (actual, expected, previous) => {
-      const comparatorResult = actual && expected ? comparator(actual, expected, options) : undefined;
+      const comparatorResult = actual && expected ? comparator(actual, expected, options.comparatorOptions) : undefined;
       if (comparatorResult !== undefined && !!comparatorResult === !!options.isNot) return true;
       if (comparatorResult) intermediateResult = {
         errorMessage: comparatorResult.errorMessage,
@@ -563,7 +520,6 @@ Page.Events = {
   FrameAttached: 'frameattached',
   FrameDetached: 'framedetached',
   InternalFrameNavigatedToNewDocument: 'internalframenavigatedtonewdocument',
-  LocatorHandlerTriggered: 'locatorhandlertriggered',
   ScreencastFrame: 'screencastframe',
   Video: 'video',
   WebSocket: 'websocket',

package/lib/server/pipeTransport.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PipeTransport = void 0;
 var _utils = require("../utils");
-var _debugLogger = require("../utils/debugLogger");
+var _debugLogger = require("../common/debugLogger");
 /**
  * Copyright 2018 Google Inc. All rights reserved.
  * Modifications copyright (c) Microsoft Corporation.

package/lib/server/playwright.js

@@ -13,7 +13,7 @@ var _firefox = require("./firefox/firefox");
 var _selectors = require("./selectors");
 var _webkit = require("./webkit/webkit");
 var _instrumentation = require("./instrumentation");
-var _debugLogger = require("../utils/debugLogger");
+var _debugLogger = require("../common/debugLogger");
 var _debugController = require("./debugController");
 /**
  * Copyright (c) Microsoft Corporation.

package/lib/server/progress.js

@@ -57,9 +57,17 @@ class ProgressController {
     (_this$sdkObject$attri = this.sdkObject.attribution.context) === null || _this$sdkObject$attri === void 0 || _this$sdkObject$attri._activeProgressControllers.add(this);
     const progress = {
       log: message => {
-        if (this._state === 'running') this.metadata.log.push(message);
-        // Note: we might be sending logs after progress has finished, for example browser logs.
-        this.instrumentation.onCallLog(this.sdkObject, this.metadata, this._logName, message);
+        progress.logEntry({
+          message
+        });
+      },
+      logEntry: entry => {
+        if ('message' in entry) {
+          const message = entry.message;
+          if (this._state === 'running') this.metadata.log.push(message);
+          // Note: we might be sending logs after progress has finished, for example browser logs.
+          this.instrumentation.onCallLog(this.sdkObject, this.metadata, this._logName, message);
+        }
       },
       timeUntilDeadline: () => this._deadline ? this._deadline - (0, _utils.monotonicTime)() : 2147483647,
       // 2^31-1 safe setTimeout in Node.

package/lib/server/recorder/csharp.js

@@ -138,7 +138,7 @@ class CSharpLanguageGenerator {
         return `await Expect(${subject}.${this._asLocator(action.selector)}).ToBeVisibleAsync();`;
       case 'assertValue':
         {
-          const assertion = action.value ? `ToHaveValueAsync(${quote(action.value)})` : `ToBeEmptyAsync()`;
+          const assertion = action.value ? `ToHaveValueAsync(${quote(action.value)})` : `ToBeEmpty()`;
           return `await Expect(${subject}.${this._asLocator(action.selector)}).${assertion};`;
         }
     }

package/lib/server/recorder.js

@@ -690,7 +690,7 @@ async function findFrameSelector(frame) {
     const utility = await parent._utilityContext();
     const injected = await utility.injectedScript();
     const selector = await injected.evaluate((injected, element) => {
-      return injected.generateSelectorSimple(element, {
+      return injected.generateSelector(element, {
         testIdAttributeName: '',
         omitInternalEngines: true
       });

package/lib/server/registry/browserFetcher.js

@@ -10,7 +10,7 @@ var _os = _interopRequireDefault(require("os"));
 var _path = _interopRequireDefault(require("path"));
 var _child_process = _interopRequireDefault(require("child_process"));
 var _fileUtils = require("../../utils/fileUtils");
-var _debugLogger = require("../../utils/debugLogger");
+var _debugLogger = require("../../common/debugLogger");
 var _manualPromise = require("../../utils/manualPromise");
 var _utilsBundle = require("../../utilsBundle");
 var _ = require(".");

package/lib/server/registry/dependencies.js

@@ -166,7 +166,7 @@ async function validateDependenciesWindows(windowsExeAndDllDirectories) {
   }
 }
 async function validateDependenciesLinux(sdkLanguage, linuxLddDirectories, dlOpenLibraries) {
-  var _deps$hostPlatform, _process$getuid, _process;
+  var _deps$hostPlatform;
   const directoryPaths = linuxLddDirectories;
   const lddPaths = [];
   for (const directoryPath of directoryPaths) lddPaths.push(...(await executablesOrSharedLibraries(directoryPath)));
@@ -192,7 +192,7 @@ async function validateDependenciesLinux(sdkLanguage, linuxLddDirectories, dlOpe
       missingDeps.delete(missingDep);
     }
   }
-  const maybeSudo = (_process$getuid = (_process = process).getuid) !== null && _process$getuid !== void 0 && _process$getuid.call(_process) && os.platform() !== 'win32' ? 'sudo ' : '';
+  const maybeSudo = process.getuid() !== 0 && os.platform() !== 'win32' ? 'sudo ' : '';
   const dockerInfo = readDockerVersionSync();
   const errorLines = [`Host system is missing dependencies to run browsers.`];
   // Ignore patch versions when comparing docker container version and Playwright version:
@@ -202,7 +202,7 @@ async function validateDependenciesLinux(sdkLanguage, linuxLddDirectories, dlOpe
     // In this case, we know how to install dependencies in it.
     const pwVersion = (0, _userAgent.getPlaywrightVersion)();
     const requiredDockerImage = dockerInfo.dockerImageName.replace(dockerInfo.driverVersion, pwVersion);
-    errorLines.push(...[`This is most likely due to Docker image version not matching Playwright version:`, `- Playwright  : ${pwVersion}`, `- Docker image: ${dockerInfo.driverVersion}`, ``, `Either:`, `- (recommended) use Docker image "${requiredDockerImage}"`, `- (alternative 1) run the following command inside Docker to install missing dependencies:`, ``, `    ${maybeSudo}${(0, _.buildPlaywrightCLICommand)(sdkLanguage, 'install-deps')}`, ``, `- (alternative 2) use apt inside Docker:`, ``, `    ${maybeSudo}apt-get install ${[...missingPackages].join('\\\n        ')}`, ``, `<3 Playwright Team`]);
+    errorLines.push(...[`This is most likely due to docker image version not matching Playwright version:`, `- Playwright: ${pwVersion}`, `-     Docker: ${dockerInfo.driverVersion}`, ``, `Either:`, `- (recommended) use docker image "${requiredDockerImage}"`, `- (alternative 1) run the following command inside docker to install missing dependencies:`, ``, `    ${maybeSudo}${(0, _.buildPlaywrightCLICommand)(sdkLanguage, 'install-deps')}`, ``, `- (alternative 2) use apt inside docker:`, ``, `    ${maybeSudo}apt-get install ${[...missingPackages].join('\\\n        ')}`, ``, `<3 Playwright Team`]);
   } else if (missingPackages.size && !missingDeps.size) {
     // Only known dependencies are missing for browsers.
     // Suggest installation with a Playwright CLI.
@@ -301,8 +301,7 @@ function quoteProcessArgs(args) {
   });
 }
 async function transformCommandsForRoot(commands) {
-  var _process$getuid2, _process2;
-  const isRoot = ((_process$getuid2 = (_process2 = process).getuid) === null || _process$getuid2 === void 0 ? void 0 : _process$getuid2.call(_process2)) === 0;
+  const isRoot = process.getuid() === 0;
   if (isRoot) return {
     command: 'sh',
     args: ['-c', `${commands.join('&& ')}`],