chrome-devtools-mcp-for-extension 0.5.0

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();
+};

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

@@ -0,0 +1,69 @@
+// Copyright 2016 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 { TextCursor } from './TextCursor.js';
+import { SourceRange, TextRange } from './TextRange.js';
+export class Text {
+    #value;
+    #lineEndings;
+    constructor(value) {
+        this.#value = value;
+    }
+    lineEndings() {
+        if (!this.#lineEndings) {
+            this.#lineEndings = Platform.StringUtilities.findLineEndingIndexes(this.#value);
+        }
+        return this.#lineEndings;
+    }
+    value() {
+        return this.#value;
+    }
+    lineCount() {
+        const lineEndings = this.lineEndings();
+        return lineEndings.length;
+    }
+    offsetFromPosition(lineNumber, columnNumber) {
+        return (lineNumber ? this.lineEndings()[lineNumber - 1] + 1 : 0) + columnNumber;
+    }
+    positionFromOffset(offset) {
+        const lineEndings = this.lineEndings();
+        const lineNumber = Platform.ArrayUtilities.lowerBound(lineEndings, offset, Platform.ArrayUtilities.DEFAULT_COMPARATOR);
+        return { lineNumber, columnNumber: offset - (lineNumber && (lineEndings[lineNumber - 1] + 1)) };
+    }
+    lineAt(lineNumber) {
+        const lineEndings = this.lineEndings();
+        const lineStart = lineNumber > 0 ? lineEndings[lineNumber - 1] + 1 : 0;
+        const lineEnd = lineEndings[lineNumber];
+        let lineContent = this.#value.substring(lineStart, lineEnd);
+        if (lineContent.length > 0 && lineContent.charAt(lineContent.length - 1) === '\r') {
+            lineContent = lineContent.substring(0, lineContent.length - 1);
+        }
+        return lineContent;
+    }
+    toSourceRange(range) {
+        const start = this.offsetFromPosition(range.startLine, range.startColumn);
+        const end = this.offsetFromPosition(range.endLine, range.endColumn);
+        return new SourceRange(start, end - start);
+    }
+    toTextRange(sourceRange) {
+        const cursor = new TextCursor(this.lineEndings());
+        const result = TextRange.createFromLocation(0, 0);
+        cursor.resetTo(sourceRange.offset);
+        result.startLine = cursor.lineNumber();
+        result.startColumn = cursor.columnNumber();
+        cursor.advance(sourceRange.offset + sourceRange.length);
+        result.endLine = cursor.lineNumber();
+        result.endColumn = cursor.columnNumber();
+        return result;
+    }
+    replaceRange(range, replacement) {
+        const sourceRange = this.toSourceRange(range);
+        return this.#value.substring(0, sourceRange.offset) + replacement +
+            this.#value.substring(sourceRange.offset + sourceRange.length);
+    }
+    extract(range) {
+        const sourceRange = this.toSourceRange(range);
+        return this.#value.substr(sourceRange.offset, sourceRange.length);
+    }
+}

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

@@ -0,0 +1,35 @@
+// Copyright 2020 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';
+export class TextCursor {
+    #lineEndings;
+    #offset = 0;
+    #lineNumber = 0;
+    #columnNumber = 0;
+    constructor(lineEndings) {
+        this.#lineEndings = lineEndings;
+    }
+    advance(offset) {
+        this.#offset = offset;
+        while (this.#lineNumber < this.#lineEndings.length && this.#lineEndings[this.#lineNumber] < this.#offset) {
+            ++this.#lineNumber;
+        }
+        this.#columnNumber = this.#lineNumber ? this.#offset - this.#lineEndings[this.#lineNumber - 1] - 1 : this.#offset;
+    }
+    offset() {
+        return this.#offset;
+    }
+    resetTo(offset) {
+        this.#offset = offset;
+        this.#lineNumber =
+            Platform.ArrayUtilities.lowerBound(this.#lineEndings, offset, Platform.ArrayUtilities.DEFAULT_COMPARATOR);
+        this.#columnNumber = this.#lineNumber ? this.#offset - this.#lineEndings[this.#lineNumber - 1] - 1 : this.#offset;
+    }
+    lineNumber() {
+        return this.#lineNumber;
+    }
+    columnNumber() {
+        return this.#columnNumber;
+    }
+}

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

@@ -0,0 +1,231 @@
+// 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';
+const MAX_SAFE_INT32 = 2 ** 31 - 1;
+export class TextRange {
+    startLine;
+    startColumn;
+    endLine;
+    endColumn;
+    constructor(startLine, startColumn, endLine, endColumn) {
+        this.startLine = startLine;
+        this.startColumn = startColumn;
+        this.endLine = endLine;
+        this.endColumn = endColumn;
+    }
+    static createFromLocation(line, column) {
+        return new TextRange(line, column, line, column);
+    }
+    static createUnboundedFromLocation(line, column) {
+        return new TextRange(line, column, MAX_SAFE_INT32, MAX_SAFE_INT32);
+    }
+    static fromObject(serializedTextRange) {
+        return new TextRange(serializedTextRange.startLine, serializedTextRange.startColumn, serializedTextRange.endLine, serializedTextRange.endColumn);
+    }
+    static comparator(range1, range2) {
+        return range1.compareTo(range2);
+    }
+    static fromEdit(oldRange, newText) {
+        let endLine = oldRange.startLine;
+        let endColumn = oldRange.startColumn + newText.length;
+        const lineEndings = Platform.StringUtilities.findLineEndingIndexes(newText);
+        if (lineEndings.length > 1) {
+            endLine = oldRange.startLine + lineEndings.length - 1;
+            const len = lineEndings.length;
+            endColumn = lineEndings[len - 1] - lineEndings[len - 2] - 1;
+        }
+        return new TextRange(oldRange.startLine, oldRange.startColumn, endLine, endColumn);
+    }
+    isEmpty() {
+        return this.startLine === this.endLine && this.startColumn === this.endColumn;
+    }
+    immediatelyPrecedes(range) {
+        if (!range) {
+            return false;
+        }
+        return this.endLine === range.startLine && this.endColumn === range.startColumn;
+    }
+    immediatelyFollows(range) {
+        if (!range) {
+            return false;
+        }
+        return range.immediatelyPrecedes(this);
+    }
+    follows(range) {
+        return (range.endLine === this.startLine && range.endColumn <= this.startColumn) || range.endLine < this.startLine;
+    }
+    get linesCount() {
+        return this.endLine - this.startLine;
+    }
+    collapseToEnd() {
+        return new TextRange(this.endLine, this.endColumn, this.endLine, this.endColumn);
+    }
+    collapseToStart() {
+        return new TextRange(this.startLine, this.startColumn, this.startLine, this.startColumn);
+    }
+    normalize() {
+        if (this.startLine > this.endLine || (this.startLine === this.endLine && this.startColumn > this.endColumn)) {
+            return new TextRange(this.endLine, this.endColumn, this.startLine, this.startColumn);
+        }
+        return this.clone();
+    }
+    clone() {
+        return new TextRange(this.startLine, this.startColumn, this.endLine, this.endColumn);
+    }
+    serializeToObject() {
+        return {
+            startLine: this.startLine,
+            startColumn: this.startColumn,
+            endLine: this.endLine,
+            endColumn: this.endColumn,
+        };
+    }
+    compareTo(other) {
+        if (this.startLine > other.startLine) {
+            return 1;
+        }
+        if (this.startLine < other.startLine) {
+            return -1;
+        }
+        if (this.startColumn > other.startColumn) {
+            return 1;
+        }
+        if (this.startColumn < other.startColumn) {
+            return -1;
+        }
+        return 0;
+    }
+    compareToPosition(lineNumber, columnNumber) {
+        if (lineNumber < this.startLine || (lineNumber === this.startLine && columnNumber < this.startColumn)) {
+            return -1;
+        }
+        if (lineNumber > this.endLine || (lineNumber === this.endLine && columnNumber > this.endColumn)) {
+            return 1;
+        }
+        return 0;
+    }
+    equal(other) {
+        return this.startLine === other.startLine && this.endLine === other.endLine &&
+            this.startColumn === other.startColumn && this.endColumn === other.endColumn;
+    }
+    relativeTo(line, column) {
+        const relative = this.clone();
+        if (this.startLine === line) {
+            relative.startColumn -= column;
+        }
+        if (this.endLine === line) {
+            relative.endColumn -= column;
+        }
+        relative.startLine -= line;
+        relative.endLine -= line;
+        return relative;
+    }
+    relativeFrom(line, column) {
+        const relative = this.clone();
+        if (this.startLine === 0) {
+            relative.startColumn += column;
+        }
+        if (this.endLine === 0) {
+            relative.endColumn += column;
+        }
+        relative.startLine += line;
+        relative.endLine += line;
+        return relative;
+    }
+    rebaseAfterTextEdit(originalRange, editedRange) {
+        console.assert(originalRange.startLine === editedRange.startLine);
+        console.assert(originalRange.startColumn === editedRange.startColumn);
+        const rebase = this.clone();
+        if (!this.follows(originalRange)) {
+            return rebase;
+        }
+        const lineDelta = editedRange.endLine - originalRange.endLine;
+        const columnDelta = editedRange.endColumn - originalRange.endColumn;
+        rebase.startLine += lineDelta;
+        rebase.endLine += lineDelta;
+        if (rebase.startLine === editedRange.endLine) {
+            rebase.startColumn += columnDelta;
+        }
+        if (rebase.endLine === editedRange.endLine) {
+            rebase.endColumn += columnDelta;
+        }
+        return rebase;
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
+    /**
+     * Checks whether this {@link TextRange} contains the location identified by the
+     * {@link lineNumber} and {@link columnNumber}. The beginning of the text range is
+     * considered inclusive while the end of the text range is considered exclusive
+     * for this comparison, meaning that for example a range `(0,1)-(1,4)` contains the
+     * location `(0,1)` but does not contain the location `(1,4)`.
+     *
+     * @param lineNumber the location's line offset.
+     * @param columnNumber the location's column offset.
+     * @returns `true` if the location identified by {@link lineNumber} and {@link columnNumber}
+     *          is contained within this text range.
+     */
+    containsLocation(lineNumber, columnNumber) {
+        if (this.startLine === this.endLine) {
+            return this.startLine === lineNumber && this.startColumn <= columnNumber && columnNumber < this.endColumn;
+        }
+        if (this.startLine === lineNumber) {
+            return this.startColumn <= columnNumber;
+        }
+        if (this.endLine === lineNumber) {
+            return columnNumber < this.endColumn;
+        }
+        return this.startLine < lineNumber && lineNumber < this.endLine;
+    }
+    get start() {
+        return { lineNumber: this.startLine, columnNumber: this.startColumn };
+    }
+    get end() {
+        return { lineNumber: this.endLine, columnNumber: this.endColumn };
+    }
+    /**
+     * Checks whether this and `that` {@link TextRange} overlap and if they do, computes the
+     * intersection range. If they don't overlap an empty text range is returned instead (for
+     * which {@link #isEmpty()} yields `true`).
+     *
+     * The beginning of text ranges is considered to be includes while the end of the text
+     * ranges is considered exclusive for the intersection, meaning that for example intersecting
+     * `(0,1)-(1,4)` and `(1,4)-(1,6)` yields an empty range.
+     *
+     * @param that the other text range.
+     * @returns the intersection of this and `that` text range, which might be empty if their don't
+     *          overlap.
+     */
+    intersection(that) {
+        let { startLine, startColumn } = this;
+        if (startLine < that.startLine) {
+            startLine = that.startLine;
+            startColumn = that.startColumn;
+        }
+        else if (startLine === that.startLine) {
+            startColumn = Math.max(startColumn, that.startColumn);
+        }
+        let { endLine, endColumn } = this;
+        if (endLine > that.endLine) {
+            endLine = that.endLine;
+            endColumn = that.endColumn;
+        }
+        else if (endLine === that.endLine) {
+            endColumn = Math.min(endColumn, that.endColumn);
+        }
+        if (startLine > endLine || (startLine === endLine && startColumn >= endColumn)) {
+            return new TextRange(0, 0, 0, 0);
+        }
+        return new TextRange(startLine, startColumn, endLine, endColumn);
+    }
+}
+export class SourceRange {
+    offset;
+    length;
+    constructor(offset, length) {
+        this.offset = offset;
+        this.length = length;
+    }
+}