How to get rid of the console logs from JsonRpcProvider class

[C0D3O]

There is a console log in the provider-jsonrpc.ts file

JsonRpcProvider failed to detect network and cannot start up; retry in 1s (perhaps the URL is wrong or the node is not started)

and here's how I try removing it (AT THE VERY BOTTOM OF THE CODE ALMOST )
upd ( SKIP THE CODE ) it's redundant and irrelevant, you know what console.log I'm talking about

import {
	JsonRpcApiProviderOptions,
	JsonRpcError,
	JsonRpcPayload,
	JsonRpcProvider,
	JsonRpcResult,
	Network,
	Networkish,
	Wallet,
	assertArgument,
	makeError,
} from 'ethers';

type Payload = { payload: JsonRpcPayload; resolve: ResolveFunc; reject: RejectFunc };
type ResolveFunc = (result: JsonRpcResult) => void;
type RejectFunc = (error: Error) => void;
type Timer = ReturnType<typeof setTimeout>;

function stall(duration: number): Promise<void> {
	return new Promise((resolve) => {
		setTimeout(resolve, duration);
	});
}

const defaultOptions = {
	polling: false,
	staticNetwork: null,

	batchStallTime: 10, // 10ms
	batchMaxSize: 1 << 20, // 1Mb
	batchMaxCount: 100, // 100 requests

	cacheTimeout: 250,
	pollingInterval: 4000,
};

export class RetriableJsonRpcProvider extends JsonRpcProvider {
	#options: Required<JsonRpcApiProviderOptions>;

	#scheduleDrain(): void {
		if (this.#drainTimer) {
			return;
		}

		// If we aren't using batching, no harm in sending it immediately
		const stallTime = this._getOption('batchMaxCount') === 1 ? 0 : this._getOption('batchStallTime');

		this.#drainTimer = setTimeout(() => {
			this.#drainTimer = null;

			const payloads = this.#payloads;
			this.#payloads = [];

			while (payloads.length) {
				// Create payload batches that satisfy our batch constraints
				const batch = [<Payload>payloads.shift()];
				while (payloads.length) {
					if (batch.length === this.#options.batchMaxCount) {
						break;
					}
					batch.push(<Payload>payloads.shift());
					const bytes = JSON.stringify(batch.map((p) => p.payload));
					if (bytes.length > this.#options.batchMaxSize) {
						payloads.unshift(<Payload>batch.pop());
						break;
					}
				}

				// Process the result to each payload
				(async () => {
					const payload = batch.length === 1 ? batch[0].payload : batch.map((p) => p.payload);

					this.emit('debug', { action: 'sendRpcPayload', payload });

					try {
						const result = await this._send(payload);
						this.emit('debug', { action: 'receiveRpcResult', result });

						// Process results in batch order
						for (const { resolve, reject, payload } of batch) {
							if (this.destroyed) {
								reject(makeError('provider destroyed; cancelled request', 'UNSUPPORTED_OPERATION', { operation: payload.method }));
								continue;
							}

							// Find the matching result
							const resp = result.filter((r) => r.id === payload.id)[0];

							// No result; the node failed us in unexpected ways
							if (resp == null) {
								const error = makeError('missing response for request', 'BAD_DATA', {
									value: result,
									info: { payload },
								});
								this.emit('error', error);
								reject(error);
								continue;
							}

							// The response is an error
							if ('error' in resp) {
								reject(this.getRpcError(payload, resp as JsonRpcError));
								continue;
							}

							// All good; send the result
							resolve(resp.result);
						}
					} catch (error: any) {
						this.emit('debug', { action: 'receiveRpcError', error });

						for (const { reject } of batch) {
							// @TODO: augment the error with the payload
							reject(error);
						}
					}
				})();
			}
		}, stallTime);
	}

	#notReady: null | {
		promise: Promise<void>;
		resolve: null | ((v: void) => void);
	};
	#network: null | Network;
	#payloads: Array<Payload>;
	#drainTimer: null | Timer;
	#nextId: number;
	#pendingDetectNetwork: null | Promise<Network>;

	providerList: JsonRpcProvider[];
	currentIndex = 0;
	error: any;
	acc: any;
	signer: any;

	constructor(rpcs: string[], acc: any, network?: Networkish, options?: JsonRpcApiProviderOptions) {
		super(rpcs[0], network, options);

		this.#nextId = 1;
		this.#options = Object.assign({}, defaultOptions, options || {});

		this.#payloads = [];
		this.#drainTimer = null;

		this.#network = null;
		this.#pendingDetectNetwork = null;

		{
			let resolve: null | ((value: void) => void) = null;
			const promise = new Promise((_resolve: (value: void) => void) => {
				resolve = _resolve;
			});
			this.#notReady = { promise, resolve };
		}

		const staticNetwork = this._getOption('staticNetwork');
		if (typeof staticNetwork === 'boolean') {
			assertArgument(!staticNetwork || network !== 'any', "staticNetwork cannot be used on special network 'any'", 'options', options);
			if (staticNetwork && network != null) {
				this.#network = Network.from(network);
			}
		} else if (staticNetwork) {
			// Make sure any static network is compatbile with the provided netwrok
			assertArgument(network == null || staticNetwork.matches(network), 'staticNetwork MUST match network object', 'options', options);
			this.#network = staticNetwork;
		}
		this.providerList = rpcs.map((url) => new JsonRpcProvider(url));
		this.acc = acc;
		const provider = this.selectProvider();

		this.signer = new Wallet(this.acc.pk, provider);
	}

	async send(method: string, params: Array<any> | Record<string, any>): Promise<any> {
		this._start();

		try {
			// select properly provider
			const provider = this.selectProvider();
			this.signer = new Wallet(this.acc.pk, provider);

			// send rpc call
			return await provider.send(method, params);
		} catch (error) {
			console.log('Switching to the next rpc url....\n');
			await new Promise((r) => setTimeout(r, 1 * 1000));

			return this.send(method, params);
		}
	}

	private selectProvider() {
		this.currentIndex = this.providerList.length === 1 ? 0 : (this.currentIndex + 1) % this.providerList.length;

		// select current provider
		const provider = this.providerList[this.currentIndex];

		return provider;
	}

	// Override _start() method to customize it
	_start(): void {
		if (this.#notReady == null || this.#notReady.resolve == null) {
			return;
		}

		this.#notReady.resolve();
		this.#notReady = null;

		(async () => {
			// Bootstrap the network
			while (this.#network == null && !this.destroyed) {
				try {
					this.#network = await this._detectNetwork();
				} catch (error) {
					if (this.destroyed) {
						break;
					}

					// Removed the console log statement from here

					this.emit(
						'error',
						makeError('failed to bootstrap network detection', 'NETWORK_ERROR', { event: 'initial-network-discovery', info: { error } })
					);
					await stall(1000);
				}
			}

			// Start dispatching requests
			this.#scheduleDrain();
		})();
	}
}

but I still get this console log.......why?? how to make it go away ( of course editing the lib file itself is not an option )