chrome-devtools-mcp 0.0.1 → 0.0.2

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,9 @@
+export const i18n = {
+    registerUIStrings: () => {},
+    getLocalizedString: (_, str) => {
+      // So that the string passed in gets output verbatim.
+      return str;
+    },
+    lockedLazyString: () => {},
+    getLazilyComputedLocalizedString: () => {}
+  };

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;
+}

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

@@ -0,0 +1,143 @@
+// 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.
+/**
+ * MIME types other than the ones with the "text" type that have text content.
+ */
+const ADDITIONAL_TEXT_MIME_TYPES = new Set([
+    'application/ecmascript',
+    'application/javascript',
+    'application/json',
+    'application/json+protobuf',
+    'application/mpegurl',
+    'application/vnd.apple.mpegurl',
+    'application/vnd.dart',
+    'application/xml',
+    'application/x-aspx',
+    'application/x-javascript',
+    'application/x-jsp',
+    'application/x-httpd-php',
+    'application/x-mpegurl',
+    'audio/mpegurl',
+    'audio/x-mpegurl',
+]);
+/**
+ * @returns true iff `mimeType` has textual content. Concretely we return true if:
+ *   - `mimeType` starts with "text/" or "multipart/"
+ *   - `mimeType` ends with "+xml"
+ *   - `mimeType` contains "json"
+ *   - if `mimeType` is one of a predefined list textual mime types.
+ */
+export function isTextType(mimeType) {
+    return mimeType.startsWith('text/') || mimeType.startsWith('multipart/') || mimeType.includes('json') ||
+        mimeType.endsWith('+xml') || ADDITIONAL_TEXT_MIME_TYPES.has(mimeType);
+}
+/**
+ * Port of net::HttpUtils::ParseContentType to extract mimeType and charset from
+ * the 'Content-Type' header.
+ */
+export function parseContentType(contentType) {
+    if (contentType === '*/*') {
+        return { mimeType: null, charset: null };
+    }
+    const { mimeType, params } = parseMimeType(contentType);
+    const charset = params.get('charset')?.toLowerCase().trim() ?? null;
+    return { mimeType, charset };
+}
+function parseMimeType(contentType) {
+    // Remove any leading and trailing whitespace. Note that String.prototype.trim removes a lot more
+    // than what the spec considers whitespace. We are fine with that.
+    contentType = contentType.trim();
+    // The mimetype is basically everything until the first ';' (but trimmed).
+    let mimeTypeEnd = findFirstIndexOf(contentType, ' \t;(');
+    if (mimeTypeEnd < 0) {
+        mimeTypeEnd = contentType.length;
+    }
+    const slashPos = contentType.indexOf('/');
+    if (slashPos < 0 || slashPos > mimeTypeEnd) {
+        return { mimeType: null, params: new Map() };
+    }
+    const mimeType = contentType.substring(0, mimeTypeEnd).toLowerCase();
+    // Iterate over parameters. We can't split the string around semicolons because quoted
+    // strings may include semicolons.
+    const params = new Map();
+    let offset = contentType.indexOf(';', mimeTypeEnd);
+    while (offset >= 0 && offset < contentType.length) {
+        // Trim off the semicolon.
+        ++offset;
+        // Trim off whitespace
+        offset = findFirstIndexNotOf(contentType, ' \t', offset);
+        if (offset < 0) {
+            continue;
+        }
+        const paramNameStart = offset;
+        // Extend parameter name until we run into semicolon or equals sign.
+        offset = findFirstIndexOf(contentType, ';=', offset);
+        if (offset < 0 || contentType[offset] === ';') {
+            // Nothing more to do if no more input or there is no parameter value.
+            continue;
+        }
+        const paramName = contentType.substring(paramNameStart, offset).toLowerCase();
+        //  Trim off the '='.
+        ++offset;
+        // Trim off whitespace.
+        offset = findFirstIndexNotOf(contentType, ' \t', offset);
+        let paramValue = '';
+        if (offset < 0 || contentType[offset] === ';') {
+            // Nothing to do here: the value is an unquoted string of only whitespace.
+            continue;
+        }
+        else if (contentType[offset] !== '"') {
+            // Not a quote so we can copy the value as-is.
+            const valueStart = offset;
+            offset = contentType.indexOf(';', offset);
+            const valueEnd = offset >= 0 ? offset : contentType.length;
+            paramValue = contentType.substring(valueStart, valueEnd).trimEnd();
+        }
+        else {
+            // Otherwise append data with special handling for backslashes, until a close quote.
+            // Don't trim whitespace for quoted strings.
+            // Trim off the opening quote '"'
+            ++offset;
+            while (offset < contentType.length && contentType[offset] !== '"') {
+                // Skip over backslash and append the next character, when not at the end
+                // of the string. Otherwise, copy the next character (which may be a backslash).
+                if (contentType[offset] === '\\' && offset + 1 < contentType.length) {
+                    ++offset;
+                }
+                paramValue += contentType[offset];
+                ++offset;
+            }
+            offset = contentType.indexOf(';', offset);
+        }
+        if (!params.has(paramName)) {
+            // The first one wins!
+            params.set(paramName, paramValue);
+        }
+    }
+    return { mimeType, params };
+}
+/**
+ * @returns the smallest index of any character in 'characters' or -1 if none of
+ * the characters occur in 'searchString'
+ */
+function findFirstIndexOf(searchString, characters, pos = 0) {
+    for (let i = pos; i < searchString.length; i++) {
+        if (characters.includes(searchString[i])) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * @returns the smallest index of any character not in 'characters' or -1 if only
+ * 'characters' occur in 'searchString'
+ */
+function findFirstIndexNotOf(searchString, characters, pos = 0) {
+    for (let i = pos; i < searchString.length; i++) {
+        if (!characters.includes(searchString[i])) {
+            return i;
+        }
+    }
+    return -1;
+}