lighthouse 9.6.7 → 10.0.0

package/core/gather/driver/execution-context.js

@@ -0,0 +1,262 @@
+/**
+ * @license Copyright 2020 The Lighthouse Authors. All Rights Reserved.
+ * 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.
+ */
+
+/* global window */
+
+import * as LH from '../../../types/lh.js';
+import {pageFunctions} from '../../lib/page-functions.js';
+
+class ExecutionContext {
+  /** @param {LH.Gatherer.FRProtocolSession} session */
+  constructor(session) {
+    this._session = session;
+
+    /** @type {number|undefined} */
+    this._executionContextId = undefined;
+    /**
+     * Marks how many execution context ids have been created, for purposes of having a unique
+     * value (that doesn't expose the actual execution context id) to
+     * use for __lighthouseExecutionContextUniqueIdentifier.
+     * @type {number}
+     */
+    this._executionContextIdentifiersCreated = 0;
+
+    // We use isolated execution contexts for `evaluateAsync` that can be destroyed through navigation
+    // and other page actions. Cleanup our relevant bookkeeping as we see those events.
+    // Domains are enabled when a dedicated execution context is requested.
+    session.on('Page.frameNavigated', () => this.clearContextId());
+    session.on('Runtime.executionContextDestroyed', event => {
+      if (event.executionContextId === this._executionContextId) {
+        this.clearContextId();
+      }
+    });
+  }
+
+  /**
+   * Returns the isolated context ID currently in use.
+   */
+  getContextId() {
+    return this._executionContextId;
+  }
+
+  /**
+   * Clears the remembered context ID. Use this method when we have knowledge that the runtime context
+   * we were using has been destroyed by the browser and is no longer available.
+   */
+  clearContextId() {
+    this._executionContextId = undefined;
+  }
+
+  /**
+   * Returns the cached isolated execution context ID or creates a new execution context for the main
+   * frame. The cached execution context is cleared on every gotoURL invocation, so a new one will
+   * always be created on the first call on a new page.
+   * @return {Promise<number>}
+   */
+  async _getOrCreateIsolatedContextId() {
+    if (typeof this._executionContextId === 'number') return this._executionContextId;
+
+    await this._session.sendCommand('Page.enable');
+    await this._session.sendCommand('Runtime.enable');
+
+    const frameTreeResponse = await this._session.sendCommand('Page.getFrameTree');
+    const mainFrameId = frameTreeResponse.frameTree.frame.id;
+
+    const isolatedWorldResponse = await this._session.sendCommand('Page.createIsolatedWorld', {
+      frameId: mainFrameId,
+      worldName: 'lighthouse_isolated_context',
+    });
+
+    this._executionContextId = isolatedWorldResponse.executionContextId;
+    this._executionContextIdentifiersCreated++;
+    return isolatedWorldResponse.executionContextId;
+  }
+
+  /**
+   * Evaluate an expression in the given execution context; an undefined contextId implies the main
+   * page without isolation.
+   * @param {string} expression
+   * @param {number|undefined} contextId
+   * @return {Promise<*>}
+   */
+  async _evaluateInContext(expression, contextId) {
+    // Use a higher than default timeout if the user hasn't specified a specific timeout.
+    // Otherwise, use whatever was requested.
+    const timeout = this._session.hasNextProtocolTimeout() ?
+      this._session.getNextProtocolTimeout() :
+      60000;
+
+    // `__lighthouseExecutionContextUniqueIdentifier` is only used by the FullPageScreenshot gatherer.
+    // See `getNodeDetails` in page-functions.
+    const uniqueExecutionContextIdentifier = contextId === undefined ?
+      undefined :
+      this._executionContextIdentifiersCreated;
+
+    const evaluationParams = {
+      // We need to explicitly wrap the raw expression for several purposes:
+      // 1. Ensure that the expression will be a native Promise and not a polyfill/non-Promise.
+      // 2. Ensure that errors in the expression are captured by the Promise.
+      // 3. Ensure that errors captured in the Promise are converted into plain-old JS Objects
+      //    so that they can be serialized properly b/c JSON.stringify(new Error('foo')) === '{}'
+      //
+      // `__lighthouseExecutionContextUniqueIdentifier` is only used by the FullPageScreenshot gatherer.
+      // See `getNodeDetails` in page-functions.
+      expression: `(function wrapInNativePromise() {
+        ${ExecutionContext._cachedNativesPreamble};
+        globalThis.__lighthouseExecutionContextUniqueIdentifier =
+          ${uniqueExecutionContextIdentifier};
+        return new Promise(function (resolve) {
+          return Promise.resolve()
+            .then(_ => ${expression})
+            .catch(${pageFunctions.wrapRuntimeEvalErrorInBrowser})
+            .then(resolve);
+        });
+      }())
+      //# sourceURL=_lighthouse-eval.js`,
+      includeCommandLineAPI: true,
+      awaitPromise: true,
+      returnByValue: true,
+      timeout,
+      contextId,
+    };
+
+    this._session.setNextProtocolTimeout(timeout);
+    const response = await this._session.sendCommand('Runtime.evaluate', evaluationParams);
+    if (response.exceptionDetails) {
+      // An error occurred before we could even create a Promise, should be *very* rare.
+      // Also occurs when the expression is not valid JavaScript.
+      const errorMessage = response.exceptionDetails.exception ?
+        response.exceptionDetails.exception.description :
+        response.exceptionDetails.text;
+      return Promise.reject(new Error(`Evaluation exception: ${errorMessage}`));
+    }
+    // Protocol should always return a 'result' object, but it is sometimes undefined.  See #6026.
+    if (response.result === undefined) {
+      return Promise.reject(
+        new Error('Runtime.evaluate response did not contain a "result" object'));
+    }
+    const value = response.result.value;
+    if (value?.__failedInBrowser) {
+      return Promise.reject(Object.assign(new Error(), value));
+    } else {
+      return value;
+    }
+  }
+
+  /**
+   * Note: Prefer `evaluate` instead.
+   * Evaluate an expression in the context of the current page. If useIsolation is true, the expression
+   * will be evaluated in a content script that has access to the page's DOM but whose JavaScript state
+   * is completely separate.
+   * Returns a promise that resolves on the expression's value.
+   * @param {string} expression
+   * @param {{useIsolation?: boolean}=} options
+   * @return {Promise<*>}
+   */
+  async evaluateAsync(expression, options = {}) {
+    const contextId = options.useIsolation ? await this._getOrCreateIsolatedContextId() : undefined;
+
+    try {
+      // `await` is not redundant here because we want to `catch` the async errors
+      return await this._evaluateInContext(expression, contextId);
+    } catch (err) {
+      // If we were using isolation and the context disappeared on us, retry one more time.
+      if (contextId && err.message.includes('Cannot find context')) {
+        this.clearContextId();
+        const freshContextId = await this._getOrCreateIsolatedContextId();
+        return this._evaluateInContext(expression, freshContextId);
+      }
+
+      throw err;
+    }
+  }
+
+  /**
+   * Evaluate a function in the context of the current page.
+   * If `useIsolation` is true, the function will be evaluated in a content script that has
+   * access to the page's DOM but whose JavaScript state is completely separate.
+   * Returns a promise that resolves on a value of `mainFn`'s return type.
+   * @template {unknown[]} T, R
+   * @param {((...args: T) => R)} mainFn The main function to call.
+   * @param {{args: T, useIsolation?: boolean, deps?: Array<Function|string>}} options `args` should
+   *   match the args of `mainFn`, and can be any serializable value. `deps` are functions that must be
+   *   defined for `mainFn` to work.
+   * @return {Promise<Awaited<R>>}
+   */
+  evaluate(mainFn, options) {
+    const argsSerialized = ExecutionContext.serializeArguments(options.args);
+    const depsSerialized = options.deps ? options.deps.join('\n') : '';
+    const expression = `(() => {
+      ${depsSerialized}
+      return (${mainFn})(${argsSerialized});
+    })()`;
+    return this.evaluateAsync(expression, options);
+  }
+
+  /**
+   * Evaluate a function on every new frame from now on.
+   * @template {unknown[]} T
+   * @param {((...args: T) => void)} mainFn The main function to call.
+   * @param {{args: T, deps?: Array<Function|string>}} options `args` should
+   *   match the args of `mainFn`, and can be any serializable value. `deps` are functions that must be
+   *   defined for `mainFn` to work.
+   * @return {Promise<void>}
+   */
+  async evaluateOnNewDocument(mainFn, options) {
+    const argsSerialized = ExecutionContext.serializeArguments(options.args);
+    const depsSerialized = options.deps ? options.deps.join('\n') : '';
+
+    const expression = `(() => {
+      ${ExecutionContext._cachedNativesPreamble};
+      ${depsSerialized};
+      (${mainFn})(${argsSerialized});
+    })()
+    //# sourceURL=_lighthouse-eval.js`;
+
+    await this._session.sendCommand('Page.addScriptToEvaluateOnNewDocument', {source: expression});
+  }
+
+  /**
+   * Cache native functions/objects inside window so we are sure polyfills do not overwrite the
+   * native implementations when the page loads.
+   * @return {Promise<void>}
+   */
+  async cacheNativesOnNewDocument() {
+    await this.evaluateOnNewDocument(() => {
+      /* c8 ignore start */
+      window.__nativePromise = window.Promise;
+      window.__nativeURL = window.URL;
+      window.__nativePerformance = window.performance;
+      window.__nativeFetch = window.fetch;
+      window.__ElementMatches = window.Element.prototype.matches;
+      window.__HTMLElementBoundingClientRect = window.HTMLElement.prototype.getBoundingClientRect;
+      /* c8 ignore stop */
+    }, {args: []});
+  }
+
+  /**
+   * Prefix every script evaluation with a shadowing of common globals that tend to be ponyfilled
+   * incorrectly by many sites. This allows functions to still refer to `Promise` instead of
+   * Lighthouse-specific backups like `__nativePromise` (injected by `cacheNativesOnNewDocument` above).
+   */
+  static _cachedNativesPreamble = [
+    'const Promise = globalThis.__nativePromise || globalThis.Promise',
+    'const URL = globalThis.__nativeURL || globalThis.URL',
+    'const performance = globalThis.__nativePerformance || globalThis.performance',
+    'const fetch = globalThis.__nativeFetch || globalThis.fetch',
+  ].join(';\n');
+
+  /**
+   * Serializes an array of arguments for use in an `eval` string across the protocol.
+   * @param {unknown[]} args
+   * @return {string}
+   */
+  static serializeArguments(args) {
+    return args.map(arg => arg === undefined ? 'undefined' : JSON.stringify(arg)).join(',');
+  }
+}
+
+export {ExecutionContext};

package/core/gather/driver/navigation.d.ts

@@ -0,0 +1,33 @@
+export type NavigationOptions = {
+    waitUntil: Array<'fcp' | 'load' | 'navigated'>;
+} & LH.Config.SharedPassNavigationJson & Partial<Pick<LH.Config.Settings, 'maxWaitForFcp' | 'maxWaitForLoad' | 'debugNavigation'>>;
+/**
+ * Navigates to the given URL, assuming that the page is not already on this URL.
+ * Resolves on the url of the loaded page, taking into account any redirects.
+ * Typical use of this method involves navigating to a neutral page such as `about:blank` in between
+ * navigations.
+ *
+ * @param {LH.Gatherer.FRTransitionalDriver} driver
+ * @param {LH.NavigationRequestor} requestor
+ * @param {NavigationOptions} options
+ * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, warnings: Array<LH.IcuMessage>}>}
+ */
+export function gotoURL(driver: LH.Gatherer.FRTransitionalDriver, requestor: LH.NavigationRequestor, options: NavigationOptions): Promise<{
+    requestedUrl: string;
+    mainDocumentUrl: string;
+    warnings: Array<LH.IcuMessage>;
+}>;
+/**
+ * @param {{timedOut: boolean, requestedUrl: string, mainDocumentUrl: string; }} navigation
+ * @return {Array<LH.IcuMessage>}
+ */
+export function getNavigationWarnings(navigation: {
+    timedOut: boolean;
+    requestedUrl: string;
+    mainDocumentUrl: string;
+}): Array<LH.IcuMessage>;
+export namespace UIStrings {
+    const warningRedirected: string;
+    const warningTimeout: string;
+}
+//# sourceMappingURL=navigation.d.ts.map

package/core/gather/driver/navigation.js

@@ -0,0 +1,182 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * 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.
+ */
+
+import log from 'lighthouse-logger';
+
+import {NetworkMonitor} from './network-monitor.js';
+import {waitForFullyLoaded, waitForFrameNavigated, waitForUserToContinue} from './wait-for-condition.js'; // eslint-disable-line max-len
+import * as constants from '../../config/constants.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+import UrlUtils from '../../lib/url-utils.js';
+
+const UIStrings = {
+  /**
+   * @description Warning that the web page redirected during testing and that may have affected the load.
+   * @example {https://example.com/requested/page} requested
+   * @example {https://example.com/final/resolved/page} final
+   */
+  warningRedirected: 'The page may not be loading as expected because your test URL ' +
+  `({requested}) was redirected to {final}. ` +
+  'Try testing the second URL directly.',
+  /**
+   * @description Warning that Lighthouse timed out while waiting for the page to load.
+   */
+  warningTimeout: 'The page loaded too slowly to finish within the time limit. ' +
+  'Results may be incomplete.',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+
+// Controls how long to wait after FCP before continuing
+const DEFAULT_PAUSE_AFTER_FCP = 0;
+// Controls how long to wait after onLoad before continuing
+const DEFAULT_PAUSE_AFTER_LOAD = 0;
+// Controls how long to wait between network requests before determining the network is quiet
+const DEFAULT_NETWORK_QUIET_THRESHOLD = 5000;
+// Controls how long to wait between longtasks before determining the CPU is idle, off by default
+const DEFAULT_CPU_QUIET_THRESHOLD = 0;
+
+/** @typedef {{waitUntil: Array<'fcp'|'load'|'navigated'>} & LH.Config.SharedPassNavigationJson & Partial<Pick<LH.Config.Settings, 'maxWaitForFcp'|'maxWaitForLoad'|'debugNavigation'>>} NavigationOptions */
+
+/** @param {NavigationOptions} options */
+function resolveWaitForFullyLoadedOptions(options) {
+  /* eslint-disable max-len */
+  let {pauseAfterFcpMs, pauseAfterLoadMs, networkQuietThresholdMs, cpuQuietThresholdMs} = options;
+  let maxWaitMs = options.maxWaitForLoad;
+  let maxFCPMs = options.maxWaitForFcp;
+
+  if (typeof pauseAfterFcpMs !== 'number') pauseAfterFcpMs = DEFAULT_PAUSE_AFTER_FCP;
+  if (typeof pauseAfterLoadMs !== 'number') pauseAfterLoadMs = DEFAULT_PAUSE_AFTER_LOAD;
+  if (typeof networkQuietThresholdMs !== 'number') {
+    networkQuietThresholdMs = DEFAULT_NETWORK_QUIET_THRESHOLD;
+  }
+  if (typeof cpuQuietThresholdMs !== 'number') cpuQuietThresholdMs = DEFAULT_CPU_QUIET_THRESHOLD;
+  if (typeof maxWaitMs !== 'number') maxWaitMs = constants.defaultSettings.maxWaitForLoad;
+  if (typeof maxFCPMs !== 'number') maxFCPMs = constants.defaultSettings.maxWaitForFcp;
+  /* eslint-enable max-len */
+
+  if (!options.waitUntil.includes('fcp')) maxFCPMs = undefined;
+
+  return {
+    pauseAfterFcpMs,
+    pauseAfterLoadMs,
+    networkQuietThresholdMs,
+    cpuQuietThresholdMs,
+    maxWaitForLoadedMs: maxWaitMs,
+    maxWaitForFcpMs: maxFCPMs,
+  };
+}
+
+/**
+ * Navigates to the given URL, assuming that the page is not already on this URL.
+ * Resolves on the url of the loaded page, taking into account any redirects.
+ * Typical use of this method involves navigating to a neutral page such as `about:blank` in between
+ * navigations.
+ *
+ * @param {LH.Gatherer.FRTransitionalDriver} driver
+ * @param {LH.NavigationRequestor} requestor
+ * @param {NavigationOptions} options
+ * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, warnings: Array<LH.IcuMessage>}>}
+ */
+async function gotoURL(driver, requestor, options) {
+  const status = typeof requestor === 'string' ?
+    {msg: `Navigating to ${requestor}`, id: 'lh:driver:navigate'} :
+    {msg: 'Navigating using a user defined function', id: 'lh:driver:navigate'};
+  log.time(status);
+
+  const session = driver.defaultSession;
+  const networkMonitor = new NetworkMonitor(driver.targetManager);
+
+  // Enable the events and network monitor needed to track navigation progress.
+  await networkMonitor.enable();
+  await session.sendCommand('Page.enable');
+  await session.sendCommand('Page.setLifecycleEventsEnabled', {enabled: true});
+
+  let waitForNavigationTriggered;
+  if (typeof requestor === 'string') {
+    // No timeout needed for Page.navigate. See https://github.com/GoogleChrome/lighthouse/pull/6413
+    session.setNextProtocolTimeout(Infinity);
+    waitForNavigationTriggered = session.sendCommand('Page.navigate', {url: requestor});
+  } else {
+    waitForNavigationTriggered = requestor();
+  }
+
+  const waitForNavigated = options.waitUntil.includes('navigated');
+  const waitForLoad = options.waitUntil.includes('load');
+  const waitForFcp = options.waitUntil.includes('fcp');
+
+  /** @type {Array<Promise<{timedOut: boolean}>>} */
+  const waitConditionPromises = [];
+
+  if (waitForNavigated) {
+    const navigatedPromise = waitForFrameNavigated(session).promise;
+    waitConditionPromises.push(navigatedPromise.then(() => ({timedOut: false})));
+  }
+
+  if (waitForLoad) {
+    const waitOptions = resolveWaitForFullyLoadedOptions(options);
+    waitConditionPromises.push(waitForFullyLoaded(session, networkMonitor, waitOptions));
+  } else if (waitForFcp) {
+    throw new Error('Cannot wait for FCP without waiting for page load');
+  }
+
+  const waitConditions = await Promise.all(waitConditionPromises);
+  const timedOut = waitConditions.some(condition => condition.timedOut);
+  const navigationUrls = await networkMonitor.getNavigationUrls();
+
+  let requestedUrl = navigationUrls.requestedUrl;
+  if (typeof requestor === 'string') {
+    if (requestedUrl && !UrlUtils.equalWithExcludedFragments(requestor, requestedUrl)) {
+      log.error(
+        'Navigation',
+        `Provided URL (${requestor}) did not match initial navigation URL (${requestedUrl})`
+      );
+    }
+    requestedUrl = requestor;
+  }
+  if (!requestedUrl) throw Error('No navigations detected when running user defined requestor.');
+
+  const mainDocumentUrl = navigationUrls.mainDocumentUrl || requestedUrl;
+
+  // Bring `Page.navigate` errors back into the promise chain. See https://github.com/GoogleChrome/lighthouse/pull/6739.
+  await waitForNavigationTriggered;
+  await networkMonitor.disable();
+
+  if (options.debugNavigation) {
+    await waitForUserToContinue(driver);
+  }
+
+  log.timeEnd(status);
+  return {
+    requestedUrl,
+    mainDocumentUrl,
+    warnings: getNavigationWarnings({timedOut, mainDocumentUrl, requestedUrl}),
+  };
+}
+
+/**
+ * @param {{timedOut: boolean, requestedUrl: string, mainDocumentUrl: string; }} navigation
+ * @return {Array<LH.IcuMessage>}
+ */
+function getNavigationWarnings(navigation) {
+  const {requestedUrl, mainDocumentUrl} = navigation;
+  /** @type {Array<LH.IcuMessage>} */
+  const warnings = [];
+
+  if (navigation.timedOut) warnings.push(str_(UIStrings.warningTimeout));
+
+  if (!UrlUtils.equalWithExcludedFragments(requestedUrl, mainDocumentUrl)) {
+    warnings.push(str_(UIStrings.warningRedirected, {
+      requested: requestedUrl,
+      final: mainDocumentUrl,
+    }));
+  }
+
+  return warnings;
+}
+
+export {gotoURL, getNavigationWarnings, UIStrings};

package/core/gather/driver/network-monitor.d.ts

@@ -0,0 +1,82 @@
+export type NetworkRecorderEventMap = import('../../lib/network-recorder.js').NetworkRecorderEventMap;
+export type NetworkMonitorEvent_ = 'network-2-idle' | 'network-critical-idle' | 'networkidle' | 'networkbusy' | 'network-critical-busy' | 'network-2-busy';
+export type NetworkMonitorEventMap = Record<NetworkMonitorEvent_, []> & NetworkRecorderEventMap;
+export type NetworkMonitorEvent = keyof NetworkMonitorEventMap;
+export type NetworkMonitorEmitter = LH.Protocol.StrictEventEmitterClass<NetworkMonitorEventMap>;
+declare const NetworkMonitor_base: NetworkMonitorEmitter;
+export class NetworkMonitor extends NetworkMonitor_base {
+    /**
+     * Finds all time periods where the number of inflight requests is less than or equal to the
+     * number of allowed concurrent requests.
+     * @param {Array<LH.Artifacts.NetworkRequest>} requests
+     * @param {number} allowedConcurrentRequests
+     * @param {number=} endTime
+     * @return {Array<{start: number, end: number}>}
+     */
+    static findNetworkQuietPeriods(requests: Array<LH.Artifacts.NetworkRequest>, allowedConcurrentRequests: number, endTime?: number | undefined): Array<{
+        start: number;
+        end: number;
+    }>;
+    /** @param {LH.Gatherer.FRTransitionalDriver['targetManager']} targetManager */
+    constructor(targetManager: LH.Gatherer.FRTransitionalDriver['targetManager']);
+    /** @type {NetworkRecorder|undefined} */
+    _networkRecorder: NetworkRecorder | undefined;
+    /** @type {Array<LH.Crdp.Page.Frame>} */
+    _frameNavigations: Array<LH.Crdp.Page.Frame>;
+    /** @type {LH.Gatherer.FRTransitionalDriver['targetManager']} */
+    _targetManager: LH.Gatherer.FRTransitionalDriver['targetManager'];
+    /** @type {LH.Gatherer.FRProtocolSession} */
+    _session: LH.Gatherer.FRProtocolSession;
+    /** @param {LH.Crdp.Page.FrameNavigatedEvent} event */
+    _onFrameNavigated: (event: LH.Crdp.Page.FrameNavigatedEvent) => number;
+    /** @param {LH.Protocol.RawEventMessage} event */
+    _onProtocolMessage: (event: LH.Protocol.RawEventMessage) => void;
+    /**
+     * @return {Promise<void>}
+     */
+    enable(): Promise<void>;
+    /**
+     * @return {Promise<void>}
+     */
+    disable(): Promise<void>;
+    /** @return {Promise<{requestedUrl?: string, mainDocumentUrl?: string}>} */
+    getNavigationUrls(): Promise<{
+        requestedUrl?: string | undefined;
+        mainDocumentUrl?: string | undefined;
+    }>;
+    /**
+     * @return {Array<NetworkRequest>}
+     */
+    getInflightRequests(): Array<NetworkRequest>;
+    /**
+     * Returns whether the network is completely idle (i.e. there are 0 inflight network requests).
+     */
+    isIdle(): boolean;
+    /**
+     * Returns whether any important resources for the page are in progress.
+     * Above-the-fold images and XHRs should be included.
+     * Tracking pixels, low priority images, and cross frame requests should be excluded.
+     * @return {boolean}
+     */
+    isCriticalIdle(): boolean;
+    /**
+     * Returns whether the network is semi-idle (i.e. there are 2 or fewer inflight network requests).
+     */
+    is2Idle(): boolean;
+    /**
+     * Returns whether the number of currently inflight requests is less than or
+     * equal to the number of allowed concurrent requests.
+     * @param {number} allowedRequests
+     * @param {(request: NetworkRequest) => boolean} [requestFilter]
+     * @return {boolean}
+     */
+    _isActiveIdlePeriod(allowedRequests: number, requestFilter?: ((request: NetworkRequest) => boolean) | undefined): boolean;
+    /**
+     * Emits the appropriate network status event.
+     */
+    _emitNetworkStatus(): void;
+}
+import { NetworkRecorder } from "../../lib/network-recorder.js";
+import { NetworkRequest } from "../../lib/network-request.js";
+export {};
+//# sourceMappingURL=network-monitor.d.ts.map