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

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

@@ -0,0 +1,66 @@
+// 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/node_modules/chrome-devtools-frontend/front_end/core/common/JavaScriptMetaData.js

@@ -0,0 +1,4 @@
+// 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/node_modules/chrome-devtools-frontend/front_end/core/common/Lazy.js

@@ -0,0 +1,29 @@
+// 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/node_modules/chrome-devtools-frontend/front_end/core/common/MapWithDefault.js

@@ -0,0 +1,22 @@
+// 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/node_modules/chrome-devtools-frontend/front_end/core/common/Mutex.js

@@ -0,0 +1,49 @@
+// 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/node_modules/chrome-devtools-frontend/front_end/core/common/Object.js

@@ -0,0 +1,86 @@
+// 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);
+        }
+    };
+}