@nimbus21.ai/chrome-devtools-mcp 0.6.1

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

@@ -0,0 +1,12 @@
+// 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.
+import * as AidaClient from './AidaClient.js';
+import * as GdpClient from './GdpClient.js';
+import * as InspectorFrontendHost from './InspectorFrontendHost.js';
+import * as InspectorFrontendHostAPI from './InspectorFrontendHostAPI.js';
+import * as Platform from './Platform.js';
+import * as ResourceLoader from './ResourceLoader.js';
+import * as UserMetrics from './UserMetrics.js';
+export { AidaClient, GdpClient, InspectorFrontendHost, InspectorFrontendHostAPI, Platform, ResourceLoader, UserMetrics, };
+export const userMetrics = new UserMetrics.UserMetrics();

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

@@ -0,0 +1,60 @@
+
+export const i18n = {
+  registerUIStrings: () => {},
+  getLocalizedString: (_, str) => {
+    // So that the string passed in gets output verbatim.
+    return str;
+  },
+  lockedLazyString: () => {},
+  getLazilyComputedLocalizedString: () => {},
+};
+
+// TODO(jacktfranklin): once the DocumentLatency insight does not depend on
+// this method, we can remove this stub.
+export const TimeUtilities = {
+  millisToString(x) {
+    const separator = ' ';
+    const formatter = new Intl.NumberFormat('en-US', {
+      style: 'unit',
+      unitDisplay: 'narrow',
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 1,
+      unit: 'millisecond',
+    });
+
+    const parts = formatter.formatToParts(x);
+    for (const part of parts) {
+      if (part.type === 'literal') {
+        if (part.value === ' ') {
+          part.value = separator;
+        }
+      }
+    }
+
+    return parts.map(part => part.value).join('');
+  }
+};
+
+// TODO(jacktfranklin): once the ImageDelivery insight does not depend on this method, we can remove this stub.
+export const ByteUtilities = {
+  bytesToString(x) {
+    const separator = ' ';
+    const formatter = new Intl.NumberFormat('en-US', {
+      style: 'unit',
+      unit: 'kilobyte',
+      unitDisplay: 'narrow',
+      minimumFractionDigits: 1,
+      maximumFractionDigits: 1,
+    });
+    const parts = formatter.formatToParts(x / 1000);
+    for (const part of parts) {
+      if (part.type === 'literal') {
+        if (part.value === ' ') {
+          part.value = separator;
+        }
+      }
+    }
+
+    return parts.map(part => part.value).join('');
+  }
+};

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/ArrayUtilities.js

@@ -0,0 +1,199 @@
+// 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.
+export const removeElement = (array, element, firstOnly) => {
+    let index = array.indexOf(element);
+    if (index === -1) {
+        return false;
+    }
+    if (firstOnly) {
+        array.splice(index, 1);
+        return true;
+    }
+    for (let i = index + 1, n = array.length; i < n; ++i) {
+        if (array[i] !== element) {
+            array[index++] = array[i];
+        }
+    }
+    array.length = index;
+    return true;
+};
+function swap(array, i1, i2) {
+    const temp = array[i1];
+    array[i1] = array[i2];
+    array[i2] = temp;
+}
+function partition(array, comparator, left, right, pivotIndex) {
+    const pivotValue = array[pivotIndex];
+    swap(array, right, pivotIndex);
+    let storeIndex = left;
+    for (let i = left; i < right; ++i) {
+        if (comparator(array[i], pivotValue) < 0) {
+            swap(array, storeIndex, i);
+            ++storeIndex;
+        }
+    }
+    swap(array, right, storeIndex);
+    return storeIndex;
+}
+function quickSortRange(array, comparator, left, right, sortWindowLeft, sortWindowRight) {
+    if (right <= left) {
+        return;
+    }
+    const pivotIndex = Math.floor(Math.random() * (right - left)) + left;
+    const pivotNewIndex = partition(array, comparator, left, right, pivotIndex);
+    if (sortWindowLeft < pivotNewIndex) {
+        quickSortRange(array, comparator, left, pivotNewIndex - 1, sortWindowLeft, sortWindowRight);
+    }
+    if (pivotNewIndex < sortWindowRight) {
+        quickSortRange(array, comparator, pivotNewIndex + 1, right, sortWindowLeft, sortWindowRight);
+    }
+}
+export function sortRange(array, comparator, leftBound, rightBound, sortWindowLeft, sortWindowRight) {
+    if (leftBound === 0 && rightBound === (array.length - 1) && sortWindowLeft === 0 && sortWindowRight >= rightBound) {
+        array.sort(comparator);
+    }
+    else {
+        quickSortRange(array, comparator, leftBound, rightBound, sortWindowLeft, sortWindowRight);
+    }
+    return array;
+}
+export const binaryIndexOf = (array, value, comparator) => {
+    const index = lowerBound(array, value, comparator);
+    return index < array.length && comparator(value, array[index]) === 0 ? index : -1;
+};
+function mergeOrIntersect(array1, array2, comparator, mergeNotIntersect) {
+    const result = [];
+    let i = 0;
+    let j = 0;
+    while (i < array1.length && j < array2.length) {
+        const compareValue = comparator(array1[i], array2[j]);
+        if (mergeNotIntersect || !compareValue) {
+            result.push(compareValue <= 0 ? array1[i] : array2[j]);
+        }
+        if (compareValue <= 0) {
+            i++;
+        }
+        if (compareValue >= 0) {
+            j++;
+        }
+    }
+    if (mergeNotIntersect) {
+        while (i < array1.length) {
+            result.push(array1[i++]);
+        }
+        while (j < array2.length) {
+            result.push(array2[j++]);
+        }
+    }
+    return result;
+}
+export const intersectOrdered = (array1, array2, comparator) => {
+    return mergeOrIntersect(array1, array2, comparator, false);
+};
+export const mergeOrdered = (array1, array2, comparator) => {
+    return mergeOrIntersect(array1, array2, comparator, true);
+};
+export const DEFAULT_COMPARATOR = (a, b) => {
+    return a < b ? -1 : (a > b ? 1 : 0);
+};
+export function lowerBound(array, needle, comparator, left, right) {
+    let l = left || 0;
+    let r = right !== undefined ? right : array.length;
+    while (l < r) {
+        const m = (l + r) >> 1;
+        if (comparator(needle, array[m]) > 0) {
+            l = m + 1;
+        }
+        else {
+            r = m;
+        }
+    }
+    return r;
+}
+export function upperBound(array, needle, comparator, left, right) {
+    let l = left || 0;
+    let r = right !== undefined ? right : array.length;
+    while (l < r) {
+        const m = (l + r) >> 1;
+        if (comparator(needle, array[m]) >= 0) {
+            l = m + 1;
+        }
+        else {
+            r = m;
+        }
+    }
+    return r;
+}
+/**
+ * Obtains the first or last item in the array that satisfies the predicate function.
+ * So, for example, if the array were arr = [2, 4, 6, 8, 10], and you are looking for
+ * the last item arr[i] such that arr[i] < 5  you would be returned 1, because
+ * array[1] is 4, the last item in the array that satisfies the
+ * predicate function.
+ *
+ * If instead you were looking for the first item in the same array that satisfies
+ * arr[i] > 5 you would be returned 2 because array[2] = 6.
+ *
+ * Please note: this presupposes that the array is already ordered.
+ * This function uses a variation of Binary Search.
+ */
+function nearestIndex(arr, predicate, searchStart) {
+    const searchFromEnd = searchStart === "END" /* NearestSearchStart.END */;
+    if (arr.length === 0) {
+        return null;
+    }
+    let left = 0;
+    let right = arr.length - 1;
+    let pivot = 0;
+    let matchesPredicate = false;
+    let moveToTheRight = false;
+    let middle = 0;
+    do {
+        middle = left + (right - left) / 2;
+        pivot = searchFromEnd ? Math.ceil(middle) : Math.floor(middle);
+        matchesPredicate = predicate(arr[pivot]);
+        moveToTheRight = matchesPredicate === searchFromEnd;
+        if (moveToTheRight) {
+            left = Math.min(right, pivot + (left === pivot ? 1 : 0));
+        }
+        else {
+            right = Math.max(left, pivot + (right === pivot ? -1 : 0));
+        }
+    } while (right !== left);
+    // Special-case: the indexed item doesn't pass the predicate. This
+    // occurs when none of the items in the array are a match for the
+    // predicate.
+    if (!predicate(arr[left])) {
+        return null;
+    }
+    return left;
+}
+/**
+ * Obtains the first item in the array that satisfies the predicate function.
+ * So, for example, if the array was arr = [2, 4, 6, 8, 10], and you are looking for
+ * the first item arr[i] such that arr[i] > 5 you would be returned 2, because
+ * array[2] is 6, the first item in the array that satisfies the
+ * predicate function.
+ *
+ * Please note: this presupposes that the array is already ordered.
+ */
+export function nearestIndexFromBeginning(arr, predicate) {
+    return nearestIndex(arr, predicate, "BEGINNING" /* NearestSearchStart.BEGINNING */);
+}
+/**
+ * Obtains the last item in the array that satisfies the predicate function.
+ * So, for example, if the array was arr = [2, 4, 6, 8, 10], and you are looking for
+ * the last item arr[i] such that arr[i] < 5 you would be returned 1, because
+ * arr[1] is 4, the last item in the array that satisfies the
+ * predicate function.
+ *
+ * Please note: this presupposes that the array is already ordered.
+ */
+export function nearestIndexFromEnd(arr, predicate) {
+    return nearestIndex(arr, predicate, "END" /* NearestSearchStart.END */);
+}
+// Type guard for ensuring that `arr` does not contain null or undefined
+export function arrayDoesNotContainNullOrUndefined(arr) {
+    return !arr.includes(null) && !arr.includes(undefined);
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/Brand.js

@@ -0,0 +1,4 @@
+// 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.
+export {};

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/Constructor.js

@@ -0,0 +1,4 @@
+// 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.
+export {};

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/DOMUtilities.js

@@ -0,0 +1,122 @@
+// 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.
+/**
+ * `document.activeElement` will not enter shadow roots to find the element
+ * that has focus; use this method if you need to traverse through any shadow
+ * roots to find the actual, specific focused element.
+ */
+export function deepActiveElement(doc) {
+    let activeElement = doc.activeElement;
+    while (activeElement?.shadowRoot?.activeElement) {
+        activeElement = activeElement.shadowRoot.activeElement;
+    }
+    return activeElement;
+}
+export function getEnclosingShadowRootForNode(node) {
+    let parentNode = node.parentNodeOrShadowHost();
+    while (parentNode) {
+        if (parentNode instanceof ShadowRoot) {
+            return parentNode;
+        }
+        parentNode = parentNode.parentNodeOrShadowHost();
+    }
+    return null;
+}
+export function rangeOfWord(rootNode, offset, stopCharacters, stayWithinNode, direction) {
+    let startNode;
+    let startOffset = 0;
+    let endNode;
+    let endOffset = 0;
+    if (!stayWithinNode) {
+        stayWithinNode = rootNode;
+    }
+    if (!direction || direction === 'backward' || direction === 'both') {
+        let node = rootNode;
+        while (node) {
+            if (node === stayWithinNode) {
+                if (!startNode) {
+                    startNode = stayWithinNode;
+                }
+                break;
+            }
+            if (node.nodeType === Node.TEXT_NODE && node.nodeValue !== null) {
+                const start = (node === rootNode ? (offset - 1) : (node.nodeValue.length - 1));
+                for (let i = start; i >= 0; --i) {
+                    if (stopCharacters.indexOf(node.nodeValue[i]) !== -1) {
+                        startNode = node;
+                        startOffset = i + 1;
+                        break;
+                    }
+                }
+            }
+            if (startNode) {
+                break;
+            }
+            node = node.traversePreviousNode(stayWithinNode);
+        }
+        if (!startNode) {
+            startNode = stayWithinNode;
+            startOffset = 0;
+        }
+    }
+    else {
+        startNode = rootNode;
+        startOffset = offset;
+    }
+    if (!direction || direction === 'forward' || direction === 'both') {
+        let node = rootNode;
+        while (node) {
+            if (node === stayWithinNode) {
+                if (!endNode) {
+                    endNode = stayWithinNode;
+                }
+                break;
+            }
+            if (node.nodeType === Node.TEXT_NODE && node.nodeValue !== null) {
+                const start = (node === rootNode ? offset : 0);
+                for (let i = start; i < node.nodeValue.length; ++i) {
+                    if (stopCharacters.indexOf(node.nodeValue[i]) !== -1) {
+                        endNode = node;
+                        endOffset = i;
+                        break;
+                    }
+                }
+            }
+            if (endNode) {
+                break;
+            }
+            node = node.traverseNextNode(stayWithinNode);
+        }
+        if (!endNode) {
+            endNode = stayWithinNode;
+            endOffset = stayWithinNode.nodeType === Node.TEXT_NODE ? stayWithinNode.nodeValue?.length || 0 :
+                stayWithinNode.childNodes.length;
+        }
+    }
+    else {
+        endNode = rootNode;
+        endOffset = offset;
+    }
+    if (!rootNode.ownerDocument) {
+        throw new Error('No `ownerDocument` found for rootNode');
+    }
+    const result = rootNode.ownerDocument.createRange();
+    result.setStart(startNode, startOffset);
+    result.setEnd(endNode, endOffset);
+    return result;
+}
+/**
+ * Appends the list of `styles` as individual `<style>` elements to the
+ * given `node`.
+ *
+ * @param node the `Node` to append the `<style>` elements to.
+ * @param styles an optional list of styles to append to the `node`.
+ */
+export function appendStyle(node, ...styles) {
+    for (const cssText of styles) {
+        const style = (node.ownerDocument ?? document).createElement('style');
+        style.textContent = cssText;
+        node.appendChild(style);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/DateUtilities.js

@@ -0,0 +1,13 @@
+// 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.
+export const isValid = (date) => {
+    return !isNaN(date.getTime());
+};
+export const toISO8601Compact = (date) => {
+    function leadZero(x) {
+        return (x > 9 ? '' : '0') + x;
+    }
+    return date.getFullYear() + leadZero(date.getMonth() + 1) + leadZero(date.getDate()) + 'T' +
+        leadZero(date.getHours()) + leadZero(date.getMinutes()) + leadZero(date.getSeconds());
+};

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/DevToolsPath.js

@@ -0,0 +1,27 @@
+// 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 const EmptyUrlString = '';
+/**
+ * Tagged template helper to construct `UrlString`s in a more readable form,
+ * without having to sprinkle casts throughout the codebase. Primarily useful
+ * for writing unit tests.
+ *
+ * Usage:
+ * ```js
+ * const url1 = urlString`https://www.example.com/404.html`;
+ * const url2 = urlString`http://${host}/path/to/file.js`;
+ * ```
+ *
+ * This is implemented as a wrapper around `String.raw` for convenience. This
+ * function doesn't perform any kind of validation that the returned string is
+ * really a valid `UrlString`.
+ *
+ * @param strings the string parts of the template.
+ * @param values the dynamic values of the template.
+ * @returns the string constructed from `strings` and `values` casted to an
+ *         `UrlString`.
+ */
+export const urlString = (strings, ...values) => String.raw({ raw: strings }, ...values);
+export const EmptyRawPathString = '';
+export const EmptyEncodedPathString = '';

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/KeyboardUtilities.js

@@ -0,0 +1,21 @@
+// 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.
+export const ENTER_KEY = 'Enter';
+export const ESCAPE_KEY = 'Escape';
+export const TAB_KEY = 'Tab';
+export const ARROW_KEYS = new Set([
+    "ArrowUp" /* ArrowKey.UP */,
+    "ArrowDown" /* ArrowKey.DOWN */,
+    "ArrowLeft" /* ArrowKey.LEFT */,
+    "ArrowRight" /* ArrowKey.RIGHT */,
+]);
+export function keyIsArrowKey(key) {
+    return ARROW_KEYS.has(key);
+}
+export function isEscKey(event) {
+    return event.key === 'Escape';
+}
+export function isEnterOrSpaceKey(event) {
+    return event.key === 'Enter' || event.key === ' ';
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/MapUtilities.js

@@ -0,0 +1,79 @@
+// 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.
+export const inverse = function (map) {
+    const result = new Multimap();
+    for (const [key, value] of map.entries()) {
+        result.set(value, key);
+    }
+    return result;
+};
+export class Multimap {
+    map = new Map();
+    set(key, value) {
+        let set = this.map.get(key);
+        if (!set) {
+            set = new Set();
+            this.map.set(key, set);
+        }
+        set.add(value);
+    }
+    get(key) {
+        return this.map.get(key) || new Set();
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    hasValue(key, value) {
+        const set = this.map.get(key);
+        if (!set) {
+            return false;
+        }
+        return set.has(value);
+    }
+    get size() {
+        return this.map.size;
+    }
+    delete(key, value) {
+        const values = this.get(key);
+        if (!values) {
+            return false;
+        }
+        const result = values.delete(value);
+        if (!values.size) {
+            this.map.delete(key);
+        }
+        return result;
+    }
+    deleteAll(key) {
+        this.map.delete(key);
+    }
+    keysArray() {
+        return [...this.map.keys()];
+    }
+    keys() {
+        return this.map.keys();
+    }
+    valuesArray() {
+        const result = [];
+        for (const set of this.map.values()) {
+            result.push(...set.values());
+        }
+        return result;
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+/**
+ * Gets value for key, assigning a default if value is falsy.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export function getWithDefault(map, key, defaultValueFactory) {
+    let value = map.get(key);
+    if (value === undefined || value === null) {
+        value = defaultValueFactory(key);
+        map.set(key, value);
+    }
+    return value;
+}