lighthouse 9.5.0-dev.20230118 → 9.5.0-dev.20230119

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

@@ -0,0 +1,214 @@
+export type CrdpEventEmitter = LH.Protocol.StrictEventEmitter<LH.CrdpEvents>;
+/**
+ * @typedef {LH.Protocol.StrictEventEmitter<LH.CrdpEvents>} CrdpEventEmitter
+ */
+/**
+ * @implements {LH.Gatherer.FRTransitionalDriver}
+ */
+export class Driver implements LH.Gatherer.FRTransitionalDriver {
+    /** @deprecated - Not available on Fraggle Rock driver. */
+    static get traceCategories(): string[];
+    /**
+     * @param {import('./connections/connection.js').Connection} connection
+     */
+    constructor(connection: import('./connections/connection.js').Connection);
+    /**
+     * @pri_vate (This should be private, but that makes our tests harder).
+     * An event emitter that enforces mapping between Crdp event names and payload types.
+     */
+    _eventEmitter: CrdpEventEmitter;
+    /**
+     * @private
+     * Used to save network and lifecycle protocol traffic. Just Page and Network are needed.
+     */
+    private _devtoolsLog;
+    /**
+     * @private
+     * @type {Map<string, number>}
+     */
+    private _domainEnabledCounts;
+    /**
+     * @type {number}
+     * @private
+     */
+    private _nextProtocolTimeout;
+    online: boolean;
+    executionContext: ExecutionContext;
+    defaultSession: Driver;
+    fetcher: Fetcher;
+    _connection: import("./connections/connection.js").Connection;
+    /** @private @deprecated Only available for plugin backcompat. */
+    private evaluate;
+    /** @private @deprecated Only available for plugin backcompat. */
+    private evaluateAsync;
+    targetManager: {
+        rootSession: () => Driver;
+        /**
+         * Bind to *any* protocol event.
+         * @param {'protocolevent'} event
+         * @param {(payload: LH.Protocol.RawEventMessage) => void} callback
+         */
+        on: (event: 'protocolevent', callback: (payload: LH.Protocol.RawEventMessage) => void) => void;
+        /**
+         * Unbind to *any* protocol event.
+         * @param {'protocolevent'} event
+         * @param {(payload: LH.Protocol.RawEventMessage) => void} callback
+         */
+        off: (event: 'protocolevent', callback: (payload: LH.Protocol.RawEventMessage) => void) => void;
+    };
+    /**
+     * @return {Promise<LH.Crdp.Browser.GetVersionResponse & {milestone: number}>}
+     */
+    getBrowserVersion(): Promise<LH.Crdp.Browser.GetVersionResponse & {
+        milestone: number;
+    }>;
+    /**
+     * @return {Promise<void>}
+     */
+    connect(): Promise<void>;
+    /**
+     * @return {Promise<void>}
+     */
+    disconnect(): Promise<void>;
+    /** @return {Promise<void>} */
+    dispose(): Promise<void>;
+    /**
+     * Get the browser WebSocket endpoint for devtools protocol clients like Puppeteer.
+     * Only works with WebSocket connection, not extension or devtools.
+     * @return {Promise<string>}
+     */
+    wsEndpoint(): Promise<string>;
+    /**
+     * Bind listeners for protocol events.
+     * @template {keyof LH.CrdpEvents} E
+     * @param {E} eventName
+     * @param {(...args: LH.CrdpEvents[E]) => void} cb
+     */
+    on<E extends keyof LH.CrdpEvents>(eventName: E, cb: (...args: LH.CrdpEvents[E]) => void): void;
+    /**
+     * Bind a one-time listener for protocol events. Listener is removed once it
+     * has been called.
+     * @template {keyof LH.CrdpEvents} E
+     * @param {E} eventName
+     * @param {(...args: LH.CrdpEvents[E]) => void} cb
+     */
+    once<E_1 extends keyof LH.CrdpEvents>(eventName: E_1, cb: (...args: LH.CrdpEvents[E_1]) => void): void;
+    /**
+     * Unbind event listener.
+     * @template {keyof LH.CrdpEvents} E
+     * @param {E} eventName
+     * @param {Function} cb
+     */
+    off<E_2 extends keyof LH.CrdpEvents>(eventName: E_2, cb: Function): void;
+    /** @param {LH.Crdp.Target.TargetInfo} targetInfo */
+    setTargetInfo(targetInfo: LH.Crdp.Target.TargetInfo): void;
+    /**
+     * Debounce enabling or disabling domains to prevent driver users from
+     * stomping on each other. Maintains an internal count of the times a domain
+     * has been enabled. Returns false if the command would have no effect (domain
+     * is already enabled or disabled), or if command would interfere with another
+     * user of that domain (e.g. two gatherers have enabled a domain, both need to
+     * disable it for it to be disabled). Returns true otherwise.
+     * @param {string} domain
+     * @param {string|undefined} sessionId
+     * @param {boolean} enable
+     * @return {boolean}
+     * @private
+     */
+    private _shouldToggleDomain;
+    /**
+     * @return {boolean}
+     */
+    hasNextProtocolTimeout(): boolean;
+    /**
+     * @return {number}
+     */
+    getNextProtocolTimeout(): number;
+    /**
+     * timeout is used for the next call to 'sendCommand'.
+     * NOTE: This can eventually be replaced when TypeScript
+     * resolves https://github.com/Microsoft/TypeScript/issues/5453.
+     * @param {number} timeout
+     */
+    setNextProtocolTimeout(timeout: number): void;
+    /**
+     * @param {LH.Protocol.RawEventMessage} event
+     */
+    _handleProtocolEvent(event: LH.Protocol.RawEventMessage): void;
+    /**
+     * @param {Error} error
+     */
+    _handleEventError(error: Error): void;
+    /**
+     * @param {LH.Crdp.Target.AttachedToTargetEvent} event
+     */
+    _handleTargetAttached(event: LH.Crdp.Target.AttachedToTargetEvent): Promise<void>;
+    /**
+     * Call protocol methods, with a timeout.
+     * To configure the timeout for the next call, use 'setNextProtocolTimeout'.
+     * If 'sessionId' is undefined, the message is sent to the main session.
+     * @template {keyof LH.CrdpCommands} C
+     * @param {C} method
+     * @param {string|undefined} sessionId
+     * @param {LH.CrdpCommands[C]['paramsType']} params
+     * @return {Promise<LH.CrdpCommands[C]['returnType']>}
+     */
+    sendCommandToSession<C extends keyof LH.CrdpCommands>(method: C, sessionId: string | undefined, ...params: LH.CrdpCommands[C]["paramsType"]): Promise<LH.CrdpCommands[C]["returnType"]>;
+    /**
+     * Alias for 'sendCommandToSession(method, undefined, ...params)'
+     * @template {keyof LH.CrdpCommands} C
+     * @param {C} method
+     * @param {LH.CrdpCommands[C]['paramsType']} params
+     * @return {Promise<LH.CrdpCommands[C]['returnType']>}
+     */
+    sendCommand<C_1 extends keyof LH.CrdpCommands>(method: C_1, ...params: LH.CrdpCommands[C_1]["paramsType"]): Promise<LH.CrdpCommands[C_1]["returnType"]>;
+    /**
+     * Call protocol methods.
+     * @private
+     * @template {keyof LH.CrdpCommands} C
+     * @param {C} method
+     * @param {string|undefined} sessionId
+     * @param {LH.CrdpCommands[C]['paramsType']} params
+     * @return {Promise<LH.CrdpCommands[C]['returnType']>}
+     */
+    private _innerSendCommand;
+    /**
+     * Returns whether a domain is currently enabled.
+     * @param {string} domain
+     * @return {boolean}
+     */
+    isDomainEnabled(domain: string): boolean;
+    /**
+     * Return the body of the response with the given ID. Rejects if getting the
+     * body times out.
+     * @param {string} requestId
+     * @param {number} [timeout]
+     * @return {Promise<string>}
+     */
+    getRequestContent(requestId: string, timeout?: number | undefined): Promise<string>;
+    /**
+     * @param {{additionalTraceCategories?: string|null}=} settings
+     * @return {Promise<void>}
+     */
+    beginTrace(settings?: {
+        additionalTraceCategories?: string | null;
+    } | undefined): Promise<void>;
+    /**
+     * @return {Promise<LH.Trace>}
+     */
+    endTrace(): Promise<LH.Trace>;
+    /**
+     * Begin recording devtools protocol messages.
+     */
+    beginDevtoolsLog(): void;
+    /**
+     * Stop recording to devtoolsLog and return log contents.
+     * @return {LH.DevtoolsLog}
+     */
+    endDevtoolsLog(): LH.DevtoolsLog;
+    url(): Promise<string>;
+}
+import * as LH from "../../../types/lh.js";
+import { ExecutionContext } from "../../gather/driver/execution-context.js";
+import { Fetcher } from "../../gather/fetcher.js";
+//# sourceMappingURL=driver.d.ts.map

package/core/legacy/gather/driver.js

@@ -8,6 +8,7 @@ import {EventEmitter} from 'events';
 
 import log from 'lighthouse-logger';
 
+import * as LH from '../../../types/lh.js';
 import {Fetcher} from '../../gather/fetcher.js';
 import {ExecutionContext} from '../../gather/driver/execution-context.js';
 import {LighthouseError} from '../../lib/lh-error.js';

package/core/legacy/gather/gather-runner.d.ts

@@ -0,0 +1,166 @@
+export type Driver = import('./driver.js').Driver;
+export type ArbitraryEqualityMap = import('../../lib/arbitrary-equality-map.js').ArbitraryEqualityMap;
+/**
+ * Each entry in each gatherer result array is the output of a gatherer phase:
+ * `beforePass`, `pass`, and `afterPass`. Flattened into an `LH.Artifacts` in
+ * `collectArtifacts`.
+ */
+export type GathererResults = Record<keyof LH.GathererArtifacts, Array<LH.Gatherer.PhaseResult>>;
+export type GathererResultsEntries = Array<[keyof GathererResults, GathererResults[keyof GathererResults]]>;
+/** @typedef {import('./driver.js').Driver} Driver */
+/** @typedef {import('../../lib/arbitrary-equality-map.js').ArbitraryEqualityMap} ArbitraryEqualityMap */
+/**
+ * Each entry in each gatherer result array is the output of a gatherer phase:
+ * `beforePass`, `pass`, and `afterPass`. Flattened into an `LH.Artifacts` in
+ * `collectArtifacts`.
+ * @typedef {Record<keyof LH.GathererArtifacts, Array<LH.Gatherer.PhaseResult>>} GathererResults
+ */
+/** @typedef {Array<[keyof GathererResults, GathererResults[keyof GathererResults]]>} GathererResultsEntries */
+/**
+ * Class that drives browser to load the page and runs gatherer lifecycle hooks.
+ */
+export class GatherRunner {
+    /**
+     * Loads about:blank and waits there briefly. Since a Page.reload command does
+     * not let a service worker take over, we navigate away and then come back to
+     * reload. We do not `waitForLoad` on about:blank since a page load event is
+     * never fired on it.
+     * @param {Driver} driver
+     * @param {string=} url
+     * @return {Promise<void>}
+     */
+    static loadBlank(driver: Driver, url?: string | undefined): Promise<void>;
+    /**
+     * Loads options.url with specified options. If the main document URL
+     * redirects, options.url will be updated accordingly. As such, options.url
+     * will always represent the post-redirected URL. options.requestedUrl is the
+     * pre-redirect starting URL. If the navigation errors with "expected" errors such as
+     * NO_FCP, a `navigationError` is returned.
+     * @param {Driver} driver
+     * @param {LH.Gatherer.PassContext} passContext
+     * @return {Promise<{navigationError?: LH.LighthouseError}>}
+     */
+    static loadPage(driver: Driver, passContext: LH.Gatherer.PassContext): Promise<{
+        navigationError?: LH.LighthouseError;
+    }>;
+    /**
+     * Rejects if any open tabs would share a service worker with the target URL.
+     * This includes the target tab, so navigation to something like about:blank
+     * should be done before calling.
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @param {string} pageUrl
+     * @return {Promise<void>}
+     */
+    static assertNoSameOriginServiceWorkerClients(session: LH.Gatherer.FRProtocolSession, pageUrl: string): Promise<void>;
+    /**
+     * @param {Driver} driver
+     * @param {{requestedUrl: string, settings: LH.Config.Settings}} options
+     * @return {Promise<void>}
+     */
+    static setupDriver(driver: Driver, options: {
+        requestedUrl: string;
+        settings: LH.Config.Settings;
+    }): Promise<void>;
+    /**
+     * Reset browser state where needed and release the connection.
+     * @param {Driver} driver
+     * @param {{requestedUrl: string, settings: LH.Config.Settings}} options
+     * @return {Promise<void>}
+     */
+    static disposeDriver(driver: Driver, options: {
+        requestedUrl: string;
+        settings: LH.Config.Settings;
+    }): Promise<void>;
+    /**
+     * Beging recording devtoolsLog and trace (if requested).
+     * @param {LH.Gatherer.PassContext} passContext
+     * @return {Promise<void>}
+     */
+    static beginRecording(passContext: LH.Gatherer.PassContext): Promise<void>;
+    /**
+     * End recording devtoolsLog and trace (if requested), returning an
+     * `LH.Gatherer.LoadData` with the recorded data.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @return {Promise<LH.Gatherer.LoadData>}
+     */
+    static endRecording(passContext: LH.Gatherer.PassContext): Promise<LH.Gatherer.LoadData>;
+    /**
+     * Run beforePass() on gatherers.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {Partial<GathererResults>} gathererResults
+     * @return {Promise<void>}
+     */
+    static beforePass(passContext: LH.Gatherer.PassContext, gathererResults: Partial<GathererResults>): Promise<void>;
+    /**
+     * Run pass() on gatherers.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {Partial<GathererResults>} gathererResults
+     * @return {Promise<void>}
+     */
+    static pass(passContext: LH.Gatherer.PassContext, gathererResults: Partial<GathererResults>): Promise<void>;
+    /**
+     * Run afterPass() on gatherers.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @param {Partial<GathererResults>} gathererResults
+     * @return {Promise<void>}
+     */
+    static afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData, gathererResults: Partial<GathererResults>): Promise<void>;
+    /**
+     * Takes the results of each gatherer phase for each gatherer and uses the
+     * last produced value (that's not undefined) as the artifact for that
+     * gatherer. If an error was rejected from a gatherer phase,
+     * uses that error object as the artifact instead.
+     * @param {Partial<GathererResults>} gathererResults
+     * @return {Promise<{artifacts: Partial<LH.GathererArtifacts>}>}
+     */
+    static collectArtifacts(gathererResults: Partial<GathererResults>): Promise<{
+        artifacts: Partial<LH.GathererArtifacts>;
+    }>;
+    /**
+     * Return an initialized but mostly empty set of base artifacts, to be
+     * populated as the run continues.
+     * @param {{driver: Driver, requestedUrl: string, settings: LH.Config.Settings}} options
+     * @return {Promise<LH.BaseArtifacts>}
+     */
+    static initializeBaseArtifacts(options: {
+        driver: Driver;
+        requestedUrl: string;
+        settings: LH.Config.Settings;
+    }): Promise<LH.BaseArtifacts>;
+    /**
+     * Populates the important base artifacts from a fully loaded test page.
+     * Currently must be run before `start-url` gatherer so that `WebAppManifest`
+     * will be available to it.
+     * @param {LH.Gatherer.PassContext} passContext
+     */
+    static populateBaseArtifacts(passContext: LH.Gatherer.PassContext): Promise<void>;
+    /**
+     * @param {Array<LH.Config.Pass>} passConfigs
+     * @param {{driver: Driver, requestedUrl: string, settings: LH.Config.Settings, computedCache: Map<string, ArbitraryEqualityMap>}} options
+     * @return {Promise<LH.Artifacts>}
+     */
+    static run(passConfigs: Array<LH.Config.Pass>, options: {
+        driver: Driver;
+        requestedUrl: string;
+        settings: LH.Config.Settings;
+        computedCache: Map<string, ArbitraryEqualityMap>;
+    }): Promise<LH.Artifacts>;
+    /**
+     * Save the devtoolsLog and trace (if applicable) to baseArtifacts.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @param {string} passName
+     */
+    static _addLoadDataToBaseArtifacts(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData, passName: string): void;
+    /**
+     * Starting from about:blank, load the page and run gatherers for this pass.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @return {Promise<{artifacts: Partial<LH.GathererArtifacts>, pageLoadError?: LH.LighthouseError}>}
+     */
+    static runPass(passContext: LH.Gatherer.PassContext): Promise<{
+        artifacts: Partial<LH.GathererArtifacts>;
+        pageLoadError?: import("../../lib/lh-error.js").LighthouseError | undefined;
+    }>;
+}
+//# sourceMappingURL=gather-runner.d.ts.map

package/core/lib/arbitrary-equality-map.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview This class is designed to allow maps with arbitrary equality functions.
+ * It is not meant to be performant and is well-suited to use cases where the number of entries is
+ * likely to be small (like computed artifacts).
+ */
+export class ArbitraryEqualityMap {
+    /**
+     * Determines whether two objects are deeply equal. Defers to lodash isEqual, but is kept here for
+     * easy usage by consumers.
+     * See https://lodash.com/docs/4.17.5#isEqual.
+     * @param {*} objA
+     * @param {*} objB
+     * @return {boolean}
+     */
+    static deepEquals(objA: any, objB: any): boolean;
+    _equalsFn: typeof ArbitraryEqualityMap.deepEquals;
+    /** @type {Array<{key: *, value: *}>} */
+    _entries: {
+        key: any;
+        value: any;
+    }[];
+    /**
+     * @param {function(*,*):boolean} equalsFn
+     */
+    setEqualityFn(equalsFn: (arg0: any, arg1: any) => boolean): void;
+    /**
+     * @param {*} key
+     * @return {boolean}
+     */
+    has(key: any): boolean;
+    /**
+     * @param {*} key
+     * @return {*}
+     */
+    get(key: any): any;
+    /**
+     * @param {*} key
+     * @param {*} value
+     */
+    set(key: any, value: any): void;
+    /**
+     * @param {*} key
+     * @return {number}
+     */
+    _findIndexOf(key: any): number;
+}
+//# sourceMappingURL=arbitrary-equality-map.d.ts.map

package/core/lib/asset-saver.d.ts

@@ -0,0 +1,101 @@
+export type PreparedAssets = {
+    passName: string;
+    traceData: LH.Trace;
+    devtoolsLog: import("../index.js").DevtoolsLog;
+};
+/**
+ * Save artifacts object mostly to single file located at basePath/artifacts.json.
+ * Also save the traces & devtoolsLogs to their own files
+ * @param {LH.Artifacts} artifacts
+ * @param {string} basePath
+ * @return {Promise<void>}
+ */
+export function saveArtifacts(artifacts: LH.Artifacts, basePath: string): Promise<void>;
+/**
+ * Saves flow artifacts with the following file structure:
+ *   flow/                             --  Directory specified by `basePath`.
+ *     options.json                    --  Flow options (e.g. flow name, flags).
+ *     step0/                          --  Directory containing artifacts for the first step.
+ *       options.json                  --  First step's options (e.g. step flags).
+ *       artifacts.json                --  First step's artifacts except the DevTools log and trace.
+ *       defaultPass.devtoolslog.json  --  First step's DevTools log.
+ *       defaultPass.trace.json        --  First step's trace.
+ *     step1/                          --  Directory containing artifacts for the second step.
+ *
+ * @param {LH.UserFlow.FlowArtifacts} flowArtifacts
+ * @param {string} basePath
+ * @return {Promise<void>}
+ */
+export function saveFlowArtifacts(flowArtifacts: LH.UserFlow.FlowArtifacts, basePath: string): Promise<void>;
+/**
+ * Save LHR to file located at basePath/lhr.report.json.
+ * @param {LH.Result} lhr
+ * @param {string} basePath
+ */
+export function saveLhr(lhr: LH.Result, basePath: string): void;
+/**
+ * @typedef {object} PreparedAssets
+ * @property {string} passName
+ * @property {LH.Trace} traceData
+ * @property {LH.DevtoolsLog} devtoolsLog
+ */
+/**
+ * Load artifacts object from files located within basePath
+ * Also save the traces to their own files
+ * @param {string} basePath
+ * @return {LH.Artifacts}
+ */
+export function loadArtifacts(basePath: string): LH.Artifacts;
+/**
+ * @param {string} basePath
+ * @return {LH.UserFlow.FlowArtifacts}
+ */
+export function loadFlowArtifacts(basePath: string): LH.UserFlow.FlowArtifacts;
+/**
+ * Writes trace(s) and associated asset(s) to disk.
+ * @param {LH.Artifacts} artifacts
+ * @param {LH.Result['audits']} audits
+ * @param {string} pathWithBasename
+ * @return {Promise<void>}
+ */
+export function saveAssets(artifacts: LH.Artifacts, audits: LH.Result['audits'], pathWithBasename: string): Promise<void>;
+/**
+ * Filter traces and extract screenshots to prepare for saving.
+ * @param {LH.Artifacts} artifacts
+ * @param {LH.Result['audits']} [audits]
+ * @return {Promise<Array<PreparedAssets>>}
+ */
+export function prepareAssets(artifacts: LH.Artifacts, audits?: Record<string, import("../../types/lhr/audit-result.js").Result> | undefined): Promise<Array<PreparedAssets>>;
+/**
+ * Save a trace as JSON by streaming to disk at traceFilename.
+ * @param {LH.Trace} traceData
+ * @param {string} traceFilename
+ * @return {Promise<void>}
+ */
+export function saveTrace(traceData: LH.Trace, traceFilename: string): Promise<void>;
+/**
+ * Save a devtoolsLog as JSON by streaming to disk at devtoolLogFilename.
+ * @param {LH.DevtoolsLog} devtoolsLog
+ * @param {string} devtoolLogFilename
+ * @return {Promise<void>}
+ */
+export function saveDevtoolsLog(devtoolsLog: import("../index.js").DevtoolsLog, devtoolLogFilename: string): Promise<void>;
+/**
+ * @param {LH.DevtoolsLog} devtoolsLog
+ * @param {string} outputPath
+ * @return {Promise<void>}
+ */
+export function saveLanternNetworkData(devtoolsLog: import("../index.js").DevtoolsLog, outputPath: string): Promise<void>;
+/**
+ * A replacer function for JSON.stingify of the artifacts. Used to serialize objects that
+ * JSON won't normally handle.
+ * @param {string} key
+ * @param {any} value
+ */
+export function stringifyReplacer(key: string, value: any): any;
+/**
+ * Normalize timing data so it doesn't change every update.
+ * @param {LH.Result.MeasureEntry[]} timings
+ */
+export function normalizeTimingEntries(timings: LH.Result.MeasureEntry[]): void;
+//# sourceMappingURL=asset-saver.d.ts.map

package/core/lib/axe.d.ts

@@ -0,0 +1,2 @@
+export const axeSource: string;
+//# sourceMappingURL=axe.d.ts.map

package/core/lib/bf-cache-strings.d.ts

@@ -0,0 +1,121 @@
+/** @type {Record<string, {name: LH.IcuMessage} | undefined>} */
+export const NotRestoredReasonDescription: Record<string, {
+    name: LH.IcuMessage;
+} | undefined>;
+export namespace UIStrings {
+    const notMainFrame: string;
+    const backForwardCacheDisabled: string;
+    const relatedActiveContentsExist: string;
+    const HTTPStatusNotOK: string;
+    const schemeNotHTTPOrHTTPS: string;
+    const loading: string;
+    const wasGrantedMediaAccess: string;
+    const HTTPMethodNotGET: string;
+    const subframeIsNavigating: string;
+    const timeout: string;
+    const cacheLimit: string;
+    const JavaScriptExecution: string;
+    const rendererProcessKilled: string;
+    const rendererProcessCrashed: string;
+    const grantedMediaStreamAccess: string;
+    const cacheFlushed: string;
+    const serviceWorkerVersionActivation: string;
+    const sessionRestored: string;
+    const serviceWorkerPostMessage: string;
+    const enteredBackForwardCacheBeforeServiceWorkerHostAdded: string;
+    const serviceWorkerClaim: string;
+    const haveInnerContents: string;
+    const timeoutPuttingInCache: string;
+    const backForwardCacheDisabledByLowMemory: string;
+    const backForwardCacheDisabledByCommandLine: string;
+    const networkRequestDatapipeDrainedAsBytesConsumer: string;
+    const networkRequestRedirected: string;
+    const networkRequestTimeout: string;
+    const networkExceedsBufferLimit: string;
+    const navigationCancelledWhileRestoring: string;
+    const backForwardCacheDisabledForPrerender: string;
+    const userAgentOverrideDiffers: string;
+    const foregroundCacheLimit: string;
+    const backForwardCacheDisabledForDelegate: string;
+    const unloadHandlerExistsInMainFrame: string;
+    const unloadHandlerExistsInSubFrame: string;
+    const serviceWorkerUnregistration: string;
+    const noResponseHead: string;
+    const cacheControlNoStore: string;
+    const ineligibleAPI: string;
+    const internalError: string;
+    const webSocket: string;
+    const webTransport: string;
+    const webRTC: string;
+    const mainResourceHasCacheControlNoStore: string;
+    const mainResourceHasCacheControlNoCache: string;
+    const subresourceHasCacheControlNoStore: string;
+    const subresourceHasCacheControlNoCache: string;
+    const containsPlugins: string;
+    const documentLoaded: string;
+    const dedicatedWorkerOrWorklet: string;
+    const outstandingNetworkRequestOthers: string;
+    const outstandingIndexedDBTransaction: string;
+    const requestedNotificationsPermission: string;
+    const requestedMIDIPermission: string;
+    const requestedAudioCapturePermission: string;
+    const requestedVideoCapturePermission: string;
+    const requestedBackForwardCacheBlockedSensors: string;
+    const requestedBackgroundWorkPermission: string;
+    const broadcastChannel: string;
+    const indexedDBConnection: string;
+    const webXR: string;
+    const sharedWorker: string;
+    const webLocks: string;
+    const webHID: string;
+    const webShare: string;
+    const requestedStorageAccessGrant: string;
+    const webNfc: string;
+    const outstandingNetworkRequestFetch: string;
+    const outstandingNetworkRequestXHR: string;
+    const appBanner: string;
+    const printing: string;
+    const webDatabase: string;
+    const pictureInPicture: string;
+    const portal: string;
+    const speechRecognizer: string;
+    const idleManager: string;
+    const paymentManager: string;
+    const speechSynthesis: string;
+    const keyboardLock: string;
+    const webOTPService: string;
+    const outstandingNetworkRequestDirectSocket: string;
+    const injectedJavascript: string;
+    const injectedStyleSheet: string;
+    const contentSecurityHandler: string;
+    const contentWebAuthenticationAPI: string;
+    const contentFileChooser: string;
+    const contentSerial: string;
+    const contentFileSystemAccess: string;
+    const contentMediaDevicesDispatcherHost: string;
+    const contentWebBluetooth: string;
+    const contentWebUSB: string;
+    const contentMediaSession: string;
+    const contentMediaSessionService: string;
+    const contentMediaPlay: string;
+    const contentScreenReader: string;
+    const embedderPopupBlockerTabHelper: string;
+    const embedderSafeBrowsingTriggeredPopupBlocker: string;
+    const embedderSafeBrowsingThreatDetails: string;
+    const embedderAppBannerManager: string;
+    const embedderDomDistillerViewerSource: string;
+    const embedderDomDistillerSelfDeletingRequestDelegate: string;
+    const embedderOomInterventionTabHelper: string;
+    const embedderOfflinePage: string;
+    const embedderChromePasswordManagerClientBindCredentialManager: string;
+    const embedderPermissionRequestManager: string;
+    const embedderModalDialog: string;
+    const embedderExtensions: string;
+    const embedderExtensionMessaging: string;
+    const embedderExtensionMessagingForOpenPort: string;
+    const embedderExtensionSentMessageToCachedFrame: string;
+    const errorDocument: string;
+    const fencedFramesEmbedder: string;
+    const keepaliveRequest: string;
+}
+//# sourceMappingURL=bf-cache-strings.d.ts.map

package/core/lib/cdt/Common.d.ts

@@ -0,0 +1,3 @@
+export { ParsedURL };
+import ParsedURL = require("./generated/ParsedURL.js");
+//# sourceMappingURL=Common.d.ts.map