chrome-devtools-mcp 0.0.1 → 0.0.2

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

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