@mcp-b/chrome-devtools-mcp 1.1.1 → 1.1.3

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/ServerSentEvents.js

@@ -1,67 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-import * as TextUtils from '../../models/text_utils/text_utils.js';
-import { Events } from './NetworkRequest.js';
-import { ServerSentEventsParser } from './ServerSentEventsProtocol.js';
-/**
- * Server sent events only arrive via CDP (Explicit Network.eventSourceMessageReceived) when
- * the page uses "EventSource" in the code.
- *
- * If the page manually uses 'fetch' or XHR we have to do the protocol parsing
- * ourselves.
- *
- * `ServerSentEvents` is a small helper class that manages this distinction for a specific
- * request, stores the event data and sends out "EventSourceMessageAdded" events for a request.
- */
-export class ServerSentEvents {
-    #request;
-    #parser;
-    // In the case where we parse the events ourselves we use the time of the last 'dataReceived'
-    // event for all the events that come out of the corresponding chunk of data.
-    #lastDataReceivedTime = 0;
-    #eventSourceMessages = [];
-    constructor(request, parseFromStreamedData) {
-        this.#request = request;
-        // Only setup parsing if we don't get the events over CDP directly.
-        if (parseFromStreamedData) {
-            this.#lastDataReceivedTime = request.pseudoWallTime(request.startTime);
-            this.#parser = new ServerSentEventsParser(this.#onParserEvent.bind(this), request.charset() ?? undefined);
-            // Get the streaming content and add the already received bytes if someone else started
-            // the streaming earlier.
-            void this.#request.requestStreamingContent().then(streamingContentData => {
-                if (!TextUtils.StreamingContentData.isError(streamingContentData)) {
-                    void this.#parser?.addBase64Chunk(streamingContentData.content().base64);
-                    streamingContentData.addEventListener("ChunkAdded" /* TextUtils.StreamingContentData.Events.CHUNK_ADDED */, ({ data: { chunk } }) => {
-                        this.#lastDataReceivedTime = request.pseudoWallTime(request.endTime);
-                        void this.#parser?.addBase64Chunk(chunk);
-                    });
-                }
-            });
-        }
-    }
-    get eventSourceMessages() {
-        return this.#eventSourceMessages;
-    }
-    /** Forwarded Network.eventSourceMessage received */
-    onProtocolEventSourceMessageReceived(eventName, data, eventId, time) {
-        this.#recordMessageAndDispatchEvent({
-            eventName,
-            eventId,
-            data,
-            time,
-        });
-    }
-    #onParserEvent(eventName, data, eventId) {
-        this.#recordMessageAndDispatchEvent({
-            eventName,
-            eventId,
-            data,
-            time: this.#lastDataReceivedTime,
-        });
-    }
-    #recordMessageAndDispatchEvent(message) {
-        this.#eventSourceMessages.push(message);
-        this.#request.dispatchEventToListeners(Events.EVENT_SOURCE_MESSAGE_ADDED, message);
-    }
-}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/ServerSentEventsProtocol.js

@@ -1,113 +0,0 @@
-// Copyright 2023 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-/**
- * Implements Server-Sent-Events protocl parsing as described by
- * https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
- *
- * Webpages can use SSE over fetch/XHR and not go through EventSource. DevTools
- * only receives the raw binary data in this case, which means we have to decode
- * and parse the event stream ourselves here.
- *
- * Implementation mostly ported over from blink
- * third_party/blink/renderer/modules/eventsource/event_source_parser.cc.
- */
-export class ServerSentEventsParser {
-    #onEventCallback;
-    #decoder;
-    // Parser state.
-    #isRecognizingCrLf = false;
-    #line = '';
-    #id = '';
-    #data = '';
-    #eventType = '';
-    constructor(callback, encodingLabel) {
-        this.#onEventCallback = callback;
-        this.#decoder = new Base64TextDecoder(this.#onTextChunk.bind(this), encodingLabel);
-    }
-    async addBase64Chunk(raw) {
-        await this.#decoder.addBase64Chunk(raw);
-    }
-    addTextChunk(chunk) {
-        this.#onTextChunk(chunk);
-    }
-    #onTextChunk(chunk) {
-        // A line consists of "this.#line" plus a slice of "chunk[start:<next new cr/lf>]".
-        let start = 0;
-        for (let i = 0; i < chunk.length; ++i) {
-            if (this.#isRecognizingCrLf && chunk[i] === '\n') {
-                // We found the latter part of "\r\n".
-                this.#isRecognizingCrLf = false;
-                ++start;
-                continue;
-            }
-            this.#isRecognizingCrLf = false;
-            if (chunk[i] === '\r' || chunk[i] === '\n') {
-                this.#line += chunk.substring(start, i);
-                this.#parseLine();
-                this.#line = '';
-                start = i + 1;
-                this.#isRecognizingCrLf = chunk[i] === '\r';
-            }
-        }
-        this.#line += chunk.substring(start);
-    }
-    #parseLine() {
-        if (this.#line.length === 0) {
-            // We dispatch an event when seeing an empty line.
-            if (this.#data.length > 0) {
-                const data = this.#data.slice(0, -1); // Remove the last newline.
-                this.#onEventCallback(this.#eventType || 'message', data, this.#id);
-                this.#data = '';
-            }
-            this.#eventType = '';
-            return;
-        }
-        let fieldNameEnd = this.#line.indexOf(':');
-        let fieldValueStart;
-        if (fieldNameEnd < 0) {
-            fieldNameEnd = this.#line.length;
-            fieldValueStart = fieldNameEnd;
-        }
-        else {
-            fieldValueStart = fieldNameEnd + 1;
-            if (fieldValueStart < this.#line.length && this.#line[fieldValueStart] === ' ') {
-                // Skip a single space preceeding the value.
-                ++fieldValueStart;
-            }
-        }
-        const fieldName = this.#line.substring(0, fieldNameEnd);
-        if (fieldName === 'event') {
-            this.#eventType = this.#line.substring(fieldValueStart);
-            return;
-        }
-        if (fieldName === 'data') {
-            this.#data += this.#line.substring(fieldValueStart);
-            this.#data += '\n';
-        }
-        if (fieldName === 'id') {
-            // We should do a check here whether the id field contains "\0" and ignore it.
-            this.#id = this.#line.substring(fieldValueStart);
-        }
-        // Ignore all other fields. Also ignore "retry", we won't forward that to the backend.
-    }
-}
-/**
- * Small helper class that can decode a stream of base64 encoded bytes. Specify the
- * text encoding for the raw bytes via constructor. Default is utf-8.
- */
-class Base64TextDecoder {
-    #decoder;
-    #writer;
-    constructor(onTextChunk, encodingLabel) {
-        this.#decoder = new TextDecoderStream(encodingLabel);
-        this.#writer = this.#decoder.writable.getWriter();
-        void this.#decoder.readable.pipeTo(new WritableStream({ write: onTextChunk }));
-    }
-    async addBase64Chunk(chunk) {
-        const binString = window.atob(chunk);
-        const bytes = Uint8Array.from(binString, m => m.codePointAt(0));
-        await this.#writer.ready;
-        await this.#writer.write(bytes);
-    }
-}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/ServerTiming.js

@@ -1,216 +0,0 @@
-// Copyright 2016 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-import * as Common from '../common/common.js';
-import * as i18n from '../i18n/i18n.js';
-const UIStrings = {
-    /**
-     * @description Text in Server Timing
-     * @example {sql-lookup} PH1
-     */
-    deprecatedSyntaxFoundPleaseUse: 'Deprecated syntax found for metric "{PH1}". Please use: <name>;dur=<duration>;desc=<description>',
-    /**
-     * @description Text in Server Timing
-     * @example {https} PH1
-     */
-    duplicateParameterSIgnored: 'Duplicate parameter "{PH1}" ignored.',
-    /**
-     * @description Text in Server Timing
-     * @example {https} PH1
-     */
-    noValueFoundForParameterS: 'No value found for parameter "{PH1}".',
-    /**
-     * @description Text in Server Timing
-     * @example {https} PH1
-     */
-    unrecognizedParameterS: 'Unrecognized parameter "{PH1}".',
-    /**
-     * @description Text in Server Timing
-     */
-    extraneousTrailingCharacters: 'Extraneous trailing characters.',
-    /**
-     * @description Text in Server Timing
-     * @example {https} PH1
-     * @example {2.0} PH2
-     */
-    unableToParseSValueS: 'Unable to parse "{PH1}" value "{PH2}".',
-};
-const str_ = i18n.i18n.registerUIStrings('core/sdk/ServerTiming.ts', UIStrings);
-const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-export const cloudflarePrefix = '(cf) ';
-export const cloudinaryPrefix = '(cld) ';
-export class ServerTiming {
-    metric;
-    value;
-    description;
-    constructor(metric, value, description) {
-        this.metric = metric;
-        this.value = value;
-        this.description = description;
-    }
-    static parseHeaders(headers) {
-        const rawServerTimingHeaders = headers.filter(item => item.name.toLowerCase() === 'server-timing');
-        if (!rawServerTimingHeaders.length) {
-            return null;
-        }
-        const serverTimings = rawServerTimingHeaders.reduce((timings, header) => {
-            const timing = this.createFromHeaderValue(header.value);
-            timings.push(...timing.map(function (entry) {
-                return new ServerTiming(entry.name, entry.dur ?? null, entry.desc ?? '');
-            }));
-            return timings;
-        }, []);
-        return serverTimings;
-    }
-    static createFromHeaderValue(valueString) {
-        function trimLeadingWhiteSpace() {
-            valueString = valueString.replace(/^\s*/, '');
-        }
-        function consumeDelimiter(char) {
-            console.assert(char.length === 1);
-            trimLeadingWhiteSpace();
-            if (valueString.charAt(0) !== char) {
-                return false;
-            }
-            valueString = valueString.substring(1);
-            return true;
-        }
-        function consumeToken() {
-            // https://tools.ietf.org/html/rfc7230#appendix-B
-            const result = /^(?:\s*)([\w!#$%&'*+\-.^`|~]+)(?:\s*)(.*)/.exec(valueString);
-            if (!result) {
-                return null;
-            }
-            valueString = result[2];
-            return result[1];
-        }
-        function consumeTokenOrQuotedString() {
-            trimLeadingWhiteSpace();
-            if (valueString.charAt(0) === '"') {
-                return consumeQuotedString();
-            }
-            return consumeToken();
-        }
-        function consumeQuotedString() {
-            console.assert(valueString.charAt(0) === '"');
-            valueString = valueString.substring(1); // remove leading DQUOTE
-            let value = '';
-            while (valueString.length) {
-                // split into two parts:
-                //  -everything before the first " or \
-                //  -everything else
-                const result = /^([^"\\]*)(.*)/.exec(valueString);
-                if (!result) {
-                    return null; // not a valid quoted-string
-                }
-                value += result[1];
-                if (result[2].charAt(0) === '"') {
-                    // we have found our closing "
-                    valueString = result[2].substring(1); // strip off everything after the closing "
-                    return value; // we are done here
-                }
-                console.assert(result[2].charAt(0) === '\\');
-                // special rules for \ found in quoted-string (https://tools.ietf.org/html/rfc7230#section-3.2.6)
-                value += result[2].charAt(1); // grab the character AFTER the \ (if there was one)
-                valueString = result[2].substring(2); // strip off \ and next character
-            }
-            return null; // not a valid quoted-string
-        }
-        function consumeExtraneous() {
-            const result = /([,;].*)/.exec(valueString);
-            if (result) {
-                valueString = result[1];
-            }
-        }
-        const result = [];
-        let name;
-        while ((name = consumeToken()) !== null) {
-            const entry = { name };
-            if (valueString.charAt(0) === '=') {
-                this.showWarning(i18nString(UIStrings.deprecatedSyntaxFoundPleaseUse, { PH1: name }));
-            }
-            while (consumeDelimiter(';')) {
-                let paramName;
-                if ((paramName = consumeToken()) === null) {
-                    continue;
-                }
-                paramName = paramName.toLowerCase();
-                const parseParameter = this.getParserForParameter(paramName);
-                let paramValue = null;
-                if (consumeDelimiter('=')) {
-                    // always parse the value, even if we don't recognize the parameter #name
-                    paramValue = consumeTokenOrQuotedString();
-                    consumeExtraneous();
-                }
-                if (parseParameter) {
-                    // paramName is valid
-                    if (entry.hasOwnProperty(paramName)) {
-                        this.showWarning(i18nString(UIStrings.duplicateParameterSIgnored, { PH1: paramName }));
-                        continue;
-                    }
-                    if (paramValue === null) {
-                        this.showWarning(i18nString(UIStrings.noValueFoundForParameterS, { PH1: paramName }));
-                    }
-                    parseParameter.call(this, entry, paramValue);
-                }
-                else {
-                    // paramName is not valid
-                    // TODO(paulirish): consider showing other included params, like `start`: https://github.com/w3c/server-timing/issues/43
-                    this.showWarning(i18nString(UIStrings.unrecognizedParameterS, { PH1: paramName }));
-                }
-            }
-            result.push(entry);
-            // Special parsing for cloudflare's bespoke format. https://blog.cloudflare.com/new-standards/#measuring-impact
-            // We extract the individual items of the cfL4 server-timing for clear presentation
-            if (entry.name === 'cfL4' && entry.desc) {
-                new URLSearchParams(entry.desc).entries().forEach(([key, val]) => {
-                    result.push({ name: `${cloudflarePrefix}${key}`, desc: val });
-                });
-            }
-            // Special parsing for cloudinary's bespoke format. https://cloudinary.com/blog/inside_the_black_box_with_server_timing#what_details_are_you_sharing_
-            // The format has changed since this blog post
-            if (entry.name === 'content-info' && entry.desc) {
-                new URLSearchParams(entry.desc.replace(/,/g, '&')).entries().forEach(([key, val]) => {
-                    result.push({ name: `${cloudinaryPrefix}${key}`, desc: val });
-                });
-            }
-            if (!consumeDelimiter(',')) {
-                break;
-            }
-        }
-        if (valueString.length) {
-            this.showWarning(i18nString(UIStrings.extraneousTrailingCharacters));
-        }
-        return result;
-    }
-    static getParserForParameter(paramName) {
-        switch (paramName) {
-            case 'dur': {
-                function durParser(entry, paramValue) {
-                    entry.dur = 0;
-                    if (paramValue !== null) {
-                        const duration = parseFloat(paramValue);
-                        if (isNaN(duration)) {
-                            ServerTiming.showWarning(i18nString(UIStrings.unableToParseSValueS, { PH1: paramName, PH2: paramValue }));
-                            return;
-                        }
-                        entry.dur = duration;
-                    }
-                }
-                return durParser;
-            }
-            case 'desc': {
-                function descParser(entry, paramValue) {
-                    entry.desc = paramValue || '';
-                }
-                return descParser;
-            }
-            default: {
-                return null;
-            }
-        }
-    }
-    static showWarning(msg) {
-        Common.Console.Console.instance().warn(`ServerTiming: ${msg}`);
-    }
-}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/ServiceWorkerCacheModel.js

@@ -1,271 +0,0 @@
-// Copyright 2014 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-import * as Common from '../common/common.js';
-import * as i18n from '../i18n/i18n.js';
-import { SDKModel } from './SDKModel.js';
-import { StorageBucketsModel } from './StorageBucketsModel.js';
-const UIStrings = {
-    /**
-     * @description Text in Service Worker Cache Model
-     * @example {https://cache} PH1
-     * @example {error message} PH2
-     */
-    serviceworkercacheagentError: '`ServiceWorkerCacheAgent` error deleting cache entry {PH1} in cache: {PH2}',
-};
-const str_ = i18n.i18n.registerUIStrings('core/sdk/ServiceWorkerCacheModel.ts', UIStrings);
-const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-export class ServiceWorkerCacheModel extends SDKModel {
-    cacheAgent;
-    #storageAgent;
-    #storageBucketModel;
-    #caches = new Map();
-    #storageKeysTracked = new Set();
-    #storageBucketsUpdated = new Set();
-    #throttler = new Common.Throttler.Throttler(2000);
-    #enabled = false;
-    // Used by tests to remove the Throttler timeout.
-    #scheduleAsSoonAsPossible = false;
-    /**
-     * Invariant: This #model can only be constructed on a ServiceWorker target.
-     */
-    constructor(target) {
-        super(target);
-        target.registerStorageDispatcher(this);
-        this.cacheAgent = target.cacheStorageAgent();
-        this.#storageAgent = target.storageAgent();
-        this.#storageBucketModel = target.model(StorageBucketsModel);
-    }
-    enable() {
-        if (this.#enabled) {
-            return;
-        }
-        this.#storageBucketModel.addEventListener("BucketAdded" /* StorageBucketsModelEvents.BUCKET_ADDED */, this.storageBucketAdded, this);
-        this.#storageBucketModel.addEventListener("BucketRemoved" /* StorageBucketsModelEvents.BUCKET_REMOVED */, this.storageBucketRemoved, this);
-        for (const storageBucket of this.#storageBucketModel.getBuckets()) {
-            this.addStorageBucket(storageBucket.bucket);
-        }
-        this.#enabled = true;
-    }
-    clearForStorageKey(storageKey) {
-        for (const [opaqueId, cache] of this.#caches.entries()) {
-            if (cache.storageKey === storageKey) {
-                this.#caches.delete((opaqueId));
-                this.cacheRemoved((cache));
-            }
-        }
-        for (const storageBucket of this.#storageBucketModel.getBucketsForStorageKey(storageKey)) {
-            void this.loadCacheNames(storageBucket.bucket);
-        }
-    }
-    refreshCacheNames() {
-        for (const cache of this.#caches.values()) {
-            this.cacheRemoved(cache);
-        }
-        this.#caches.clear();
-        const storageBuckets = this.#storageBucketModel.getBuckets();
-        for (const storageBucket of storageBuckets) {
-            void this.loadCacheNames(storageBucket.bucket);
-        }
-    }
-    async deleteCache(cache) {
-        const response = await this.cacheAgent.invoke_deleteCache({ cacheId: cache.cacheId });
-        if (response.getError()) {
-            console.error(`ServiceWorkerCacheAgent error deleting cache ${cache.toString()}: ${response.getError()}`);
-            return;
-        }
-        this.#caches.delete(cache.cacheId);
-        this.cacheRemoved(cache);
-    }
-    async deleteCacheEntry(cache, request) {
-        const response = await this.cacheAgent.invoke_deleteEntry({ cacheId: cache.cacheId, request });
-        if (response.getError()) {
-            Common.Console.Console.instance().error(i18nString(UIStrings.serviceworkercacheagentError, { PH1: cache.toString(), PH2: String(response.getError()) }));
-            return;
-        }
-    }
-    loadCacheData(cache, skipCount, pageSize, pathFilter, callback) {
-        void this.requestEntries(cache, skipCount, pageSize, pathFilter, callback);
-    }
-    loadAllCacheData(cache, pathFilter, callback) {
-        void this.requestAllEntries(cache, pathFilter, callback);
-    }
-    caches() {
-        return [...this.#caches.values()];
-    }
-    dispose() {
-        for (const cache of this.#caches.values()) {
-            this.cacheRemoved(cache);
-        }
-        this.#caches.clear();
-        if (this.#enabled) {
-            this.#storageBucketModel.removeEventListener("BucketAdded" /* StorageBucketsModelEvents.BUCKET_ADDED */, this.storageBucketAdded, this);
-            this.#storageBucketModel.removeEventListener("BucketRemoved" /* StorageBucketsModelEvents.BUCKET_REMOVED */, this.storageBucketRemoved, this);
-        }
-    }
-    addStorageBucket(storageBucket) {
-        void this.loadCacheNames(storageBucket);
-        if (!this.#storageKeysTracked.has(storageBucket.storageKey)) {
-            this.#storageKeysTracked.add(storageBucket.storageKey);
-            void this.#storageAgent.invoke_trackCacheStorageForStorageKey({ storageKey: storageBucket.storageKey });
-        }
-    }
-    removeStorageBucket(storageBucket) {
-        let storageKeyCount = 0;
-        for (const [opaqueId, cache] of this.#caches.entries()) {
-            if (storageBucket.storageKey === cache.storageKey) {
-                storageKeyCount++;
-            }
-            if (cache.inBucket(storageBucket)) {
-                storageKeyCount--;
-                this.#caches.delete((opaqueId));
-                this.cacheRemoved((cache));
-            }
-        }
-        if (storageKeyCount === 0) {
-            this.#storageKeysTracked.delete(storageBucket.storageKey);
-            void this.#storageAgent.invoke_untrackCacheStorageForStorageKey({ storageKey: storageBucket.storageKey });
-        }
-    }
-    async loadCacheNames(storageBucket) {
-        const response = await this.cacheAgent.invoke_requestCacheNames({ storageBucket });
-        if (response.getError()) {
-            return;
-        }
-        this.updateCacheNames(storageBucket, response.caches);
-    }
-    updateCacheNames(storageBucket, cachesJson) {
-        function deleteAndSaveOldCaches(cache) {
-            if (cache.inBucket(storageBucket) && !updatingCachesIds.has(cache.cacheId)) {
-                oldCaches.set(cache.cacheId, cache);
-                this.#caches.delete(cache.cacheId);
-            }
-        }
-        const updatingCachesIds = new Set();
-        const newCaches = new Map();
-        const oldCaches = new Map();
-        for (const cacheJson of cachesJson) {
-            const storageBucket = cacheJson.storageBucket ??
-                this.#storageBucketModel.getDefaultBucketForStorageKey(cacheJson.storageKey)?.bucket;
-            if (!storageBucket) {
-                continue;
-            }
-            const cache = new Cache(this, storageBucket, cacheJson.cacheName, cacheJson.cacheId);
-            updatingCachesIds.add(cache.cacheId);
-            if (this.#caches.has(cache.cacheId)) {
-                continue;
-            }
-            newCaches.set(cache.cacheId, cache);
-            this.#caches.set(cache.cacheId, cache);
-        }
-        this.#caches.forEach(deleteAndSaveOldCaches, this);
-        newCaches.forEach(this.cacheAdded, this);
-        oldCaches.forEach(this.cacheRemoved, this);
-    }
-    storageBucketAdded({ data: { bucketInfo: { bucket } } }) {
-        this.addStorageBucket(bucket);
-    }
-    storageBucketRemoved({ data: { bucketInfo: { bucket } } }) {
-        this.removeStorageBucket(bucket);
-    }
-    cacheAdded(cache) {
-        this.dispatchEventToListeners("CacheAdded" /* Events.CACHE_ADDED */, { model: this, cache });
-    }
-    cacheRemoved(cache) {
-        this.dispatchEventToListeners("CacheRemoved" /* Events.CACHE_REMOVED */, { model: this, cache });
-    }
-    async requestEntries(cache, skipCount, pageSize, pathFilter, callback) {
-        const response = await this.cacheAgent.invoke_requestEntries({ cacheId: cache.cacheId, skipCount, pageSize, pathFilter });
-        if (response.getError()) {
-            console.error('ServiceWorkerCacheAgent error while requesting entries: ', response.getError());
-            return;
-        }
-        callback(response.cacheDataEntries, response.returnCount);
-    }
-    async requestAllEntries(cache, pathFilter, callback) {
-        const response = await this.cacheAgent.invoke_requestEntries({ cacheId: cache.cacheId, pathFilter });
-        if (response.getError()) {
-            console.error('ServiceWorkerCacheAgent error while requesting entries: ', response.getError());
-            return;
-        }
-        callback(response.cacheDataEntries, response.returnCount);
-    }
-    cacheStorageListUpdated({ bucketId }) {
-        const storageBucket = this.#storageBucketModel.getBucketById(bucketId)?.bucket;
-        if (storageBucket) {
-            this.#storageBucketsUpdated.add(storageBucket);
-            void this.#throttler.schedule(() => {
-                const promises = Array.from(this.#storageBucketsUpdated, storageBucket => this.loadCacheNames(storageBucket));
-                this.#storageBucketsUpdated.clear();
-                return Promise.all(promises);
-            }, this.#scheduleAsSoonAsPossible ? "AsSoonAsPossible" /* Common.Throttler.Scheduling.AS_SOON_AS_POSSIBLE */ :
-                "Default" /* Common.Throttler.Scheduling.DEFAULT */);
-        }
-    }
-    cacheStorageContentUpdated({ bucketId, cacheName }) {
-        const storageBucket = this.#storageBucketModel.getBucketById(bucketId)?.bucket;
-        if (storageBucket) {
-            this.dispatchEventToListeners("CacheStorageContentUpdated" /* Events.CACHE_STORAGE_CONTENT_UPDATED */, { storageBucket, cacheName });
-        }
-    }
-    attributionReportingTriggerRegistered(_event) {
-    }
-    indexedDBListUpdated(_event) {
-    }
-    indexedDBContentUpdated(_event) {
-    }
-    interestGroupAuctionEventOccurred(_event) {
-    }
-    interestGroupAccessed(_event) {
-    }
-    interestGroupAuctionNetworkRequestCreated(_event) {
-    }
-    sharedStorageAccessed(_event) {
-    }
-    sharedStorageWorkletOperationExecutionFinished(_event) {
-    }
-    storageBucketCreatedOrUpdated(_event) {
-    }
-    storageBucketDeleted(_event) {
-    }
-    setThrottlerSchedulesAsSoonAsPossibleForTest() {
-        this.#scheduleAsSoonAsPossible = true;
-    }
-    attributionReportingSourceRegistered(_event) {
-    }
-    attributionReportingReportSent(_event) {
-    }
-    attributionReportingVerboseDebugReportSent(_event) {
-    }
-}
-export class Cache {
-    #model;
-    storageKey;
-    storageBucket;
-    cacheName;
-    cacheId;
-    constructor(model, storageBucket, cacheName, cacheId) {
-        this.#model = model;
-        this.storageBucket = storageBucket;
-        this.storageKey = storageBucket.storageKey;
-        this.cacheName = cacheName;
-        this.cacheId = cacheId;
-    }
-    inBucket(storageBucket) {
-        return this.storageKey === storageBucket.storageKey && this.storageBucket.name === storageBucket.name;
-    }
-    equals(cache) {
-        return this.cacheId === cache.cacheId;
-    }
-    toString() {
-        return this.storageKey + this.cacheName;
-    }
-    async requestCachedResponse(url, requestHeaders) {
-        const response = await this.#model.cacheAgent.invoke_requestCachedResponse({ cacheId: this.cacheId, requestURL: url, requestHeaders });
-        if (response.getError()) {
-            return null;
-        }
-        return response.response;
-    }
-}
-SDKModel.register(ServiceWorkerCacheModel, { capabilities: 8192 /* Capability.STORAGE */, autostart: false });