@codingame/monaco-vscode-api 10.0.2 → 10.1.1

package/vscode/src/vs/platform/terminal/common/capabilities/commandDetection/promptInputModel.js

@@ -1,345 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter, Event } from '../../../../../base/common/event.js';
-import { Disposable } from '../../../../../base/common/lifecycle.js';
-import { LogLevel } from '../../../../log/common/log.js';
-import { ILogService } from '../../../../log/common/log.service.js';
-import { throttle } from '../../../../../base/common/decorators.js';
-let PromptInputModel = class PromptInputModel extends Disposable {
-    get value() { return this._value; }
-    get prefix() { return this._value.substring(0, this._cursorIndex); }
-    get suffix() { return this._value.substring(this._cursorIndex, this._ghostTextIndex === -1 ? undefined : this._ghostTextIndex); }
-    get cursorIndex() { return this._cursorIndex; }
-    get ghostTextIndex() { return this._ghostTextIndex; }
-    constructor(_xterm, onCommandStart, onCommandExecuted, _logService) {
-        super();
-        this._xterm = _xterm;
-        this._logService = _logService;
-        this._state = 0 ;
-        this._commandStartX = 0;
-        this._lastUserInput = '';
-        this._value = '';
-        this._cursorIndex = 0;
-        this._ghostTextIndex = -1;
-        this._onDidStartInput = this._register(( new Emitter()));
-        this.onDidStartInput = this._onDidStartInput.event;
-        this._onDidChangeInput = this._register(( new Emitter()));
-        this.onDidChangeInput = this._onDidChangeInput.event;
-        this._onDidFinishInput = this._register(( new Emitter()));
-        this.onDidFinishInput = this._onDidFinishInput.event;
-        this._onDidInterrupt = this._register(( new Emitter()));
-        this.onDidInterrupt = this._onDidInterrupt.event;
-        this._register(Event.any(this._xterm.onCursorMove, this._xterm.onData, this._xterm.onWriteParsed)(() => this._sync()));
-        this._register(this._xterm.onData(e => this._handleUserInput(e)));
-        this._register(onCommandStart(e => this._handleCommandStart(e)));
-        this._register(onCommandExecuted(() => this._handleCommandExecuted()));
-        this._register(this.onDidStartInput(() => this._logCombinedStringIfTrace('PromptInputModel#onDidStartInput')));
-        this._register(this.onDidChangeInput(() => this._logCombinedStringIfTrace('PromptInputModel#onDidChangeInput')));
-        this._register(this.onDidFinishInput(() => this._logCombinedStringIfTrace('PromptInputModel#onDidFinishInput')));
-        this._register(this.onDidInterrupt(() => this._logCombinedStringIfTrace('PromptInputModel#onDidInterrupt')));
-    }
-    _logCombinedStringIfTrace(message) {
-        if (this._logService.getLevel() === LogLevel.Trace) {
-            this._logService.trace(message, this.getCombinedString());
-        }
-    }
-    setContinuationPrompt(value) {
-        this._continuationPrompt = value;
-        this._sync();
-    }
-    setLastPromptLine(value) {
-        this._lastPromptLine = value;
-        this._sync();
-    }
-    setConfidentCommandLine(value) {
-        if (this._value !== value) {
-            this._value = value;
-            this._cursorIndex = -1;
-            this._ghostTextIndex = -1;
-            this._onDidChangeInput.fire(this._createStateObject());
-        }
-    }
-    getCombinedString() {
-        const value = this._value.replaceAll('\n', '\u23CE');
-        if (this._cursorIndex === -1) {
-            return value;
-        }
-        let result = `${value.substring(0, this.cursorIndex)}|`;
-        if (this.ghostTextIndex !== -1) {
-            result += `${value.substring(this.cursorIndex, this.ghostTextIndex)}[`;
-            result += `${value.substring(this.ghostTextIndex)}]`;
-        }
-        else {
-            result += value.substring(this.cursorIndex);
-        }
-        return result;
-    }
-    serialize() {
-        return {
-            modelState: this._createStateObject(),
-            commandStartX: this._commandStartX,
-            lastPromptLine: this._lastPromptLine,
-            continuationPrompt: this._continuationPrompt,
-            lastUserInput: this._lastUserInput
-        };
-    }
-    deserialize(serialized) {
-        this._value = serialized.modelState.value;
-        this._cursorIndex = serialized.modelState.cursorIndex;
-        this._ghostTextIndex = serialized.modelState.ghostTextIndex;
-        this._commandStartX = serialized.commandStartX;
-        this._lastPromptLine = serialized.lastPromptLine;
-        this._continuationPrompt = serialized.continuationPrompt;
-        this._lastUserInput = serialized.lastUserInput;
-    }
-    _handleCommandStart(command) {
-        if (this._state === 1 ) {
-            return;
-        }
-        this._state = 1 ;
-        this._commandStartMarker = command.marker;
-        this._commandStartX = this._xterm.buffer.active.cursorX;
-        this._value = '';
-        this._cursorIndex = 0;
-        this._onDidStartInput.fire(this._createStateObject());
-        this._onDidChangeInput.fire(this._createStateObject());
-        if (this._lastPromptLine) {
-            if (this._commandStartX !== this._lastPromptLine.length) {
-                const line = this._xterm.buffer.active.getLine(this._commandStartMarker.line);
-                if (line?.translateToString(true).startsWith(this._lastPromptLine)) {
-                    this._commandStartX = this._lastPromptLine.length;
-                    this._sync();
-                }
-            }
-        }
-    }
-    _handleCommandExecuted() {
-        if (this._state === 2 ) {
-            return;
-        }
-        this._cursorIndex = -1;
-        if (this._ghostTextIndex !== -1) {
-            this._value = this._value.substring(0, this._ghostTextIndex);
-            this._ghostTextIndex = -1;
-        }
-        const event = this._createStateObject();
-        if (this._lastUserInput === '\u0003') {
-            this._lastUserInput = '';
-            this._onDidInterrupt.fire(event);
-        }
-        this._state = 2 ;
-        this._onDidFinishInput.fire(event);
-        this._onDidChangeInput.fire(event);
-    }
-    _sync() {
-        try {
-            this._doSync();
-        }
-        catch (e) {
-            this._logService.error('Error while syncing prompt input model', e);
-        }
-    }
-    _doSync() {
-        if (this._state !== 1 ) {
-            return;
-        }
-        const commandStartY = this._commandStartMarker?.line;
-        if (commandStartY === undefined) {
-            return;
-        }
-        const buffer = this._xterm.buffer.active;
-        let line = buffer.getLine(commandStartY);
-        const commandLine = line?.translateToString(true, this._commandStartX);
-        if (!line || commandLine === undefined) {
-            this._logService.trace(`PromptInputModel#_sync: no line`);
-            return;
-        }
-        const absoluteCursorY = buffer.baseY + buffer.cursorY;
-        let value = commandLine;
-        let ghostTextIndex = -1;
-        let cursorIndex;
-        if (absoluteCursorY === commandStartY) {
-            cursorIndex = this._getRelativeCursorIndex(this._commandStartX, buffer, line);
-        }
-        else {
-            cursorIndex = commandLine.trimEnd().length;
-        }
-        if (absoluteCursorY === commandStartY && buffer.cursorX > 1) {
-            ghostTextIndex = this._scanForGhostText(buffer, line, cursorIndex);
-        }
-        for (let y = commandStartY + 1; y <= absoluteCursorY; y++) {
-            line = buffer.getLine(y);
-            const lineText = line?.translateToString(true);
-            if (lineText && line) {
-                if (line.isWrapped) {
-                    value += lineText;
-                    const relativeCursorIndex = this._getRelativeCursorIndex(0, buffer, line);
-                    if (absoluteCursorY === y) {
-                        cursorIndex += relativeCursorIndex;
-                    }
-                    else {
-                        cursorIndex += lineText.length;
-                    }
-                }
-                else if (this._continuationPrompt === undefined || this._lineContainsContinuationPrompt(lineText)) {
-                    const trimmedLineText = this._trimContinuationPrompt(lineText);
-                    value += `\n${trimmedLineText}`;
-                    if (absoluteCursorY === y) {
-                        const continuationCellWidth = this._getContinuationPromptCellWidth(line, lineText);
-                        const relativeCursorIndex = this._getRelativeCursorIndex(continuationCellWidth, buffer, line);
-                        cursorIndex += relativeCursorIndex + 1;
-                    }
-                    else {
-                        cursorIndex += trimmedLineText.length + 1;
-                    }
-                }
-                else {
-                    break;
-                }
-            }
-        }
-        for (let y = absoluteCursorY + 1; y < buffer.baseY + this._xterm.rows; y++) {
-            line = buffer.getLine(y);
-            const lineText = line?.translateToString(true);
-            if (lineText && line) {
-                if (this._continuationPrompt === undefined || this._lineContainsContinuationPrompt(lineText)) {
-                    value += `\n${this._trimContinuationPrompt(lineText)}`;
-                }
-                else {
-                    break;
-                }
-            }
-            else {
-                break;
-            }
-        }
-        if (this._logService.getLevel() === LogLevel.Trace) {
-            this._logService.trace(`PromptInputModel#_sync: ${this.getCombinedString()}`);
-        }
-        {
-            let trailingWhitespace = this._value.length - this._value.trimEnd().length;
-            if (this._lastUserInput === '\x7F') {
-                this._lastUserInput = '';
-                if (cursorIndex === this._cursorIndex - 1) {
-                    if (this._value.trimEnd().length > value.trimEnd().length && value.trimEnd().length <= cursorIndex) {
-                        trailingWhitespace = Math.max((this._value.length - 1) - value.trimEnd().length, 0);
-                    }
-                    else {
-                        trailingWhitespace = Math.max(trailingWhitespace - 1, 0);
-                    }
-                }
-            }
-            if (this._lastUserInput === '\x1b[3~') {
-                this._lastUserInput = '';
-                if (cursorIndex === this._cursorIndex) {
-                    trailingWhitespace = Math.max(trailingWhitespace - 1, 0);
-                }
-            }
-            const valueLines = value.split('\n');
-            const isMultiLine = valueLines.length > 1;
-            const valueEndTrimmed = value.trimEnd();
-            if (!isMultiLine) {
-                if (valueEndTrimmed.length < value.length) {
-                    if (this._lastUserInput === ' ') {
-                        this._lastUserInput = '';
-                        if (cursorIndex > valueEndTrimmed.length && cursorIndex > this._cursorIndex) {
-                            trailingWhitespace++;
-                        }
-                    }
-                    trailingWhitespace = Math.max(cursorIndex - valueEndTrimmed.length, trailingWhitespace, 0);
-                }
-                const charBeforeCursor = cursorIndex === 0 ? '' : value[cursorIndex - 1];
-                if (trailingWhitespace > 0 && cursorIndex === this._cursorIndex + 1 && this._lastUserInput !== '' && charBeforeCursor !== ' ') {
-                    trailingWhitespace = this._value.length - this._cursorIndex;
-                }
-            }
-            if (isMultiLine) {
-                valueLines[valueLines.length - 1] = valueLines.at(-1)?.trimEnd() ?? '';
-                const continuationOffset = (valueLines.length - 1) * (this._continuationPrompt?.length ?? 0);
-                trailingWhitespace = Math.max(0, cursorIndex - value.length - continuationOffset);
-            }
-            value = ( valueLines.map(e => e.trimEnd())).join('\n') + ' '.repeat(trailingWhitespace);
-        }
-        if (this._value !== value || this._cursorIndex !== cursorIndex || this._ghostTextIndex !== ghostTextIndex) {
-            this._value = value;
-            this._cursorIndex = cursorIndex;
-            this._ghostTextIndex = ghostTextIndex;
-            this._onDidChangeInput.fire(this._createStateObject());
-        }
-    }
-    _handleUserInput(e) {
-        this._lastUserInput = e;
-    }
-    _scanForGhostText(buffer, line, cursorIndex) {
-        let ghostTextIndex = -1;
-        let proceedWithGhostTextCheck = false;
-        let x = buffer.cursorX;
-        while (x > 0) {
-            const cell = line.getCell(--x);
-            if (!cell) {
-                break;
-            }
-            if (cell.getChars().trim().length > 0) {
-                proceedWithGhostTextCheck = !this._isCellStyledLikeGhostText(cell);
-                break;
-            }
-        }
-        if (proceedWithGhostTextCheck) {
-            let potentialGhostIndexOffset = 0;
-            let x = buffer.cursorX;
-            while (x < line.length) {
-                const cell = line.getCell(x++);
-                if (!cell || cell.getCode() === 0) {
-                    break;
-                }
-                if (this._isCellStyledLikeGhostText(cell)) {
-                    ghostTextIndex = cursorIndex + potentialGhostIndexOffset;
-                    break;
-                }
-                potentialGhostIndexOffset += cell.getChars().length;
-            }
-        }
-        return ghostTextIndex;
-    }
-    _trimContinuationPrompt(lineText) {
-        if (this._lineContainsContinuationPrompt(lineText)) {
-            lineText = lineText.substring(this._continuationPrompt.length);
-        }
-        return lineText;
-    }
-    _lineContainsContinuationPrompt(lineText) {
-        return !!(this._continuationPrompt && lineText.startsWith(this._continuationPrompt));
-    }
-    _getContinuationPromptCellWidth(line, lineText) {
-        if (!this._continuationPrompt || !lineText.startsWith(this._continuationPrompt)) {
-            return 0;
-        }
-        let buffer = '';
-        let x = 0;
-        while (buffer !== this._continuationPrompt) {
-            buffer += line.getCell(x++).getChars();
-        }
-        return x;
-    }
-    _getRelativeCursorIndex(startCellX, buffer, line) {
-        return line?.translateToString(true, startCellX, buffer.cursorX).length ?? 0;
-    }
-    _isCellStyledLikeGhostText(cell) {
-        return !!(cell.isItalic() || cell.isDim());
-    }
-    _createStateObject() {
-        return ( Object.freeze({
-            value: this._value,
-            prefix: this.prefix,
-            suffix: this.suffix,
-            cursorIndex: this._cursorIndex,
-            ghostTextIndex: this._ghostTextIndex
-        }));
-    }
-};
-PromptInputModel.__decorator = ( __decorate([
-    throttle(0)
-], PromptInputModel.prototype, "_sync", null));
-PromptInputModel = ( __decorate([
-    ( __param(3, ILogService))
-], PromptInputModel));
-export { PromptInputModel };

package/vscode/src/vs/platform/terminal/common/capabilities/commandDetection/terminalCommand.js

@@ -1,296 +0,0 @@
-class TerminalCommand {
-    get command() { return this._properties.command; }
-    get commandLineConfidence() { return this._properties.commandLineConfidence; }
-    get isTrusted() { return this._properties.isTrusted; }
-    get timestamp() { return this._properties.timestamp; }
-    get duration() { return this._properties.duration; }
-    get promptStartMarker() { return this._properties.promptStartMarker; }
-    get marker() { return this._properties.marker; }
-    get endMarker() { return this._properties.endMarker; }
-    set endMarker(value) { this._properties.endMarker = value; }
-    get executedMarker() { return this._properties.executedMarker; }
-    get aliases() { return this._properties.aliases; }
-    get wasReplayed() { return this._properties.wasReplayed; }
-    get cwd() { return this._properties.cwd; }
-    get exitCode() { return this._properties.exitCode; }
-    get commandStartLineContent() { return this._properties.commandStartLineContent; }
-    get markProperties() { return this._properties.markProperties; }
-    get executedX() { return this._properties.executedX; }
-    get startX() { return this._properties.startX; }
-    constructor(_xterm, _properties) {
-        this._xterm = _xterm;
-        this._properties = _properties;
-    }
-    static deserialize(xterm, serialized, isCommandStorageDisabled) {
-        const buffer = xterm.buffer.normal;
-        const marker = serialized.startLine !== undefined ? xterm.registerMarker(serialized.startLine - (buffer.baseY + buffer.cursorY)) : undefined;
-        if (!marker) {
-            return undefined;
-        }
-        const promptStartMarker = serialized.promptStartLine !== undefined ? xterm.registerMarker(serialized.promptStartLine - (buffer.baseY + buffer.cursorY)) : undefined;
-        const endMarker = serialized.endLine !== undefined ? xterm.registerMarker(serialized.endLine - (buffer.baseY + buffer.cursorY)) : undefined;
-        const executedMarker = serialized.executedLine !== undefined ? xterm.registerMarker(serialized.executedLine - (buffer.baseY + buffer.cursorY)) : undefined;
-        const newCommand = ( new TerminalCommand(xterm, {
-            command: isCommandStorageDisabled ? '' : serialized.command,
-            commandLineConfidence: serialized.commandLineConfidence ?? 'low',
-            isTrusted: serialized.isTrusted,
-            promptStartMarker,
-            marker,
-            startX: serialized.startX,
-            endMarker,
-            executedMarker,
-            executedX: serialized.executedX,
-            timestamp: serialized.timestamp,
-            duration: serialized.duration,
-            cwd: serialized.cwd,
-            commandStartLineContent: serialized.commandStartLineContent,
-            exitCode: serialized.exitCode,
-            markProperties: serialized.markProperties,
-            aliases: undefined,
-            wasReplayed: true
-        }));
-        return newCommand;
-    }
-    serialize(isCommandStorageDisabled) {
-        return {
-            promptStartLine: this.promptStartMarker?.line,
-            startLine: this.marker?.line,
-            startX: undefined,
-            endLine: this.endMarker?.line,
-            executedLine: this.executedMarker?.line,
-            executedX: this.executedX,
-            command: isCommandStorageDisabled ? '' : this.command,
-            commandLineConfidence: isCommandStorageDisabled ? 'low' : this.commandLineConfidence,
-            isTrusted: this.isTrusted,
-            cwd: this.cwd,
-            exitCode: this.exitCode,
-            commandStartLineContent: this.commandStartLineContent,
-            timestamp: this.timestamp,
-            duration: this.duration,
-            markProperties: this.markProperties,
-        };
-    }
-    extractCommandLine() {
-        return extractCommandLine(this._xterm.buffer.active, this._xterm.cols, this.marker, this.startX, this.executedMarker, this.executedX);
-    }
-    getOutput() {
-        if (!this.executedMarker || !this.endMarker) {
-            return undefined;
-        }
-        const startLine = this.executedMarker.line;
-        const endLine = this.endMarker.line;
-        if (startLine === endLine) {
-            return undefined;
-        }
-        let output = '';
-        let line;
-        for (let i = startLine; i < endLine; i++) {
-            line = this._xterm.buffer.active.getLine(i);
-            if (!line) {
-                continue;
-            }
-            output += line.translateToString(!line.isWrapped) + (line.isWrapped ? '' : '\n');
-        }
-        return output === '' ? undefined : output;
-    }
-    getOutputMatch(outputMatcher) {
-        if (!this.executedMarker || !this.endMarker) {
-            return undefined;
-        }
-        const endLine = this.endMarker.line;
-        if (endLine === -1) {
-            return undefined;
-        }
-        const buffer = this._xterm.buffer.active;
-        const startLine = Math.max(this.executedMarker.line, 0);
-        const matcher = outputMatcher.lineMatcher;
-        const linesToCheck = typeof matcher === 'string' ? 1 : outputMatcher.length || countNewLines(matcher);
-        const lines = [];
-        let match;
-        if (outputMatcher.anchor === 'bottom') {
-            for (let i = endLine - (outputMatcher.offset || 0); i >= startLine; i--) {
-                let wrappedLineStart = i;
-                const wrappedLineEnd = i;
-                while (wrappedLineStart >= startLine && buffer.getLine(wrappedLineStart)?.isWrapped) {
-                    wrappedLineStart--;
-                }
-                i = wrappedLineStart;
-                lines.unshift(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, this._xterm.cols));
-                if (!match) {
-                    match = lines[0].match(matcher);
-                }
-                if (lines.length >= linesToCheck) {
-                    break;
-                }
-            }
-        }
-        else {
-            for (let i = startLine + (outputMatcher.offset || 0); i < endLine; i++) {
-                const wrappedLineStart = i;
-                let wrappedLineEnd = i;
-                while (wrappedLineEnd + 1 < endLine && buffer.getLine(wrappedLineEnd + 1)?.isWrapped) {
-                    wrappedLineEnd++;
-                }
-                i = wrappedLineEnd;
-                lines.push(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, this._xterm.cols));
-                if (!match) {
-                    match = lines[lines.length - 1].match(matcher);
-                }
-                if (lines.length >= linesToCheck) {
-                    break;
-                }
-            }
-        }
-        return match ? { regexMatch: match, outputLines: lines } : undefined;
-    }
-    hasOutput() {
-        return (!this.executedMarker?.isDisposed &&
-            !this.endMarker?.isDisposed &&
-            !!(this.executedMarker &&
-                this.endMarker &&
-                this.executedMarker.line < this.endMarker.line));
-    }
-    getPromptRowCount() {
-        return getPromptRowCount(this, this._xterm.buffer.active);
-    }
-    getCommandRowCount() {
-        return getCommandRowCount(this);
-    }
-}
-class PartialTerminalCommand {
-    constructor(_xterm) {
-        this._xterm = _xterm;
-    }
-    serialize(cwd) {
-        if (!this.commandStartMarker) {
-            return undefined;
-        }
-        return {
-            promptStartLine: this.promptStartMarker?.line,
-            startLine: this.commandStartMarker.line,
-            startX: this.commandStartX,
-            endLine: undefined,
-            executedLine: undefined,
-            executedX: undefined,
-            command: '',
-            commandLineConfidence: 'low',
-            isTrusted: true,
-            cwd,
-            exitCode: undefined,
-            commandStartLineContent: undefined,
-            timestamp: 0,
-            duration: 0,
-            markProperties: undefined
-        };
-    }
-    promoteToFullCommand(cwd, exitCode, ignoreCommandLine, markProperties) {
-        if (exitCode === undefined && this.command === undefined) {
-            this.command = '';
-        }
-        if ((this.command !== undefined && !this.command.startsWith('\\')) || ignoreCommandLine) {
-            return ( new TerminalCommand(this._xterm, {
-                command: ignoreCommandLine ? '' : (this.command || ''),
-                commandLineConfidence: ignoreCommandLine ? 'low' : (this.commandLineConfidence || 'low'),
-                isTrusted: !!this.isTrusted,
-                promptStartMarker: this.promptStartMarker,
-                marker: this.commandStartMarker,
-                startX: this.commandStartX,
-                endMarker: this.commandFinishedMarker,
-                executedMarker: this.commandExecutedMarker,
-                executedX: this.commandExecutedX,
-                timestamp: Date.now(),
-                duration: this.commandDuration || 0,
-                cwd,
-                exitCode,
-                commandStartLineContent: this.commandStartLineContent,
-                markProperties
-            }));
-        }
-        return undefined;
-    }
-    markExecutedTime() {
-        if (this.commandExecutedTimestamp === undefined) {
-            this.commandExecutedTimestamp = Date.now();
-        }
-    }
-    markFinishedTime() {
-        if (this.commandDuration === undefined && this.commandExecutedTimestamp !== undefined) {
-            this.commandDuration = Date.now() - this.commandExecutedTimestamp;
-        }
-    }
-    extractCommandLine() {
-        return extractCommandLine(this._xterm.buffer.active, this._xterm.cols, this.commandStartMarker, this.commandStartX, this.commandExecutedMarker, this.commandExecutedX);
-    }
-    getPromptRowCount() {
-        return getPromptRowCount(this, this._xterm.buffer.active);
-    }
-    getCommandRowCount() {
-        return getCommandRowCount(this);
-    }
-}
-function extractCommandLine(buffer, cols, commandStartMarker, commandStartX, commandExecutedMarker, commandExecutedX) {
-    if (!commandStartMarker || !commandExecutedMarker || commandStartX === undefined || commandExecutedX === undefined) {
-        return '';
-    }
-    let content = '';
-    for (let i = commandStartMarker.line; i <= commandExecutedMarker.line; i++) {
-        const line = buffer.getLine(i);
-        if (line) {
-            content += line.translateToString(true, i === commandStartMarker.line ? commandStartX : 0, i === commandExecutedMarker.line ? commandExecutedX : cols);
-        }
-    }
-    return content;
-}
-function getXtermLineContent(buffer, lineStart, lineEnd, cols) {
-    const maxLineLength = Math.max(2048 / cols * 2);
-    lineEnd = Math.min(lineEnd, lineStart + maxLineLength);
-    let content = '';
-    for (let i = lineStart; i <= lineEnd; i++) {
-        const line = buffer.getLine(i);
-        if (line) {
-            content += line.translateToString(true, 0, cols);
-        }
-    }
-    return content;
-}
-function countNewLines(regex) {
-    if (!regex.multiline) {
-        return 1;
-    }
-    const source = regex.source;
-    let count = 1;
-    let i = source.indexOf('\\n');
-    while (i !== -1) {
-        count++;
-        i = source.indexOf('\\n', i + 1);
-    }
-    return count;
-}
-function getPromptRowCount(command, buffer) {
-    const marker = 'hasOutput' in command ? command.marker : command.commandStartMarker;
-    if (!marker || !command.promptStartMarker) {
-        return 1;
-    }
-    let promptRowCount = 1;
-    let promptStartLine = command.promptStartMarker.line;
-    while (promptStartLine < marker.line && (buffer.getLine(promptStartLine)?.translateToString(true) ?? '').length === 0) {
-        promptStartLine++;
-    }
-    promptRowCount = marker.line - promptStartLine + 1;
-    return promptRowCount;
-}
-function getCommandRowCount(command) {
-    const marker = 'hasOutput' in command ? command.marker : command.commandStartMarker;
-    const executedMarker = 'hasOutput' in command ? command.executedMarker : command.commandExecutedMarker;
-    if (!marker || !executedMarker) {
-        return 1;
-    }
-    const commandExecutedLine = Math.max(executedMarker.line, marker.line);
-    let commandRowCount = commandExecutedLine - marker.line + 1;
-    const executedX = 'hasOutput' in command ? command.executedX : command.commandExecutedX;
-    if (executedX === 0) {
-        commandRowCount--;
-    }
-    return commandRowCount;
-}
-export { PartialTerminalCommand, TerminalCommand };