@alchemy.run/sigil 0.0.0-alpha.1 → 0.0.0-alpha.10

package/dist/session-DDQ5V300.js

@@ -0,0 +1,723 @@
+import { G as pasteEnd, K as pasteStart, S as ansiEscapes } from "./sgr-BhwaWAJB.js";
+import { a as setPointerShape, c as setWorkingDirectory, i as setClipboard, l as tmuxPassthrough, n as notify, o as setTerminalProgress, s as setWindowTitle, u as cliCursor } from "./osc-BFKKSqpg.js";
+import { d as isTerminalQueryResponse, i as getCapabilities, t as colorState } from "./color-policy-BAC9-TZX.js";
+import { n as cellsEqual, t as cellAttributes } from "./cell-_ZVhbfl0.js";
+import { n as serializeScreen, t as serializeLine } from "./serialize-BTkAZgw1.js";
+//#region src/cursor-position.ts
+const showCursorEscape = ansiEscapes.cursorShow;
+const hideCursorEscape = ansiEscapes.cursorHide;
+/**
+Compare two cursor positions. Returns true if they differ.
+*/
+const cursorPositionChanged = (a, b) => a?.x !== b?.x || a?.y !== b?.y;
+/**
+Build escape sequence to move cursor from the bottom of the output to the target position and show it.
+
+`bottomLine` is the row the renderer left the cursor on, counted from the top of the output.
+That is always `lines.length - 1` for `lines = str.split('\n')`, whether or not the output ends
+with a newline:
+
+- With a trailing newline, `split` yields one extra empty element and the renderer stops just
+past the last visible line — which is `lines.length - 1`.
+- Without one, there is no extra element and the renderer deliberately stops on the last visible
+line instead of moving past it — which is also `lines.length - 1`.
+
+This is the same row basis `buildReturnToBottom` measures from, so the two stay in step.
+*/
+const buildCursorSuffix = (bottomLine, cursorPosition) => {
+	if (!cursorPosition) return "";
+	const moveUp = bottomLine - cursorPosition.y;
+	return (moveUp > 0 ? ansiEscapes.cursorUp(moveUp) : "") + ansiEscapes.cursorTo(cursorPosition.x) + showCursorEscape;
+};
+/**
+Build escape sequence to move cursor from previousCursorPosition back to the bottom of output.
+This must be done before eraseLines or any operation that assumes cursor is at the bottom.
+*/
+const buildReturnToBottom = (previousLineCount, previousCursorPosition) => {
+	if (!previousCursorPosition) return "";
+	const down = previousLineCount - 1 - previousCursorPosition.y;
+	return (down > 0 ? ansiEscapes.cursorDown(down) : "") + ansiEscapes.cursorTo(0);
+};
+/**
+Build the escape sequence for cursor-only updates (output unchanged, cursor moved).
+Hides cursor if it was previously shown, returns to bottom, then repositions.
+
+`buildReturnToBottom` has just placed the cursor on row `previousLineCount - 1`, so the
+suffix measures from there rather than recomputing the row from the output.
+*/
+const buildCursorOnlySequence = (input) => {
+	const hidePrefix = input.cursorWasShown ? hideCursorEscape : "";
+	const returnToBottom = buildReturnToBottom(input.previousLineCount, input.previousCursorPosition);
+	const cursorSuffix = buildCursorSuffix(input.previousLineCount - 1, input.cursorPosition);
+	return hidePrefix + returnToBottom + cursorSuffix;
+};
+/**
+Build the prefix that hides cursor and returns to bottom before erasing or rewriting.
+Returns empty string if cursor was not shown.
+*/
+const buildReturnToBottomPrefix = (cursorWasShown, previousLineCount, previousCursorPosition) => {
+	if (!cursorWasShown) return "";
+	return hideCursorEscape + buildReturnToBottom(previousLineCount, previousCursorPosition);
+};
+//#endregion
+//#region src/input-parser.ts
+const escape = "\x1B";
+const isCsiParameterByte = (byte) => {
+	return byte >= 48 && byte <= 63;
+};
+const isCsiIntermediateByte = (byte) => {
+	return byte >= 32 && byte <= 47;
+};
+const isCsiFinalByte = (byte) => {
+	return byte >= 64 && byte <= 126;
+};
+const parseCsiSequence = (input, startIndex, prefixLength) => {
+	const csiPayloadStart = startIndex + prefixLength + 1;
+	let index = csiPayloadStart;
+	for (; index < input.length; index++) {
+		const byte = input.codePointAt(index);
+		if (byte === void 0) return "pending";
+		if (byte === 27 || byte === 3) return {
+			sequence: "",
+			nextIndex: index
+		};
+		if (isCsiParameterByte(byte) || isCsiIntermediateByte(byte)) continue;
+		if (byte === 91 && index === csiPayloadStart) continue;
+		if (isCsiFinalByte(byte)) return {
+			sequence: input.slice(startIndex, index + 1),
+			nextIndex: index + 1
+		};
+		return;
+	}
+	return "pending";
+};
+const parseSs3Sequence = (input, startIndex, prefixLength) => {
+	const nextIndex = startIndex + prefixLength + 2;
+	if (nextIndex > input.length) return "pending";
+	const finalByte = input.codePointAt(nextIndex - 1);
+	if (finalByte === void 0 || !isCsiFinalByte(finalByte)) return;
+	return {
+		sequence: input.slice(startIndex, nextIndex),
+		nextIndex
+	};
+};
+const parseControlSequence = (input, startIndex, prefixLength) => {
+	const sequenceType = input[startIndex + prefixLength];
+	if (sequenceType === void 0) return "pending";
+	if (sequenceType === "[") return parseCsiSequence(input, startIndex, prefixLength);
+	if (sequenceType === "]" || sequenceType === "P" || sequenceType === "_") {
+		for (let index = startIndex + prefixLength + 1; index < input.length; index++) {
+			if (input[index] === "" || input[index] === escape && index + 1 < input.length && input[index + 1] !== "\\") return {
+				sequence: "",
+				nextIndex: index
+			};
+			const bel = sequenceType === "]" && input[index] === "\x07";
+			const st = input[index] === escape && input[index + 1] === "\\";
+			if (bel || st) {
+				const nextIndex = index + (st ? 2 : 1);
+				return {
+					sequence: input.slice(startIndex, nextIndex),
+					nextIndex
+				};
+			}
+		}
+		return "pending";
+	}
+	if (sequenceType === "O") return parseSs3Sequence(input, startIndex, prefixLength);
+};
+const parseEscapedCodePoint = (input, escapeIndex) => {
+	const nextCodePoint = input.codePointAt(escapeIndex + 1);
+	const nextCodePointLength = nextCodePoint !== void 0 && nextCodePoint > 65535 ? 2 : 1;
+	const nextIndex = escapeIndex + 1 + nextCodePointLength;
+	return {
+		sequence: input.slice(escapeIndex, nextIndex),
+		nextIndex
+	};
+};
+const parseEscapeSequence = (input, escapeIndex) => {
+	if (escapeIndex === input.length - 1) return "pending";
+	if (input[escapeIndex + 1] === escape) {
+		if (escapeIndex + 2 >= input.length) return "pending";
+		const doubleEscapeSequence = parseControlSequence(input, escapeIndex, 2);
+		if (doubleEscapeSequence === "pending") return "pending";
+		if (doubleEscapeSequence) return doubleEscapeSequence;
+		return {
+			sequence: input.slice(escapeIndex, escapeIndex + 2),
+			nextIndex: escapeIndex + 2
+		};
+	}
+	const controlSequence = parseControlSequence(input, escapeIndex, 1);
+	if (controlSequence === "pending") return "pending";
+	if (controlSequence) return controlSequence;
+	return parseEscapedCodePoint(input, escapeIndex);
+};
+/**
+Split a chunk of non-escape text so that backspace bytes (`0x7F` and `0x08`) become individual events. When a user holds the backspace key, the terminal sends repeated bytes in a single stdin chunk. Without splitting, `parseKeypress` receives the multi-byte string and fails to recognize it as a key event, corrupting the input state.
+
+Other control characters like `\r` and `\t` are NOT split because they can legitimately appear inside pasted text.
+*/
+const splitBackspaceBytes = (text, events) => {
+	let textSegmentStart = 0;
+	for (let index = 0; index < text.length; index++) {
+		const character = text[index];
+		if (character === "" || character === "\b") {
+			if (index > textSegmentStart) events.push(text.slice(textSegmentStart, index));
+			events.push(character);
+			textSegmentStart = index + 1;
+		}
+	}
+	if (textSegmentStart < text.length) events.push(text.slice(textSegmentStart));
+};
+const parseKeypresses = (input) => {
+	const events = [];
+	let index = 0;
+	const pendingFrom = (pendingStartIndex) => ({
+		events,
+		pending: input.slice(pendingStartIndex)
+	});
+	while (index < input.length) {
+		const escapeIndex = input.indexOf(escape, index);
+		if (escapeIndex === -1) {
+			splitBackspaceBytes(input.slice(index), events);
+			return {
+				events,
+				pending: ""
+			};
+		}
+		if (escapeIndex > index) splitBackspaceBytes(input.slice(index, escapeIndex), events);
+		const parsedEscapeSequence = parseEscapeSequence(input, escapeIndex);
+		if (parsedEscapeSequence === "pending") return pendingFrom(escapeIndex);
+		if (parsedEscapeSequence.sequence === pasteStart) {
+			const afterStart = parsedEscapeSequence.nextIndex;
+			const endIndex = input.indexOf(pasteEnd, afterStart);
+			if (endIndex === -1) return pendingFrom(escapeIndex);
+			events.push({ paste: input.slice(afterStart, endIndex) });
+			index = endIndex + pasteEnd.length;
+			continue;
+		}
+		if (parsedEscapeSequence.sequence.length > 0) events.push(parsedEscapeSequence.sequence);
+		index = parsedEscapeSequence.nextIndex;
+	}
+	return {
+		events,
+		pending: ""
+	};
+};
+const createInputParser = () => {
+	let pending = "";
+	const hasPendingEscape = () => pending.startsWith(escape) && !/^\u001B{1,2}[[\]P_]/.test(pending);
+	return {
+		push(chunk) {
+			const parsedInput = parseKeypresses(pending + chunk);
+			pending = parsedInput.pending;
+			return parsedInput.events;
+		},
+		hasPendingEscape,
+		flushPendingEscape() {
+			if (!hasPendingEscape()) return;
+			const pendingEscape = pending;
+			pending = "";
+			return pendingEscape;
+		},
+		reset() {
+			pending = "";
+		}
+	};
+};
+//#endregion
+//#region src/terminal/input.ts
+const sgrMouse = /^\u001B\[<(\d+);(\d+);(\d+)([Mm])$/;
+/** Stateful stdin decoder that separates terminal reports from application input. */
+var TerminalInput = class {
+	#parser = createInputParser();
+	#capabilities;
+	#mouseListeners = /* @__PURE__ */ new Set();
+	constructor(capabilities) {
+		this.#capabilities = capabilities;
+	}
+	push(chunk) {
+		return this.#parser.push(chunk).flatMap((event) => {
+			if (typeof event !== "string") return [event];
+			if (event.startsWith("\x1B\x1B") && isTerminalQueryResponse(event.slice(1))) return ["\x1B"];
+			if (this.#capabilities.ingest(event)) return [];
+			if (isTerminalQueryResponse(event)) return [];
+			const mouse = parseMouseEvent(event);
+			if (!mouse) return [event];
+			for (const listener of this.#mouseListeners) listener(mouse);
+			return [];
+		});
+	}
+	subscribeMouse(listener) {
+		this.#mouseListeners.add(listener);
+		return () => this.#mouseListeners.delete(listener);
+	}
+	hasPendingEscape() {
+		return this.#parser.hasPendingEscape();
+	}
+	flushPendingEscape() {
+		return this.#parser.flushPendingEscape();
+	}
+	reset() {
+		this.#parser.reset();
+	}
+};
+function parseMouseEvent(sequence) {
+	const match = sequence.match(sgrMouse);
+	if (!match) return;
+	const code = Number(match[1]);
+	const column = Number(match[2]);
+	const row = Number(match[3]);
+	if (column < 1 || row < 1) return;
+	const wheel = (code & 64) !== 0;
+	const move = (code & 32) !== 0;
+	const buttonCode = code & 3;
+	const button = wheel ? buttonCode === 0 ? "wheel-up" : "wheel-down" : [
+		"left",
+		"middle",
+		"right",
+		"none"
+	][buttonCode];
+	return {
+		type: wheel ? "wheel" : move ? "move" : match[4] === "m" || buttonCode === 3 ? "release" : "press",
+		x: column - 1,
+		y: row - 1,
+		button,
+		shift: (code & 4) !== 0,
+		alt: (code & 8) !== 0,
+		ctrl: (code & 16) !== 0
+	};
+}
+//#endregion
+//#region src/terminal/screen-presenter.ts
+/** Presents structured frames in an inline terminal region. */
+var ScreenPresenter = class {
+	#screen;
+	#lineCount = 0;
+	#cursor;
+	#cursorWasShown = false;
+	#fullscreen = false;
+	#hidden = false;
+	#write;
+	#stream;
+	constructor(write, stream) {
+		this.#write = write;
+		this.#stream = stream;
+	}
+	present(screen, options) {
+		if (!this.#hidden) {
+			cliCursor.hide(this.#stream);
+			this.#hidden = true;
+		}
+		const previousScreen = this.#screen;
+		const sameScreen = previousScreen !== void 0 && screensEqual(previousScreen, screen);
+		const cursorChanged = cursorPositionChanged(options.cursor, this.#cursor);
+		const fullscreen = options.fullscreen ?? false;
+		const presentationModeChanged = this.#fullscreen !== fullscreen;
+		if (!options.forceRewrite && sameScreen && !cursorChanged && !presentationModeChanged) return false;
+		if (!options.forceRewrite && sameScreen && !presentationModeChanged) {
+			this.#write(buildCursorOnlySequence({
+				cursorWasShown: this.#cursorWasShown,
+				previousLineCount: this.#lineCount,
+				previousCursorPosition: this.#cursor,
+				cursorPosition: options.cursor
+			}));
+			this.#remember(screen, options.cursor, options.fullscreen ?? false);
+			return true;
+		}
+		const firstChangedRow = !options.forceRewrite && previousScreen !== void 0 && previousScreen.width === screen.width && this.#fullscreen === fullscreen ? findFirstChangedRow(previousScreen, screen) : void 0;
+		const serializeOptions = {
+			colorProfile: options.colorProfile,
+			styles: options.colorProfile !== "none"
+		};
+		if (firstChangedRow !== void 0) {
+			const eraseCount = this.#lineCount - firstChangedRow;
+			const body = screen.toRows().slice(firstChangedRow).map((line) => serializeLine(line, serializeOptions)).join("\n");
+			const output = fullscreen || body === "" ? body : `${body}\n`;
+			this.#write(buildReturnToBottomPrefix(this.#cursorWasShown, this.#lineCount, this.#cursor) + ansiEscapes.eraseLines(eraseCount) + output + buildCursorSuffix(screen.height - (fullscreen ? 1 : 0), options.cursor));
+		} else {
+			const body = serializeScreen(screen, serializeOptions);
+			const output = fullscreen ? body : `${body}\n`;
+			this.#write(buildReturnToBottomPrefix(this.#cursorWasShown, this.#lineCount, this.#cursor) + ansiEscapes.eraseLines(this.#lineCount) + output + buildCursorSuffix(screen.height - (fullscreen ? 1 : 0), options.cursor));
+		}
+		this.#remember(screen, options.cursor, fullscreen);
+		return true;
+	}
+	willPresent(screen, cursor, fullscreen = false, forceRewrite = false) {
+		return forceRewrite || this.#screen === void 0 || !screensEqual(this.#screen, screen) || cursorPositionChanged(cursor, this.#cursor) || fullscreen !== this.#fullscreen;
+	}
+	/**
+	Erases the presented frame from the cursor upward.
+	
+	`columns` is the terminal's current width. When it is narrower than the width
+	the frame was painted at, a reflowing emulator (xterm.js, Ghostty, kitty,
+	iTerm2, WezTerm, tmux, …) has already rewrapped every wider row onto several
+	physical rows before the resize event reaches us, so the erase has to cover
+	that physical footprint. Erasing only the logical row count leaves the frame's
+	top rows behind as ghosts, one more batch per resize event.
+	*/
+	clear(options = {}) {
+		this.#write(buildReturnToBottomPrefix(this.#cursorWasShown, this.#lineCount, this.#cursor) + ansiEscapes.eraseLines(this.#physicalLineCount(options.columns)));
+		this.#lineCount = 0;
+		this.#cursor = void 0;
+		this.#cursorWasShown = false;
+		this.#fullscreen = false;
+	}
+	#physicalLineCount(columns) {
+		if (this.#screen === void 0 || this.#lineCount === 0 || columns === void 0 || columns < 1) return this.#lineCount;
+		let rows = 0;
+		for (const line of this.#screen.toRows()) rows += Math.max(1, Math.ceil(contentWidth(line) / columns));
+		return rows + (this.#fullscreen ? 0 : 1);
+	}
+	reset() {
+		this.#screen = void 0;
+		this.#lineCount = 0;
+		this.#cursor = void 0;
+		this.#cursorWasShown = false;
+	}
+	done() {
+		this.reset();
+		if (this.#hidden) {
+			cliCursor.show(this.#stream);
+			this.#hidden = false;
+		}
+	}
+	get current() {
+		return this.#screen;
+	}
+	#remember(screen, cursor, fullscreen) {
+		this.#screen = screen;
+		this.#lineCount = screen.height + (fullscreen ? 0 : 1);
+		this.#cursor = cursor ? { ...cursor } : void 0;
+		this.#cursorWasShown = cursor !== void 0;
+		this.#fullscreen = fullscreen;
+	}
+};
+/**
+The columns a row occupies once written: everything up to its last visible
+cell. Trailing unstyled blanks are trimmed by the serializer and never reach
+the terminal, while styled blanks (a highlighted tab's padding) do.
+*/
+function contentWidth(line) {
+	let width = 0;
+	let end = 0;
+	for (const cell of line) {
+		width += cell.width;
+		if (!isBlank(cell)) end = width;
+	}
+	return end;
+}
+function isBlank(cell) {
+	const { style } = cell;
+	return (cell.grapheme === " " || cell.width === 0) && style.foreground === void 0 && style.background === void 0 && style.underlineColor === void 0 && style.underline === "none" && style.attributes === cellAttributes.none && cell.hyperlink === void 0;
+}
+function findFirstChangedRow(previous, next) {
+	const height = Math.max(previous.height, next.height);
+	for (let y = 0; y < height; y++) if (!rowsEqual(previous, next, y)) return y;
+}
+function rowsEqual(left, right, y) {
+	const length = Math.max(left.rowLength(y), right.rowLength(y));
+	for (let x = 0; x < length; x++) if (!cellsEqual(left.cellAt(x, y), right.cellAt(x, y))) return false;
+	return true;
+}
+function screensEqual(left, right) {
+	if (left.width !== right.width || left.height !== right.height) return false;
+	for (let y = 0; y < left.height; y++) if (!rowsEqual(left, right, y)) return false;
+	return true;
+}
+//#endregion
+//#region src/terminal/session.ts
+const imperativeProgressOwner = Symbol("imperative-progress");
+const imperativeTitleOwner = Symbol("imperative-title");
+/** Instance-scoped terminal state and lifecycle ownership. */
+var TerminalSession = class {
+	stdin;
+	stdout;
+	stderr;
+	capabilities;
+	input;
+	#presenter;
+	cursor = {
+		visible: true,
+		shape: "block",
+		blinking: true
+	};
+	suspended = false;
+	alternateScreen = false;
+	inlineScreen = true;
+	#policy;
+	#profile;
+	#modes = /* @__PURE__ */ new Map();
+	#pendingWrites = /* @__PURE__ */ new Set();
+	#unsubscribe;
+	#cleaned = false;
+	#progressActive = false;
+	#progressSequence;
+	#progressHeartbeat;
+	#progressPublishers = /* @__PURE__ */ new Map();
+	#titlePublishers = /* @__PURE__ */ new Map();
+	#titleActive = false;
+	constructor(options) {
+		this.stdin = options.stdin;
+		this.stdout = options.stdout;
+		this.stderr = options.stderr;
+		this.capabilities = getCapabilities(this.stdin, this.stdout);
+		this.input = new TerminalInput(this.capabilities);
+		this.#presenter = new ScreenPresenter((data) => this.write(data), this.stdout);
+		this.#policy = options.colorPolicy ?? "auto";
+		this.#profile = colorState(this.capabilities.current, this.#policy).effective;
+		this.#unsubscribe = this.capabilities.subscribe((capabilities) => {
+			const profile = colorState(capabilities, this.#policy).effective;
+			if (profile !== this.#profile) {
+				this.#profile = profile;
+				this.#presenter.reset();
+			}
+			options.onCapabilitiesChange?.();
+		}, { resizes: false });
+	}
+	get colorProfile() {
+		return this.#profile;
+	}
+	/** Encodes a structured frame at the terminal boundary. */
+	encode(screen) {
+		return serializeScreen(screen, {
+			colorProfile: this.colorProfile,
+			styles: this.colorProfile !== "none"
+		});
+	}
+	present(screen, options = {}) {
+		return this.#presenter.present(screen, {
+			colorProfile: this.colorProfile,
+			cursor: this.cursor.position,
+			...options
+		});
+	}
+	willPresent(screen, options = {}) {
+		return this.#presenter.willPresent(screen, this.cursor.position, options.fullscreen, options.forceRewrite);
+	}
+	/** Erases the presented frame; pass the current `columns` after a resize so the erase covers rows the emulator rewrapped. */
+	clearFrame(options = {}) {
+		this.#presenter.clear(options);
+	}
+	resetFrame() {
+		this.#presenter.reset();
+	}
+	finishFrame() {
+		this.#presenter.done();
+	}
+	setColorPolicy(policy) {
+		this.#policy = policy;
+		const profile = colorState(this.capabilities.current, policy).effective;
+		if (profile !== this.#profile) {
+			this.#profile = profile;
+			this.#presenter.reset();
+		}
+	}
+	/** Writes through the session and tracks callback-based backpressure completion. */
+	write(data) {
+		let settle;
+		const completion = new Promise((resolve) => {
+			settle = resolve;
+		});
+		this.#pendingWrites.add(completion);
+		try {
+			return this.stdout.write(data, () => {
+				this.#pendingWrites.delete(completion);
+				settle();
+			});
+		} catch (error) {
+			this.#pendingWrites.delete(completion);
+			settle();
+			throw error;
+		}
+	}
+	async flush() {
+		await Promise.all(this.#pendingWrites);
+	}
+	/** Copy text through OSC 52, including tmux passthrough when required. */
+	copyToClipboard(text, selection = "clipboard") {
+		return this.write(this.#wrapOsc(setClipboard(text, selection)));
+	}
+	setTitle(title) {
+		return this.publishTitle(imperativeTitleOwner, title);
+	}
+	publishTitle(owner, title) {
+		this.#titlePublishers.delete(owner);
+		if (title !== void 0) this.#titlePublishers.set(owner, title);
+		const current = [...this.#titlePublishers.values()].at(-1);
+		if (current !== void 0) {
+			this.#titleActive = true;
+			return this.write(this.#wrapOsc(setWindowTitle(current)));
+		}
+		if (!this.#titleActive) return true;
+		this.#titleActive = false;
+		return this.write(this.#wrapOsc(setWindowTitle("")));
+	}
+	setWorkingDirectory(directory) {
+		return this.write(this.#wrapOsc(setWorkingDirectory(directory)));
+	}
+	notify(title) {
+		return this.write(this.#wrapOsc(notify(title)));
+	}
+	setPointerShape(shape) {
+		return this.write(this.#wrapOsc(setPointerShape(shape)));
+	}
+	publishProgress(owner, state, value) {
+		this.#progressPublishers.delete(owner);
+		if (state !== "inactive") this.#progressPublishers.set(owner, {
+			state,
+			value
+		});
+		return this.#applyPublishedProgress();
+	}
+	#applyPublishedProgress() {
+		const current = [...this.#progressPublishers.values()].at(-1);
+		return current === void 0 ? this.#writeProgress("inactive") : this.#writeProgress(current.state, current.value);
+	}
+	/**
+	* Update terminal-native progress. Active progress is reset during cleanup
+	* so a completed or failed process cannot leave a stale terminal indicator.
+	*/
+	setProgress(state, value) {
+		this.#progressPublishers.delete(imperativeProgressOwner);
+		if (state !== "inactive") this.#progressPublishers.set(imperativeProgressOwner, {
+			state,
+			value
+		});
+		return this.#applyPublishedProgress();
+	}
+	#writeProgress(state, value) {
+		this.#progressActive = state !== "inactive";
+		const sequence = this.#wrapOsc(setTerminalProgress(state, value));
+		if (!this.#progressActive) this.#stopProgressHeartbeat();
+		else {
+			this.#progressSequence = sequence;
+			if (this.#progressHeartbeat === void 0) {
+				this.#progressHeartbeat = setInterval(() => {
+					if (this.#progressSequence !== void 0) this.write(this.#progressSequence);
+				}, 1e3);
+				this.#progressHeartbeat.unref?.();
+			}
+		}
+		return this.write(sequence);
+	}
+	#stopProgressHeartbeat() {
+		if (this.#progressHeartbeat !== void 0) {
+			clearInterval(this.#progressHeartbeat);
+			this.#progressHeartbeat = void 0;
+		}
+		this.#progressSequence = void 0;
+	}
+	enableMode(modeOrEnable, disable) {
+		const mode = typeof modeOrEnable === "string" ? {
+			id: disable ?? modeOrEnable,
+			enable: modeOrEnable,
+			disable: disable ?? ""
+		} : modeOrEnable;
+		const active = this.#modes.get(mode.id);
+		if (active) {
+			active.count++;
+			return;
+		}
+		this.write(mode.enable);
+		this.#modes.set(mode.id, {
+			...mode,
+			count: 1
+		});
+	}
+	disableMode(idOrDisable) {
+		const entry = this.#modes.get(idOrDisable) ?? [...this.#modes.values()].find((mode) => mode.disable === idOrDisable);
+		if (!entry) return;
+		if (--entry.count > 0) return;
+		this.#modes.delete(entry.id);
+		this.write(entry.disable);
+	}
+	setCursor(position) {
+		this.cursor = {
+			...this.cursor,
+			position,
+			visible: position !== void 0
+		};
+	}
+	setCursorAppearance(options) {
+		const next = {
+			...this.cursor,
+			...options.visible === void 0 ? {} : { visible: options.visible },
+			...options.shape === void 0 ? {} : { shape: options.shape },
+			...options.blinking === void 0 ? {} : { blinking: options.blinking },
+			...options.color === void 0 ? {} : { color: options.color ?? void 0 }
+		};
+		let output = "";
+		if (next.shape !== this.cursor.shape || next.blinking !== this.cursor.blinking) output += ansiEscapes.cursorShape(next.shape, next.blinking);
+		if (options.color !== void 0) output += options.color === null ? ansiEscapes.resetCursorColor : ansiEscapes.cursorColor(options.color);
+		if (next.visible !== this.cursor.visible) output += next.visible ? ansiEscapes.cursorShow : ansiEscapes.cursorHide;
+		this.cursor = next;
+		if (output) this.write(output);
+	}
+	setAlternateScreen(enabled, options = {}) {
+		if (enabled === this.alternateScreen) return;
+		this.alternateScreen = enabled;
+		this.inlineScreen = !enabled;
+		if (enabled) {
+			this.enableMode({
+				id: "alternate-screen",
+				enable: ansiEscapes.enterAlternativeScreen,
+				disable: ansiEscapes.exitAlternativeScreen
+			});
+			if (options.hideCursor) this.setCursorAppearance({ visible: false });
+		} else this.disableMode("alternate-screen");
+		this.#presenter.reset();
+	}
+	beginSuspension() {
+		if (this.suspended) throw new Error("The terminal session is already suspended");
+		this.suspended = true;
+	}
+	resume() {
+		if (!this.suspended) return;
+		this.suspended = false;
+		this.#presenter.reset();
+	}
+	cleanup() {
+		if (this.#cleaned) return;
+		this.#cleaned = true;
+		this.#unsubscribe();
+		this.#stopProgressHeartbeat();
+		this.#progressPublishers.clear();
+		if (this.#progressActive) {
+			try {
+				this.stdout.write(this.#wrapOsc(setTerminalProgress("inactive")));
+			} catch {}
+			this.#progressActive = false;
+		}
+		this.#titlePublishers.clear();
+		if (this.#titleActive) {
+			try {
+				this.stdout.write(this.#wrapOsc(setWindowTitle("")));
+			} catch {}
+			this.#titleActive = false;
+		}
+		for (const mode of [...this.#modes.values()].reverse()) try {
+			this.stdout.write(mode.disable);
+		} catch {}
+		if (this.cursor.color !== void 0) try {
+			this.stdout.write(ansiEscapes.resetCursorColor);
+		} catch {}
+		if (!this.cursor.visible) try {
+			this.stdout.write(ansiEscapes.cursorShow);
+		} catch {}
+		this.#modes.clear();
+		this.alternateScreen = false;
+		this.inlineScreen = true;
+		this.suspended = false;
+		this.cursor = {
+			visible: true,
+			shape: "block",
+			blinking: true
+		};
+		this.#presenter.done();
+	}
+	#wrapOsc(sequence) {
+		return this.capabilities.current.terminal.multiplexer === "tmux" ? tmuxPassthrough(sequence) : sequence;
+	}
+};
+//#endregion
+export { buildCursorSuffix as a, hideCursorEscape as c, buildCursorOnlySequence as i, TerminalInput as n, buildReturnToBottomPrefix as o, parseMouseEvent as r, cursorPositionChanged as s, TerminalSession as t };