chrome-devtools-mcp 0.12.0 → 0.12.1

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

@@ -1,67 +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;
-        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

@@ -1,97 +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 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

@@ -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/node_modules/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/node_modules/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/node_modules/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/node_modules/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');

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

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

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

@@ -1,79 +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 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();
-};