patchright-core 1.48.2

package/lib/server/socksClientCertificatesInterceptor.js

@@ -0,0 +1,340 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ClientCertificatesProxy = void 0;
+exports.getMatchingTLSOptionsForOrigin = getMatchingTLSOptionsForOrigin;
+exports.rewriteOpenSSLErrorIfNeeded = rewriteOpenSSLErrorIfNeeded;
+var _net = _interopRequireDefault(require("net"));
+var _http = _interopRequireDefault(require("http2"));
+var _tls = _interopRequireDefault(require("tls"));
+var _stream = _interopRequireDefault(require("stream"));
+var _happyEyeballs = require("../utils/happy-eyeballs");
+var _utils = require("../utils");
+var _socksProxy = require("../common/socksProxy");
+var _debugLogger = require("../utils/debugLogger");
+var _fetch = require("./fetch");
+var _events = require("events");
+var _browserContext = require("./browserContext");
+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.
+ */
+
+let dummyServerTlsOptions = undefined;
+function loadDummyServerCertsIfNeeded() {
+  if (dummyServerTlsOptions) return;
+  const {
+    cert,
+    key
+  } = (0, _utils.generateSelfSignedCertificate)();
+  dummyServerTlsOptions = {
+    key,
+    cert
+  };
+}
+class ALPNCache {
+  constructor() {
+    this._cache = new Map();
+  }
+  get(host, port, success) {
+    const cacheKey = `${host}:${port}`;
+    {
+      const result = this._cache.get(cacheKey);
+      if (result) {
+        result.then(success);
+        return;
+      }
+    }
+    const result = new _utils.ManualPromise();
+    this._cache.set(cacheKey, result);
+    result.then(success);
+    (0, _happyEyeballs.createTLSSocket)({
+      host,
+      port,
+      servername: _net.default.isIP(host) ? undefined : host,
+      ALPNProtocols: ['h2', 'http/1.1'],
+      rejectUnauthorized: false
+    }).then(socket => {
+      // The server may not respond with ALPN, in which case we default to http/1.1.
+      result.resolve(socket.alpnProtocol || 'http/1.1');
+      socket.end();
+    }).catch(error => {
+      _debugLogger.debugLogger.log('client-certificates', `ALPN error: ${error.message}`);
+      result.resolve('http/1.1');
+    });
+  }
+}
+class SocksProxyConnection {
+  constructor(socksProxy, uid, host, port) {
+    this.socksProxy = void 0;
+    this.uid = void 0;
+    this.host = void 0;
+    this.port = void 0;
+    this.firstPackageReceived = false;
+    this.target = void 0;
+    // In case of http, we just pipe data to the target socket and they are |undefined|.
+    this.internal = void 0;
+    this.internalTLS = void 0;
+    this._targetCloseEventListener = void 0;
+    this._dummyServer = void 0;
+    this._closed = false;
+    this.socksProxy = socksProxy;
+    this.uid = uid;
+    this.host = host;
+    this.port = port;
+    this._targetCloseEventListener = () => {
+      var _this$internalTLS, _this$_dummyServer;
+      // Close the other end and cleanup TLS resources.
+      this.socksProxy._socksProxy.sendSocketEnd({
+        uid: this.uid
+      });
+      (_this$internalTLS = this.internalTLS) === null || _this$internalTLS === void 0 || _this$internalTLS.destroy();
+      (_this$_dummyServer = this._dummyServer) === null || _this$_dummyServer === void 0 || _this$_dummyServer.close();
+    };
+  }
+  async connect() {
+    if (this.socksProxy.proxyAgentFromOptions) this.target = await this.socksProxy.proxyAgentFromOptions.callback(new _events.EventEmitter(), {
+      host: rewriteToLocalhostIfNeeded(this.host),
+      port: this.port,
+      secureEndpoint: false
+    });else this.target = await (0, _happyEyeballs.createSocket)(rewriteToLocalhostIfNeeded(this.host), this.port);
+    this.target.once('close', this._targetCloseEventListener);
+    this.target.once('error', error => this.socksProxy._socksProxy.sendSocketError({
+      uid: this.uid,
+      error: error.message
+    }));
+    if (this._closed) {
+      this.target.destroy();
+      return;
+    }
+    this.socksProxy._socksProxy.socketConnected({
+      uid: this.uid,
+      host: this.target.localAddress,
+      port: this.target.localPort
+    });
+  }
+  onClose() {
+    var _this$internalTLS2, _this$_dummyServer2;
+    // Close the other end and cleanup TLS resources.
+    this.target.destroy();
+    (_this$internalTLS2 = this.internalTLS) === null || _this$internalTLS2 === void 0 || _this$internalTLS2.destroy();
+    (_this$_dummyServer2 = this._dummyServer) === null || _this$_dummyServer2 === void 0 || _this$_dummyServer2.close();
+    this._closed = true;
+  }
+  onData(data) {
+    // HTTP / TLS are client-hello based protocols. This allows us to detect
+    // the protocol on the first package and attach appropriate listeners.
+    if (!this.firstPackageReceived) {
+      this.firstPackageReceived = true;
+      // 0x16 is SSLv3/TLS "handshake" content type: https://en.wikipedia.org/wiki/Transport_Layer_Security#TLS_record
+      if (data[0] === 0x16) this._attachTLSListeners();else this.target.on('data', data => this.socksProxy._socksProxy.sendSocketData({
+        uid: this.uid,
+        data
+      }));
+    }
+    if (this.internal) this.internal.push(data);else this.target.write(data);
+  }
+  _attachTLSListeners() {
+    this.internal = new _stream.default.Duplex({
+      read: () => {},
+      write: (data, encoding, callback) => {
+        this.socksProxy._socksProxy.sendSocketData({
+          uid: this.uid,
+          data
+        });
+        callback();
+      }
+    });
+    this.socksProxy.alpnCache.get(rewriteToLocalhostIfNeeded(this.host), this.port, alpnProtocolChosenByServer => {
+      _debugLogger.debugLogger.log('client-certificates', `Proxy->Target ${this.host}:${this.port} chooses ALPN ${alpnProtocolChosenByServer}`);
+      if (this._closed) return;
+      this._dummyServer = _tls.default.createServer({
+        ...dummyServerTlsOptions,
+        ALPNProtocols: alpnProtocolChosenByServer === 'h2' ? ['h2', 'http/1.1'] : ['http/1.1']
+      });
+      this._dummyServer.emit('connection', this.internal);
+      this._dummyServer.once('secureConnection', internalTLS => {
+        this.internalTLS = internalTLS;
+        _debugLogger.debugLogger.log('client-certificates', `Browser->Proxy ${this.host}:${this.port} chooses ALPN ${internalTLS.alpnProtocol}`);
+        let targetTLS = undefined;
+        const handleError = error => {
+          _debugLogger.debugLogger.log('client-certificates', `error when connecting to target: ${error.message.replaceAll('\n', ' ')}`);
+          const responseBody = (0, _utils.escapeHTML)('Playwright client-certificate error: ' + error.message).replaceAll('\n', ' <br>');
+          if ((internalTLS === null || internalTLS === void 0 ? void 0 : internalTLS.alpnProtocol) === 'h2') {
+            // This method is available only in Node.js 20+
+            if ('performServerHandshake' in _http.default) {
+              // In case of an 'error' event on the target connection, we still need to perform the http2 handshake on the browser side.
+              // This is an async operation, so we need to remove the listener to prevent the socket from being closed too early.
+              // This means we call this._targetCloseEventListener manually.
+              this.target.removeListener('close', this._targetCloseEventListener);
+              // @ts-expect-error
+              const session = _http.default.performServerHandshake(internalTLS);
+              session.on('error', () => {
+                this.target.destroy();
+                this._targetCloseEventListener();
+              });
+              session.once('stream', stream => {
+                stream.respond({
+                  'content-type': 'text/html',
+                  [_http.default.constants.HTTP2_HEADER_STATUS]: 503
+                });
+                const cleanup = () => {
+                  session.close();
+                  this.target.destroy();
+                  this._targetCloseEventListener();
+                };
+                stream.end(responseBody, cleanup);
+                stream.once('error', cleanup);
+              });
+            } else {
+              this.target.destroy();
+            }
+          } else {
+            internalTLS.end(['HTTP/1.1 503 Internal Server Error', 'Content-Type: text/html; charset=utf-8', 'Content-Length: ' + Buffer.byteLength(responseBody), '', responseBody].join('\r\n'));
+            this.target.destroy();
+          }
+        };
+        if (this._closed) {
+          internalTLS.destroy();
+          return;
+        }
+        targetTLS = _tls.default.connect({
+          socket: this.target,
+          host: this.host,
+          port: this.port,
+          rejectUnauthorized: !this.socksProxy.ignoreHTTPSErrors,
+          ALPNProtocols: [internalTLS.alpnProtocol || 'http/1.1'],
+          servername: !_net.default.isIP(this.host) ? this.host : undefined,
+          secureContext: this.socksProxy.secureContextMap.get(new URL(`https://${this.host}:${this.port}`).origin)
+        });
+        targetTLS.once('secureConnect', () => {
+          internalTLS.pipe(targetTLS);
+          targetTLS.pipe(internalTLS);
+        });
+        internalTLS.once('error', () => this.target.destroy());
+        targetTLS.once('error', handleError);
+      });
+    });
+  }
+}
+class ClientCertificatesProxy {
+  constructor(contextOptions) {
+    this._socksProxy = void 0;
+    this._connections = new Map();
+    this.ignoreHTTPSErrors = void 0;
+    this.secureContextMap = new Map();
+    this.alpnCache = void 0;
+    this.proxyAgentFromOptions = void 0;
+    (0, _browserContext.verifyClientCertificates)(contextOptions.clientCertificates);
+    this.alpnCache = new ALPNCache();
+    this.ignoreHTTPSErrors = contextOptions.ignoreHTTPSErrors;
+    this.proxyAgentFromOptions = contextOptions.proxy ? (0, _fetch.createProxyAgent)(contextOptions.proxy) : undefined;
+    this._initSecureContexts(contextOptions.clientCertificates);
+    this._socksProxy = new _socksProxy.SocksProxy();
+    this._socksProxy.setPattern('*');
+    this._socksProxy.addListener(_socksProxy.SocksProxy.Events.SocksRequested, async payload => {
+      try {
+        const connection = new SocksProxyConnection(this, payload.uid, payload.host, payload.port);
+        await connection.connect();
+        this._connections.set(payload.uid, connection);
+      } catch (error) {
+        this._socksProxy.socketFailed({
+          uid: payload.uid,
+          errorCode: error.code
+        });
+      }
+    });
+    this._socksProxy.addListener(_socksProxy.SocksProxy.Events.SocksData, async payload => {
+      var _this$_connections$ge;
+      (_this$_connections$ge = this._connections.get(payload.uid)) === null || _this$_connections$ge === void 0 || _this$_connections$ge.onData(payload.data);
+    });
+    this._socksProxy.addListener(_socksProxy.SocksProxy.Events.SocksClosed, payload => {
+      var _this$_connections$ge2;
+      (_this$_connections$ge2 = this._connections.get(payload.uid)) === null || _this$_connections$ge2 === void 0 || _this$_connections$ge2.onClose();
+      this._connections.delete(payload.uid);
+    });
+    loadDummyServerCertsIfNeeded();
+  }
+  _initSecureContexts(clientCertificates) {
+    // Step 1. Group certificates by origin.
+    const origin2certs = new Map();
+    for (const cert of clientCertificates || []) {
+      const origin = normalizeOrigin(cert.origin);
+      const certs = origin2certs.get(origin) || [];
+      certs.push(cert);
+      origin2certs.set(origin, certs);
+    }
+
+    // Step 2. Create secure contexts for each origin.
+    for (const [origin, certs] of origin2certs) {
+      try {
+        this.secureContextMap.set(origin, _tls.default.createSecureContext(convertClientCertificatesToTLSOptions(certs)));
+      } catch (error) {
+        error = rewriteOpenSSLErrorIfNeeded(error);
+        throw (0, _utils.rewriteErrorMessage)(error, `Failed to load client certificate: ${error.message}`);
+      }
+    }
+  }
+  async listen() {
+    const port = await this._socksProxy.listen(0, '127.0.0.1');
+    return {
+      server: `socks5://127.0.0.1:${port}`
+    };
+  }
+  async close() {
+    await this._socksProxy.close();
+  }
+}
+exports.ClientCertificatesProxy = ClientCertificatesProxy;
+function normalizeOrigin(origin) {
+  try {
+    return new URL(origin).origin;
+  } catch (error) {
+    return origin;
+  }
+}
+function convertClientCertificatesToTLSOptions(clientCertificates) {
+  if (!clientCertificates || !clientCertificates.length) return;
+  const tlsOptions = {
+    pfx: [],
+    key: [],
+    cert: []
+  };
+  for (const cert of clientCertificates) {
+    if (cert.cert) tlsOptions.cert.push(cert.cert);
+    if (cert.key) tlsOptions.key.push({
+      pem: cert.key,
+      passphrase: cert.passphrase
+    });
+    if (cert.pfx) tlsOptions.pfx.push({
+      buf: cert.pfx,
+      passphrase: cert.passphrase
+    });
+  }
+  return tlsOptions;
+}
+function getMatchingTLSOptionsForOrigin(clientCertificates, origin) {
+  const matchingCerts = clientCertificates === null || clientCertificates === void 0 ? void 0 : clientCertificates.filter(c => normalizeOrigin(c.origin) === origin);
+  return convertClientCertificatesToTLSOptions(matchingCerts);
+}
+function rewriteToLocalhostIfNeeded(host) {
+  return host === 'local.playwright' ? 'localhost' : host;
+}
+function rewriteOpenSSLErrorIfNeeded(error) {
+  if (error.message !== 'unsupported' && error.code !== 'ERR_CRYPTO_UNSUPPORTED_OPERATION') return error;
+  return (0, _utils.rewriteErrorMessage)(error, ['Unsupported TLS certificate.', 'Most likely, the security algorithm of the given certificate was deprecated by OpenSSL.', 'For more details, see https://github.com/openssl/openssl/blob/master/README-PROVIDERS.md#the-legacy-provider', 'You could probably modernize the certificate by following the steps at https://github.com/nodejs/node/issues/40672#issuecomment-1243648223'].join('\n'));
+}

package/lib/server/socksInterceptor.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SocksInterceptor = void 0;
+var socks = _interopRequireWildcard(require("../common/socksProxy"));
+var _events = _interopRequireDefault(require("events"));
+var _validator = require("../protocol/validator");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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 SocksInterceptor {
+  constructor(transport, pattern, redirectPortForTest) {
+    this._handler = void 0;
+    this._channel = void 0;
+    this._socksSupportObjectGuid = void 0;
+    this._ids = new Set();
+    this._handler = new socks.SocksProxyHandler(pattern, redirectPortForTest);
+    let lastId = -1;
+    this._channel = new Proxy(new _events.default(), {
+      get: (obj, prop) => {
+        if (prop in obj || obj[prop] !== undefined || typeof prop !== 'string') return obj[prop];
+        return params => {
+          try {
+            const id = --lastId;
+            this._ids.add(id);
+            const validator = (0, _validator.findValidator)('SocksSupport', prop, 'Params');
+            params = validator(params, '', {
+              tChannelImpl: tChannelForSocks,
+              binary: 'toBase64'
+            });
+            transport.send({
+              id,
+              guid: this._socksSupportObjectGuid,
+              method: prop,
+              params,
+              metadata: {
+                stack: [],
+                apiName: '',
+                internal: true
+              }
+            });
+          } catch (e) {}
+        };
+      }
+    });
+    this._handler.on(socks.SocksProxyHandler.Events.SocksConnected, payload => this._channel.socksConnected(payload));
+    this._handler.on(socks.SocksProxyHandler.Events.SocksData, payload => this._channel.socksData(payload));
+    this._handler.on(socks.SocksProxyHandler.Events.SocksError, payload => this._channel.socksError(payload));
+    this._handler.on(socks.SocksProxyHandler.Events.SocksFailed, payload => this._channel.socksFailed(payload));
+    this._handler.on(socks.SocksProxyHandler.Events.SocksEnd, payload => this._channel.socksEnd(payload));
+    this._channel.on('socksRequested', payload => this._handler.socketRequested(payload));
+    this._channel.on('socksClosed', payload => this._handler.socketClosed(payload));
+    this._channel.on('socksData', payload => this._handler.sendSocketData(payload));
+  }
+  cleanup() {
+    this._handler.cleanup();
+  }
+  interceptMessage(message) {
+    if (this._ids.has(message.id)) {
+      this._ids.delete(message.id);
+      return true;
+    }
+    if (message.method === '__create__' && message.params.type === 'SocksSupport') {
+      this._socksSupportObjectGuid = message.params.guid;
+      return false;
+    }
+    if (this._socksSupportObjectGuid && message.guid === this._socksSupportObjectGuid) {
+      const validator = (0, _validator.findValidator)('SocksSupport', message.method, 'Event');
+      const params = validator(message.params, '', {
+        tChannelImpl: tChannelForSocks,
+        binary: 'fromBase64'
+      });
+      this._channel.emit(message.method, params);
+      return true;
+    }
+    return false;
+  }
+}
+exports.SocksInterceptor = SocksInterceptor;
+function tChannelForSocks(names, arg, path, context) {
+  throw new _validator.ValidationError(`${path}: channels are not expected in SocksSupport`);
+}

package/lib/server/trace/recorder/snapshotter.js

@@ -0,0 +1,172 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Snapshotter = void 0;
+var _browserContext = require("../../browserContext");
+var _page = require("../../page");
+var _eventsHelper = require("../../../utils/eventsHelper");
+var _debugLogger = require("../../../utils/debugLogger");
+var _snapshotterInjected = require("./snapshotterInjected");
+var _utils = require("../../../utils");
+var _utilsBundle = require("../../../utilsBundle");
+/**
+ * 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 Snapshotter {
+  constructor(context, delegate) {
+    this._context = void 0;
+    this._delegate = void 0;
+    this._eventListeners = [];
+    this._snapshotStreamer = void 0;
+    this._initialized = false;
+    this._started = false;
+    this._context = context;
+    this._delegate = delegate;
+    const guid = (0, _utils.createGuid)();
+    this._snapshotStreamer = '__playwright_snapshot_streamer_' + guid;
+  }
+  started() {
+    return this._started;
+  }
+  async start() {
+    this._started = true;
+    if (!this._initialized) {
+      this._initialized = true;
+      await this._initialize();
+    }
+    await this.reset();
+  }
+  async reset() {
+    if (this._started) await this._runInAllFrames(`window["${this._snapshotStreamer}"].reset()`);
+  }
+  async stop() {
+    this._started = false;
+  }
+  resetForReuse() {
+    // Next time we start recording, we will call addInitScript again.
+    this._initialized = false;
+  }
+  async _initialize() {
+    for (const page of this._context.pages()) this._onPage(page);
+    this._eventListeners = [_eventsHelper.eventsHelper.addEventListener(this._context, _browserContext.BrowserContext.Events.Page, this._onPage.bind(this))];
+    const {
+      javaScriptEnabled
+    } = this._context._options;
+    const initScript = `(${_snapshotterInjected.frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === undefined})`;
+    await this._context.addInitScript(initScript);
+    await this._runInAllFrames(initScript);
+  }
+  async _runInAllFrames(expression) {
+    const frames = [];
+    for (const page of this._context.pages()) frames.push(...page.frames());
+    await Promise.all(frames.map(frame => {
+      return frame.nonStallingRawEvaluateInExistingMainContext(expression).catch(e => _debugLogger.debugLogger.log('error', e));
+    }));
+  }
+  dispose() {
+    _eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
+  }
+  async captureSnapshot(page, callId, snapshotName, element) {
+    // Prepare expression synchronously.
+    const expression = `window["${this._snapshotStreamer}"].captureSnapshot(${JSON.stringify(snapshotName)})`;
+
+    // In a best-effort manner, without waiting for it, mark target element.
+    element === null || element === void 0 || element.callFunctionNoReply((element, callId) => {
+      const customEvent = new CustomEvent('__playwright_target__', {
+        bubbles: true,
+        cancelable: true,
+        detail: callId,
+        composed: true
+      });
+      element.dispatchEvent(customEvent);
+    }, callId);
+
+    // In each frame, in a non-stalling manner, capture the snapshots.
+    const snapshots = page.frames().map(async frame => {
+      const data = await frame.nonStallingRawEvaluateInExistingMainContext(expression).catch(e => _debugLogger.debugLogger.log('error', e));
+      // Something went wrong -> bail out, our snapshots are best-efforty.
+      if (!data || !this._started) return;
+      const snapshot = {
+        callId,
+        snapshotName,
+        pageId: page.guid,
+        frameId: frame.guid,
+        frameUrl: data.url,
+        doctype: data.doctype,
+        html: data.html,
+        viewport: data.viewport,
+        timestamp: (0, _utils.monotonicTime)(),
+        wallTime: data.wallTime,
+        collectionTime: data.collectionTime,
+        resourceOverrides: [],
+        isMainFrame: page.mainFrame() === frame
+      };
+      for (const {
+        url,
+        content,
+        contentType
+      } of data.resourceOverrides) {
+        if (typeof content === 'string') {
+          const buffer = Buffer.from(content);
+          const sha1 = (0, _utils.calculateSha1)(buffer) + '.' + (_utilsBundle.mime.getExtension(contentType) || 'dat');
+          this._delegate.onSnapshotterBlob({
+            sha1,
+            buffer
+          });
+          snapshot.resourceOverrides.push({
+            url,
+            sha1
+          });
+        } else {
+          snapshot.resourceOverrides.push({
+            url,
+            ref: content
+          });
+        }
+      }
+      this._delegate.onFrameSnapshot(snapshot);
+    });
+    await Promise.all(snapshots);
+  }
+  _onPage(page) {
+    // Annotate frame hierarchy so that snapshots could include frame ids.
+    for (const frame of page.frames()) this._annotateFrameHierarchy(frame);
+    this._eventListeners.push(_eventsHelper.eventsHelper.addEventListener(page, _page.Page.Events.FrameAttached, frame => this._annotateFrameHierarchy(frame)));
+  }
+  async _annotateFrameHierarchy(frame) {
+    try {
+      const frameElement = await frame.frameElement();
+      const parent = frame.parentFrame();
+      if (!parent) return;
+      const context = await parent._mainContext();
+      await (context === null || context === void 0 ? void 0 : context.evaluate(({
+        snapshotStreamer,
+        frameElement,
+        frameId
+      }) => {
+        window[snapshotStreamer].markIframe(frameElement, frameId);
+      }, {
+        snapshotStreamer: this._snapshotStreamer,
+        frameElement,
+        frameId: frame.guid
+      }));
+      frameElement.dispose();
+    } catch (e) {}
+  }
+}
+exports.Snapshotter = Snapshotter;