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

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,122 @@
+// 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/source_map_scopes/FunctionCodeResolver.js

@@ -0,0 +1,192 @@
+// 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.
+import * as SDK from '../../core/sdk/sdk.js';
+import * as Bindings from '../bindings/bindings.js';
+import * as Formatter from '../formatter/formatter.js';
+import * as TextUtils from '../text_utils/text_utils.js';
+import * as Workspace from '../workspace/workspace.js';
+const inputCache = new WeakMap();
+async function prepareInput(uiSourceCode, content) {
+    const formattedContent = await format(uiSourceCode, content);
+    const text = new TextUtils.Text.Text(formattedContent ? formattedContent.formattedContent : content);
+    let performanceData = uiSourceCode.getDecorationData("performance" /* Workspace.UISourceCode.DecoratorType.PERFORMANCE */);
+    // Map profile data to the formatted view of the text.
+    if (formattedContent && performanceData) {
+        performanceData = Workspace.UISourceCode.createMappedProfileData(performanceData, (line, column) => {
+            return formattedContent.formattedMapping.originalToFormatted(line, column);
+        });
+    }
+    return { text, formattedContent, performanceData };
+}
+/** Formatting and parsing line endings for Text is expensive, so cache it. */
+async function prepareInputAndCache(uiSourceCode, content) {
+    let cachedPromise = inputCache.get(uiSourceCode);
+    if (cachedPromise) {
+        return await cachedPromise;
+    }
+    cachedPromise = prepareInput(uiSourceCode, content);
+    inputCache.set(uiSourceCode, cachedPromise);
+    return await cachedPromise;
+}
+function extractPerformanceDataByLine(textRange, performanceData) {
+    const { startLine, startColumn, endLine, endColumn } = textRange;
+    const byLine = new Array(endLine - startLine + 1).fill(0);
+    for (let line = startLine; line <= endLine; line++) {
+        const lineData = performanceData.get(line + 1);
+        if (!lineData) {
+            continue;
+        }
+        // Fast-path for when the entire line's data is relevant.
+        if (line !== startLine && line !== endLine) {
+            byLine[line - startLine] = lineData.values().reduce((acc, cur) => acc + cur);
+            continue;
+        }
+        const column0 = line === startLine ? startColumn + 1 : 0;
+        const column1 = line === endLine ? endColumn + 1 : Number.POSITIVE_INFINITY;
+        let totalData = 0;
+        for (const [column, data] of lineData) {
+            if (column >= column0 && column <= column1) {
+                totalData += data;
+            }
+        }
+        byLine[line - startLine] = totalData;
+    }
+    return byLine.map(data => Math.round(data * 10) / 10);
+}
+function createFunctionCode(inputData, functionBounds, options) {
+    let { startLine, startColumn, endLine, endColumn } = functionBounds.range;
+    if (inputData.formattedContent) {
+        const startMapped = inputData.formattedContent.formattedMapping.originalToFormatted(startLine, startColumn);
+        startLine = startMapped[0];
+        startColumn = startMapped[1];
+        const endMapped = inputData.formattedContent.formattedMapping.originalToFormatted(endLine, endColumn);
+        endLine = endMapped[0];
+        endColumn = endMapped[1];
+    }
+    const text = inputData.text;
+    const content = text.value();
+    // Define two ranges - the first is just the function bounds, the second includes
+    // that plus some surrounding context as dictated by the options.
+    const range = new TextUtils.TextRange.TextRange(startLine, startColumn, endLine, endColumn);
+    const functionStartOffset = text.offsetFromPosition(startLine, startColumn);
+    const functionEndOffset = text.offsetFromPosition(endLine, endColumn);
+    let contextStartOffset = 0;
+    if (options?.contextLength !== undefined) {
+        const contextLength = options.contextLength;
+        contextStartOffset = Math.max(contextStartOffset, functionStartOffset - contextLength);
+    }
+    if (options?.contextLineLength !== undefined) {
+        const contextLineLength = options.contextLineLength;
+        const position = text.offsetFromPosition(Math.max(startLine - contextLineLength, 0), 0);
+        contextStartOffset = Math.max(contextStartOffset, position);
+    }
+    let contextEndOffset = content.length;
+    if (options?.contextLength !== undefined) {
+        const contextLength = options.contextLength;
+        contextEndOffset = Math.min(contextEndOffset, functionEndOffset + contextLength);
+    }
+    if (options?.contextLineLength !== undefined) {
+        const contextLineLength = options.contextLineLength;
+        const position = text.offsetFromPosition(Math.min(endLine + contextLineLength, text.lineCount() - 1), Number.POSITIVE_INFINITY);
+        contextEndOffset = Math.min(contextEndOffset, position);
+    }
+    const contextStart = text.positionFromOffset(contextStartOffset);
+    const contextEnd = text.positionFromOffset(contextEndOffset);
+    const rangeWithContext = new TextUtils.TextRange.TextRange(contextStart.lineNumber, contextStart.columnNumber, contextEnd.lineNumber, contextEnd.columnNumber);
+    // Grab substrings for the function range, and for the context range.
+    const code = content.substring(functionStartOffset, functionEndOffset);
+    const before = content.substring(contextStartOffset, functionStartOffset);
+    const after = content.substring(functionEndOffset, contextEndOffset);
+    let codeWithContext;
+    if (options?.appendProfileData && inputData.performanceData) {
+        const performanceDataByLine = extractPerformanceDataByLine(range, inputData.performanceData);
+        const lines = performanceDataByLine.map((data, i) => {
+            let line = text.lineAt(startLine + i);
+            const isLastLine = i === performanceDataByLine.length - 1;
+            if (i === 0) {
+                if (isLastLine) {
+                    line = line.substring(startColumn, endColumn);
+                }
+                else {
+                    line = line.substring(startColumn);
+                }
+            }
+            else if (isLastLine) {
+                line = line.substring(0, endColumn);
+            }
+            if (isLastLine) {
+                // Don't ever annotate the last line - it could make the rest of the code on
+                // that line get commented out.
+                data = 0;
+            }
+            return data ? `${line} // ${data} ms` : line;
+        });
+        const annotatedCode = lines.join('\n');
+        codeWithContext = before + `<FUNCTION_START>${annotatedCode}<FUNCTION_END>` + after;
+    }
+    else {
+        codeWithContext = before + `<FUNCTION_START>${code}<FUNCTION_END>` + after;
+    }
+    return {
+        functionBounds,
+        text,
+        code,
+        range,
+        codeWithContext,
+        rangeWithContext,
+    };
+}
+/**
+ * The input location may be a source mapped location or a raw location.
+ */
+export async function getFunctionCodeFromLocation(target, url, line, column, options) {
+    const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
+    if (!debuggerModel) {
+        throw new Error('missing debugger model');
+    }
+    let uiSourceCode;
+    const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
+    const projects = debuggerWorkspaceBinding.workspace.projectsForType(Workspace.Workspace.projectTypes.Network);
+    for (const project of projects) {
+        uiSourceCode = project.uiSourceCodeForURL(url);
+        if (uiSourceCode) {
+            break;
+        }
+    }
+    if (!uiSourceCode) {
+        return null;
+    }
+    const rawLocations = await debuggerWorkspaceBinding.uiLocationToRawLocations(uiSourceCode, line, column);
+    const rawLocation = rawLocations.at(-1);
+    if (!rawLocation) {
+        return null;
+    }
+    return await getFunctionCodeFromRawLocation(rawLocation, options);
+}
+async function format(uiSourceCode, content) {
+    const contentType = uiSourceCode.contentType();
+    const shouldFormat = !contentType.isFromSourceMap() && (contentType.isDocument() || contentType.isScript()) &&
+        TextUtils.TextUtils.isMinified(content);
+    if (!shouldFormat) {
+        return null;
+    }
+    return await Formatter.ScriptFormatter.formatScriptContent(contentType.canonicalMimeType(), content, '\t');
+}
+/**
+ * Returns a {@link FunctionCode} for the given raw location.
+ */
+export async function getFunctionCodeFromRawLocation(rawLocation, options) {
+    const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
+    const functionBounds = await debuggerWorkspaceBinding.functionBoundsAtRawLocation(rawLocation);
+    if (!functionBounds) {
+        return null;
+    }
+    await functionBounds.uiSourceCode.requestContentData();
+    const content = functionBounds.uiSourceCode.content();
+    if (!content) {
+        return null;
+    }
+    const inputData = await prepareInputAndCache(functionBounds.uiSourceCode, content);
+    return createFunctionCode(inputData, functionBounds, options);
+}