@mcp-b/chrome-devtools-mcp 1.6.2 → 2.0.0

package/build/vendor/chrome-devtools-frontend/front_end/core/common/Gzip.js

@@ -1,66 +0,0 @@
-// Copyright 2025 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-/**
- * Quickly determine if gzipped, by seeing if the first 3 bytes of the file header match the gzip signature
- */
-export function isGzip(ab) {
-    const buf = new Uint8Array(ab);
-    if (!buf || buf.length < 3) {
-        return false;
-    }
-    // https://www.rfc-editor.org/rfc/rfc1952#page-6
-    return buf[0] === 0x1F && buf[1] === 0x8B && buf[2] === 0x08;
-}
-/** Decode a gzipped _or_ plain text ArrayBuffer to a decoded string */
-export async function arrayBufferToString(ab) {
-    if (isGzip(ab)) {
-        return await decompress(ab);
-    }
-    const str = new TextDecoder('utf-8').decode(ab);
-    return str;
-}
-export async function fileToString(file) {
-    let stream = file.stream();
-    if (file.type.endsWith('gzip')) {
-        stream = decompressStream(stream);
-    }
-    const arrayBuffer = await new Response(stream).arrayBuffer();
-    const str = new TextDecoder('utf-8').decode(arrayBuffer);
-    return str;
-}
-/**
- * Decompress a gzipped ArrayBuffer to a string.
- * Consider using `arrayBufferToString` instead, which can handle both gzipped and plain text buffers.
- */
-export async function decompress(gzippedBuffer) {
-    const buffer = await gzipCodec(gzippedBuffer, new DecompressionStream('gzip'));
-    const str = new TextDecoder('utf-8').decode(buffer);
-    return str;
-}
-export async function compress(str) {
-    const encoded = new TextEncoder().encode(str);
-    const buffer = await gzipCodec(encoded, new CompressionStream('gzip'));
-    return buffer;
-}
-/** Private coder/decoder **/
-async function gzipCodec(buffer, codecStream) {
-    const readable = new ReadableStream({
-        start(controller) {
-            controller.enqueue(buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer);
-            controller.close();
-        }
-    });
-    const codecReadable = readable.pipeThrough(codecStream);
-    // A response is a convenient way to get an ArrayBuffer from a ReadableStream.
-    return await new Response(codecReadable).arrayBuffer();
-}
-export function decompressStream(stream) {
-    // https://github.com/wicg/compression/blob/main/explainer.md#deflate-compress-an-arraybuffer
-    const ds = new DecompressionStream('gzip');
-    return stream.pipeThrough(ds);
-}
-export function compressStream(stream) {
-    const cs = new CompressionStream('gzip');
-    return stream.pipeThrough(cs);
-}

package/build/vendor/chrome-devtools-frontend/front_end/core/common/JavaScriptMetaData.js

@@ -1,4 +0,0 @@
-// Copyright 2019 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-export {};

package/build/vendor/chrome-devtools-frontend/front_end/core/common/Lazy.js

@@ -1,29 +0,0 @@
-// Copyright 2020 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-const UNINITIALIZED = Symbol('uninitialized');
-const ERROR_STATE = Symbol('error');
-/**
- * Very basic memoizer. Will only invoke its callback the first time, returning the cached value all subsequent calls.
- */
-export function lazy(producer) {
-    let value = UNINITIALIZED;
-    let error = new Error('Initial');
-    return () => {
-        if (value === ERROR_STATE) {
-            throw error;
-        }
-        else if (value !== UNINITIALIZED) {
-            return value;
-        }
-        try {
-            value = producer();
-            return value;
-        }
-        catch (err) {
-            error = err instanceof Error ? err : new Error(err);
-            value = ERROR_STATE;
-            throw error;
-        }
-    };
-}

package/build/vendor/chrome-devtools-frontend/front_end/core/common/MapWithDefault.js

@@ -1,22 +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.
-/**
- * Polyfill of https://github.com/tc39/proposal-upsert with a subclass.
- *
- * TODO: Once the proposal is merged, just replace `MapWithDefault` with `Map` and remove it.
- **/
-export class MapWithDefault extends Map {
-    getOrInsert(key, defaultValue) {
-        if (!this.has(key)) {
-            this.set(key, defaultValue);
-        }
-        return this.get(key);
-    }
-    getOrInsertComputed(key, callbackFunction) {
-        if (!this.has(key)) {
-            this.set(key, callbackFunction(key));
-        }
-        return this.get(key);
-    }
-}

package/build/vendor/chrome-devtools-frontend/front_end/core/common/Mutex.js

@@ -1,49 +0,0 @@
-// Copyright 2022 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-/**
- * Use Mutex class to coordinate local concurrent operations.
- * Once `acquire` promise resolves, you hold the lock and must
- * call `release` function returned by `acquire` to release the
- * lock. Failing to `release` the lock may lead to deadlocks.
- */
-export class Mutex {
-    #locked = false;
-    #acquirers = [];
-    // This is FIFO.
-    acquire() {
-        const state = { resolved: false };
-        if (this.#locked) {
-            return new Promise(resolve => {
-                this.#acquirers.push(() => resolve(this.#release.bind(this, state)));
-            });
-        }
-        this.#locked = true;
-        return Promise.resolve(this.#release.bind(this, state));
-    }
-    #release(state) {
-        if (state.resolved) {
-            throw new Error('Cannot release more than once.');
-        }
-        state.resolved = true;
-        const resolve = this.#acquirers.shift();
-        if (!resolve) {
-            this.#locked = false;
-            return;
-        }
-        resolve();
-    }
-    async run(action) {
-        const release = await this.acquire();
-        try {
-            // Note we need to await here because we want the await to release AFTER
-            // that await happens. Returning action() will trigger the release
-            // immediately which is counter to what we want.
-            const result = await action();
-            return result;
-        }
-        finally {
-            release();
-        }
-    }
-}

package/build/vendor/chrome-devtools-frontend/front_end/core/common/Object.js

@@ -1,86 +0,0 @@
-// Copyright 2021 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-export class ObjectWrapper {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    listeners;
-    addEventListener(eventType, listener, thisObject) {
-        if (!this.listeners) {
-            this.listeners = new Map();
-        }
-        let listenersForEventType = this.listeners.get(eventType);
-        if (!listenersForEventType) {
-            listenersForEventType = new Set();
-            this.listeners.set(eventType, listenersForEventType);
-        }
-        listenersForEventType.add({ thisObject, listener });
-        return { eventTarget: this, eventType, thisObject, listener };
-    }
-    once(eventType) {
-        return new Promise(resolve => {
-            const descriptor = this.addEventListener(eventType, event => {
-                this.removeEventListener(eventType, descriptor.listener);
-                resolve(event.data);
-            });
-        });
-    }
-    removeEventListener(eventType, listener, thisObject) {
-        const listeners = this.listeners?.get(eventType);
-        if (!listeners) {
-            return;
-        }
-        for (const listenerTuple of listeners) {
-            if (listenerTuple.listener === listener && listenerTuple.thisObject === thisObject) {
-                listenerTuple.disposed = true;
-                listeners.delete(listenerTuple);
-            }
-        }
-        if (!listeners.size) {
-            this.listeners?.delete(eventType);
-        }
-    }
-    hasEventListeners(eventType) {
-        return Boolean(this.listeners?.has(eventType));
-    }
-    dispatchEventToListeners(eventType, ...[eventData]) {
-        const listeners = this.listeners?.get(eventType);
-        if (!listeners) {
-            return;
-        }
-        // `eventData` is typed as `Events[T] | undefined`:
-        //   - `undefined` when `Events[T]` is void.
-        //   - `Events[T]` otherwise.
-        // We cast it to `Events[T]` which is the correct type in all instances, as
-        // `void` will be cast and used as `undefined`.
-        const event = { data: eventData, source: this };
-        // Work on a snapshot of the current listeners, callbacks might remove/add
-        // new listeners.
-        for (const listener of [...listeners]) {
-            if (!listener.disposed) {
-                listener.listener.call(listener.thisObject, event);
-            }
-        }
-    }
-}
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function eventMixin(base) {
-    console.assert(base !== HTMLElement);
-    return class EventHandling extends base {
-        #events = new ObjectWrapper();
-        addEventListener(eventType, listener, thisObject) {
-            return this.#events.addEventListener(eventType, listener, thisObject);
-        }
-        once(eventType) {
-            return this.#events.once(eventType);
-        }
-        removeEventListener(eventType, listener, thisObject) {
-            this.#events.removeEventListener(eventType, listener, thisObject);
-        }
-        hasEventListeners(eventType) {
-            return this.#events.hasEventListeners(eventType);
-        }
-        dispatchEventToListeners(eventType, ...eventData) {
-            this.#events.dispatchEventToListeners(eventType, ...eventData);
-        }
-    };
-}