@codingame/monaco-vscode-api 10.1.0 → 10.1.1

package/vscode/src/vs/platform/terminal/common/capabilities/commandDetectionCapability.js

@@ -1,761 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { RunOnceScheduler } from '../../../../base/common/async.js';
-import { debounce } from '../../../../base/common/decorators.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { Disposable, MandatoryMutableDisposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
-import { ILogService } from '../../../log/common/log.service.js';
-import { PartialTerminalCommand, TerminalCommand } from './commandDetection/terminalCommand.js';
-import { PromptInputModel } from './commandDetection/promptInputModel.js';
-let CommandDetectionCapability = class CommandDetectionCapability extends Disposable {
-    get promptInputModel() { return this._promptInputModel; }
-    get commands() { return this._commands; }
-    get executingCommand() { return this._currentCommand.command; }
-    get executingCommandObject() {
-        if (this._currentCommand.commandStartMarker) {
-            return { marker: this._currentCommand.commandStartMarker };
-        }
-        return undefined;
-    }
-    get currentCommand() {
-        return this._currentCommand;
-    }
-    get cwd() { return this._cwd; }
-    get promptTerminator() { return this._promptTerminator; }
-    constructor(_terminal, _logService) {
-        super();
-        this._terminal = _terminal;
-        this._logService = _logService;
-        this.type = 2 ;
-        this._commands = [];
-        this._currentCommand = ( new PartialTerminalCommand(this._terminal));
-        this._commandMarkers = [];
-        this.__isCommandStorageDisabled = false;
-        this._onCommandStarted = this._register(( new Emitter()));
-        this.onCommandStarted = this._onCommandStarted.event;
-        this._onBeforeCommandFinished = this._register(( new Emitter()));
-        this.onBeforeCommandFinished = this._onBeforeCommandFinished.event;
-        this._onCommandFinished = this._register(( new Emitter()));
-        this.onCommandFinished = this._onCommandFinished.event;
-        this._onCommandExecuted = this._register(( new Emitter()));
-        this.onCommandExecuted = this._onCommandExecuted.event;
-        this._onCommandInvalidated = this._register(( new Emitter()));
-        this.onCommandInvalidated = this._onCommandInvalidated.event;
-        this._onCurrentCommandInvalidated = this._register(( new Emitter()));
-        this.onCurrentCommandInvalidated = this._onCurrentCommandInvalidated.event;
-        this._promptInputModel = this._register(( new PromptInputModel(
-            this._terminal,
-            this.onCommandStarted,
-            this.onCommandExecuted,
-            this._logService
-        )));
-        this._register(this.onCommandExecuted(command => {
-            if (command.commandLineConfidence !== 'high') {
-                const typedCommand = command;
-                command.command = typedCommand.extractCommandLine();
-                command.commandLineConfidence = 'low';
-                if ('getOutput' in typedCommand) {
-                    if (
-                    typedCommand.promptStartMarker && typedCommand.marker && typedCommand.executedMarker &&
-                        command.command.indexOf('\n') === -1 &&
-                        typedCommand.startX !== undefined && typedCommand.startX > 0) {
-                        command.commandLineConfidence = 'medium';
-                    }
-                }
-                else {
-                    if (
-                    typedCommand.promptStartMarker && typedCommand.commandStartMarker && typedCommand.commandExecutedMarker &&
-                        command.command.indexOf('\n') === -1 &&
-                        typedCommand.commandStartX !== undefined && typedCommand.commandStartX > 0) {
-                        command.commandLineConfidence = 'medium';
-                    }
-                }
-            }
-        }));
-        const that = this;
-        this._ptyHeuristicsHooks = new (class {
-            get onCurrentCommandInvalidatedEmitter() { return that._onCurrentCommandInvalidated; }
-            get onCommandStartedEmitter() { return that._onCommandStarted; }
-            get onCommandExecutedEmitter() { return that._onCommandExecuted; }
-            get dimensions() { return that._dimensions; }
-            get isCommandStorageDisabled() { return that.__isCommandStorageDisabled; }
-            get commandMarkers() { return that._commandMarkers; }
-            set commandMarkers(value) { that._commandMarkers = value; }
-            get clearCommandsInViewport() { return that._clearCommandsInViewport.bind(that); }
-            commitCommandFinished() {
-                that._commitCommandFinished?.flush();
-                that._commitCommandFinished = undefined;
-            }
-        });
-        this._ptyHeuristics = this._register(( new MandatoryMutableDisposable(( new UnixPtyHeuristics(this._terminal, this, this._ptyHeuristicsHooks, this._logService)))));
-        this._dimensions = {
-            cols: this._terminal.cols,
-            rows: this._terminal.rows
-        };
-        this._register(this._terminal.onResize(e => this._handleResize(e)));
-        this._register(this._terminal.onCursorMove(() => this._handleCursorMove()));
-    }
-    _handleResize(e) {
-        this._ptyHeuristics.value.preHandleResize?.(e);
-        this._dimensions.cols = e.cols;
-        this._dimensions.rows = e.rows;
-    }
-    _handleCursorMove() {
-        if (this._store.isDisposed) {
-            return;
-        }
-        if (this._terminal.buffer.active === this._terminal.buffer.normal && this._currentCommand.commandStartMarker) {
-            if (this._terminal.buffer.active.baseY + this._terminal.buffer.active.cursorY < this._currentCommand.commandStartMarker.line) {
-                this._clearCommandsInViewport();
-                this._currentCommand.isInvalid = true;
-                this._onCurrentCommandInvalidated.fire({ reason: "windows"  });
-            }
-        }
-    }
-    _clearCommandsInViewport() {
-        let count = 0;
-        for (let i = this._commands.length - 1; i >= 0; i--) {
-            const line = this._commands[i].marker?.line;
-            if (line && line < this._terminal.buffer.active.baseY) {
-                break;
-            }
-            count++;
-        }
-        if (count > 0) {
-            this._onCommandInvalidated.fire(this._commands.splice(this._commands.length - count, count));
-        }
-    }
-    setContinuationPrompt(value) {
-        this._promptInputModel.setContinuationPrompt(value);
-    }
-    setPromptTerminator(promptTerminator, lastPromptLine) {
-        this._logService.debug('CommandDetectionCapability#setPromptTerminator', promptTerminator);
-        this._promptTerminator = promptTerminator;
-        this._promptInputModel.setLastPromptLine(lastPromptLine);
-    }
-    setCwd(value) {
-        this._cwd = value;
-    }
-    setIsWindowsPty(value) {
-        if (value && !(this._ptyHeuristics.value instanceof WindowsPtyHeuristics)) {
-            const that = this;
-            this._ptyHeuristics.value = ( new WindowsPtyHeuristics(this._terminal, this, new (class {
-                get onCurrentCommandInvalidatedEmitter() { return that._onCurrentCommandInvalidated; }
-                get onCommandStartedEmitter() { return that._onCommandStarted; }
-                get onCommandExecutedEmitter() { return that._onCommandExecuted; }
-                get dimensions() { return that._dimensions; }
-                get isCommandStorageDisabled() { return that.__isCommandStorageDisabled; }
-                get commandMarkers() { return that._commandMarkers; }
-                set commandMarkers(value) { that._commandMarkers = value; }
-                get clearCommandsInViewport() { return that._clearCommandsInViewport.bind(that); }
-                commitCommandFinished() {
-                    that._commitCommandFinished?.flush();
-                    that._commitCommandFinished = undefined;
-                }
-            }), this._logService));
-        }
-        else if (!value && !(this._ptyHeuristics.value instanceof UnixPtyHeuristics)) {
-            this._ptyHeuristics.value = ( new UnixPtyHeuristics(this._terminal, this, this._ptyHeuristicsHooks, this._logService));
-        }
-    }
-    setIsCommandStorageDisabled() {
-        this.__isCommandStorageDisabled = true;
-    }
-    getCommandForLine(line) {
-        if (this._currentCommand.promptStartMarker && line >= this._currentCommand.promptStartMarker?.line) {
-            return this._currentCommand;
-        }
-        if (this._commands.length === 0) {
-            return undefined;
-        }
-        if ((this._commands[0].promptStartMarker ?? this._commands[0].marker).line > line) {
-            return undefined;
-        }
-        for (let i = this.commands.length - 1; i >= 0; i--) {
-            if ((this.commands[i].promptStartMarker ?? this.commands[i].marker).line <= line) {
-                return this.commands[i];
-            }
-        }
-        return undefined;
-    }
-    getCwdForLine(line) {
-        if (this._currentCommand.promptStartMarker && line >= this._currentCommand.promptStartMarker?.line) {
-            return this._cwd;
-        }
-        const command = this.getCommandForLine(line);
-        if (command && 'cwd' in command) {
-            return command.cwd;
-        }
-        return undefined;
-    }
-    handlePromptStart(options) {
-        const lastCommand = this.commands.at(-1);
-        if (lastCommand?.endMarker && lastCommand?.executedMarker && lastCommand.endMarker.line === lastCommand.executedMarker.line) {
-            this._logService.debug('CommandDetectionCapability#handlePromptStart adjusted commandFinished', `${lastCommand.endMarker.line} -> ${lastCommand.executedMarker.line + 1}`);
-            lastCommand.endMarker = cloneMarker(this._terminal, lastCommand.executedMarker, 1);
-        }
-        this._currentCommand.promptStartMarker = options?.marker || (lastCommand?.endMarker ? cloneMarker(this._terminal, lastCommand.endMarker) : this._terminal.registerMarker(0));
-        this._logService.debug('CommandDetectionCapability#handlePromptStart', this._terminal.buffer.active.cursorX, this._currentCommand.promptStartMarker?.line);
-    }
-    handleContinuationStart() {
-        this._currentCommand.currentContinuationMarker = this._terminal.registerMarker(0);
-        this._logService.debug('CommandDetectionCapability#handleContinuationStart', this._currentCommand.currentContinuationMarker);
-    }
-    handleContinuationEnd() {
-        if (!this._currentCommand.currentContinuationMarker) {
-            this._logService.warn('CommandDetectionCapability#handleContinuationEnd Received continuation end without start');
-            return;
-        }
-        if (!this._currentCommand.continuations) {
-            this._currentCommand.continuations = [];
-        }
-        this._currentCommand.continuations.push({
-            marker: this._currentCommand.currentContinuationMarker,
-            end: this._terminal.buffer.active.cursorX
-        });
-        this._currentCommand.currentContinuationMarker = undefined;
-        this._logService.debug('CommandDetectionCapability#handleContinuationEnd', this._currentCommand.continuations[this._currentCommand.continuations.length - 1]);
-    }
-    handleRightPromptStart() {
-        this._currentCommand.commandRightPromptStartX = this._terminal.buffer.active.cursorX;
-        this._logService.debug('CommandDetectionCapability#handleRightPromptStart', this._currentCommand.commandRightPromptStartX);
-    }
-    handleRightPromptEnd() {
-        this._currentCommand.commandRightPromptEndX = this._terminal.buffer.active.cursorX;
-        this._logService.debug('CommandDetectionCapability#handleRightPromptEnd', this._currentCommand.commandRightPromptEndX);
-    }
-    handleCommandStart(options) {
-        this._handleCommandStartOptions = options;
-        this._currentCommand.cwd = this._cwd;
-        this._currentCommand.commandStartMarker = options?.marker || this._currentCommand.commandStartMarker;
-        if (this._currentCommand.commandStartMarker?.line === this._terminal.buffer.active.cursorY) {
-            this._currentCommand.commandStartX = this._terminal.buffer.active.cursorX;
-            this._logService.debug('CommandDetectionCapability#handleCommandStart', this._currentCommand.commandStartX, this._currentCommand.commandStartMarker?.line);
-            return;
-        }
-        this._ptyHeuristics.value.handleCommandStart(options);
-    }
-    handleGenericCommand(options) {
-        if (options?.markProperties?.disableCommandStorage) {
-            this.setIsCommandStorageDisabled();
-        }
-        this.handlePromptStart(options);
-        this.handleCommandStart(options);
-        this.handleCommandExecuted(options);
-        this.handleCommandFinished(undefined, options);
-    }
-    handleCommandExecuted(options) {
-        this._ptyHeuristics.value.handleCommandExecuted(options);
-        this._currentCommand.markExecutedTime();
-    }
-    handleCommandFinished(exitCode, options) {
-        this._currentCommand.markFinishedTime();
-        this._ptyHeuristics.value.preHandleCommandFinished?.();
-        this._logService.debug('CommandDetectionCapability#handleCommandFinished', this._terminal.buffer.active.cursorX, options?.marker?.line, this._currentCommand.command, this._currentCommand);
-        if (exitCode === undefined) {
-            const lastCommand = this.commands.length > 0 ? this.commands[this.commands.length - 1] : undefined;
-            if (this._currentCommand.command && this._currentCommand.command.length > 0 && lastCommand?.command === this._currentCommand.command) {
-                exitCode = lastCommand.exitCode;
-            }
-        }
-        if (this._currentCommand.commandStartMarker === undefined || !this._terminal.buffer.active) {
-            return;
-        }
-        this._currentCommand.commandFinishedMarker = options?.marker || this._terminal.registerMarker(0);
-        this._ptyHeuristics.value.postHandleCommandFinished?.();
-        const newCommand = this._currentCommand.promoteToFullCommand(this._cwd, exitCode, this._handleCommandStartOptions?.ignoreCommandLine ?? false, options?.markProperties);
-        if (newCommand) {
-            this._commands.push(newCommand);
-            this._commitCommandFinished = ( new RunOnceScheduler(() => {
-                this._onBeforeCommandFinished.fire(newCommand);
-                if (!this._currentCommand.isInvalid) {
-                    this._logService.debug('CommandDetectionCapability#onCommandFinished', newCommand);
-                    this._onCommandFinished.fire(newCommand);
-                }
-            }, 50));
-            this._commitCommandFinished.schedule();
-        }
-        this._currentCommand = ( new PartialTerminalCommand(this._terminal));
-        this._handleCommandStartOptions = undefined;
-    }
-    setCommandLine(commandLine, isTrusted) {
-        this._logService.debug('CommandDetectionCapability#setCommandLine', commandLine, isTrusted);
-        this._currentCommand.command = commandLine;
-        this._currentCommand.commandLineConfidence = 'high';
-        this._currentCommand.isTrusted = isTrusted;
-        if (isTrusted) {
-            this._promptInputModel.setConfidentCommandLine(commandLine);
-        }
-    }
-    serialize() {
-        const commands = ( this.commands.map(e => e.serialize(this.__isCommandStorageDisabled)));
-        const partialCommand = this._currentCommand.serialize(this._cwd);
-        if (partialCommand) {
-            commands.push(partialCommand);
-        }
-        return {
-            isWindowsPty: this._ptyHeuristics.value instanceof WindowsPtyHeuristics,
-            commands,
-            promptInputModel: this._promptInputModel.serialize(),
-        };
-    }
-    deserialize(serialized) {
-        if (serialized.isWindowsPty) {
-            this.setIsWindowsPty(serialized.isWindowsPty);
-        }
-        const buffer = this._terminal.buffer.normal;
-        for (const e of serialized.commands) {
-            if (!e.endLine) {
-                const marker = e.startLine !== undefined ? this._terminal.registerMarker(e.startLine - (buffer.baseY + buffer.cursorY)) : undefined;
-                if (!marker) {
-                    continue;
-                }
-                this._currentCommand.commandStartMarker = e.startLine !== undefined ? this._terminal.registerMarker(e.startLine - (buffer.baseY + buffer.cursorY)) : undefined;
-                this._currentCommand.commandStartX = e.startX;
-                this._currentCommand.promptStartMarker = e.promptStartLine !== undefined ? this._terminal.registerMarker(e.promptStartLine - (buffer.baseY + buffer.cursorY)) : undefined;
-                this._cwd = e.cwd;
-                this._onCommandStarted.fire({ marker });
-                continue;
-            }
-            const newCommand = TerminalCommand.deserialize(this._terminal, e, this.__isCommandStorageDisabled);
-            if (!newCommand) {
-                continue;
-            }
-            this._commands.push(newCommand);
-            this._logService.debug('CommandDetectionCapability#onCommandFinished', newCommand);
-            this._onCommandFinished.fire(newCommand);
-        }
-        if (serialized.promptInputModel) {
-            this._promptInputModel.deserialize(serialized.promptInputModel);
-        }
-    }
-};
-CommandDetectionCapability.__decorator = ( __decorate([
-    debounce(500)
-], CommandDetectionCapability.prototype, "_handleCursorMove", null));
-CommandDetectionCapability = ( __decorate([
-    ( __param(1, ILogService))
-], CommandDetectionCapability));
-class UnixPtyHeuristics extends Disposable {
-    constructor(_terminal, _capability, _hooks, _logService) {
-        super();
-        this._terminal = _terminal;
-        this._capability = _capability;
-        this._hooks = _hooks;
-        this._logService = _logService;
-        this._register(_terminal.parser.registerCsiHandler({ final: 'J' }, params => {
-            if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
-                _hooks.clearCommandsInViewport();
-            }
-            return false;
-        }));
-    }
-    handleCommandStart(options) {
-        this._hooks.commitCommandFinished();
-        const currentCommand = this._capability.currentCommand;
-        currentCommand.commandStartX = this._terminal.buffer.active.cursorX;
-        currentCommand.commandStartMarker = options?.marker || this._terminal.registerMarker(0);
-        currentCommand.commandExecutedMarker?.dispose();
-        currentCommand.commandExecutedMarker = undefined;
-        currentCommand.commandExecutedX = undefined;
-        for (const m of this._hooks.commandMarkers) {
-            m.dispose();
-        }
-        this._hooks.commandMarkers.length = 0;
-        this._hooks.onCommandStartedEmitter.fire({ marker: options?.marker || currentCommand.commandStartMarker, markProperties: options?.markProperties });
-        this._logService.debug('CommandDetectionCapability#handleCommandStart', currentCommand.commandStartX, currentCommand.commandStartMarker?.line);
-    }
-    handleCommandExecuted(options) {
-        const currentCommand = this._capability.currentCommand;
-        currentCommand.commandExecutedMarker = options?.marker || this._terminal.registerMarker(0);
-        currentCommand.commandExecutedX = this._terminal.buffer.active.cursorX;
-        this._logService.debug('CommandDetectionCapability#handleCommandExecuted', currentCommand.commandExecutedX, currentCommand.commandExecutedMarker?.line);
-        if (!currentCommand.commandStartMarker || !currentCommand.commandExecutedMarker || currentCommand.commandStartX === undefined) {
-            return;
-        }
-        currentCommand.command = this._hooks.isCommandStorageDisabled ? '' : this._terminal.buffer.active.getLine(currentCommand.commandStartMarker.line)?.translateToString(true, currentCommand.commandStartX, currentCommand.commandRightPromptStartX).trim();
-        let y = currentCommand.commandStartMarker.line + 1;
-        const commandExecutedLine = currentCommand.commandExecutedMarker.line;
-        for (; y < commandExecutedLine; y++) {
-            const line = this._terminal.buffer.active.getLine(y);
-            if (line) {
-                const continuation = currentCommand.continuations?.find(e => e.marker.line === y);
-                if (continuation) {
-                    currentCommand.command += '\n';
-                }
-                const startColumn = continuation?.end ?? 0;
-                currentCommand.command += line.translateToString(true, startColumn);
-            }
-        }
-        if (y === commandExecutedLine) {
-            currentCommand.command += this._terminal.buffer.active.getLine(commandExecutedLine)?.translateToString(true, undefined, currentCommand.commandExecutedX) || '';
-        }
-        this._hooks.onCommandExecutedEmitter.fire(currentCommand);
-    }
-}
-let WindowsPtyHeuristics = class WindowsPtyHeuristics extends Disposable {
-    constructor(_terminal, _capability, _hooks, _logService) {
-        super();
-        this._terminal = _terminal;
-        this._capability = _capability;
-        this._hooks = _hooks;
-        this._logService = _logService;
-        this._onCursorMoveListener = this._register(( new MutableDisposable()));
-        this._tryAdjustCommandStartMarkerScannedLineCount = 0;
-        this._tryAdjustCommandStartMarkerPollCount = 0;
-        this._register(_terminal.parser.registerCsiHandler({ final: 'J' }, params => {
-            if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
-                this._hooks.clearCommandsInViewport();
-            }
-            return false;
-        }));
-        this._register(this._capability.onBeforeCommandFinished(command => {
-            if (command.command.trim().toLowerCase() === 'clear' || command.command.trim().toLowerCase() === 'cls') {
-                this._tryAdjustCommandStartMarkerScheduler?.cancel();
-                this._tryAdjustCommandStartMarkerScheduler = undefined;
-                this._hooks.clearCommandsInViewport();
-                this._capability.currentCommand.isInvalid = true;
-                this._hooks.onCurrentCommandInvalidatedEmitter.fire({ reason: "windows"  });
-            }
-        }));
-    }
-    preHandleResize(e) {
-        const baseY = this._terminal.buffer.active.baseY;
-        const rowsDifference = e.rows - this._hooks.dimensions.rows;
-        if (rowsDifference > 0) {
-            this._waitForCursorMove().then(() => {
-                const potentialShiftedLineCount = Math.min(rowsDifference, baseY);
-                for (let i = this._capability.commands.length - 1; i >= 0; i--) {
-                    const command = this._capability.commands[i];
-                    if (!command.marker || command.marker.line < baseY || command.commandStartLineContent === undefined) {
-                        break;
-                    }
-                    const line = this._terminal.buffer.active.getLine(command.marker.line);
-                    if (!line || line.translateToString(true) === command.commandStartLineContent) {
-                        continue;
-                    }
-                    const shiftedY = command.marker.line - potentialShiftedLineCount;
-                    const shiftedLine = this._terminal.buffer.active.getLine(shiftedY);
-                    if (shiftedLine?.translateToString(true) !== command.commandStartLineContent) {
-                        continue;
-                    }
-                    this._terminal._core._bufferService.buffer.lines.onDeleteEmitter.fire({
-                        index: this._terminal.buffer.active.baseY,
-                        amount: potentialShiftedLineCount
-                    });
-                }
-            });
-        }
-    }
-    handleCommandStart() {
-        this._capability.currentCommand.commandStartX = this._terminal.buffer.active.cursorX;
-        this._hooks.commandMarkers.length = 0;
-        const initialCommandStartMarker = this._capability.currentCommand.commandStartMarker = (this._capability.currentCommand.promptStartMarker
-            ? cloneMarker(this._terminal, this._capability.currentCommand.promptStartMarker)
-            : this._terminal.registerMarker(0));
-        this._capability.currentCommand.commandStartX = 0;
-        this._tryAdjustCommandStartMarkerScannedLineCount = 0;
-        this._tryAdjustCommandStartMarkerPollCount = 0;
-        this._tryAdjustCommandStartMarkerScheduler = ( new RunOnceScheduler(
-            () => this._tryAdjustCommandStartMarker(initialCommandStartMarker),
-            20
-        ));
-        this._tryAdjustCommandStartMarkerScheduler.schedule();
-    }
-    _tryAdjustCommandStartMarker(start) {
-        if (this._store.isDisposed) {
-            return;
-        }
-        const buffer = this._terminal.buffer.active;
-        let scannedLineCount = this._tryAdjustCommandStartMarkerScannedLineCount;
-        while (scannedLineCount < 10  && start.line + scannedLineCount < buffer.baseY + this._terminal.rows) {
-            if (this._cursorOnNextLine()) {
-                const prompt = this._getWindowsPrompt(start.line + scannedLineCount);
-                if (prompt) {
-                    const adjustedPrompt = typeof prompt === 'string' ? prompt : prompt.prompt;
-                    this._capability.currentCommand.commandStartMarker = this._terminal.registerMarker(0);
-                    if (typeof prompt === 'object' && prompt.likelySingleLine) {
-                        this._logService.debug('CommandDetectionCapability#_tryAdjustCommandStartMarker adjusted promptStart', `${this._capability.currentCommand.promptStartMarker?.line} -> ${this._capability.currentCommand.commandStartMarker.line}`);
-                        this._capability.currentCommand.promptStartMarker?.dispose();
-                        this._capability.currentCommand.promptStartMarker = cloneMarker(this._terminal, this._capability.currentCommand.commandStartMarker);
-                        const lastCommand = this._capability.commands.at(-1);
-                        if (lastCommand && this._capability.currentCommand.commandStartMarker.line !== lastCommand.endMarker?.line) {
-                            lastCommand.endMarker?.dispose();
-                            lastCommand.endMarker = cloneMarker(this._terminal, this._capability.currentCommand.commandStartMarker);
-                        }
-                    }
-                    this._capability.currentCommand.commandStartX = adjustedPrompt.length;
-                    this._logService.debug('CommandDetectionCapability#_tryAdjustCommandStartMarker adjusted commandStart', `${start.line} -> ${this._capability.currentCommand.commandStartMarker.line}:${this._capability.currentCommand.commandStartX}`);
-                    this._flushPendingHandleCommandStartTask();
-                    return;
-                }
-            }
-            scannedLineCount++;
-        }
-        if (scannedLineCount < 10 ) {
-            this._tryAdjustCommandStartMarkerScannedLineCount = scannedLineCount;
-            if (++this._tryAdjustCommandStartMarkerPollCount < 10 ) {
-                this._tryAdjustCommandStartMarkerScheduler?.schedule();
-            }
-            else {
-                this._flushPendingHandleCommandStartTask();
-            }
-        }
-        else {
-            this._flushPendingHandleCommandStartTask();
-        }
-    }
-    _flushPendingHandleCommandStartTask() {
-        if (this._tryAdjustCommandStartMarkerScheduler) {
-            this._tryAdjustCommandStartMarkerPollCount = 10 ;
-            this._tryAdjustCommandStartMarkerScheduler.flush();
-            this._tryAdjustCommandStartMarkerScheduler = undefined;
-        }
-        this._hooks.commitCommandFinished();
-        if (!this._capability.currentCommand.commandExecutedMarker) {
-            this._onCursorMoveListener.value = this._terminal.onCursorMove(() => {
-                if (this._hooks.commandMarkers.length === 0 || this._hooks.commandMarkers[this._hooks.commandMarkers.length - 1].line !== this._terminal.buffer.active.cursorY) {
-                    const marker = this._terminal.registerMarker(0);
-                    if (marker) {
-                        this._hooks.commandMarkers.push(marker);
-                    }
-                }
-            });
-        }
-        if (this._capability.currentCommand.commandStartMarker) {
-            const line = this._terminal.buffer.active.getLine(this._capability.currentCommand.commandStartMarker.line);
-            if (line) {
-                this._capability.currentCommand.commandStartLineContent = line.translateToString(true);
-            }
-        }
-        this._hooks.onCommandStartedEmitter.fire({ marker: this._capability.currentCommand.commandStartMarker });
-        this._logService.debug('CommandDetectionCapability#_handleCommandStartWindows', this._capability.currentCommand.commandStartX, this._capability.currentCommand.commandStartMarker?.line);
-    }
-    handleCommandExecuted(options) {
-        if (this._tryAdjustCommandStartMarkerScheduler) {
-            this._flushPendingHandleCommandStartTask();
-        }
-        this._onCursorMoveListener.clear();
-        this._evaluateCommandMarkers();
-        this._capability.currentCommand.commandExecutedX = this._terminal.buffer.active.cursorX;
-        this._hooks.onCommandExecutedEmitter.fire(this._capability.currentCommand);
-        this._logService.debug('CommandDetectionCapability#handleCommandExecuted', this._capability.currentCommand.commandExecutedX, this._capability.currentCommand.commandExecutedMarker?.line);
-    }
-    preHandleCommandFinished() {
-        if (this._capability.currentCommand.commandExecutedMarker) {
-            return;
-        }
-        if (this._hooks.commandMarkers.length === 0) {
-            if (!this._capability.currentCommand.commandStartMarker) {
-                this._capability.currentCommand.commandStartMarker = this._terminal.registerMarker(0);
-            }
-            if (this._capability.currentCommand.commandStartMarker) {
-                this._hooks.commandMarkers.push(this._capability.currentCommand.commandStartMarker);
-            }
-        }
-        this._evaluateCommandMarkers();
-    }
-    postHandleCommandFinished() {
-        const currentCommand = this._capability.currentCommand;
-        const commandText = currentCommand.command;
-        const commandLine = currentCommand.commandStartMarker?.line;
-        const executedLine = currentCommand.commandExecutedMarker?.line;
-        if (!commandText || commandText.length === 0 ||
-            commandLine === undefined || commandLine === -1 ||
-            executedLine === undefined || executedLine === -1) {
-            return;
-        }
-        let current = 0;
-        let found = false;
-        for (let i = commandLine; i <= executedLine; i++) {
-            const line = this._terminal.buffer.active.getLine(i);
-            if (!line) {
-                break;
-            }
-            const text = line.translateToString(true);
-            for (let j = 0; j < text.length; j++) {
-                while (commandText.length < current && commandText[current] === ' ') {
-                    current++;
-                }
-                if (text[j] === commandText[current]) {
-                    current++;
-                }
-                if (current === commandText.length) {
-                    const wrapsToNextLine = j >= this._terminal.cols - 1;
-                    currentCommand.commandExecutedMarker = this._terminal.registerMarker(i - (this._terminal.buffer.active.baseY + this._terminal.buffer.active.cursorY) + (wrapsToNextLine ? 1 : 0));
-                    currentCommand.commandExecutedX = wrapsToNextLine ? 0 : j + 1;
-                    found = true;
-                    break;
-                }
-            }
-            if (found) {
-                break;
-            }
-        }
-    }
-    _evaluateCommandMarkers() {
-        if (this._hooks.commandMarkers.length === 0) {
-            return;
-        }
-        this._hooks.commandMarkers = this._hooks.commandMarkers.sort((a, b) => a.line - b.line);
-        this._capability.currentCommand.commandStartMarker = this._hooks.commandMarkers[0];
-        if (this._capability.currentCommand.commandStartMarker) {
-            const line = this._terminal.buffer.active.getLine(this._capability.currentCommand.commandStartMarker.line);
-            if (line) {
-                this._capability.currentCommand.commandStartLineContent = line.translateToString(true);
-            }
-        }
-        this._capability.currentCommand.commandExecutedMarker = this._hooks.commandMarkers[this._hooks.commandMarkers.length - 1];
-        this._hooks.onCommandExecutedEmitter.fire(this._capability.currentCommand);
-    }
-    _cursorOnNextLine() {
-        const lastCommand = this._capability.commands.at(-1);
-        if (!lastCommand) {
-            return true;
-        }
-        const cursorYAbsolute = this._terminal.buffer.active.baseY + this._terminal.buffer.active.cursorY;
-        const lastCommandYAbsolute = (lastCommand.endMarker ? lastCommand.endMarker.line : lastCommand.marker?.line) ?? -1;
-        return cursorYAbsolute > lastCommandYAbsolute;
-    }
-    _waitForCursorMove() {
-        const cursorX = this._terminal.buffer.active.cursorX;
-        const cursorY = this._terminal.buffer.active.cursorY;
-        let totalDelay = 0;
-        return ( new Promise((resolve, reject) => {
-            const interval = setInterval(() => {
-                if (cursorX !== this._terminal.buffer.active.cursorX || cursorY !== this._terminal.buffer.active.cursorY) {
-                    resolve();
-                    clearInterval(interval);
-                    return;
-                }
-                totalDelay += 10;
-                if (totalDelay > 1000) {
-                    clearInterval(interval);
-                    resolve();
-                }
-            }, 10);
-        }));
-    }
-    _getWindowsPrompt(y = this._terminal.buffer.active.baseY + this._terminal.buffer.active.cursorY) {
-        const line = this._terminal.buffer.active.getLine(y);
-        if (!line) {
-            return;
-        }
-        const lineText = line.translateToString(true);
-        if (!lineText) {
-            return;
-        }
-        const pwshPrompt = lineText.match(/(?<prompt>(\(.+\)\s)?(?:PS.+>\s?))/)?.groups?.prompt;
-        if (pwshPrompt) {
-            const adjustedPrompt = this._adjustPrompt(pwshPrompt, lineText, '>');
-            if (adjustedPrompt) {
-                return {
-                    prompt: adjustedPrompt,
-                    likelySingleLine: true
-                };
-            }
-        }
-        const customPrompt = lineText.match(/.*\u276f(?=[^\u276f]*$)/g)?.[0];
-        if (customPrompt) {
-            const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, '\u276f');
-            if (adjustedPrompt) {
-                return adjustedPrompt;
-            }
-        }
-        const bashPrompt = lineText.match(/^(?<prompt>\$)/)?.groups?.prompt;
-        if (bashPrompt) {
-            const adjustedPrompt = this._adjustPrompt(bashPrompt, lineText, '$');
-            if (adjustedPrompt) {
-                return adjustedPrompt;
-            }
-        }
-        const pythonPrompt = lineText.match(/^(?<prompt>>>> )/g)?.groups?.prompt;
-        if (pythonPrompt) {
-            return {
-                prompt: pythonPrompt,
-                likelySingleLine: true
-            };
-        }
-        if (this._capability.promptTerminator && lineText.trim().endsWith(this._capability.promptTerminator)) {
-            const adjustedPrompt = this._adjustPrompt(lineText, lineText, this._capability.promptTerminator);
-            if (adjustedPrompt) {
-                return adjustedPrompt;
-            }
-        }
-        const cmdMatch = lineText.match(/^(?<prompt>(\(.+\)\s)?(?:[A-Z]:\\.*>))/);
-        return cmdMatch?.groups?.prompt ? {
-            prompt: cmdMatch.groups.prompt,
-            likelySingleLine: true
-        } : undefined;
-    }
-    _adjustPrompt(prompt, lineText, char) {
-        if (!prompt) {
-            return;
-        }
-        if (lineText === prompt && prompt.endsWith(char)) {
-            prompt += ' ';
-        }
-        return prompt;
-    }
-};
-WindowsPtyHeuristics = ( __decorate([
-    ( __param(3, ILogService))
-], WindowsPtyHeuristics));
-function getLinesForCommand(buffer, command, cols, outputMatcher) {
-    if (!outputMatcher) {
-        return undefined;
-    }
-    const executedMarker = command.executedMarker;
-    const endMarker = command.endMarker;
-    if (!executedMarker || !endMarker) {
-        return undefined;
-    }
-    const startLine = executedMarker.line;
-    const endLine = endMarker.line;
-    const linesToCheck = outputMatcher.length;
-    const lines = [];
-    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, cols));
-            if (lines.length > linesToCheck) {
-                lines.pop();
-            }
-        }
-    }
-    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, cols));
-            if (lines.length === linesToCheck) {
-                lines.shift();
-            }
-        }
-    }
-    return lines;
-}
-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 cloneMarker(xterm, marker, offset = 0) {
-    return xterm.registerMarker(marker.line - (xterm.buffer.active.baseY + xterm.buffer.active.cursorY) + offset);
-}
-export { CommandDetectionCapability, getLinesForCommand };