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

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

@@ -0,0 +1,67 @@
+// 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;
+        syncFragment.stackTraces.add(this);
+        this.asyncFragments.forEach(asyncFragment => asyncFragment.fragment.stackTraces.add(this));
+    }
+}
+export class 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() {
+        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;
+    }
+}

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

@@ -0,0 +1,97 @@
+// 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';
+// eslint-disable-next-line @devtools/es-modules-import
+import * as StackTrace from './stack_trace.js';
+import { AsyncFragmentImpl, 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();
+    /** @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(StackTraceModel);
+        if (!model) {
+            throw new Error('Unable to find StackTraceModel');
+        }
+        return model;
+    }
+    async createFromProtocolRuntime(stackTrace, rawFramesToUIFrames) {
+        const translatePromises = [];
+        const fragment = this.#createFragment(stackTrace.callFrames);
+        translatePromises.push(this.#translateFragment(fragment, rawFramesToUIFrames));
+        const asyncFragments = [];
+        const debuggerModel = this.target().model(SDK.DebuggerModel.DebuggerModel);
+        if (debuggerModel) {
+            for await (const { stackTrace: asyncStackTrace, target } of debuggerModel.iterateAsyncParents(stackTrace)) {
+                const model = StackTraceModel.#modelForTarget(target);
+                const asyncFragment = model.#createFragment(asyncStackTrace.callFrames);
+                translatePromises.push(model.#translateFragment(asyncFragment, rawFramesToUIFrames));
+                asyncFragments.push(new AsyncFragmentImpl(asyncStackTrace.description ?? '', asyncFragment));
+            }
+        }
+        await Promise.all(translatePromises);
+        return new StackTraceImpl(fragment, asyncFragments);
+    }
+    /** Trigger re-translation of all fragments with the provide script in their call stack */
+    async scriptInfoChanged(script, translateRawFrames) {
+        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 */);
+        }
+    }
+    #createFragment(frames) {
+        return FragmentImpl.getOrCreate(this.#trie.insert(frames));
+    }
+    async #translateFragment(fragment, rawFramesToUIFrames) {
+        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;
+    }
+}
+SDK.SDKModel.SDKModel.register(StackTraceModel, { capabilities: 0 /* SDK.Target.Capability.NONE */, autostart: false });

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

@@ -0,0 +1,121 @@
+// 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/node_modules/chrome-devtools-frontend/front_end/models/stack_trace/stack_trace.js

@@ -0,0 +1,5 @@
+// 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/node_modules/chrome-devtools-frontend/front_end/models/stack_trace/stack_trace_impl.js

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

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

@@ -0,0 +1,173 @@
+// 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');

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

@@ -0,0 +1,30 @@
+// Copyright 2012 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export class SearchMatch {
+    lineNumber;
+    lineContent;
+    columnNumber;
+    matchLength;
+    constructor(lineNumber, lineContent, columnNumber, matchLength) {
+        this.lineNumber = lineNumber;
+        this.lineContent = lineContent;
+        this.columnNumber = columnNumber;
+        this.matchLength = matchLength;
+    }
+    static comparator(a, b) {
+        return a.lineNumber - b.lineNumber || a.columnNumber - b.columnNumber;
+    }
+}
+export const contentAsDataURL = function (content, mimeType, contentEncoded, charset, limitSize = true) {
+    const maxDataUrlSize = 1024 * 1024;
+    if (content === undefined || content === null || (limitSize && content.length > maxDataUrlSize)) {
+        return null;
+    }
+    content = contentEncoded ? content : encodeURIComponent(content);
+    return 'data:' + mimeType + (charset ? ';charset=' + charset : '') + (contentEncoded ? ';base64' : '') + ',' +
+        content;
+};
+export const isStreamingContentProvider = function (provider) {
+    return 'requestStreamingContent' in provider;
+};

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

@@ -0,0 +1,32 @@
+// Copyright 2014 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { ContentData } from './ContentData.js';
+import { performSearchInContentData } from './TextUtils.js';
+export class StaticContentProvider {
+    #contentURL;
+    #contentType;
+    #lazyContent;
+    constructor(contentURL, contentType, lazyContent) {
+        this.#contentURL = contentURL;
+        this.#contentType = contentType;
+        this.#lazyContent = lazyContent;
+    }
+    static fromString(contentURL, contentType, content) {
+        const lazyContent = () => Promise.resolve(new ContentData(content, /* isBase64 */ false, contentType.canonicalMimeType()));
+        return new StaticContentProvider(contentURL, contentType, lazyContent);
+    }
+    contentURL() {
+        return this.#contentURL;
+    }
+    contentType() {
+        return this.#contentType;
+    }
+    requestContentData() {
+        return this.#lazyContent();
+    }
+    async searchInContent(query, caseSensitive, isRegex) {
+        const contentData = await this.requestContentData();
+        return performSearchInContentData(contentData, query, caseSensitive, isRegex);
+    }
+}

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

@@ -0,0 +1,79 @@
+// 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 Common from '../../core/common/common.js';
+import * as Platform from '../../core/platform/platform.js';
+import { ContentData } from './ContentData.js';
+/**
+ * Usage of this class is mostly intended for content that is never "complete".
+ * E.g. streaming XHR/fetch requests.
+ *
+ * Due to the streaming nature this class only supports base64-encoded binary data.
+ * Decoding to text only happens on-demand by clients. This ensures that at most we have
+ * incomplete unicode at the end and not in-between chunks.
+ */
+export class StreamingContentData extends Common.ObjectWrapper.ObjectWrapper {
+    mimeType;
+    #charset;
+    #disallowStreaming;
+    #chunks = [];
+    #contentData;
+    constructor(mimeType, charset, initialContent) {
+        super();
+        this.mimeType = mimeType;
+        this.#charset = charset;
+        this.#disallowStreaming = Boolean(initialContent && !initialContent.createdFromBase64);
+        this.#contentData = initialContent;
+    }
+    /**
+     * Creates a new StreamingContentData with the given MIME type/charset.
+     */
+    static create(mimeType, charset) {
+        return new StreamingContentData(mimeType, charset);
+    }
+    /**
+     * Creates a new StringContentData from an existing ContentData instance.
+     *
+     * Calling `addChunk` is on the resulting `StreamingContentData` is illegal if
+     * `content` was not created from base64 data. The reason is that JavaScript TextEncoder
+     * only supports UTF-8. We can't convert text with arbitrary encoding back to base64 for concatenation.
+     */
+    static from(content) {
+        return new StreamingContentData(content.mimeType, content.charset, content);
+    }
+    /** @returns true, if this `ContentData` was constructed from text content or the mime type indicates text that can be decoded */
+    get isTextContent() {
+        if (this.#contentData) {
+            return this.#contentData.isTextContent;
+        }
+        return Platform.MimeType.isTextType(this.mimeType);
+    }
+    /** @param chunk base64 encoded data */
+    addChunk(chunk) {
+        if (this.#disallowStreaming) {
+            throw new Error('Cannot add base64 data to a text-only ContentData.');
+        }
+        this.#chunks.push(chunk);
+        this.dispatchEventToListeners("ChunkAdded" /* Events.CHUNK_ADDED */, { content: this, chunk });
+    }
+    /** @returns An immutable ContentData with all the bytes received so far */
+    content() {
+        if (this.#contentData && this.#chunks.length === 0) {
+            return this.#contentData;
+        }
+        const initialBase64 = this.#contentData?.base64 ?? '';
+        const base64Content = this.#chunks.reduce((acc, chunk) => Platform.StringUtilities.concatBase64(acc, chunk), initialBase64);
+        this.#contentData = new ContentData(base64Content, /* isBase64=*/ true, this.mimeType, this.#charset);
+        this.#chunks = [];
+        return this.#contentData;
+    }
+}
+export const isError = function (contentDataOrError) {
+    return 'error' in contentDataOrError;
+};
+export const asContentDataOrError = function (contentDataOrError) {
+    if (isError(contentDataOrError)) {
+        return contentDataOrError;
+    }
+    return contentDataOrError.content();
+};