@checkly/playwright-core 1.42.18 → 1.47.20-alpha

package/lib/server/chromium/crPage.js

@@ -64,6 +64,7 @@ class CRPage {
     this.rawTouchscreen = void 0;
     this._targetId = void 0;
     this._opener = void 0;
+    this._networkManager = void 0;
     this._pdf = void 0;
     this._coverage = void 0;
     this._browserContext = void 0;
@@ -87,6 +88,13 @@ class CRPage {
     this._coverage = new _crCoverage.CRCoverage(client);
     this._browserContext = browserContext;
     this._page = new _page.Page(this, browserContext);
+    this._networkManager = new _crNetworkManager.CRNetworkManager(this._page, null);
+    // Sync any browser context state to the network manager. This does not talk over CDP because
+    // we have not connected any sessions to the network manager yet.
+    this.updateOffline();
+    this.updateExtraHTTPHeaders();
+    this.updateHttpCredentials();
+    this.updateRequestInterception();
     this._mainFrameSession = new FrameSession(this, client, targetId, null);
     this._sessions.set(targetId, this._mainFrameSession);
     if (opener && !browserContext._options.noDefaultViewport) {
@@ -157,24 +165,18 @@ class CRPage {
   async navigateFrame(frame, url, referrer) {
     return this._sessionForFrame(frame)._navigate(frame, url, referrer);
   }
-  async exposeBinding(binding) {
-    await this._forAllFrameSessions(frame => frame._initBinding(binding));
-    await Promise.all(this._page.frames().map(frame => frame.evaluateExpression(binding.source).catch(e => {})));
-  }
-  async removeExposedBindings() {
-    await this._forAllFrameSessions(frame => frame._removeExposedBindings());
-  }
   async updateExtraHTTPHeaders() {
-    await this._forAllFrameSessions(frame => frame._updateExtraHTTPHeaders(false));
+    const headers = network.mergeHeaders([this._browserContext._options.extraHTTPHeaders, this._page.extraHTTPHeaders()]);
+    await this._networkManager.setExtraHTTPHeaders(headers);
   }
   async updateGeolocation() {
     await this._forAllFrameSessions(frame => frame._updateGeolocation(false));
   }
   async updateOffline() {
-    await this._forAllFrameSessions(frame => frame._updateOffline(false));
+    await this._networkManager.setOffline(!!this._browserContext._options.offline);
   }
   async updateHttpCredentials() {
-    await this._forAllFrameSessions(frame => frame._updateHttpCredentials(false));
+    await this._networkManager.authenticate(this._browserContext._options.httpCredentials || null);
   }
   async updateEmulatedViewportSize(preserveWindowBoundaries) {
     await this._mainFrameSession._updateViewport(preserveWindowBoundaries);
@@ -189,7 +191,7 @@ class CRPage {
     await this._forAllFrameSessions(frame => frame._updateUserAgent());
   }
   async updateRequestInterception() {
-    await this._forAllFrameSessions(frame => frame._updateRequestInterception());
+    await this._networkManager.setRequestInterception(this._page.needsRequestInterception());
   }
   async updateFileChooserInterception() {
     await this._forAllFrameSessions(frame => frame._updateFileChooserInterception(false));
@@ -212,10 +214,10 @@ class CRPage {
   goForward() {
     return this._go(+1);
   }
-  async addInitScript(source, world = 'main') {
-    await this._forAllFrameSessions(frame => frame._evaluateOnNewDocument(source, world));
+  async addInitScript(initScript, world = 'main') {
+    await this._forAllFrameSessions(frame => frame._evaluateOnNewDocument(initScript, world));
   }
-  async removeInitScripts() {
+  async removeNonInternalInitScripts() {
     await this._forAllFrameSessions(frame => frame._removeEvaluatesOnNewDocument());
   }
   async closePage(runBeforeUnload) {
@@ -295,7 +297,7 @@ class CRPage {
   async setInputFiles(handle, files) {
     await handle.evaluateInUtility(([injected, node, files]) => injected.setInputFiles(node, files), files);
   }
-  async setInputFilePaths(progress, handle, files) {
+  async setInputFilePaths(handle, files) {
     const frame = await handle.ownerFrame();
     if (!frame) throw new Error('Cannot set input files to detached input element');
     const parentSession = this._sessionForFrame(frame);
@@ -346,7 +348,6 @@ class FrameSession {
     this._client = void 0;
     this._crPage = void 0;
     this._page = void 0;
-    this._networkManager = void 0;
     this._parentSession = void 0;
     this._childSessions = new Set();
     this._contextIdToContext = new Map();
@@ -363,14 +364,12 @@ class FrameSession {
     this._screencastId = null;
     this._screencastClients = new Set();
     this._evaluateOnNewDocumentIdentifiers = [];
-    this._exposedBindingNames = [];
     this._metricsOverride = void 0;
     this._workerSessions = new Map();
     this._client = client;
     this._crPage = crPage;
     this._page = crPage._page;
     this._targetId = targetId;
-    this._networkManager = new _crNetworkManager.CRNetworkManager(client, this._page, null, parentSession ? parentSession._networkManager : null);
     this._parentSession = parentSession;
     if (parentSession) parentSession._childSessions.add(this);
     this._firstNonInitialNavigationCommittedPromise = new Promise((f, r) => {
@@ -430,12 +429,11 @@ class FrameSession {
           grantUniveralAccess: true,
           worldName: UTILITY_WORLD_NAME
         });
-        for (const binding of this._crPage._browserContext._pageBindings.values()) frame.evaluateExpression(binding.source).catch(e => {});
-        for (const source of this._crPage._browserContext.initScripts) frame.evaluateExpression(source).catch(e => {});
+        for (const initScript of this._crPage._page.allInitScripts()) frame.evaluateExpression(initScript.source).catch(e => {});
       }
       const isInitialEmptyPage = this._isMainFrame() && this._page.mainFrame().url() === ':';
       if (isInitialEmptyPage) {
-        // Ignore lifecycle events for the initial empty page. It is never the final page
+        // Ignore lifecycle events, worlds and bindings for the initial empty page. It is never the final page
         // hence we are going to get more lifecycle updates after the actual navigation has
         // started (even if the target url is about:blank).
         lifecycleEventsEnabled.catch(e => {}).then(() => {
@@ -447,10 +445,12 @@ class FrameSession {
       }
     }), this._client.send('Log.enable', {}), lifecycleEventsEnabled = this._client.send('Page.setLifecycleEventsEnabled', {
       enabled: true
-    }), this._client.send('Runtime.enable', {}), this._client.send('Page.addScriptToEvaluateOnNewDocument', {
+    }), this._client.send('Runtime.enable', {}), this._client.send('Runtime.addBinding', {
+      name: _page.PageBinding.kPlaywrightBinding
+    }), this._client.send('Page.addScriptToEvaluateOnNewDocument', {
       source: '',
       worldName: UTILITY_WORLD_NAME
-    }), this._networkManager.initialize(), this._client.send('Target.setAutoAttach', {
+    }), this._crPage._networkManager.addSession(this._client, undefined, this._isMainFrame()), this._client.send('Target.setAutoAttach', {
       autoAttach: true,
       waitForDebuggerOnStart: true,
       flatten: true
@@ -478,15 +478,9 @@ class FrameSession {
       if (options.timezoneId) promises.push(emulateTimezone(this._client, options.timezoneId));
       if (!this._crPage._browserContext._browser.options.headful) promises.push(this._setDefaultFontFamilies(this._client));
       promises.push(this._updateGeolocation(true));
-      promises.push(this._updateExtraHTTPHeaders(true));
-      promises.push(this._updateRequestInterception());
-      promises.push(this._updateOffline(true));
-      promises.push(this._updateHttpCredentials(true));
       promises.push(this._updateEmulateMedia());
       promises.push(this._updateFileChooserInterception(true));
-      for (const binding of this._crPage._page.allBindings()) promises.push(this._initBinding(binding));
-      for (const source of this._crPage._browserContext.initScripts) promises.push(this._evaluateOnNewDocument(source, 'main'));
-      for (const source of this._crPage._page.initScripts) promises.push(this._evaluateOnNewDocument(source, 'main'));
+      for (const initScript of this._crPage._page.allInitScripts()) promises.push(this._evaluateOnNewDocument(initScript, 'main'));
       if (screencastOptions) promises.push(this._startVideoRecording(screencastOptions));
     }
     promises.push(this._client.send('Runtime.runIfWaitingForDebugger'));
@@ -498,7 +492,7 @@ class FrameSession {
     for (const childSession of this._childSessions) childSession.dispose();
     if (this._parentSession) this._parentSession._childSessions.delete(this);
     _eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
-    this._networkManager.dispose();
+    this._crPage._networkManager.removeSession(this._client);
     this._crPage._sessions.delete(this._targetId);
     this._client.dispose();
   }
@@ -575,7 +569,7 @@ class FrameSession {
       return;
     }
     if (reason === 'swap') {
-      // This is a local -> remote frame transtion, where
+      // This is a local -> remote frame transition, where
       // Page.frameDetached arrives before Target.attachedToTarget.
       // We should keep the frame in the tree, and it will be used for the new target.
       const frame = this._page._frameManager.frame(frameId);
@@ -589,11 +583,11 @@ class FrameSession {
     const frame = contextPayload.auxData ? this._page._frameManager.frame(contextPayload.auxData.frameId) : null;
     if (!frame || this._eventBelongsToStaleFrame(frame._id)) return;
     const delegate = new _crExecutionContext.CRExecutionContext(this._client, contextPayload);
-    let worldName = null;
-    if (contextPayload.auxData && !!contextPayload.auxData.isDefault) worldName = 'main';else if (contextPayload.name === UTILITY_WORLD_NAME) worldName = 'utility';
+    let worldName;
+    if (contextPayload.auxData && !!contextPayload.auxData.isDefault) worldName = 'main';else if (contextPayload.name === UTILITY_WORLD_NAME) worldName = 'utility';else return;
     const context = new dom.FrameExecutionContext(delegate, frame, worldName);
     context[contextDelegateSymbol] = delegate;
-    if (worldName) frame._contextCreated(worldName, context);
+    frame._contextCreated(worldName, context);
     this._contextIdToContext.set(contextPayload.id, context);
   }
   _onExecutionContextDestroyed(executionContextId) {
@@ -632,7 +626,8 @@ class FrameSession {
     });
     // This might fail if the target is closed before we initialize.
     session._sendMayFail('Runtime.enable');
-    session._sendMayFail('Network.enable');
+    // TODO: attribute workers to the right frame.
+    this._crPage._networkManager.addSession(session, (_this$_page$_frameMan = this._page._frameManager.frame(this._targetId)) !== null && _this$_page$_frameMan !== void 0 ? _this$_page$_frameMan : undefined).catch(() => {});
     session._sendMayFail('Runtime.runIfWaitingForDebugger');
     session._sendMayFail('Target.setAutoAttach', {
       autoAttach: true,
@@ -646,11 +641,6 @@ class FrameSession {
       this._page._addConsoleMessage(event.type, args, (0, _crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
     });
     session.on('Runtime.exceptionThrown', exception => this._page.emitOnContextOnceInitialized(_browserContext.BrowserContext.Events.PageError, (0, _crProtocolHelper.exceptionToError)(exception.exceptionDetails), this._page));
-    // TODO: attribute workers to the right frame.
-    this._networkManager.instrumentNetworkEvents({
-      session,
-      workerFrame: (_this$_page$_frameMan = this._page._frameManager.frame(this._targetId)) !== null && _this$_page$_frameMan !== void 0 ? _this$_page$_frameMan : undefined
-    });
   }
   _onDetachedFromTarget(event) {
     // This might be a worker...
@@ -707,24 +697,6 @@ class FrameSession {
     const values = event.args.map(arg => context.createHandle(arg));
     this._page._addConsoleMessage(event.type, values, (0, _crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
   }
-  async _initBinding(binding) {
-    const [, response] = await Promise.all([this._client.send('Runtime.addBinding', {
-      name: binding.name
-    }), this._client.send('Page.addScriptToEvaluateOnNewDocument', {
-      source: binding.source
-    })]);
-    this._exposedBindingNames.push(binding.name);
-    if (!binding.name.startsWith('__pw')) this._evaluateOnNewDocumentIdentifiers.push(response.identifier);
-  }
-  async _removeExposedBindings() {
-    const toRetain = [];
-    const toRemove = [];
-    for (const name of this._exposedBindingNames) (name.startsWith('__pw_') ? toRetain : toRemove).push(name);
-    this._exposedBindingNames = toRetain;
-    await Promise.all(toRemove.map(name => this._client.send('Runtime.removeBinding', {
-      name
-    })));
-  }
   async _onBindingCalled(event) {
     const pageOrError = await this._crPage.pageOrError();
     if (!(pageOrError instanceof Error)) {
@@ -846,24 +818,10 @@ class FrameSession {
     this._screencastClients.delete(client);
     if (!this._screencastClients.size) await this._client._sendMayFail('Page.stopScreencast');
   }
-  async _updateExtraHTTPHeaders(initial) {
-    const headers = network.mergeHeaders([this._crPage._browserContext._options.extraHTTPHeaders, this._page.extraHTTPHeaders()]);
-    if (!initial || headers.length) await this._client.send('Network.setExtraHTTPHeaders', {
-      headers: (0, _utils.headersArrayToObject)(headers, false /* lowerCase */)
-    });
-  }
   async _updateGeolocation(initial) {
     const geolocation = this._crPage._browserContext._options.geolocation;
     if (!initial || geolocation) await this._client.send('Emulation.setGeolocationOverride', geolocation || {});
   }
-  async _updateOffline(initial) {
-    const offline = !!this._crPage._browserContext._options.offline;
-    if (!initial || offline) await this._networkManager.setOffline(offline);
-  }
-  async _updateHttpCredentials(initial) {
-    const credentials = this._crPage._browserContext._options.httpCredentials || null;
-    if (!initial || credentials) await this._networkManager.authenticate(credentials);
-  }
   async _updateViewport(preserveWindowBoundaries) {
     if (this._crPage._browserContext._browser.isClank()) return;
     (0, _utils.assert)(this._isMainFrame());
@@ -978,9 +936,6 @@ class FrameSession {
     const fontFamilies = _defaultFontFamilies.platformToFontFamilies[this._crPage._browserContext._browser._platform()];
     await session.send('Page.setFontFamilies', fontFamilies);
   }
-  async _updateRequestInterception() {
-    await this._networkManager.setRequestInterception(this._page.needsRequestInterception());
-  }
   async _updateFileChooserInterception(initial) {
     const enabled = this._page.fileChooserIntercepted();
     if (initial && !enabled) return;
@@ -988,15 +943,15 @@ class FrameSession {
       enabled
     }).catch(() => {}); // target can be closed.
   }
-  async _evaluateOnNewDocument(source, world) {
+  async _evaluateOnNewDocument(initScript, world) {
     const worldName = world === 'utility' ? UTILITY_WORLD_NAME : undefined;
     const {
       identifier
     } = await this._client.send('Page.addScriptToEvaluateOnNewDocument', {
-      source,
+      source: initScript.source,
       worldName
     });
-    this._evaluateOnNewDocumentIdentifiers.push(identifier);
+    if (!initScript.internal) this._evaluateOnNewDocumentIdentifiers.push(identifier);
   }
   async _removeEvaluatesOnNewDocument() {
     const identifiers = this._evaluateOnNewDocumentIdentifiers;

package/lib/server/chromium/crProtocolHelper.js

@@ -94,6 +94,7 @@ function toConsoleMessageLocation(stackTrace) {
   };
 }
 function exceptionToError(exceptionDetails) {
+  var _exceptionDetails$exc, _nameOverride$value;
   const messageWithStack = getExceptionMessage(exceptionDetails);
   const lines = messageWithStack.split('\n');
   const firstStackTraceLine = lines.findIndex(line => line.startsWith('    at'));
@@ -111,7 +112,8 @@ function exceptionToError(exceptionDetails) {
   } = (0, _stackTrace.splitErrorMessage)(messageWithName);
   const err = new Error(message);
   err.stack = stack;
-  err.name = name;
+  const nameOverride = (_exceptionDetails$exc = exceptionDetails.exception) === null || _exceptionDetails$exc === void 0 || (_exceptionDetails$exc = _exceptionDetails$exc.preview) === null || _exceptionDetails$exc === void 0 ? void 0 : _exceptionDetails$exc.properties.find(o => o.name === 'name');
+  err.name = nameOverride ? (_nameOverride$value = nameOverride.value) !== null && _nameOverride$value !== void 0 ? _nameOverride$value : 'Error' : name;
   return err;
 }
 function toModifiersMask(modifiers) {

package/lib/server/chromium/crServiceWorker.js

@@ -9,7 +9,6 @@ var _crExecutionContext = require("./crExecutionContext");
 var _crNetworkManager = require("./crNetworkManager");
 var network = _interopRequireWildcard(require("../network"));
 var _browserContext = require("../browserContext");
-var _utils = require("../../utils");
 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; }
 /**
@@ -34,19 +33,18 @@ class CRServiceWorker extends _page.Worker {
     this._browserContext = void 0;
     this._networkManager = void 0;
     this._session = void 0;
-    this._extraHTTPHeaders = null;
     this._session = session;
     this._browserContext = browserContext;
-    if (!!process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS) this._networkManager = new _crNetworkManager.CRNetworkManager(session, null, this, null);
+    if (!!process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS) this._networkManager = new _crNetworkManager.CRNetworkManager(null, this);
     session.once('Runtime.executionContextCreated', event => {
       this._createExecutionContext(new _crExecutionContext.CRExecutionContext(session, event.context));
     });
     if (this._networkManager && this._isNetworkInspectionEnabled()) {
-      this._networkManager.initialize().catch(() => {});
       this.updateRequestInterception();
-      this.updateExtraHTTPHeaders(true);
-      this.updateHttpCredentials(true);
-      this.updateOffline(true);
+      this.updateExtraHTTPHeaders();
+      this.updateHttpCredentials();
+      this.updateOffline();
+      this._networkManager.addSession(session, undefined, true /* isMain */).catch(() => {});
     }
     session.send('Runtime.enable', {}).catch(e => {});
     session.send('Runtime.runIfWaitingForDebugger').catch(e => {});
@@ -56,31 +54,30 @@ class CRServiceWorker extends _page.Worker {
     });
   }
   didClose() {
+    var _this$_networkManager;
+    (_this$_networkManager = this._networkManager) === null || _this$_networkManager === void 0 || _this$_networkManager.removeSession(this._session);
     this._session.dispose();
     super.didClose();
   }
-  async updateOffline(initial) {
-    var _this$_networkManager;
+  async updateOffline() {
+    var _this$_networkManager2;
     if (!this._isNetworkInspectionEnabled()) return;
-    const offline = !!this._browserContext._options.offline;
-    if (!initial || offline) await ((_this$_networkManager = this._networkManager) === null || _this$_networkManager === void 0 ? void 0 : _this$_networkManager.setOffline(offline));
+    await ((_this$_networkManager2 = this._networkManager) === null || _this$_networkManager2 === void 0 ? void 0 : _this$_networkManager2.setOffline(!!this._browserContext._options.offline).catch(() => {}));
   }
-  async updateHttpCredentials(initial) {
-    var _this$_networkManager2;
+  async updateHttpCredentials() {
+    var _this$_networkManager3;
     if (!this._isNetworkInspectionEnabled()) return;
-    const credentials = this._browserContext._options.httpCredentials || null;
-    if (!initial || credentials) await ((_this$_networkManager2 = this._networkManager) === null || _this$_networkManager2 === void 0 ? void 0 : _this$_networkManager2.authenticate(credentials));
+    await ((_this$_networkManager3 = this._networkManager) === null || _this$_networkManager3 === void 0 ? void 0 : _this$_networkManager3.authenticate(this._browserContext._options.httpCredentials || null).catch(() => {}));
   }
-  async updateExtraHTTPHeaders(initial) {
+  async updateExtraHTTPHeaders() {
+    var _this$_networkManager4;
     if (!this._isNetworkInspectionEnabled()) return;
-    const headers = network.mergeHeaders([this._browserContext._options.extraHTTPHeaders, this._extraHTTPHeaders]);
-    if (!initial || headers.length) await this._session.send('Network.setExtraHTTPHeaders', {
-      headers: (0, _utils.headersArrayToObject)(headers, false /* lowerCase */)
-    });
+    await ((_this$_networkManager4 = this._networkManager) === null || _this$_networkManager4 === void 0 ? void 0 : _this$_networkManager4.setExtraHTTPHeaders(this._browserContext._options.extraHTTPHeaders || []).catch(() => {}));
   }
-  updateRequestInterception() {
-    if (!this._networkManager || !this._isNetworkInspectionEnabled()) return Promise.resolve();
-    return this._networkManager.setRequestInterception(this.needsRequestInterception()).catch(e => {});
+  async updateRequestInterception() {
+    var _this$_networkManager5;
+    if (!this._isNetworkInspectionEnabled()) return;
+    await ((_this$_networkManager5 = this._networkManager) === null || _this$_networkManager5 === void 0 ? void 0 : _this$_networkManager5.setRequestInterception(this.needsRequestInterception()).catch(() => {}));
   }
   needsRequestInterception() {
     return this._isNetworkInspectionEnabled() && !!this._browserContext._requestInterceptor;

package/lib/server/chromium/videoRecorder.js

@@ -94,7 +94,7 @@ class VideoRecorder {
 
     const w = options.width;
     const h = options.height;
-    const args = `-loglevel error -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i - -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(' ');
+    const args = `-loglevel error -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i pipe:0 -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(' ');
     args.push(options.outputFile);
     const progress = this._progress;
     const {

package/lib/server/clock.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Clock = void 0;
+var clockSource = _interopRequireWildcard(require("../generated/clockSource"));
+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; }
+/**
+ * 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 Clock {
+  constructor(browserContext) {
+    this._browserContext = void 0;
+    this._scriptInstalled = false;
+    this._browserContext = browserContext;
+  }
+  markAsUninstalled() {
+    this._scriptInstalled = false;
+  }
+  async fastForward(ticks) {
+    await this._installIfNeeded();
+    const ticksMillis = parseTicks(ticks);
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('fastForward', ${Date.now()}, ${ticksMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.fastForward(${ticksMillis})`);
+  }
+  async install(time) {
+    await this._installIfNeeded();
+    const timeMillis = time !== undefined ? parseTime(time) : Date.now();
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('install', ${Date.now()}, ${timeMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.install(${timeMillis})`);
+  }
+  async pauseAt(ticks) {
+    await this._installIfNeeded();
+    const timeMillis = parseTime(ticks);
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('pauseAt', ${Date.now()}, ${timeMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.pauseAt(${timeMillis})`);
+  }
+  async resume() {
+    await this._installIfNeeded();
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('resume', ${Date.now()})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`);
+  }
+  async setFixedTime(time) {
+    await this._installIfNeeded();
+    const timeMillis = parseTime(time);
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setFixedTime', ${Date.now()}, ${timeMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.setFixedTime(${timeMillis})`);
+  }
+  async setSystemTime(time) {
+    await this._installIfNeeded();
+    const timeMillis = parseTime(time);
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setSystemTime', ${Date.now()}, ${timeMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.setSystemTime(${timeMillis})`);
+  }
+  async runFor(ticks) {
+    await this._installIfNeeded();
+    const ticksMillis = parseTicks(ticks);
+    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('runFor', ${Date.now()}, ${ticksMillis})`);
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.runFor(${ticksMillis})`);
+  }
+  async _installIfNeeded() {
+    if (this._scriptInstalled) return;
+    this._scriptInstalled = true;
+    const script = `(() => {
+      const module = {};
+      ${clockSource.source}
+      globalThis.__pwClock = (module.exports.inject())(globalThis);
+    })();`;
+    await this._browserContext.addInitScript(script);
+    await this._evaluateInFrames(script);
+  }
+  async _evaluateInFrames(script) {
+    await this._browserContext.safeNonStallingEvaluateInAllFrames(script, 'main', {
+      throwOnJSErrors: true
+    });
+  }
+}
+
+/**
+ * Parse strings like '01:10:00' (meaning 1 hour, 10 minutes, 0 seconds) into
+ * number of milliseconds. This is used to support human-readable strings passed
+ * to clock.tick()
+ */
+exports.Clock = Clock;
+function parseTicks(value) {
+  if (typeof value === 'number') return value;
+  if (!value) return 0;
+  const str = value;
+  const strings = str.split(':');
+  const l = strings.length;
+  let i = l;
+  let ms = 0;
+  let parsed;
+  if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+    throw new Error(`Clock only understands numbers, 'mm:ss' and 'hh:mm:ss'`);
+  }
+  while (i--) {
+    parsed = parseInt(strings[i], 10);
+    if (parsed >= 60) throw new Error(`Invalid time ${str}`);
+    ms += parsed * Math.pow(60, l - i - 1);
+  }
+  return ms * 1000;
+}
+function parseTime(epoch) {
+  if (!epoch) return 0;
+  if (typeof epoch === 'number') return epoch;
+  const parsed = new Date(epoch);
+  if (!isFinite(parsed.getTime())) throw new Error(`Invalid date: ${epoch}`);
+  return parsed.getTime();
+}