chrome-devtools-mcp 0.0.1 → 0.0.2

package/build/node_modules/chrome-devtools-frontend/front_end/models/logs/RequestResolver.js

@@ -0,0 +1,49 @@
+// 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.
+import * as Common from '../../core/common/common.js';
+import { Events as NetworkLogEvents, NetworkLog } from './NetworkLog.js';
+/**
+ * A class that facilitates resolving a requestId to a network request. If the requestId does not resolve, a listener
+ * is installed on the network request to wait for the request to appear. This is useful if an attempt to resolve the
+ * requestId is made before the network request got reported.
+ *
+ * This functionality is intentionally provided in this class (instead of as part of NetworkLog) to enable clients
+ * to control the duration of the wait and the lifetime of the associated promises by using the `clear` method on
+ * this class.
+ */
+export class RequestResolver extends Common.ResolverBase.ResolverBase {
+    networkListener = null;
+    networkLog;
+    constructor(networkLog = NetworkLog.instance()) {
+        super();
+        this.networkLog = networkLog;
+    }
+    getForId(id) {
+        const requests = this.networkLog.requestsForId(id);
+        if (requests.length > 0) {
+            return requests[0];
+        }
+        return null;
+    }
+    onRequestAdded(event) {
+        const { request } = event.data;
+        const backendRequestId = request.backendRequestId();
+        if (backendRequestId) {
+            this.onResolve(backendRequestId, request);
+        }
+    }
+    startListening() {
+        if (this.networkListener) {
+            return;
+        }
+        this.networkListener = this.networkLog.addEventListener(NetworkLogEvents.RequestAdded, this.onRequestAdded, this);
+    }
+    stopListening() {
+        if (!this.networkListener) {
+            return;
+        }
+        Common.EventTarget.removeEventListeners([this.networkListener]);
+        this.networkListener = null;
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/logs/logs-meta.js

@@ -0,0 +1,73 @@
+// 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 Common from '../../core/common/common.js';
+import * as i18n from '../../core/i18n/i18n.js';
+const UIStrings = {
+    /**
+     * @description Text to preserve the log after refreshing
+     */
+    preserveLog: 'Preserve log',
+    /**
+     * @description A term that can be used to search in the command menu, and will find the search
+     * result 'Preserve log on page reload / navigation'. This is an additional search term to help
+     * user find the setting even when they don't know the exact name of it.
+     */
+    preserve: 'preserve',
+    /**
+     * @description A term that can be used to search in the command menu, and will find the search
+     * result 'Preserve log on page reload / navigation'. This is an additional search term to help
+     * user find the setting even when they don't know the exact name of it.
+     */
+    clear: 'clear',
+    /**
+     * @description A term that can be used to search in the command menu, and will find the search
+     * result 'Preserve log on page reload / navigation'. This is an additional search term to help
+     * user find the setting even when they don't know the exact name of it.
+     */
+    reset: 'reset',
+    /**
+     * @description Title of a setting under the Network category that can be invoked through the Command Menu
+     */
+    preserveLogOnPageReload: 'Preserve log on page reload / navigation',
+    /**
+     * @description Title of a setting under the Network category that can be invoked through the Command Menu
+     */
+    doNotPreserveLogOnPageReload: 'Do not preserve log on page reload / navigation',
+    /**
+     * @description Title of an action in the network tool to toggle recording
+     */
+    recordNetworkLog: 'Record network log',
+};
+const str_ = i18n.i18n.registerUIStrings('models/logs/logs-meta.ts', UIStrings);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+Common.Settings.registerSettingExtension({
+    category: "NETWORK" /* Common.Settings.SettingCategory.NETWORK */,
+    title: i18nLazyString(UIStrings.preserveLog),
+    settingName: 'network-log.preserve-log',
+    settingType: "boolean" /* Common.Settings.SettingType.BOOLEAN */,
+    defaultValue: false,
+    tags: [
+        i18nLazyString(UIStrings.preserve),
+        i18nLazyString(UIStrings.clear),
+        i18nLazyString(UIStrings.reset),
+    ],
+    options: [
+        {
+            value: true,
+            title: i18nLazyString(UIStrings.preserveLogOnPageReload),
+        },
+        {
+            value: false,
+            title: i18nLazyString(UIStrings.doNotPreserveLogOnPageReload),
+        },
+    ],
+});
+Common.Settings.registerSettingExtension({
+    category: "NETWORK" /* Common.Settings.SettingCategory.NETWORK */,
+    title: i18nLazyString(UIStrings.recordNetworkLog),
+    settingName: 'network-log.record-log',
+    settingType: "boolean" /* Common.Settings.SettingType.BOOLEAN */,
+    defaultValue: true,
+    storageType: "Session" /* Common.Settings.SettingStorageType.SESSION */,
+});

package/build/node_modules/chrome-devtools-frontend/front_end/models/logs/logs.js

@@ -0,0 +1,7 @@
+// 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 LogManager from './LogManager.js';
+import * as NetworkLog from './NetworkLog.js';
+import * as RequestResolver from './RequestResolver.js';
+export { LogManager, NetworkLog, RequestResolver };

package/build/node_modules/chrome-devtools-frontend/front_end/models/network_time_calculator/Calculator.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/models/network_time_calculator/NetworkTimeCalculator.js

@@ -0,0 +1,256 @@
+// 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.
+/*
+ * Copyright (C) 2007, 2008 Apple Inc.  All rights reserved.
+ * Copyright (C) 2008, 2009 Anthony Ricaud <rik@webkit.org>
+ * Copyright (C) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import * as Common from '../../core/common/common.js';
+import * as i18n from '../../core/i18n/i18n.js';
+const UIStrings = {
+    /**
+     * @description Latency download total format in Network Time Calculator of the Network panel
+     * @example {20ms} PH1
+     * @example {20ms} PH2
+     * @example {40ms} PH3
+     */
+    sLatencySDownloadSTotal: '{PH1} latency, {PH2} download ({PH3} total)',
+    /**
+     * @description Latency format in Network Time Calculator of the Network panel
+     * @example {20ms} PH1
+     */
+    sLatency: '{PH1} latency',
+    /**
+     * @description Duration of the download in ms/s shown for a completed network request.
+     * @example {5ms} PH1
+     */
+    sDownload: '{PH1} download',
+    /**
+     * @description From service worker format in Network Time Calculator of the Network panel
+     * @example {20ms latency} PH1
+     */
+    sFromServiceworker: '{PH1} (from `ServiceWorker`)',
+    /**
+     * @description From cache format in Network Time Calculator of the Network panel
+     * @example {20ms latency} PH1
+     */
+    sFromCache: '{PH1} (from cache)',
+};
+const str_ = i18n.i18n.registerUIStrings('models/network_time_calculator/NetworkTimeCalculator.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class NetworkTimeBoundary {
+    minimum;
+    maximum;
+    constructor(minimum, maximum) {
+        this.minimum = minimum;
+        this.maximum = maximum;
+    }
+    equals(other) {
+        return (this.minimum === other.minimum) && (this.maximum === other.maximum);
+    }
+}
+export class NetworkTimeCalculator extends Common.ObjectWrapper.ObjectWrapper {
+    #minimumBoundary = -1;
+    #maximumBoundary = -1;
+    #boundaryChangedEventThrottler = new Common.Throttler.Throttler(0);
+    #window = null;
+    #workingArea;
+    startAtZero;
+    constructor(startAtZero) {
+        super();
+        this.startAtZero = startAtZero;
+    }
+    setWindow(window) {
+        this.#window = window;
+        this.boundaryChanged();
+    }
+    computePosition(time) {
+        return (time - this.minimumBoundary()) / this.boundarySpan() * (this.#workingArea || 0);
+    }
+    formatValue(value, precision) {
+        return i18n.TimeUtilities.secondsToString(value, Boolean(precision));
+    }
+    minimumBoundary() {
+        return this.#window ? this.#window.minimum : this.#minimumBoundary;
+    }
+    zeroTime() {
+        return this.#minimumBoundary;
+    }
+    maximumBoundary() {
+        return this.#window ? this.#window.maximum : this.#maximumBoundary;
+    }
+    boundary() {
+        return new NetworkTimeBoundary(this.minimumBoundary(), this.maximumBoundary());
+    }
+    boundarySpan() {
+        return this.maximumBoundary() - this.minimumBoundary();
+    }
+    reset() {
+        this.#minimumBoundary = -1;
+        this.#maximumBoundary = -1;
+        this.boundaryChanged();
+    }
+    value() {
+        return 0;
+    }
+    setDisplayWidth(clientWidth) {
+        this.#workingArea = clientWidth;
+    }
+    computeBarGraphPercentages(request) {
+        let start;
+        let middle;
+        let end;
+        if (request.startTime !== -1) {
+            start = ((request.startTime - this.minimumBoundary()) / this.boundarySpan()) * 100;
+        }
+        else {
+            start = 0;
+        }
+        if (request.responseReceivedTime !== -1) {
+            middle = ((request.responseReceivedTime - this.minimumBoundary()) / this.boundarySpan()) * 100;
+        }
+        else {
+            middle = (this.startAtZero ? start : 100);
+        }
+        if (request.endTime !== -1) {
+            end = ((request.endTime - this.minimumBoundary()) / this.boundarySpan()) * 100;
+        }
+        else {
+            end = (this.startAtZero ? middle : 100);
+        }
+        if (this.startAtZero) {
+            end -= start;
+            middle -= start;
+            start = 0;
+        }
+        return { start, middle, end };
+    }
+    boundaryChanged() {
+        void this.#boundaryChangedEventThrottler.schedule(async () => {
+            this.dispatchEventToListeners("BoundariesChanged" /* Events.BOUNDARIES_CHANGED */);
+        });
+    }
+    updateBoundariesForEventTime(eventTime) {
+        if (eventTime === -1 || this.startAtZero) {
+            return;
+        }
+        if (this.#maximumBoundary === undefined || eventTime > this.#maximumBoundary) {
+            this.#maximumBoundary = eventTime;
+            this.boundaryChanged();
+        }
+    }
+    computeBarGraphLabels(request) {
+        let rightLabel = '';
+        if (request.responseReceivedTime !== -1 && request.endTime !== -1) {
+            rightLabel = i18n.TimeUtilities.secondsToString(request.endTime - request.responseReceivedTime);
+        }
+        const hasLatency = request.latency > 0;
+        const leftLabel = hasLatency ? i18n.TimeUtilities.secondsToString(request.latency) : rightLabel;
+        if (request.timing) {
+            return { left: leftLabel, right: rightLabel, tooltip: undefined };
+        }
+        let tooltip;
+        if (hasLatency && rightLabel) {
+            const total = i18n.TimeUtilities.secondsToString(request.duration);
+            tooltip = i18nString(UIStrings.sLatencySDownloadSTotal, { PH1: leftLabel, PH2: rightLabel, PH3: total });
+        }
+        else if (hasLatency) {
+            tooltip = i18nString(UIStrings.sLatency, { PH1: leftLabel });
+        }
+        else if (rightLabel) {
+            tooltip = i18nString(UIStrings.sDownload, { PH1: rightLabel });
+        }
+        if (request.fetchedViaServiceWorker) {
+            tooltip = i18nString(UIStrings.sFromServiceworker, { PH1: String(tooltip) });
+        }
+        else if (request.cached()) {
+            tooltip = i18nString(UIStrings.sFromCache, { PH1: String(tooltip) });
+        }
+        return { left: leftLabel, right: rightLabel, tooltip };
+    }
+    updateBoundaries(request) {
+        const lowerBound = this.lowerBound(request);
+        const upperBound = this.upperBound(request);
+        let changed = false;
+        if (lowerBound !== -1 || this.startAtZero) {
+            changed = this.extendBoundariesToIncludeTimestamp(this.startAtZero ? 0 : lowerBound);
+        }
+        if (upperBound !== -1) {
+            changed = this.extendBoundariesToIncludeTimestamp(upperBound) || changed;
+        }
+        if (changed) {
+            this.boundaryChanged();
+        }
+    }
+    extendBoundariesToIncludeTimestamp(timestamp) {
+        const previousMinimumBoundary = this.#minimumBoundary;
+        const previousMaximumBoundary = this.#maximumBoundary;
+        const minOffset = MINIMUM_SPREAD;
+        if (this.#minimumBoundary === -1 || this.#maximumBoundary === -1) {
+            this.#minimumBoundary = timestamp;
+            this.#maximumBoundary = timestamp + minOffset;
+        }
+        else {
+            this.#minimumBoundary = Math.min(timestamp, this.#minimumBoundary);
+            this.#maximumBoundary = Math.max(timestamp, this.#minimumBoundary + minOffset, this.#maximumBoundary);
+        }
+        return previousMinimumBoundary !== this.#minimumBoundary || previousMaximumBoundary !== this.#maximumBoundary;
+    }
+    lowerBound(_request) {
+        return 0;
+    }
+    upperBound(_request) {
+        return 0;
+    }
+}
+const MINIMUM_SPREAD = 0.1;
+export class NetworkTransferTimeCalculator extends NetworkTimeCalculator {
+    constructor() {
+        super(false);
+    }
+    formatValue(value, precision) {
+        return i18n.TimeUtilities.secondsToString(value - this.zeroTime(), Boolean(precision));
+    }
+    lowerBound(request) {
+        return request.issueTime();
+    }
+    upperBound(request) {
+        return request.endTime;
+    }
+}
+export class NetworkTransferDurationCalculator extends NetworkTimeCalculator {
+    constructor() {
+        super(true);
+    }
+    formatValue(value, precision) {
+        return i18n.TimeUtilities.secondsToString(value, Boolean(precision));
+    }
+    upperBound(request) {
+        return request.duration;
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/network_time_calculator/RequestTimeRanges.js

@@ -0,0 +1,120 @@
+// 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 const ServiceWorkerRangeNames = new Set([
+    "serviceworker" /* RequestTimeRangeNames.SERVICE_WORKER */,
+    "serviceworker-preparation" /* RequestTimeRangeNames.SERVICE_WORKER_PREPARATION */,
+    "serviceworker-respondwith" /* RequestTimeRangeNames.SERVICE_WORKER_RESPOND_WITH */,
+    "serviceworker-routerevaluation" /* RequestTimeRangeNames.SERVICE_WORKER_ROUTER_EVALUATION */,
+    "serviceworker-cachelookup" /* RequestTimeRangeNames.SERVICE_WORKER_CACHE_LOOKUP */,
+]);
+export const ConnectionSetupRangeNames = new Set([
+    "queueing" /* RequestTimeRangeNames.QUEUEING */,
+    "blocking" /* RequestTimeRangeNames.BLOCKING */,
+    "connecting" /* RequestTimeRangeNames.CONNECTING */,
+    "dns" /* RequestTimeRangeNames.DNS */,
+    "proxy" /* RequestTimeRangeNames.PROXY */,
+    "ssl" /* RequestTimeRangeNames.SSL */,
+]);
+export function calculateRequestTimeRanges(request, navigationStart) {
+    const result = [];
+    function addRange(name, start, end) {
+        if (start < Number.MAX_VALUE && start <= end) {
+            result.push({ name, start, end });
+        }
+    }
+    function firstPositive(numbers) {
+        for (let i = 0; i < numbers.length; ++i) {
+            if (numbers[i] > 0) {
+                return numbers[i];
+            }
+        }
+        return undefined;
+    }
+    function addOffsetRange(name, start, end) {
+        if (start >= 0 && end >= 0) {
+            addRange(name, startTime + (start / 1000), startTime + (end / 1000));
+        }
+    }
+    // In some situations, argument `start` may come before `startTime` (`timing.requestStart`). This is especially true
+    // in cases such as SW static routing API where fields like `workerRouterEvaluationStart` or `workerCacheLookupStart`
+    // is set before setting `timing.requestStart`. If the `start` and `end` is known to be a valid value (i.e. not default
+    // invalid value -1 or undefined), we allow adding the range.
+    function addMaybeNegativeOffsetRange(name, start, end) {
+        addRange(name, startTime + (start / 1000), startTime + (end / 1000));
+    }
+    const timing = request.timing;
+    if (!timing) {
+        const start = request.issueTime() !== -1 ? request.issueTime() : request.startTime !== -1 ? request.startTime : 0;
+        const hasDifferentIssueAndStartTime = request.issueTime() !== -1 && request.startTime !== -1 && request.issueTime() !== request.startTime;
+        const middle = (request.responseReceivedTime === -1) ?
+            (hasDifferentIssueAndStartTime ? request.startTime : Number.MAX_VALUE) :
+            request.responseReceivedTime;
+        const end = (request.endTime === -1) ? Number.MAX_VALUE : request.endTime;
+        addRange("total" /* RequestTimeRangeNames.TOTAL */, start, end);
+        addRange("blocking" /* RequestTimeRangeNames.BLOCKING */, start, middle);
+        const state = request.responseReceivedTime === -1 ? "connecting" /* RequestTimeRangeNames.CONNECTING */ : "receiving" /* RequestTimeRangeNames.RECEIVING */;
+        addRange(state, middle, end);
+        return result;
+    }
+    const issueTime = request.issueTime();
+    const startTime = timing.requestTime;
+    const endTime = firstPositive([request.endTime, request.responseReceivedTime]) || startTime;
+    addRange("total" /* RequestTimeRangeNames.TOTAL */, issueTime < startTime ? issueTime : startTime, endTime);
+    if (timing.pushStart) {
+        const pushEnd = timing.pushEnd || endTime;
+        // Only show the part of push that happened after the navigation/reload.
+        // Pushes that happened on the same connection before we started main request will not be shown.
+        if (pushEnd > navigationStart) {
+            addRange("push" /* RequestTimeRangeNames.PUSH */, Math.max(timing.pushStart, navigationStart), pushEnd);
+        }
+    }
+    if (issueTime < startTime) {
+        addRange("queueing" /* RequestTimeRangeNames.QUEUEING */, issueTime, startTime);
+    }
+    const responseReceived = (request.responseReceivedTime - startTime) * 1000;
+    if (request.fetchedViaServiceWorker) {
+        addOffsetRange("blocking" /* RequestTimeRangeNames.BLOCKING */, 0, timing.workerStart);
+        addOffsetRange("serviceworker-preparation" /* RequestTimeRangeNames.SERVICE_WORKER_PREPARATION */, timing.workerStart, timing.workerReady);
+        addOffsetRange("serviceworker-respondwith" /* RequestTimeRangeNames.SERVICE_WORKER_RESPOND_WITH */, timing.workerFetchStart, timing.workerRespondWithSettled);
+        addOffsetRange("serviceworker" /* RequestTimeRangeNames.SERVICE_WORKER */, timing.workerReady, timing.sendEnd);
+        addOffsetRange("waiting" /* RequestTimeRangeNames.WAITING */, timing.sendEnd, responseReceived);
+    }
+    else if (!timing.pushStart) {
+        const blockingEnd = firstPositive([timing.dnsStart, timing.connectStart, timing.sendStart, responseReceived]) || 0;
+        addOffsetRange("blocking" /* RequestTimeRangeNames.BLOCKING */, 0, blockingEnd);
+        addOffsetRange("proxy" /* RequestTimeRangeNames.PROXY */, timing.proxyStart, timing.proxyEnd);
+        addOffsetRange("dns" /* RequestTimeRangeNames.DNS */, timing.dnsStart, timing.dnsEnd);
+        addOffsetRange("connecting" /* RequestTimeRangeNames.CONNECTING */, timing.connectStart, timing.connectEnd);
+        addOffsetRange("ssl" /* RequestTimeRangeNames.SSL */, timing.sslStart, timing.sslEnd);
+        addOffsetRange("sending" /* RequestTimeRangeNames.SENDING */, timing.sendStart, timing.sendEnd);
+        addOffsetRange("waiting" /* RequestTimeRangeNames.WAITING */, Math.max(timing.sendEnd, timing.connectEnd, timing.dnsEnd, timing.proxyEnd, blockingEnd), responseReceived);
+    }
+    const { serviceWorkerRouterInfo } = request;
+    if (serviceWorkerRouterInfo) {
+        if (timing.workerRouterEvaluationStart) {
+            // Depending on the source,the next timestamp will be different. Determine the timestamp by checking
+            // the matched and actual source.
+            let routerEvaluationEnd = timing.sendStart;
+            if (serviceWorkerRouterInfo?.matchedSourceType === "cache" /* Protocol.Network.ServiceWorkerRouterSource.Cache */ &&
+                timing.workerCacheLookupStart) {
+                routerEvaluationEnd = timing.workerCacheLookupStart;
+            }
+            else if (serviceWorkerRouterInfo?.actualSourceType === "fetch-event" /* Protocol.Network.ServiceWorkerRouterSource.FetchEvent */) {
+                routerEvaluationEnd = timing.workerStart;
+            }
+            addMaybeNegativeOffsetRange("serviceworker-routerevaluation" /* RequestTimeRangeNames.SERVICE_WORKER_ROUTER_EVALUATION */, timing.workerRouterEvaluationStart, routerEvaluationEnd);
+        }
+        if (timing.workerCacheLookupStart) {
+            let cacheLookupEnd = timing.sendStart;
+            if (serviceWorkerRouterInfo?.actualSourceType === "cache" /* Protocol.Network.ServiceWorkerRouterSource.Cache */) {
+                cacheLookupEnd = timing.receiveHeadersStart;
+            }
+            addMaybeNegativeOffsetRange("serviceworker-cachelookup" /* RequestTimeRangeNames.SERVICE_WORKER_CACHE_LOOKUP */, timing.workerCacheLookupStart, cacheLookupEnd);
+        }
+    }
+    if (request.endTime !== -1) {
+        addRange(timing.pushStart ? "receiving-push" /* RequestTimeRangeNames.RECEIVING_PUSH */ : "receiving" /* RequestTimeRangeNames.RECEIVING */, request.responseReceivedTime, endTime);
+    }
+    return result;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/network_time_calculator/network_time_calculator.js

@@ -0,0 +1,6 @@
+// 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 * from './Calculator.js';
+export * from './NetworkTimeCalculator.js';
+export * from './RequestTimeRanges.js';

package/build/node_modules/chrome-devtools-frontend/front_end/models/text_utils/CodeMirrorUtils.js

@@ -0,0 +1,32 @@
+// 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.
+import * as CodeMirror from '../../third_party/codemirror.next/codemirror.next.js';
+export function createCssTokenizer() {
+    async function tokenize(line, callback) {
+        const streamParser = await CodeMirror.cssStreamParser();
+        const stream = new CodeMirror.StringStream(line, 4, 2);
+        const state = streamParser.startState(2);
+        let lastPos = stream.pos;
+        while (!stream.eol()) {
+            stream.start = lastPos;
+            let tokenType = streamParser.token(stream, state);
+            /**
+             * We expect unknown properties (like `unknownProp: unknownPropVal`) to still be
+             * formatted correctly. However, `tokenType` for such properties are marked
+             * as `error` from CodeMirror side and the internal state of the parser becomes `maybeprop`.
+             *
+             * So, we handle that specific keyword to be marked as `property` even though it is
+             * not a known property. We do this because for our formatting purposes it doesn't matter
+             * whether a property is a known CSS property or not.
+             */
+            if (tokenType === 'error' && state.state === 'maybeprop') {
+                tokenType = 'property';
+            }
+            const segment = stream.current();
+            callback(segment, tokenType);
+            lastPos = stream.pos;
+        }
+    }
+    return tokenize;
+}