javascript/selenium-webdriver/bidi/network.js - external/github.com/SeleniumHQ/selenium - Git at Google

 // Licensed to the Software Freedom Conservancy (SFC) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The SFC licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.

 const { BeforeRequestSent, ResponseStarted, FetchError } = require('./networkTypes')
 const { AddInterceptParameters } = require('./addInterceptParameters')
 const { ContinueResponseParameters } = require('./continueResponseParameters')
 const { ContinueRequestParameters } = require('./continueRequestParameters')
 const { ProvideResponseParameters } = require('./provideResponseParameters')

 const NetworkEvent = {
   BEFORE_REQUEST_SENT: 'network.beforeRequestSent',
   RESPONSE_STARTED: 'network.responseStarted',
   RESPONSE_COMPLETED: 'network.responseCompleted',
   AUTH_REQUIRED: 'network.authRequired',
   FETCH_ERROR: 'network.fetchError',
 }

 const CacheBehavior = Object.freeze({
   DEFAULT: 'default',
   BYPASS: 'bypass',
 })

 /**
  * Represents all commands and events of Network module.
  * Described in https://w3c.github.io/webdriver-bidi/#module-network.
  */
 class Network {
   #callbackId = 0
   #listener

   /**
    * Represents a Network object.
    * @constructor
    * @param {Driver} driver - The driver to fetch the BiDi connection.
    * @param {Array} browsingContextIds - An array of browsing context IDs that the network events will be subscribed to.
    */
   constructor(driver, browsingContextIds) {
     this._driver = driver
     this._browsingContextIds = browsingContextIds
     this.#listener = new Map()
     this.#listener.set(NetworkEvent.AUTH_REQUIRED, new Map())
     this.#listener.set(NetworkEvent.BEFORE_REQUEST_SENT, new Map())
     this.#listener.set(NetworkEvent.FETCH_ERROR, new Map())
     this.#listener.set(NetworkEvent.RESPONSE_STARTED, new Map())
     this.#listener.set(NetworkEvent.RESPONSE_COMPLETED, new Map())
   }

   addCallback(eventType, callback) {
     const id = ++this.#callbackId

     const eventCallbackMap = this.#listener.get(eventType)
     eventCallbackMap.set(id, callback)
     return id
   }

   removeCallback(id) {
     let hasId = false
     for (const [, callbacks] of this.#listener) {
       if (callbacks.has(id)) {
         callbacks.delete(id)
         hasId = true
       }
     }

     if (!hasId) {
       throw Error(`Callback with id ${id} not found`)
     }
   }

   invokeCallbacks(eventType, data) {
     const callbacks = this.#listener.get(eventType)
     if (callbacks) {
       for (const [, callback] of callbacks) {
         callback(data)
       }
     }
   }

   async init() {
     this.bidi = await this._driver.getBidi()
   }

   /**
    * Subscribes to the 'network.beforeRequestSent' event and handles it with the provided callback.
    *
    * @param {Function} callback - The callback function to handle the event.
    * @returns {Promise<void>} - A promise that resolves when the subscription is successful.
    */
   async beforeRequestSent(callback) {
     await this.subscribeAndHandleEvent('network.beforeRequestSent', callback)
   }

   /**
    * Subscribes to the 'network.responseStarted' event and handles it with the provided callback.
    *
    * @param {Function} callback - The callback function to handle the event.
    * @returns {Promise<void>} - A promise that resolves when the subscription is successful.
    */
   async responseStarted(callback) {
     await this.subscribeAndHandleEvent('network.responseStarted', callback)
   }

   /**
    * Subscribes to the 'network.responseCompleted' event and handles it with the provided callback.
    *
    * @param {Function} callback - The callback function to handle the event.
    * @returns {Promise<void>} - A promise that resolves when the subscription is successful.
    */
   async responseCompleted(callback) {
     await this.subscribeAndHandleEvent('network.responseCompleted', callback)
   }

   /**
    * Subscribes to the 'network.authRequired' event and handles it with the provided callback.
    *
    * @param {Function} callback - The callback function to handle the event.
    * @returns {Promise<number>} - A promise that resolves when the subscription is successful.
    */
   async authRequired(callback) {
     return await this.subscribeAndHandleEvent('network.authRequired', callback)
   }

   /**
    * Subscribes to the 'network.fetchError' event and handles it with the provided callback.
    *
    * @param {Function} callback - The callback function to handle the event.
    * @returns {Promise<void>} - A promise that resolves when the subscription is successful.
    */
   async fetchError(callback) {
     await this.subscribeAndHandleEvent('network.fetchError', callback)
   }

   async subscribeAndHandleEvent(eventType, callback) {
     if (this._browsingContextIds != null) {
       await this.bidi.subscribe(eventType, this._browsingContextIds)
     } else {
       await this.bidi.subscribe(eventType)
     }
     let id = this.addCallback(eventType, callback)

     this.ws = await this.bidi.socket
     this.ws.on('message', (event) => {
       const { params } = JSON.parse(Buffer.from(event.toString()))
       if (params) {
         let response = null
         if ('initiator' in params) {
           response = new BeforeRequestSent(
             params.context,
             params.navigation,
             params.redirectCount,
             params.request,
             params.timestamp,
             params.initiator,
           )
         } else if ('response' in params) {
           response = new ResponseStarted(
             params.context,
             params.navigation,
             params.redirectCount,
             params.request,
             params.timestamp,
             params.response,
           )
         } else if ('errorText' in params) {
           response = new FetchError(
             params.context,
             params.navigation,
             params.redirectCount,
             params.request,
             params.timestamp,
             params.errorText,
           )
         }
         this.invokeCallbacks(eventType, response)
       }
     })
     return id
   }

   /**
    * Adds a network intercept.
    *
    * @param {AddInterceptParameters} params - The parameters for the network intercept.
    * @returns {Promise<string>} - A promise that resolves to the added intercept's id.
    * @throws {Error} - If params is not an instance of AddInterceptParameters.
    */
   async addIntercept(params) {
     if (!(params instanceof AddInterceptParameters)) {
       throw new Error(`Params must be an instance of AddInterceptParameters. Received:'${params}'`)
     }

     const command = {
       method: 'network.addIntercept',
       params: Object.fromEntries(params.asMap()),
     }

     let response = await this.bidi.send(command)

     return response.result.intercept
   }

   /**
    * Removes an intercept.
    *
    * @param {string} interceptId - The ID of the intercept to be removed.
    * @returns {Promise<void>} - A promise that resolves when the intercept is successfully removed.
    */
   async removeIntercept(interceptId) {
     const command = {
       method: 'network.removeIntercept',
       params: { intercept: interceptId },
     }

     await this.bidi.send(command)
   }

   /**
    * Continues the network request with authentication credentials.
    * @param {string} requestId - The ID of the request to continue.
    * @param {string} username - The username for authentication.
    * @param {string} password - The password for authentication.
    * @returns {Promise<void>} - A promise that resolves when the command is sent.
    */
   async continueWithAuth(requestId, username, password) {
     const command = {
       method: 'network.continueWithAuth',
       params: {
         request: requestId.toString(),
         action: 'provideCredentials',
         credentials: {
           type: 'password',
           username: username,
           password: password,
         },
       },
     }
     await this.bidi.send(command)
   }

   /**
    * Fails a network request.
    *
    * @param {number} requestId - The ID of the request to fail.
    * @returns {Promise<void>} - A promise that resolves when the command is sent.
    */
   async failRequest(requestId) {
     const command = {
       method: 'network.failRequest',
       params: {
         request: requestId.toString(),
       },
     }
     await this.bidi.send(command)
   }

   /**
    * Continues the network request with authentication but without providing credentials.
    * @param {string} requestId - The ID of the request to continue with authentication.
    * @returns {Promise<void>} - A promise that resolves when the command is sent.
    */
   async continueWithAuthNoCredentials(requestId) {
     const command = {
       method: 'network.continueWithAuth',
       params: {
         request: requestId.toString(),
         action: 'default',
       },
     }
     await this.bidi.send(command)
   }

   /**
    * Cancels the authentication for a specific request.
    *
    * @param {string} requestId - The ID of the request to cancel authentication for.
    * @returns {Promise<void>} - A promise that resolves when the command is sent.
    */
   async cancelAuth(requestId) {
     const command = {
       method: 'network.continueWithAuth',
       params: {
         request: requestId.toString(),
         action: 'cancel',
       },
     }
     await this.bidi.send(command)
   }

   /**
    * Continues the network request with the provided parameters.
    *
    * @param {ContinueRequestParameters} params - The parameters for continuing the request.
    * @throws {Error} If params is not an instance of ContinueRequestParameters.
    * @returns {Promise<void>} A promise that resolves when the command is sent.
    */
   async continueRequest(params) {
     if (!(params instanceof ContinueRequestParameters)) {
       throw new Error(`Params must be an instance of ContinueRequestParameters. Received:'${params}'`)
     }

     const command = {
       method: 'network.continueRequest',
       params: Object.fromEntries(params.asMap()),
     }

     await this.bidi.send(command)
   }

   /**
    * Continues the network response with the given parameters.
    *
    * @param {ContinueResponseParameters} params - The parameters for continuing the response.
    * @throws {Error} If params is not an instance of ContinueResponseParameters.
    * @returns {Promise<void>} A promise that resolves when the command is sent.
    */
   async continueResponse(params) {
     if (!(params instanceof ContinueResponseParameters)) {
       throw new Error(`Params must be an instance of ContinueResponseParameters. Received:'${params}'`)
     }

     const command = {
       method: 'network.continueResponse',
       params: Object.fromEntries(params.asMap()),
     }

     await this.bidi.send(command)
   }

   /**
    * Provides a response for the network.
    *
    * @param {ProvideResponseParameters} params - The parameters for providing the response.
    * @throws {Error} If params is not an instance of ProvideResponseParameters.
    * @returns {Promise<void>} A promise that resolves when the command is sent.
    */
   async provideResponse(params) {
     if (!(params instanceof ProvideResponseParameters)) {
       throw new Error(`Params must be an instance of ProvideResponseParameters. Received:'${params}'`)
     }

     const command = {
       method: 'network.provideResponse',
       params: Object.fromEntries(params.asMap()),
     }

     await this.bidi.send(command)
   }

   /**
    * Sets the cache behavior for network requests.
    *
    * @param {string} behavior - The cache behavior ("default" or "bypass")
    * @param {Array<string>} [contexts] - Optional array of browsing context IDs
    * @returns {Promise<void>} A promise that resolves when the cache behavior is set
    * @throws {Error} If behavior is invalid or context IDs are invalid
    */
   async setCacheBehavior(behavior, contexts = null) {
     if (!Object.values(CacheBehavior).includes(behavior)) {
       throw new Error(`Cache behavior must be either "${CacheBehavior.DEFAULT}" or "${CacheBehavior.BYPASS}"`)
     }

     const command = {
       method: 'network.setCacheBehavior',
       params: {
         cacheBehavior: behavior,
       },
     }

     if (contexts !== null) {
       if (
         !Array.isArray(contexts) ||
         contexts.length === 0 ||
         contexts.some((c) => typeof c !== 'string' || c.trim() === '')
       ) {
         throw new Error('Contexts must be an array of non-empty strings')
       }
       command.params.contexts = contexts
     }

     await this.bidi.send(command)
   }

   /**
    * Unsubscribes from network events for all browsing contexts.
    * @returns {Promise<void>} A promise that resolves when the network connection is closed.
    */
   async close() {
     if (
       this._browsingContextIds !== null &&
       this._browsingContextIds !== undefined &&
       this._browsingContextIds.length > 0
     ) {
       await this.bidi.unsubscribe(
         'network.beforeRequestSent',
         'network.responseStarted',
         'network.responseCompleted',
         'network.authRequired',
         this._browsingContextIds,
       )
     } else {
       await this.bidi.unsubscribe(
         'network.beforeRequestSent',
         'network.responseStarted',
         'network.responseCompleted',
         'network.authRequired',
       )
     }
   }
 }

 async function getNetworkInstance(driver, browsingContextIds = null) {
   let instance = new Network(driver, browsingContextIds)
   await instance.init()
   return instance
 }

 module.exports = { Network: getNetworkInstance, CacheBehavior }
	// Licensed to the Software Freedom Conservancy (SFC) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The SFC licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.

	const { BeforeRequestSent, ResponseStarted, FetchError } = require('./networkTypes')
	const { AddInterceptParameters } = require('./addInterceptParameters')
	const { ContinueResponseParameters } = require('./continueResponseParameters')
	const { ContinueRequestParameters } = require('./continueRequestParameters')
	const { ProvideResponseParameters } = require('./provideResponseParameters')

	const NetworkEvent = {
	BEFORE_REQUEST_SENT: 'network.beforeRequestSent',
	RESPONSE_STARTED: 'network.responseStarted',
	RESPONSE_COMPLETED: 'network.responseCompleted',
	AUTH_REQUIRED: 'network.authRequired',
	FETCH_ERROR: 'network.fetchError',
	}

	const CacheBehavior = Object.freeze({
	DEFAULT: 'default',
	BYPASS: 'bypass',
	})

	/**
	* Represents all commands and events of Network module.
	* Described in https://w3c.github.io/webdriver-bidi/#module-network.
	*/
	class Network {
	#callbackId = 0
	#listener

	/**
	* Represents a Network object.
	* @constructor
	* @param {Driver} driver - The driver to fetch the BiDi connection.
	* @param {Array} browsingContextIds - An array of browsing context IDs that the network events will be subscribed to.
	*/
	constructor(driver, browsingContextIds) {
	this._driver = driver
	this._browsingContextIds = browsingContextIds
	this.#listener = new Map()
	this.#listener.set(NetworkEvent.AUTH_REQUIRED, new Map())
	this.#listener.set(NetworkEvent.BEFORE_REQUEST_SENT, new Map())
	this.#listener.set(NetworkEvent.FETCH_ERROR, new Map())
	this.#listener.set(NetworkEvent.RESPONSE_STARTED, new Map())
	this.#listener.set(NetworkEvent.RESPONSE_COMPLETED, new Map())
	}

	addCallback(eventType, callback) {
	const id = ++this.#callbackId

	const eventCallbackMap = this.#listener.get(eventType)
	eventCallbackMap.set(id, callback)
	return id
	}

	removeCallback(id) {
	let hasId = false
	for (const [, callbacks] of this.#listener) {
	if (callbacks.has(id)) {
	callbacks.delete(id)
	hasId = true
	}
	}

	if (!hasId) {
	throw Error(`Callback with id ${id} not found`)
	}
	}

	invokeCallbacks(eventType, data) {
	const callbacks = this.#listener.get(eventType)
	if (callbacks) {
	for (const [, callback] of callbacks) {
	callback(data)
	}
	}
	}

	async init() {
	this.bidi = await this._driver.getBidi()
	}

	/**
	* Subscribes to the 'network.beforeRequestSent' event and handles it with the provided callback.
	*
	* @param {Function} callback - The callback function to handle the event.
	* @returns {Promise<void>} - A promise that resolves when the subscription is successful.
	*/
	async beforeRequestSent(callback) {
	await this.subscribeAndHandleEvent('network.beforeRequestSent', callback)
	}

	/**
	* Subscribes to the 'network.responseStarted' event and handles it with the provided callback.
	*
	* @param {Function} callback - The callback function to handle the event.
	* @returns {Promise<void>} - A promise that resolves when the subscription is successful.
	*/
	async responseStarted(callback) {
	await this.subscribeAndHandleEvent('network.responseStarted', callback)
	}

	/**
	* Subscribes to the 'network.responseCompleted' event and handles it with the provided callback.
	*
	* @param {Function} callback - The callback function to handle the event.
	* @returns {Promise<void>} - A promise that resolves when the subscription is successful.
	*/
	async responseCompleted(callback) {
	await this.subscribeAndHandleEvent('network.responseCompleted', callback)
	}

	/**
	* Subscribes to the 'network.authRequired' event and handles it with the provided callback.
	*
	* @param {Function} callback - The callback function to handle the event.
	* @returns {Promise<number>} - A promise that resolves when the subscription is successful.
	*/
	async authRequired(callback) {
	return await this.subscribeAndHandleEvent('network.authRequired', callback)
	}

	/**
	* Subscribes to the 'network.fetchError' event and handles it with the provided callback.
	*
	* @param {Function} callback - The callback function to handle the event.
	* @returns {Promise<void>} - A promise that resolves when the subscription is successful.
	*/
	async fetchError(callback) {
	await this.subscribeAndHandleEvent('network.fetchError', callback)
	}

	async subscribeAndHandleEvent(eventType, callback) {
	if (this._browsingContextIds != null) {
	await this.bidi.subscribe(eventType, this._browsingContextIds)
	} else {
	await this.bidi.subscribe(eventType)
	}
	let id = this.addCallback(eventType, callback)

	this.ws = await this.bidi.socket
	this.ws.on('message', (event) => {
	const { params } = JSON.parse(Buffer.from(event.toString()))
	if (params) {
	let response = null
	if ('initiator' in params) {
	response = new BeforeRequestSent(
	params.context,
	params.navigation,
	params.redirectCount,
	params.request,
	params.timestamp,
	params.initiator,
	)
	} else if ('response' in params) {
	response = new ResponseStarted(
	params.context,
	params.navigation,
	params.redirectCount,
	params.request,
	params.timestamp,
	params.response,
	)
	} else if ('errorText' in params) {
	response = new FetchError(
	params.context,
	params.navigation,
	params.redirectCount,
	params.request,
	params.timestamp,
	params.errorText,
	)
	}
	this.invokeCallbacks(eventType, response)
	}
	})
	return id
	}

	/**
	* Adds a network intercept.
	*
	* @param {AddInterceptParameters} params - The parameters for the network intercept.
	* @returns {Promise<string>} - A promise that resolves to the added intercept's id.
	* @throws {Error} - If params is not an instance of AddInterceptParameters.
	*/
	async addIntercept(params) {
	if (!(params instanceof AddInterceptParameters)) {
	throw new Error(`Params must be an instance of AddInterceptParameters. Received:'${params}'`)
	}

	const command = {
	method: 'network.addIntercept',
	params: Object.fromEntries(params.asMap()),
	}

	let response = await this.bidi.send(command)

	return response.result.intercept
	}

	/**
	* Removes an intercept.
	*
	* @param {string} interceptId - The ID of the intercept to be removed.
	* @returns {Promise<void>} - A promise that resolves when the intercept is successfully removed.
	*/
	async removeIntercept(interceptId) {
	const command = {
	method: 'network.removeIntercept',
	params: { intercept: interceptId },
	}

	await this.bidi.send(command)
	}

	/**
	* Continues the network request with authentication credentials.
	* @param {string} requestId - The ID of the request to continue.
	* @param {string} username - The username for authentication.
	* @param {string} password - The password for authentication.
	* @returns {Promise<void>} - A promise that resolves when the command is sent.
	*/
	async continueWithAuth(requestId, username, password) {
	const command = {
	method: 'network.continueWithAuth',
	params: {
	request: requestId.toString(),
	action: 'provideCredentials',
	credentials: {
	type: 'password',
	username: username,
	password: password,
	},
	},
	}
	await this.bidi.send(command)
	}

	/**
	* Fails a network request.
	*
	* @param {number} requestId - The ID of the request to fail.
	* @returns {Promise<void>} - A promise that resolves when the command is sent.
	*/
	async failRequest(requestId) {
	const command = {
	method: 'network.failRequest',
	params: {
	request: requestId.toString(),
	},
	}
	await this.bidi.send(command)
	}

	/**
	* Continues the network request with authentication but without providing credentials.
	* @param {string} requestId - The ID of the request to continue with authentication.
	* @returns {Promise<void>} - A promise that resolves when the command is sent.
	*/
	async continueWithAuthNoCredentials(requestId) {
	const command = {
	method: 'network.continueWithAuth',
	params: {
	request: requestId.toString(),
	action: 'default',
	},
	}
	await this.bidi.send(command)
	}

	/**
	* Cancels the authentication for a specific request.
	*
	* @param {string} requestId - The ID of the request to cancel authentication for.
	* @returns {Promise<void>} - A promise that resolves when the command is sent.
	*/
	async cancelAuth(requestId) {
	const command = {
	method: 'network.continueWithAuth',
	params: {
	request: requestId.toString(),
	action: 'cancel',
	},
	}
	await this.bidi.send(command)
	}

	/**
	* Continues the network request with the provided parameters.
	*
	* @param {ContinueRequestParameters} params - The parameters for continuing the request.
	* @throws {Error} If params is not an instance of ContinueRequestParameters.
	* @returns {Promise<void>} A promise that resolves when the command is sent.
	*/
	async continueRequest(params) {
	if (!(params instanceof ContinueRequestParameters)) {
	throw new Error(`Params must be an instance of ContinueRequestParameters. Received:'${params}'`)
	}

	const command = {
	method: 'network.continueRequest',
	params: Object.fromEntries(params.asMap()),
	}

	await this.bidi.send(command)
	}

	/**
	* Continues the network response with the given parameters.
	*
	* @param {ContinueResponseParameters} params - The parameters for continuing the response.
	* @throws {Error} If params is not an instance of ContinueResponseParameters.
	* @returns {Promise<void>} A promise that resolves when the command is sent.
	*/
	async continueResponse(params) {
	if (!(params instanceof ContinueResponseParameters)) {
	throw new Error(`Params must be an instance of ContinueResponseParameters. Received:'${params}'`)
	}

	const command = {
	method: 'network.continueResponse',
	params: Object.fromEntries(params.asMap()),
	}

	await this.bidi.send(command)
	}

	/**
	* Provides a response for the network.
	*
	* @param {ProvideResponseParameters} params - The parameters for providing the response.
	* @throws {Error} If params is not an instance of ProvideResponseParameters.
	* @returns {Promise<void>} A promise that resolves when the command is sent.
	*/
	async provideResponse(params) {
	if (!(params instanceof ProvideResponseParameters)) {
	throw new Error(`Params must be an instance of ProvideResponseParameters. Received:'${params}'`)
	}

	const command = {
	method: 'network.provideResponse',
	params: Object.fromEntries(params.asMap()),
	}

	await this.bidi.send(command)
	}

	/**
	* Sets the cache behavior for network requests.
	*
	* @param {string} behavior - The cache behavior ("default" or "bypass")
	* @param {Array<string>} [contexts] - Optional array of browsing context IDs
	* @returns {Promise<void>} A promise that resolves when the cache behavior is set
	* @throws {Error} If behavior is invalid or context IDs are invalid
	*/
	async setCacheBehavior(behavior, contexts = null) {
	if (!Object.values(CacheBehavior).includes(behavior)) {
	throw new Error(`Cache behavior must be either "${CacheBehavior.DEFAULT}" or "${CacheBehavior.BYPASS}"`)
	}

	const command = {
	method: 'network.setCacheBehavior',
	params: {
	cacheBehavior: behavior,
	},
	}

	if (contexts !== null) {
	if (
	!Array.isArray(contexts) \|\|
	contexts.length === 0 \|\|
	contexts.some((c) => typeof c !== 'string' \|\| c.trim() === '')
	) {
	throw new Error('Contexts must be an array of non-empty strings')
	}
	command.params.contexts = contexts
	}

	await this.bidi.send(command)
	}

	/**
	* Unsubscribes from network events for all browsing contexts.
	* @returns {Promise<void>} A promise that resolves when the network connection is closed.
	*/
	async close() {
	if (
	this._browsingContextIds !== null &&
	this._browsingContextIds !== undefined &&
	this._browsingContextIds.length > 0
	) {
	await this.bidi.unsubscribe(
	'network.beforeRequestSent',
	'network.responseStarted',
	'network.responseCompleted',
	'network.authRequired',
	this._browsingContextIds,
	)
	} else {
	await this.bidi.unsubscribe(
	'network.beforeRequestSent',
	'network.responseStarted',
	'network.responseCompleted',
	'network.authRequired',
	)
	}
	}
	}

	async function getNetworkInstance(driver, browsingContextIds = null) {
	let instance = new Network(driver, browsingContextIds)
	await instance.init()
	return instance
	}

	module.exports = { Network: getNetworkInstance, CacheBehavior }