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

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

@@ -0,0 +1,24 @@
+// 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.
+const registeredLateInitializationRunnables = new Map();
+export function registerLateInitializationRunnable(setting) {
+    const { id, loadRunnable } = setting;
+    if (registeredLateInitializationRunnables.has(id)) {
+        throw new Error(`Duplicate late Initializable runnable id '${id}'`);
+    }
+    registeredLateInitializationRunnables.set(id, loadRunnable);
+}
+export function maybeRemoveLateInitializationRunnable(runnableId) {
+    return registeredLateInitializationRunnables.delete(runnableId);
+}
+export function lateInitializationRunnables() {
+    return [...registeredLateInitializationRunnables.values()];
+}
+const registeredEarlyInitializationRunnables = [];
+export function registerEarlyInitializationRunnable(runnable) {
+    registeredEarlyInitializationRunnables.push(runnable);
+}
+export function earlyInitializationRunnables() {
+    return registeredEarlyInitializationRunnables;
+}

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

@@ -0,0 +1,78 @@
+// Copyright 2016 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 Platform from '../platform/platform.js';
+export class Segment {
+    begin;
+    end;
+    data;
+    constructor(begin, end, data) {
+        if (begin > end) {
+            throw new Error('Invalid segment');
+        }
+        this.begin = begin;
+        this.end = end;
+        this.data = data;
+    }
+    intersects(that) {
+        return this.begin < that.end && that.begin < this.end;
+    }
+}
+export class SegmentedRange {
+    #segments = [];
+    #mergeCallback;
+    constructor(mergeCallback) {
+        this.#mergeCallback = mergeCallback;
+    }
+    append(newSegment) {
+        // 1. Find the proper insertion point for new segment
+        let startIndex = Platform.ArrayUtilities.lowerBound(this.#segments, newSegment, (a, b) => a.begin - b.begin);
+        let endIndex = startIndex;
+        let merged = null;
+        if (startIndex > 0) {
+            // 2. Try mering the preceding segment
+            const precedingSegment = this.#segments[startIndex - 1];
+            merged = this.tryMerge(precedingSegment, newSegment);
+            if (merged) {
+                --startIndex;
+                newSegment = merged;
+            }
+            else if (this.#segments[startIndex - 1].end >= newSegment.begin) {
+                // 2a. If merge failed and segments overlap, adjust preceding segment.
+                // If an old segment entirely contains new one, split it in two.
+                if (newSegment.end < precedingSegment.end) {
+                    this.#segments.splice(startIndex, 0, new Segment(newSegment.end, precedingSegment.end, precedingSegment.data));
+                }
+                precedingSegment.end = newSegment.begin;
+            }
+        }
+        // 3. Consume all segments that are entirely covered by the new one.
+        while (endIndex < this.#segments.length && this.#segments[endIndex].end <= newSegment.end) {
+            ++endIndex;
+        }
+        // 4. Merge or adjust the succeeding segment if it overlaps.
+        if (endIndex < this.#segments.length) {
+            merged = this.tryMerge(newSegment, this.#segments[endIndex]);
+            if (merged) {
+                endIndex++;
+                newSegment = merged;
+            }
+            else if (newSegment.intersects(this.#segments[endIndex])) {
+                this.#segments[endIndex].begin = newSegment.end;
+            }
+        }
+        this.#segments.splice(startIndex, endIndex - startIndex, newSegment);
+    }
+    segments() {
+        return this.#segments;
+    }
+    tryMerge(first, second) {
+        const merged = this.#mergeCallback && this.#mergeCallback(first, second);
+        if (!merged) {
+            return null;
+        }
+        merged.begin = first.begin;
+        merged.end = Math.max(first.end, second.end);
+        return merged;
+    }
+}

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

@@ -0,0 +1,164 @@
+// 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.
+import * as i18n from '../i18n/i18n.js';
+import * as Root from '../root/root.js';
+const UIStrings = {
+    /**
+     * @description Title of the Elements Panel
+     */
+    elements: 'Elements',
+    /**
+     * @description Text for DevTools AI
+     */
+    ai: 'AI',
+    /**
+     * @description Text for DevTools appearance
+     */
+    appearance: 'Appearance',
+    /**
+     * @description Name of the Sources panel
+     */
+    sources: 'Sources',
+    /**
+     * @description Title of the Network tool
+     */
+    network: 'Network',
+    /**
+     * @description Text for the performance of something
+     */
+    performance: 'Performance',
+    /**
+     * @description Title of the Console tool
+     */
+    console: 'Console',
+    /**
+     * @description A title of the 'Persistence' setting category
+     */
+    persistence: 'Persistence',
+    /**
+     * @description Text that refers to the debugger
+     */
+    debugger: 'Debugger',
+    /**
+     * @description Text describing global shortcuts and settings that are available throughout the DevTools
+     */
+    global: 'Global',
+    /**
+     * @description Title of the Rendering tool
+     */
+    rendering: 'Rendering',
+    /**
+     * @description Title of a section on CSS Grid tooling
+     */
+    grid: 'Grid',
+    /**
+     * @description Text for the mobile platform, as opposed to desktop
+     */
+    mobile: 'Mobile',
+    /**
+     * @description Text for the memory of the page
+     */
+    memory: 'Memory',
+    /**
+     * @description Text for the extension of the page
+     */
+    extension: 'Extension',
+    /**
+     * @description Text for the adorner of the page
+     */
+    adorner: 'Adorner',
+    /**
+     * @description Header for the "Account" section in the settings UI. The "Account"
+     * section allows users see their signed in account and configure which DevTools data is synced via Chrome Sync.
+     */
+    account: 'Account',
+    /**
+     * @description Text for the privacy section of the page.
+     */
+    privacy: 'Privacy',
+};
+const str_ = i18n.i18n.registerUIStrings('core/common/SettingRegistration.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+let registeredSettings = [];
+const settingNameSet = new Set();
+export function registerSettingExtension(registration) {
+    const settingName = registration.settingName;
+    if (settingNameSet.has(settingName)) {
+        throw new Error(`Duplicate setting name '${settingName}'`);
+    }
+    settingNameSet.add(settingName);
+    registeredSettings.push(registration);
+}
+export function getRegisteredSettings() {
+    return registeredSettings.filter(setting => Root.Runtime.Runtime.isDescriptorEnabled(setting));
+}
+export function registerSettingsForTest(settings, forceReset = false) {
+    if (registeredSettings.length === 0 || forceReset) {
+        registeredSettings = settings;
+        settingNameSet.clear();
+        for (const setting of settings) {
+            const settingName = setting.settingName;
+            if (settingNameSet.has(settingName)) {
+                throw new Error(`Duplicate setting name '${settingName}'`);
+            }
+            settingNameSet.add(settingName);
+        }
+    }
+}
+export function resetSettings() {
+    registeredSettings = [];
+    settingNameSet.clear();
+}
+export function maybeRemoveSettingExtension(settingName) {
+    const settingIndex = registeredSettings.findIndex(setting => setting.settingName === settingName);
+    if (settingIndex < 0 || !settingNameSet.delete(settingName)) {
+        return false;
+    }
+    registeredSettings.splice(settingIndex, 1);
+    return true;
+}
+export function getLocalizedSettingsCategory(category) {
+    switch (category) {
+        case "ELEMENTS" /* SettingCategory.ELEMENTS */:
+            return i18nString(UIStrings.elements);
+        case "AI" /* SettingCategory.AI */:
+            return i18nString(UIStrings.ai);
+        case "APPEARANCE" /* SettingCategory.APPEARANCE */:
+            return i18nString(UIStrings.appearance);
+        case "SOURCES" /* SettingCategory.SOURCES */:
+            return i18nString(UIStrings.sources);
+        case "NETWORK" /* SettingCategory.NETWORK */:
+            return i18nString(UIStrings.network);
+        case "PERFORMANCE" /* SettingCategory.PERFORMANCE */:
+            return i18nString(UIStrings.performance);
+        case "CONSOLE" /* SettingCategory.CONSOLE */:
+            return i18nString(UIStrings.console);
+        case "PERSISTENCE" /* SettingCategory.PERSISTENCE */:
+            return i18nString(UIStrings.persistence);
+        case "DEBUGGER" /* SettingCategory.DEBUGGER */:
+            return i18nString(UIStrings.debugger);
+        case "GLOBAL" /* SettingCategory.GLOBAL */:
+            return i18nString(UIStrings.global);
+        case "RENDERING" /* SettingCategory.RENDERING */:
+            return i18nString(UIStrings.rendering);
+        case "GRID" /* SettingCategory.GRID */:
+            return i18nString(UIStrings.grid);
+        case "MOBILE" /* SettingCategory.MOBILE */:
+            return i18nString(UIStrings.mobile);
+        case "EMULATION" /* SettingCategory.EMULATION */:
+            return i18nString(UIStrings.console);
+        case "MEMORY" /* SettingCategory.MEMORY */:
+            return i18nString(UIStrings.memory);
+        case "EXTENSIONS" /* SettingCategory.EXTENSIONS */:
+            return i18nString(UIStrings.extension);
+        case "ADORNER" /* SettingCategory.ADORNER */:
+            return i18nString(UIStrings.adorner);
+        case "" /* SettingCategory.NONE */:
+            return i18n.i18n.lockedString('');
+        case "ACCOUNT" /* SettingCategory.ACCOUNT */:
+            return i18nString(UIStrings.account);
+        case "PRIVACY" /* SettingCategory.PRIVACY */:
+            return i18nString(UIStrings.privacy);
+    }
+}