@mcp-b/chrome-devtools-mcp 2.1.0 → 2.2.0

package/build/vendor/chrome-devtools-frontend/front_end/models/text_utils/TextUtils.js

@@ -1,355 +0,0 @@
-// Copyright 2013 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 '../../core/platform/platform.js';
-import { ContentData } from './ContentData.js';
-import { SearchMatch } from './ContentProvider.js';
-const KEY_VALUE_FILTER_REGEXP = /(?:^|\s)(\-)?([\w\-]+):([^\s]+)/;
-const REGEXP_FILTER_REGEXP = /(?:^|\s)(\-)?\/([^\/\\]+(\\.[^\/]*)*)\//;
-const TEXT_FILTER_REGEXP = /(?:^|\s)(\-)?([^\s]+)/;
-const SPACE_CHAR_REGEXP = /\s/;
-export const Utils = {
-    isSpaceChar: function (char) {
-        return SPACE_CHAR_REGEXP.test(char);
-    },
-    lineIndent: function (line) {
-        let indentation = 0;
-        while (indentation < line.length && Utils.isSpaceChar(line.charAt(indentation))) {
-            ++indentation;
-        }
-        return line.substr(0, indentation);
-    },
-    splitStringByRegexes(text, regexes) {
-        const matches = [];
-        const globalRegexes = [];
-        for (let i = 0; i < regexes.length; i++) {
-            const regex = regexes[i];
-            if (!regex.global) {
-                globalRegexes.push(new RegExp(regex.source, regex.flags ? regex.flags + 'g' : 'g'));
-            }
-            else {
-                globalRegexes.push(regex);
-            }
-        }
-        doSplit(text, 0, 0);
-        return matches;
-        function doSplit(text, regexIndex, startIndex) {
-            if (regexIndex >= globalRegexes.length) {
-                // Set regexIndex as -1 if text did not match with any regular expression
-                matches.push({ value: text, position: startIndex, regexIndex: -1, captureGroups: [] });
-                return;
-            }
-            const regex = globalRegexes[regexIndex];
-            let currentIndex = 0;
-            let result;
-            regex.lastIndex = 0;
-            while ((result = regex.exec(text)) !== null) {
-                const stringBeforeMatch = text.substring(currentIndex, result.index);
-                if (stringBeforeMatch) {
-                    doSplit(stringBeforeMatch, regexIndex + 1, startIndex + currentIndex);
-                }
-                const match = result[0];
-                matches.push({
-                    value: match,
-                    position: startIndex + result.index,
-                    regexIndex,
-                    captureGroups: result.slice(1),
-                });
-                currentIndex = result.index + match.length;
-            }
-            const stringAfterMatches = text.substring(currentIndex);
-            if (stringAfterMatches) {
-                doSplit(stringAfterMatches, regexIndex + 1, startIndex + currentIndex);
-            }
-        }
-    },
-};
-export class FilterParser {
-    keys;
-    constructor(keys) {
-        this.keys = keys;
-    }
-    static cloneFilter(filter) {
-        return { key: filter.key, text: filter.text, regex: filter.regex, negative: filter.negative };
-    }
-    parse(query) {
-        const splitFilters = Utils.splitStringByRegexes(query, [KEY_VALUE_FILTER_REGEXP, REGEXP_FILTER_REGEXP, TEXT_FILTER_REGEXP]);
-        const parsedFilters = [];
-        for (const { regexIndex, captureGroups } of splitFilters) {
-            if (regexIndex === -1) {
-                continue;
-            }
-            if (regexIndex === 0) {
-                const startsWithMinus = captureGroups[0];
-                const parsedKey = captureGroups[1];
-                const parsedValue = captureGroups[2];
-                if (this.keys.indexOf(parsedKey) !== -1) {
-                    parsedFilters.push({
-                        key: parsedKey,
-                        regex: undefined,
-                        text: parsedValue,
-                        negative: Boolean(startsWithMinus),
-                    });
-                }
-                else {
-                    parsedFilters.push({
-                        key: undefined,
-                        regex: undefined,
-                        text: `${parsedKey}:${parsedValue}`,
-                        negative: Boolean(startsWithMinus),
-                    });
-                }
-            }
-            else if (regexIndex === 1) {
-                const startsWithMinus = captureGroups[0];
-                const parsedRegex = captureGroups[1];
-                try {
-                    parsedFilters.push({
-                        key: undefined,
-                        regex: new RegExp(parsedRegex, 'im'),
-                        text: undefined,
-                        negative: Boolean(startsWithMinus),
-                    });
-                }
-                catch {
-                    parsedFilters.push({
-                        key: undefined,
-                        regex: undefined,
-                        text: `/${parsedRegex}/`,
-                        negative: Boolean(startsWithMinus),
-                    });
-                }
-            }
-            else if (regexIndex === 2) {
-                const startsWithMinus = captureGroups[0];
-                const parsedText = captureGroups[1];
-                parsedFilters.push({
-                    key: undefined,
-                    regex: undefined,
-                    text: parsedText,
-                    negative: Boolean(startsWithMinus),
-                });
-            }
-        }
-        return parsedFilters;
-    }
-}
-export class BalancedJSONTokenizer {
-    callback;
-    index;
-    balance;
-    buffer;
-    findMultiple;
-    closingDoubleQuoteRegex;
-    lastBalancedIndex;
-    constructor(callback, findMultiple) {
-        this.callback = callback;
-        this.index = 0;
-        this.balance = 0;
-        this.buffer = '';
-        this.findMultiple = findMultiple || false;
-        this.closingDoubleQuoteRegex = /[^\\](?:\\\\)*"/g;
-    }
-    write(chunk) {
-        this.buffer += chunk;
-        const lastIndex = this.buffer.length;
-        const buffer = this.buffer;
-        let index;
-        for (index = this.index; index < lastIndex; ++index) {
-            const character = buffer[index];
-            if (character === '"') {
-                this.closingDoubleQuoteRegex.lastIndex = index;
-                if (!this.closingDoubleQuoteRegex.test(buffer)) {
-                    break;
-                }
-                index = this.closingDoubleQuoteRegex.lastIndex - 1;
-            }
-            else if (character === '{') {
-                ++this.balance;
-            }
-            else if (character === '}') {
-                --this.balance;
-                if (this.balance < 0) {
-                    this.reportBalanced();
-                    return false;
-                }
-                if (!this.balance) {
-                    this.lastBalancedIndex = index + 1;
-                    if (!this.findMultiple) {
-                        break;
-                    }
-                }
-            }
-            else if (character === ']' && !this.balance) {
-                this.reportBalanced();
-                return false;
-            }
-        }
-        this.index = index;
-        this.reportBalanced();
-        return true;
-    }
-    reportBalanced() {
-        if (!this.lastBalancedIndex) {
-            return;
-        }
-        this.callback(this.buffer.slice(0, this.lastBalancedIndex));
-        this.buffer = this.buffer.slice(this.lastBalancedIndex);
-        this.index -= this.lastBalancedIndex;
-        this.lastBalancedIndex = 0;
-    }
-    remainder() {
-        return this.buffer;
-    }
-}
-/**
- * Detects the indentation used by a given text document, based on the _Comparing
- * lines_ approach suggested by Heather Arthur (and also found in Firefox DevTools).
- *
- * This implementation differs from the original proposal in that tab indentation
- * isn't detected by checking if at least 50% of the lines start with a tab, but
- * instead by comparing the number of lines that start with a tab to the frequency
- * of the other indentation patterns. This way we also detect small snippets with
- * long leading comments correctly, when tab indentation is used for the snippets
- * of code.
- *
- * @param lines The input document lines.
- * @returns The indentation detected for the lines as string or `null` if it's inconclusive.
- * @see https://heathermoor.medium.com/detecting-code-indentation-eff3ed0fb56b
- */
-export const detectIndentation = function (lines) {
-    const frequencies = [0, 0, 0, 0, 0, 0, 0, 0, 0];
-    let tabs = 0, previous = 0;
-    for (const line of lines) {
-        let current = 0;
-        if (line.length !== 0) {
-            let char = line.charAt(0);
-            if (char === '\t') {
-                tabs++;
-                continue;
-            }
-            while (char === ' ') {
-                char = line.charAt(++current);
-            }
-        }
-        if (current === line.length) {
-            // Don't consider empty lines.
-            previous = 0;
-            continue;
-        }
-        const delta = Math.abs(current - previous);
-        if (delta < frequencies.length) {
-            // Don't consider deltas above 8 characters.
-            frequencies[delta] = frequencies[delta] + 1;
-        }
-        previous = current;
-    }
-    // Find most frequent non-zero width difference between adjacent lines.
-    let mostFrequentDelta = 0, highestFrequency = 0;
-    for (let delta = 1; delta < frequencies.length; ++delta) {
-        const frequency = frequencies[delta];
-        if (frequency > highestFrequency) {
-            highestFrequency = frequency;
-            mostFrequentDelta = delta;
-        }
-    }
-    if (tabs > mostFrequentDelta) {
-        // If more lines start with tabs than any other indentation,
-        // we assume that the document was written with tab indentation
-        // in mind. This differs from the original algorithm.
-        return '\t';
-    }
-    if (!mostFrequentDelta) {
-        return null;
-    }
-    return ' '.repeat(mostFrequentDelta);
-};
-/**
- * Heuristic to check whether a given text was likely minified. Intended to
- * be used for HTML, CSS, and JavaScript inputs.
- *
- * A text is considered to be the result of minification if the average
- * line length for the whole text is 80 characters or more.
- *
- * @param text The input text to check.
- * @returns `true` if the heuristic considers `text` to be minified.
- */
-export const isMinified = function (text) {
-    let lineCount = 0;
-    for (let lastIndex = 0; lastIndex < text.length; ++lineCount) {
-        let eolIndex = text.indexOf('\n', lastIndex);
-        if (eolIndex < 0) {
-            eolIndex = text.length;
-        }
-        lastIndex = eolIndex + 1;
-    }
-    return (text.length - lineCount) / lineCount >= 80;
-};
-/**
- * Small wrapper around {@link performSearchInContent} to reduce boilerplate when searching
- * in {@link ContentDataOrError}.
- *
- * @returns empty search matches if `contentData` is an error or not text content.
- */
-export const performSearchInContentData = function (contentData, query, caseSensitive, isRegex) {
-    if (ContentData.isError(contentData) || !contentData.isTextContent) {
-        return [];
-    }
-    return performSearchInContent(contentData.textObj, query, caseSensitive, isRegex);
-};
-/**
- * @returns One {@link SearchMatch} per match. Multiple matches on the same line each
- * result in their own `SearchMatchExact` instance.
- */
-export const performSearchInContent = function (text, query, caseSensitive, isRegex) {
-    const regex = Platform.StringUtilities.createSearchRegex(query, caseSensitive, isRegex);
-    const result = [];
-    for (let i = 0; i < text.lineCount(); ++i) {
-        const lineContent = text.lineAt(i);
-        const matches = lineContent.matchAll(regex);
-        for (const match of matches) {
-            result.push(new SearchMatch(i, lineContent, match.index, match[0].length));
-        }
-    }
-    return result;
-};
-/**
- * Similar to {@link performSearchInContent} but doesn't search in a whole text but rather
- * finds the exact matches on a prelminiary search result (i.e. lines with known matches).
- * @param matches is deliberatedly typed as an object literal so we can pass the
- *                CDP search result type.
- */
-export const performSearchInSearchMatches = function (matches, query, caseSensitive, isRegex) {
-    const regex = Platform.StringUtilities.createSearchRegex(query, caseSensitive, isRegex);
-    const result = [];
-    for (const { lineNumber, lineContent } of matches) {
-        const matches = lineContent.matchAll(regex);
-        for (const match of matches) {
-            result.push(new SearchMatch(lineNumber, lineContent, match.index, match[0].length));
-        }
-    }
-    return result;
-};
-/**
- * Finds the longest overlapping string segment between the end of the first
- * string and the beginning of the second string.
- *
- * @param s1 The first string (whose suffix will be checked).
- * @param s2 The second string (whose prefix will be checked).
- * @returns The overlapping string segment, or an empty string ("")
- * if no overlap is found.
- */
-export const getOverlap = function (s1, s2) {
-    const minLen = Math.min(s1.length, s2.length);
-    // Check from longest possible overlap down to 1
-    for (let n = minLen; n > 0; n--) {
-        // slice(-n) gets the last 'n' chars
-        const suffix = s1.slice(-n);
-        // substring(0, n) gets the first 'n' chars
-        const prefix = s2.substring(0, n);
-        if (suffix === prefix) {
-            return suffix;
-        }
-    }
-    return null;
-};

package/build/vendor/chrome-devtools-frontend/front_end/models/text_utils/WasmDisassembly.js

@@ -1,68 +0,0 @@
-// Copyright 2024 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 '../../core/platform/platform.js';
-import { ContentData } from './ContentData.js';
-/**
- * Metadata to map between bytecode #offsets and line numbers in the
- * disassembly for WebAssembly modules.
- */
-export class WasmDisassembly extends ContentData {
-    lines;
-    #offsets;
-    #functionBodyOffsets;
-    // Wasm can be potentially very large, so we calculate `text' lazily.
-    #cachedText;
-    constructor(lines, offsets, functionBodyOffsets) {
-        super('', /* isBase64 */ false, 'text/x-wast', 'utf-8');
-        if (lines.length !== offsets.length) {
-            throw new Error('Lines and offsets don\'t match');
-        }
-        this.lines = lines;
-        this.#offsets = offsets;
-        this.#functionBodyOffsets = functionBodyOffsets;
-    }
-    get text() {
-        if (typeof this.#cachedText === 'undefined') {
-            this.#cachedText = this.lines.join('\n');
-        }
-        return this.#cachedText;
-    }
-    get isEmpty() {
-        // Don't trigger unnecessary concatenating. Only check whether we have no lines, or a single empty line.
-        return this.lines.length === 0 || (this.lines.length === 1 && this.lines[0].length === 0);
-    }
-    get lineNumbers() {
-        return this.#offsets.length;
-    }
-    bytecodeOffsetToLineNumber(bytecodeOffset) {
-        return Platform.ArrayUtilities.upperBound(this.#offsets, bytecodeOffset, Platform.ArrayUtilities.DEFAULT_COMPARATOR) -
-            1;
-    }
-    lineNumberToBytecodeOffset(lineNumber) {
-        return this.#offsets[lineNumber];
-    }
-    /**
-     * returns an iterable enumerating all the non-breakable line numbers in the disassembly
-     */
-    *nonBreakableLineNumbers() {
-        let lineNumber = 0;
-        let functionIndex = 0;
-        while (lineNumber < this.lineNumbers) {
-            if (functionIndex < this.#functionBodyOffsets.length) {
-                const offset = this.lineNumberToBytecodeOffset(lineNumber);
-                if (offset >= this.#functionBodyOffsets[functionIndex].start) {
-                    lineNumber = this.bytecodeOffsetToLineNumber(this.#functionBodyOffsets[functionIndex++].end) + 1;
-                    continue;
-                }
-            }
-            yield lineNumber++;
-        }
-    }
-    /**
-     * @deprecated Used during migration from `DeferredContent` to `ContentData`.
-     */
-    asDeferedContent() {
-        return { content: '', isEncoded: false, wasmDisassemblyInfo: this };
-    }
-}

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

@@ -1,14 +0,0 @@
-// 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 CodeMirrorUtils from './CodeMirrorUtils.js';
-import * as ContentData from './ContentData.js';
-import * as ContentProvider from './ContentProvider.js';
-import * as StaticContentProvider from './StaticContentProvider.js';
-import * as StreamingContentData from './StreamingContentData.js';
-import * as Text from './Text.js';
-import * as TextCursor from './TextCursor.js';
-import * as TextRange from './TextRange.js';
-import * as TextUtils from './TextUtils.js';
-import * as WasmDisassembly from './WasmDisassembly.js';
-export { CodeMirrorUtils, ContentData, ContentProvider, StaticContentProvider, StreamingContentData, Text, TextCursor, TextRange, TextUtils, WasmDisassembly, };

package/build/vendor/chrome-devtools-frontend/front_end/models/trace/EntityMapper.js

@@ -1,122 +0,0 @@
-// Copyright 2024 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 Handlers from './handlers/handlers.js';
-import * as Helpers from './helpers/helpers.js';
-export class EntityMapper {
-    #parsedTrace;
-    #entityMappings;
-    #firstPartyEntity;
-    #thirdPartyEvents = [];
-    /**
-     * When resolving urls and updating our entity mapping in the
-     * SourceMapsResolver, a single call frame can appear multiple times
-     * as different cpu profile nodes. To avoid duplicate work on the
-     * same CallFrame, we can keep track of them.
-     */
-    #resolvedCallFrames = new Set();
-    constructor(parsedTrace) {
-        this.#parsedTrace = parsedTrace;
-        this.#entityMappings = this.#parsedTrace.data.Renderer.entityMappings;
-        this.#firstPartyEntity = this.#findFirstPartyEntity();
-        this.#thirdPartyEvents = this.#getThirdPartyEvents();
-    }
-    #findFirstPartyEntity() {
-        // As a starting point, we consider the first navigation as the 1P.
-        const nav = Array.from(this.#parsedTrace.data.Meta.navigationsByNavigationId.values()).sort((a, b) => a.ts - b.ts)[0];
-        const firstPartyUrl = nav?.args.data?.documentLoaderURL ?? this.#parsedTrace.data.Meta.mainFrameURL;
-        if (!firstPartyUrl) {
-            return null;
-        }
-        return Handlers.Helpers.getEntityForUrl(firstPartyUrl, this.#entityMappings) ?? null;
-    }
-    #getThirdPartyEvents() {
-        const entries = Array.from(this.#entityMappings.eventsByEntity.entries());
-        const thirdPartyEvents = entries.flatMap(([entity, events]) => {
-            return entity !== this.#firstPartyEntity ? events : [];
-        });
-        return thirdPartyEvents;
-    }
-    /**
-     * Returns an entity for a given event if any.
-     */
-    entityForEvent(event) {
-        return this.#entityMappings.entityByEvent.get(event) ?? null;
-    }
-    /**
-     * Returns trace events that correspond with a given entity if any.
-     */
-    eventsForEntity(entity) {
-        return this.#entityMappings.eventsByEntity.get(entity) ?? [];
-    }
-    firstPartyEntity() {
-        return this.#firstPartyEntity;
-    }
-    thirdPartyEvents() {
-        return this.#thirdPartyEvents;
-    }
-    mappings() {
-        return this.#entityMappings;
-    }
-    /**
-     * This updates entity mapping given a callFrame and sourceURL (newly resolved),
-     * updating both eventsByEntity and entityByEvent. The call frame provides us the
-     * URL and sourcemap source location that events map to. This describes the exact events we
-     * want to update. We then update the events with the new sourceURL.
-     *
-     * compiledURLs -> the actual file's url (e.g. my-big-bundle.min.js)
-     * sourceURLs -> the resolved urls (e.g. react.development.js, my-app.ts)
-     * @param callFrame
-     * @param sourceURL
-     */
-    updateSourceMapEntities(callFrame, sourceURL) {
-        // Avoid the extra work, if we have already resolved this callFrame.
-        if (this.#resolvedCallFrames.has(callFrame)) {
-            return;
-        }
-        const compiledURL = callFrame.url;
-        const currentEntity = Handlers.Helpers.getEntityForUrl(compiledURL, this.#entityMappings);
-        const resolvedEntity = Handlers.Helpers.getEntityForUrl(sourceURL, this.#entityMappings);
-        // If the entity changed, then we should update our caches. If we don't have a currentEntity,
-        // we can't do much with that. Additionally without our current entity, we don't have a reference to the related
-        // events so there are no relationships to be made.
-        if ((resolvedEntity === currentEntity) || (!currentEntity || !resolvedEntity)) {
-            return;
-        }
-        const currentEntityEvents = (currentEntity && this.#entityMappings.eventsByEntity.get(currentEntity)) ?? [];
-        // The events of the entity that match said source location.
-        const sourceLocationEvents = [];
-        // The events that don't match the source location, but that we should keep mapped to its current entity.
-        const unrelatedEvents = [];
-        currentEntityEvents?.forEach(e => {
-            const cf = Helpers.Trace.getStackTraceTopCallFrameInEventPayload(e);
-            const matchesCallFrame = cf && Helpers.Trace.isMatchingCallFrame(cf, callFrame);
-            if (matchesCallFrame) {
-                sourceLocationEvents.push(e);
-            }
-            else {
-                unrelatedEvents.push(e);
-            }
-        });
-        // Update current entity.
-        this.#entityMappings.eventsByEntity.set(currentEntity, unrelatedEvents);
-        // Map the source location events to the new entity.
-        this.#entityMappings.eventsByEntity.set(resolvedEntity, sourceLocationEvents);
-        sourceLocationEvents.forEach(e => {
-            this.#entityMappings.entityByEvent.set(e, resolvedEntity);
-        });
-        // Update our CallFrame cache when we've got a resolved entity.
-        this.#resolvedCallFrames.add(callFrame);
-    }
-    // Update entities with proper Chrome Extension names.
-    updateExtensionEntitiesWithName(executionContextNamesByOrigin) {
-        const entities = Array.from(this.#entityMappings.eventsByEntity.keys());
-        for (const [origin, name] of executionContextNamesByOrigin) {
-            // In makeUpChromeExtensionEntity, the extension origin is set as the only domain for the entity.
-            const entity = entities.find(e => e.domains[0] === origin);
-            if (entity) {
-                entity.name = entity.company = name;
-            }
-        }
-    }
-}

package/build/vendor/chrome-devtools-frontend/front_end/models/trace/EventsSerializer.js

@@ -1,89 +0,0 @@
-// Copyright 2024 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 Helpers from './helpers/helpers.js';
-import * as Types from './types/types.js';
-export class EventsSerializer {
-    #modifiedProfileCallByKey = new Map();
-    keyForEvent(event) {
-        if (Types.Events.isProfileCall(event)) {
-            return `${"p" /* Types.File.EventKeyType.PROFILE_CALL */}-${event.pid}-${event.tid}-${Types.Events.SampleIndex(event.sampleIndex)}-${event.nodeId}`;
-        }
-        if (Types.Events.isLegacyTimelineFrame(event)) {
-            return `${"l" /* Types.File.EventKeyType.LEGACY_TIMELINE_FRAME */}-${event.index}`;
-        }
-        if (Types.Events.isJSSample(event)) {
-            return null;
-        }
-        const rawEvents = Helpers.SyntheticEvents.SyntheticEventsManager.getActiveManager().getRawTraceEvents();
-        const isSynthetic = Types.Events.isSyntheticBased(event);
-        const index = rawEvents.indexOf(isSynthetic ? event.rawSourceEvent : event);
-        if (index === -1) {
-            return null;
-        }
-        const key = Types.Events.isSyntheticBased(event) ?
-            `${"s" /* Types.File.EventKeyType.SYNTHETIC_EVENT */}-${index}` :
-            `${"r" /* Types.File.EventKeyType.RAW_EVENT */}-${index}`;
-        if (key.length < 3) {
-            return null;
-        }
-        return key;
-    }
-    eventForKey(key, parsedTrace) {
-        const eventValues = Types.File.traceEventKeyToValues(key);
-        if (EventsSerializer.isProfileCallKey(eventValues)) {
-            return this.#getModifiedProfileCallByKeyValues(eventValues, parsedTrace);
-        }
-        if (EventsSerializer.isLegacyTimelineFrameKey(eventValues)) {
-            const event = parsedTrace.data.Frames.frames.at(eventValues.rawIndex);
-            if (!event) {
-                throw new Error(`Unknown trace event. Could not find frame with index ${eventValues.rawIndex}`);
-            }
-            return event;
-        }
-        if (EventsSerializer.isSyntheticEventKey(eventValues)) {
-            const syntheticEvents = Helpers.SyntheticEvents.SyntheticEventsManager.getActiveManager().getSyntheticTraces();
-            const syntheticEvent = syntheticEvents.at(eventValues.rawIndex);
-            if (!syntheticEvent) {
-                throw new Error(`Unknown trace event. Attempted to get a synthetic event from an unknown raw event index: ${eventValues.rawIndex}`);
-            }
-            return syntheticEvent;
-        }
-        if (EventsSerializer.isRawEventKey(eventValues)) {
-            const rawEvents = Helpers.SyntheticEvents.SyntheticEventsManager.getActiveManager().getRawTraceEvents();
-            return rawEvents[eventValues.rawIndex];
-        }
-        throw new Error(`Unknown trace event. Serializable key values: ${eventValues.join('-')}`);
-    }
-    static isProfileCallKey(key) {
-        return key.type === "p" /* Types.File.EventKeyType.PROFILE_CALL */;
-    }
-    static isLegacyTimelineFrameKey(key) {
-        return key.type === "l" /* Types.File.EventKeyType.LEGACY_TIMELINE_FRAME */;
-    }
-    static isRawEventKey(key) {
-        return key.type === "r" /* Types.File.EventKeyType.RAW_EVENT */;
-    }
-    static isSyntheticEventKey(key) {
-        return key.type === "s" /* Types.File.EventKeyType.SYNTHETIC_EVENT */;
-    }
-    #getModifiedProfileCallByKeyValues(key, parsedTrace) {
-        const cacheResult = this.#modifiedProfileCallByKey.get(key);
-        if (cacheResult) {
-            return cacheResult;
-        }
-        const profileCallsInThread = parsedTrace.data.Renderer.processes.get(key.processID)?.threads.get(key.threadID)?.profileCalls;
-        if (!profileCallsInThread) {
-            throw new Error(`Unknown profile call serializable key: ${(key)}`);
-        }
-        const match = profileCallsInThread?.find((e) => {
-            return e.sampleIndex === key.sampleIndex && e.nodeId === key.protocol;
-        });
-        if (!match) {
-            throw new Error(`Unknown profile call serializable key: ${(JSON.stringify(key))}`);
-        }
-        // Cache to avoid looking up in subsequent calls.
-        this.#modifiedProfileCallByKey.set(key, match);
-        return match;
-    }
-}