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

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;
+};
+export 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/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/HostRuntime.js

@@ -0,0 +1,19 @@
+// 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.
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore 'process' is not available when type-checking against browser types.
+export const IS_NODE = typeof process !== 'undefined' && process.versions?.node !== null;
+export const IS_BROWSER = 
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore 'window' is not available when type-checking against node.js types.
+typeof window !== 'undefined' || (typeof self !== 'undefined' && typeof self.postMessage === 'function');
+export const HOST_RUNTIME = await (async () => {
+    if (IS_NODE) {
+        return (await import('./node/node.js')).HostRuntime.HOST_RUNTIME;
+    }
+    if (IS_BROWSER) {
+        return (await import('./browser/browser.js')).HostRuntime.HOST_RUNTIME;
+    }
+    throw new Error('Unknown runtime!');
+})();

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

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

@@ -0,0 +1,72 @@
+// 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 clamp = (num, min, max) => {
+    let clampedNumber = num;
+    if (num < min) {
+        clampedNumber = min;
+    }
+    else if (num > max) {
+        clampedNumber = max;
+    }
+    return clampedNumber;
+};
+export const mod = (m, n) => {
+    return ((m % n) + n) % n;
+};
+export const toFixedIfFloating = (value) => {
+    if (!value || Number.isNaN(Number(value))) {
+        return value;
+    }
+    const number = Number(value);
+    return number % 1 ? number.toFixed(3) : String(number);
+};
+/**
+ * Rounds a number (including float) down.
+ */
+export const floor = (value, precision = 0) => {
+    // Allows for rounding to the nearest whole number.
+    // Ex: 1 / 10 -> round down to nearest 10th place
+    // Ex: 1 / 5 -> round down to nearest 5
+    // Ex: 1 / 50 -> round down to nearest 50
+    if (precision > 0 && precision < 1) {
+        precision = 1 / precision;
+        return Math.floor(value / precision) * precision;
+    }
+    const mult = Math.pow(10, precision);
+    return Math.floor(value * mult) / mult;
+};
+/**
+ * Computes the great common divisor for two numbers.
+ * If the numbers are floats, they will be rounded to an integer.
+ */
+export const greatestCommonDivisor = (a, b) => {
+    a = Math.round(a);
+    b = Math.round(b);
+    while (b !== 0) {
+        const t = b;
+        b = a % b;
+        a = t;
+    }
+    return a;
+};
+const commonRatios = new Map([
+    ['8∶5', '16∶10'],
+]);
+export const aspectRatio = (width, height) => {
+    const divisor = greatestCommonDivisor(width, height);
+    if (divisor !== 0) {
+        width /= divisor;
+        height /= divisor;
+    }
+    const result = `${width}∶${height}`;
+    return commonRatios.get(result) || result;
+};
+export const withThousandsSeparator = function (num) {
+    let str = String(num);
+    const re = /(\d+)(\d{3})/;
+    while (str.match(re)) {
+        str = str.replace(re, '$1\xA0$2');
+    } // \xa0 is a non-breaking space
+    return str;
+};