rebrowser-playwright-core 1.49.1 → 1.64.1

package/lib/server/socksClientCertificatesInterceptor.js

@@ -1,340 +0,0 @@
-"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.connect(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

@@ -1,100 +0,0 @@
-"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

@@ -1,161 +0,0 @@
-"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) {
-    // Prepare expression synchronously.
-    const expression = `window["${this._snapshotStreamer}"].captureSnapshot(${JSON.stringify(snapshotName)})`;
-
-    // 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;