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

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

@@ -1,33 +0,0 @@
-// 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.
-/**
- * A small wrapper around a DebuggableFrame usable as a UI.Context flavor.
- * This is necessary as DebuggableFrame are just interfaces and the impl classes are hidden.
- *
- * Moreover, re-translation creates a new DebuggableFrame instance even though the
- * translation result stays the same, in which case we don't need a new instance for the flavor.
- */
-export class DebuggableFrameFlavor {
-    static #last;
-    frame;
-    /** Use the static {@link for}. Only public to satisfy the `setFlavor` Ctor type  */
-    constructor(frame) {
-        this.frame = frame;
-    }
-    get sdkFrame() {
-        return this.frame.sdkFrame;
-    }
-    /** @returns the same instance of DebuggableFrameFlavor for repeated calls with the same (i.e. deep equal) DebuggableFrame */
-    static for(frame) {
-        function equals(a, b) {
-            return a.url === b.url && a.uiSourceCode === b.uiSourceCode && a.name === b.name && a.line === b.line &&
-                a.column === b.column && a.sdkFrame === b.sdkFrame &&
-                JSON.stringify(a.missingDebugInfo) === JSON.stringify(b.missingDebugInfo);
-        }
-        if (!DebuggableFrameFlavor.#last || !equals(DebuggableFrameFlavor.#last.frame, frame)) {
-            DebuggableFrameFlavor.#last = new DebuggableFrameFlavor(frame);
-        }
-        return DebuggableFrameFlavor.#last;
-    }
-}

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

@@ -1,136 +0,0 @@
-// 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 Common from '../../core/common/common.js';
-export class StackTraceImpl extends Common.ObjectWrapper.ObjectWrapper {
-    syncFragment;
-    asyncFragments;
-    constructor(syncFragment, asyncFragments) {
-        super();
-        this.syncFragment = syncFragment;
-        this.asyncFragments = asyncFragments;
-        const fragment = syncFragment instanceof DebuggableFragmentImpl ? syncFragment.fragment : syncFragment;
-        fragment.stackTraces.add(this);
-        this.asyncFragments.forEach(asyncFragment => asyncFragment.fragment.stackTraces.add(this));
-    }
-}
-export class FragmentImpl {
-    static EMPTY_FRAGMENT = new FragmentImpl();
-    node;
-    stackTraces = new Set();
-    /**
-     * Fragments are deduplicated based on the node.
-     *
-     * In turn, each fragment can be part of multiple stack traces.
-     */
-    static getOrCreate(node) {
-        if (!node.fragment) {
-            node.fragment = new FragmentImpl(node);
-        }
-        return node.fragment;
-    }
-    constructor(node) {
-        this.node = node;
-    }
-    get frames() {
-        if (!this.node) {
-            return [];
-        }
-        const frames = [];
-        for (const node of this.node.getCallStack()) {
-            frames.push(...node.frames);
-        }
-        return frames;
-    }
-}
-export class AsyncFragmentImpl {
-    description;
-    fragment;
-    constructor(description, fragment) {
-        this.description = description;
-        this.fragment = fragment;
-    }
-    get frames() {
-        return this.fragment.frames;
-    }
-}
-export class FrameImpl {
-    url;
-    uiSourceCode;
-    name;
-    line;
-    column;
-    missingDebugInfo;
-    constructor(url, uiSourceCode, name, line, column, missingDebugInfo) {
-        this.url = url;
-        this.uiSourceCode = uiSourceCode;
-        this.name = name;
-        this.line = line;
-        this.column = column;
-        this.missingDebugInfo = missingDebugInfo;
-    }
-}
-/**
- * A DebuggableFragmentImpl wraps an existing FragmentImpl. This is important: We can pause at the
- * same location multiple times and the paused information changes each and everytime while the underlying
- * FragmentImpl will stay the same.
- */
-export class DebuggableFragmentImpl {
-    fragment;
-    callFrames;
-    constructor(fragment, callFrames) {
-        this.fragment = fragment;
-        this.callFrames = callFrames;
-    }
-    get frames() {
-        if (!this.fragment.node) {
-            return [];
-        }
-        const frames = [];
-        let index = 0;
-        for (const node of this.fragment.node.getCallStack()) {
-            for (const [inlineIdx, frame] of node.frames.entries()) {
-                // Create virtual frames for inlined frames.
-                const sdkFrame = inlineIdx === 0 ? this.callFrames[index] :
-                    this.callFrames[index].createVirtualCallFrame(inlineIdx, frame.name ?? '');
-                frames.push(new DebuggableFrameImpl(frame, sdkFrame));
-            }
-            index++;
-        }
-        return frames;
-    }
-}
-/**
- * A DebuggableFrameImpl wraps an existing FrameImpl. This is important: We can pause at the
- * same location multiple times and the paused information changes each and everytime while the underlying
- * FrameImpl will stay the same.
- */
-export class DebuggableFrameImpl {
-    #frame;
-    #sdkFrame;
-    constructor(frame, sdkFrame) {
-        this.#frame = frame;
-        this.#sdkFrame = sdkFrame;
-    }
-    get url() {
-        return this.#frame.url;
-    }
-    get uiSourceCode() {
-        return this.#frame.uiSourceCode;
-    }
-    get name() {
-        return this.#frame.name;
-    }
-    get line() {
-        return this.#frame.line;
-    }
-    get column() {
-        return this.#frame.column;
-    }
-    get missingDebugInfo() {
-        return this.#frame.missingDebugInfo;
-    }
-    get sdkFrame() {
-        return this.#sdkFrame;
-    }
-}

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

@@ -1,149 +0,0 @@
-// 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.
-var _a;
-import * as Common from '../../core/common/common.js';
-import * as SDK from '../../core/sdk/sdk.js';
-// eslint-disable-next-line @devtools/es-modules-import
-import * as StackTrace from './stack_trace.js';
-import { AsyncFragmentImpl, DebuggableFragmentImpl, FragmentImpl, FrameImpl, StackTraceImpl } from './StackTraceImpl.js';
-import { Trie } from './Trie.js';
-/**
- * The {@link StackTraceModel} is a thin wrapper around a fragment trie.
- *
- * We want to store stack trace fragments per target so a SDKModel is the natural choice.
- */
-export class StackTraceModel extends SDK.SDKModel.SDKModel {
-    #trie = new Trie();
-    #mutex = new Common.Mutex.Mutex();
-    /** @returns the {@link StackTraceModel} for the target, or the model for the primaryPageTarget when passing null/undefined */
-    static #modelForTarget(target) {
-        const model = (target ?? SDK.TargetManager.TargetManager.instance().primaryPageTarget())?.model(_a);
-        if (!model) {
-            throw new Error('Unable to find StackTraceModel');
-        }
-        return model;
-    }
-    async createFromProtocolRuntime(stackTrace, rawFramesToUIFrames) {
-        const [syncFragment, asyncFragments] = await Promise.all([
-            this.#createFragment(stackTrace.callFrames, rawFramesToUIFrames),
-            this.#createAsyncFragments(stackTrace, rawFramesToUIFrames),
-        ]);
-        return new StackTraceImpl(syncFragment, asyncFragments);
-    }
-    async createFromDebuggerPaused(pausedDetails, rawFramesToUIFrames) {
-        const [syncFragment, asyncFragments] = await Promise.all([
-            this.#createDebuggableFragment(pausedDetails, rawFramesToUIFrames),
-            this.#createAsyncFragments(pausedDetails, rawFramesToUIFrames),
-        ]);
-        return new StackTraceImpl(syncFragment, asyncFragments);
-    }
-    /** Trigger re-translation of all fragments with the provide script in their call stack */
-    async scriptInfoChanged(script, translateRawFrames) {
-        const release = await this.#mutex.acquire();
-        try {
-            const translatePromises = [];
-            let stackTracesToUpdate = new Set();
-            for (const fragment of this.#affectedFragments(script)) {
-                // We trigger re-translation only for fragments of leaf-nodes. Any fragment along the ancestor-chain
-                // is re-translated as a side-effect.
-                // We just need to remember the stack traces of the skipped over fragments, so we can send the
-                // UPDATED event also to them.
-                if (fragment.node?.children.length === 0) {
-                    translatePromises.push(this.#translateFragment(fragment, translateRawFrames));
-                }
-                stackTracesToUpdate = stackTracesToUpdate.union(fragment.stackTraces);
-            }
-            await Promise.all(translatePromises);
-            for (const stackTrace of stackTracesToUpdate) {
-                stackTrace.dispatchEventToListeners("UPDATED" /* StackTrace.StackTrace.Events.UPDATED */);
-            }
-        }
-        finally {
-            release();
-        }
-    }
-    async #createDebuggableFragment(pausedDetails, rawFramesToUIFrames) {
-        const fragment = await this.#createFragment(pausedDetails.callFrames.map(frame => ({
-            scriptId: frame.script.scriptId,
-            url: frame.script.sourceURL,
-            functionName: frame.functionName,
-            lineNumber: frame.location().lineNumber,
-            columnNumber: frame.location().columnNumber,
-        })), rawFramesToUIFrames);
-        return new DebuggableFragmentImpl(fragment, pausedDetails.callFrames);
-    }
-    async #createAsyncFragments(stackTraceOrPausedEvent, rawFramesToUIFrames) {
-        const asyncFragments = [];
-        const debuggerModel = this.target().model(SDK.DebuggerModel.DebuggerModel);
-        if (debuggerModel) {
-            for await (const { stackTrace: asyncStackTrace, target } of debuggerModel.iterateAsyncParents(stackTraceOrPausedEvent)) {
-                if (asyncStackTrace.callFrames.length === 0) {
-                    // Skip empty async fragments, they don't add value.
-                    continue;
-                }
-                const model = _a.#modelForTarget(target);
-                const asyncFragmentPromise = model.#createFragment(asyncStackTrace.callFrames, rawFramesToUIFrames)
-                    .then(fragment => new AsyncFragmentImpl(asyncStackTrace.description ?? '', fragment));
-                asyncFragments.push(asyncFragmentPromise);
-            }
-        }
-        return await Promise.all(asyncFragments);
-    }
-    async #createFragment(frames, rawFramesToUIFrames) {
-        if (frames.length === 0) {
-            return FragmentImpl.EMPTY_FRAGMENT;
-        }
-        const release = await this.#mutex.acquire();
-        try {
-            const node = this.#trie.insert(frames);
-            const requiresTranslation = !Boolean(node.fragment);
-            const fragment = FragmentImpl.getOrCreate(node);
-            if (requiresTranslation) {
-                await this.#translateFragment(fragment, rawFramesToUIFrames);
-            }
-            return fragment;
-        }
-        finally {
-            release();
-        }
-    }
-    async #translateFragment(fragment, rawFramesToUIFrames) {
-        if (!fragment.node) {
-            return;
-        }
-        const rawFrames = fragment.node.getCallStack().map(node => node.rawFrame).toArray();
-        const uiFrames = await rawFramesToUIFrames(rawFrames, this.target());
-        console.assert(rawFrames.length === uiFrames.length, 'Broken rawFramesToUIFrames implementation');
-        let i = 0;
-        for (const node of fragment.node.getCallStack()) {
-            node.frames = uiFrames[i++].map(frame => new FrameImpl(frame.url, frame.uiSourceCode, frame.name, frame.line, frame.column, frame.missingDebugInfo));
-        }
-    }
-    #affectedFragments(script) {
-        // 1. Collect branches with the matching script.
-        const affectedBranches = new Set();
-        this.#trie.walk(null, node => {
-            // scriptId has precedence, but if the frame does not have one, check the URL.
-            if (node.rawFrame.scriptId === script.scriptId ||
-                (!node.rawFrame.scriptId && node.rawFrame.url === script.sourceURL)) {
-                affectedBranches.add(node);
-                return false;
-            }
-            return true;
-        });
-        // 2. For each branch collect all the fragments.
-        const fragments = new Set();
-        for (const branch of affectedBranches) {
-            this.#trie.walk(branch, node => {
-                if (node.fragment) {
-                    fragments.add(node.fragment);
-                }
-                return true;
-            });
-        }
-        return fragments;
-    }
-}
-_a = StackTraceModel;
-SDK.SDKModel.SDKModel.register(StackTraceModel, { capabilities: 0 /* SDK.Target.Capability.NONE */, autostart: false });

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

@@ -1,121 +0,0 @@
-// 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.
-/**
- * @returns whether the frame is a V8 builtin frame e.g. Array.map. Builtin frames
- * have neither source position nor script or URL. They only have a name.
- */
-export function isBuiltinFrame(rawFrame) {
-    return rawFrame.lineNumber === -1 && rawFrame.columnNumber === -1 && !Boolean(rawFrame.scriptId) &&
-        !Boolean(rawFrame.url);
-}
-export class FrameNode {
-    parent;
-    children = [];
-    rawFrame;
-    frames = [];
-    fragment;
-    constructor(rawFrame, parent) {
-        this.rawFrame = rawFrame;
-        this.parent = parent;
-    }
-    /**
-     * Produces the ancestor chain. Including `this` but excluding the `RootFrameNode`.
-     */
-    *getCallStack() {
-        // The `RootFrameNode` doesn't have an actual frame attached, that's why we check for `node.parent` instead of `node`.
-        for (let node = this; node.parent; node = node.parent) {
-            yield node;
-        }
-    }
-}
-/**
- * Stores stack trace fragments in a trie, but does not own them/keep them alive.
- */
-export class Trie {
-    #root = { parent: null, children: [] };
-    /**
-     * Most sources produce stack traces in "top-to-bottom" order, so that is what this method expects.
-     *
-     * @returns The {@link FrameNode} corresponding to the top-most stack frame.
-     */
-    insert(frames) {
-        if (frames.length === 0) {
-            throw new Error('Trie.insert called with an empty frames array.');
-        }
-        let currentNode = this.#root;
-        for (let i = frames.length - 1; i >= 0; --i) {
-            currentNode = this.#insert(currentNode, frames[i]);
-        }
-        return currentNode;
-    }
-    /**
-     * Inserts `rawFrame` into the children of the provided node if not already there.
-     *
-     * @returns the child node corresponding to `rawFrame`.
-     */
-    #insert(node, rawFrame) {
-        let i = 0;
-        for (; i < node.children.length; ++i) {
-            const maybeChild = node.children[i];
-            const child = maybeChild instanceof WeakRef ? maybeChild.deref() : maybeChild;
-            if (!child) {
-                continue;
-            }
-            const compareResult = compareRawFrames(child.rawFrame, rawFrame);
-            if (compareResult === 0) {
-                return child;
-            }
-            if (compareResult > 0) {
-                break;
-            }
-        }
-        const newNode = new FrameNode(rawFrame, node);
-        if (node.parent) {
-            node.children.splice(i, 0, newNode);
-        }
-        else {
-            node.children.splice(i, 0, new WeakRef(newNode));
-        }
-        return newNode;
-    }
-    /**
-     * Traverses the trie in pre-order.
-     *
-     * @param node Start at `node` or `null` to start with the children of the root.
-     * @param visit Called on each node in the trie. Return `true` if the visitor should descend into child nodes of the provided node.
-     */
-    walk(node, visit) {
-        const stack = node ? [node] : [...this.#root.children].map(ref => ref.deref()).filter(node => Boolean(node));
-        for (let node = stack.pop(); node; node = stack.pop()) {
-            const visitChildren = visit(node);
-            if (visitChildren) {
-                // Pushing the children in reverse means the "left-most" child is visited first (i.e. pre-order).
-                for (let i = node.children.length - 1; i >= 0; --i) {
-                    stack.push(node.children[i]);
-                }
-            }
-        }
-    }
-}
-/**
- * @returns a number < 0, 0 or > 0, if the `a` is smaller then, equal or greater then `b`.
- */
-export function compareRawFrames(a, b) {
-    const scriptIdCompare = (a.scriptId ?? '').localeCompare(b.scriptId ?? '');
-    if (scriptIdCompare !== 0) {
-        return scriptIdCompare;
-    }
-    const urlCompare = (a.url ?? '').localeCompare(b.url ?? '');
-    if (urlCompare !== 0) {
-        return urlCompare;
-    }
-    const nameCompare = (a.functionName ?? '').localeCompare(b.functionName ?? '');
-    if (nameCompare !== 0) {
-        return nameCompare;
-    }
-    if (a.lineNumber !== b.lineNumber) {
-        return a.lineNumber - b.lineNumber;
-    }
-    return a.columnNumber - b.columnNumber;
-}

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

@@ -1,5 +0,0 @@
-// 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 StackTrace from './StackTrace.js';
-export { StackTrace, };

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

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

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

@@ -1,32 +0,0 @@
-// 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;
-}

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

@@ -1,173 +0,0 @@
-// Copyright 2023 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-import * as Platform from '../../core/platform/platform.js';
-import { contentAsDataURL } from './ContentProvider.js';
-import { Text } from './Text.js';
-/**
- * This class is a small wrapper around either raw binary or text data.
- * As the binary data can actually contain textual data, we also store the
- * MIME type and if applicable, the charset.
- *
- * This information should be generally kept together, as interpreting text
- * from raw bytes requires an encoding.
- *
- * Note that we only rarely have to decode text ourselves in the frontend,
- * this is mostly handled by the backend. There are cases though (e.g. SVG,
- * or streaming response content) where we receive text data in
- * binary (base64-encoded) form.
- *
- * The class only implements decoding. We currently don't have a use-case
- * to re-encode text into base64 bytes using a specified charset.
- */
-export class ContentData {
-    mimeType;
-    charset;
-    #contentAsBase64;
-    #contentAsText;
-    #contentAsTextObj;
-    constructor(data, isBase64, mimeType, charset) {
-        this.charset = charset || 'utf-8';
-        if (isBase64) {
-            this.#contentAsBase64 = data;
-        }
-        else {
-            this.#contentAsText = data;
-        }
-        this.mimeType = mimeType;
-        if (!this.mimeType) {
-            // Tests or broken requests might pass an empty/undefined mime type. Fallback to
-            // "default" mime types.
-            this.mimeType = isBase64 ? 'application/octet-stream' : 'text/plain';
-        }
-    }
-    /**
-     * Returns the data as base64.
-     *
-     * @throws if this `ContentData` was constructed from text content.
-     */
-    get base64() {
-        if (this.#contentAsBase64 === undefined) {
-            throw new Error('Encoding text content as base64 is not supported');
-        }
-        return this.#contentAsBase64;
-    }
-    /**
-     * Returns the content as text. If this `ContentData` was constructed with base64
-     * encoded bytes, it will use the provided charset to attempt to decode the bytes.
-     *
-     * @throws if `mimeType` is not a text type.
-     */
-    get text() {
-        if (this.#contentAsText !== undefined) {
-            return this.#contentAsText;
-        }
-        if (!this.isTextContent) {
-            throw new Error('Cannot interpret binary data as text');
-        }
-        const binaryString = window.atob(this.#contentAsBase64);
-        const len = binaryString.length;
-        const bytes = new Uint8Array(len);
-        for (let i = 0; i < len; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-        }
-        this.#contentAsText = new TextDecoder(this.charset).decode(bytes);
-        return this.#contentAsText;
-    }
-    /** @returns true, if this `ContentData` was constructed from text content or the mime type indicates text that can be decoded */
-    get isTextContent() {
-        return this.#createdFromText || Platform.MimeType.isTextType(this.mimeType);
-    }
-    get isEmpty() {
-        // Don't trigger unnecessary decoding. Only check if both of the strings are empty.
-        return !Boolean(this.#contentAsBase64) && !Boolean(this.#contentAsText);
-    }
-    get createdFromBase64() {
-        return this.#contentAsBase64 !== undefined;
-    }
-    get #createdFromText() {
-        return this.#contentAsBase64 === undefined;
-    }
-    /**
-     * Returns the text content as a `Text` object. The returned object is always the same to
-     * minimize the number of times we have to calculate the line endings array.
-     *
-     * @throws if `mimeType` is not a text type.
-     */
-    get textObj() {
-        if (this.#contentAsTextObj === undefined) {
-            this.#contentAsTextObj = new Text(this.text);
-        }
-        return this.#contentAsTextObj;
-    }
-    /**
-     * @returns True, iff the contents (base64 or text) are equal.
-     * Does not compare mime type and charset, but will decode base64 data if both
-     * mime types indicate that it's text content.
-     */
-    contentEqualTo(other) {
-        if (this.#contentAsBase64 !== undefined && other.#contentAsBase64 !== undefined) {
-            return this.#contentAsBase64 === other.#contentAsBase64;
-        }
-        if (this.#contentAsText !== undefined && other.#contentAsText !== undefined) {
-            return this.#contentAsText === other.#contentAsText;
-        }
-        if (this.isTextContent && other.isTextContent) {
-            return this.text === other.text;
-        }
-        return false;
-    }
-    asDataUrl() {
-        // To keep with existing behavior we prefer to return the content
-        // encoded if that is how this ContentData was constructed with.
-        if (this.#contentAsBase64 !== undefined) {
-            const charset = this.isTextContent ? this.charset : null;
-            return contentAsDataURL(this.#contentAsBase64, this.mimeType ?? '', true, charset);
-        }
-        return contentAsDataURL(this.text, this.mimeType ?? '', false, 'utf-8');
-    }
-    /**
-     * @deprecated Used during migration from `DeferredContent` to `ContentData`.
-     */
-    asDeferedContent() {
-        // To prevent encoding mistakes, we'll return text content already decoded.
-        if (this.isTextContent) {
-            return { content: this.text, isEncoded: false };
-        }
-        if (this.#contentAsText !== undefined) {
-            // Unknown text mime type, this should not really happen.
-            return { content: this.#contentAsText, isEncoded: false };
-        }
-        if (this.#contentAsBase64 !== undefined) {
-            return { content: this.#contentAsBase64, isEncoded: true };
-        }
-        throw new Error('Unreachable');
-    }
-    static isError(contentDataOrError) {
-        return 'error' in contentDataOrError;
-    }
-    /** @returns `value` if the passed `ContentDataOrError` is an error, or the text content otherwise */
-    static textOr(contentDataOrError, value) {
-        if (ContentData.isError(contentDataOrError)) {
-            return value;
-        }
-        return contentDataOrError.text;
-    }
-    /** @returns an empty 'text/plain' content data if the passed `ContentDataOrError` is an error, or the content data itself otherwise */
-    static contentDataOrEmpty(contentDataOrError) {
-        if (ContentData.isError(contentDataOrError)) {
-            return EMPTY_TEXT_CONTENT_DATA;
-        }
-        return contentDataOrError;
-    }
-    /**
-     * @deprecated Used during migration from `DeferredContent` to `ContentData`.
-     */
-    static asDeferredContent(contentDataOrError) {
-        if (ContentData.isError(contentDataOrError)) {
-            return { error: contentDataOrError.error, content: null, isEncoded: false };
-        }
-        return contentDataOrError.asDeferedContent();
-    }
-}
-export const EMPTY_TEXT_CONTENT_DATA = new ContentData('', /* isBase64 */ false, 'text/plain');