@eclipse-docks/extension-terminal 0.0.0

package/dist/js-terminal-backend-BcQIBeMe.js

@@ -0,0 +1,741 @@
+import { PANEL_BOTTOM, commandRegistry, confirmDialog, contributionRegistry, createJsRuntime, i18n, publish, rootContext, subscribe, unsubscribe } from "@eclipse-docks/core";
+import { html } from "@eclipse-docks/core/externals/lit";
+//#region src/terminal-api.ts
+var TARGET_TERMINAL_PROFILES = "system.terminal.profiles";
+var VIEW_TERMINAL = "view.terminal";
+var TERMINAL_INSTANCES_TABS_ID = "terminal-instances";
+/** Dropdown target: contributors register items that create a terminal with a profile. */
+var TERMINAL_NEW_DROPDOWN = `${TERMINAL_INSTANCES_TABS_ID}-new`;
+var TERMINAL_PANEL_SETTINGS_KEY = "docks-terminal-panel";
+var TOPIC_TERMINAL_OPENED = "events/terminal/opened";
+var TOPIC_TERMINAL_CLOSED = "events/terminal/closed";
+var TOPIC_TERMINAL_ACTIVE_CHANGED = "events/terminal/activeChanged";
+//#endregion
+//#region src/terminal-persistence.ts
+var MAX_PERSISTED_ENV_KEYS = 32;
+function serializeTerminalState(state) {
+	return {
+		activeTerminalId: state.activeTerminalId,
+		preferredProfileId: state.preferredProfileId,
+		terminals: state.terminals.map(serializeTerminalEntry)
+	};
+}
+function serializeTerminalEntry(entry) {
+	const opts = entry.creationOptions;
+	const env = opts.env ? Object.fromEntries(Object.entries(opts.env).slice(0, MAX_PERSISTED_ENV_KEYS)) : void 0;
+	return {
+		id: entry.id,
+		name: entry.name,
+		profileId: entry.profileId,
+		groupId: entry.groupId,
+		creationOptions: {
+			name: opts.name,
+			profileId: opts.profileId,
+			cwd: opts.cwd,
+			env,
+			groupId: opts.groupId
+		}
+	};
+}
+function parseTerminalState(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const obj = raw;
+	if (!Array.isArray(obj.terminals)) return null;
+	const terminals = [];
+	for (const item of obj.terminals) {
+		if (!item || typeof item !== "object") continue;
+		const t = item;
+		if (typeof t.id !== "string" || typeof t.name !== "string" || typeof t.profileId !== "string") continue;
+		const creationOptions = t.creationOptions ?? {};
+		terminals.push({
+			id: t.id,
+			name: t.name,
+			profileId: t.profileId,
+			groupId: typeof t.groupId === "string" ? t.groupId : t.id,
+			creationOptions
+		});
+	}
+	return {
+		terminals,
+		activeTerminalId: typeof obj.activeTerminalId === "string" ? obj.activeTerminalId : null,
+		preferredProfileId: typeof obj.preferredProfileId === "string" ? obj.preferredProfileId : null
+	};
+}
+function emptyTerminalState() {
+	return {
+		terminals: [],
+		activeTerminalId: null,
+		preferredProfileId: null
+	};
+}
+//#endregion
+//#region src/terminal-service.ts
+var t = await i18n(/* @__PURE__ */ Object.assign({
+	"./i18n.de.json": () => import("./i18n.de-BVmQFS_U.js"),
+	"./i18n.en.json": () => import("./i18n.en-BzXd1VkS.js")
+}), true);
+async function confirmKillTerminal(name) {
+	return confirmDialog(t.TERMINAL_KILL_CONFIRM({ name }));
+}
+var terminalCounter = 0;
+function nextTerminalId() {
+	terminalCounter += 1;
+	return `terminal-${terminalCounter}`;
+}
+var TerminalInstance = class {
+	constructor(id, name, profileId, creationOptions, groupId) {
+		this.hidden = false;
+		this.backend = null;
+		this.id = id;
+		this.name = name;
+		this.profileId = profileId;
+		this.creationOptions = creationOptions;
+		this.groupId = groupId;
+	}
+	sendText(text, addNewLine = true) {
+		if (!this.backend) return;
+		this.backend.handleInput(text + (addNewLine ? "\r" : ""));
+	}
+	show(_preserveFocus) {
+		terminalService.focusTerminalPanel();
+		terminalService.activateTerminal(this.id);
+		this.hidden = false;
+	}
+	hide() {
+		this.hidden = true;
+	}
+	async dispose() {
+		await terminalService.disposeTerminal(this.id);
+	}
+	clear() {
+		this.clearScreen?.();
+	}
+};
+var TerminalService = class {
+	constructor() {
+		this.terminals = /* @__PURE__ */ new Map();
+		this.activeTerminalId = null;
+		this.preferredProfileId = null;
+		this.persistenceHandler = null;
+		this.persistCallback = null;
+		this.restoreStarted = false;
+		this.instanceTabsHost = null;
+	}
+	get activeTerminal() {
+		if (!this.activeTerminalId) return void 0;
+		return this.terminals.get(this.activeTerminalId);
+	}
+	getTerminals() {
+		return [...this.terminals.values()];
+	}
+	onDidOpenTerminal(callback) {
+		const token = subscribe(TOPIC_TERMINAL_OPENED, callback);
+		return () => unsubscribe(token);
+	}
+	onDidCloseTerminal(callback) {
+		const token = subscribe(TOPIC_TERMINAL_CLOSED, callback);
+		return () => unsubscribe(token);
+	}
+	onDidChangeActiveTerminal(callback) {
+		const token = subscribe(TOPIC_TERMINAL_ACTIVE_CHANGED, callback);
+		return () => unsubscribe(token);
+	}
+	setPersistenceHandlers(load, save) {
+		this.persistenceHandler = load;
+		this.persistCallback = save;
+	}
+	async restorePersistedTerminals() {
+		if (this.restoreStarted || !this.persistenceHandler) return;
+		this.restoreStarted = true;
+		const raw = await this.persistenceHandler();
+		const state = raw ? parseTerminalState(raw) : null;
+		if (!state || state.terminals.length === 0) return;
+		this.preferredProfileId = state.preferredProfileId;
+		for (const entry of state.terminals) await this.createTerminal({
+			...entry.creationOptions,
+			name: entry.name,
+			profileId: entry.profileId,
+			groupId: entry.groupId
+		}, entry.id);
+		if (state.activeTerminalId && this.terminals.has(state.activeTerminalId)) this.setActiveTerminal(state.activeTerminalId);
+	}
+	getProfiles() {
+		return contributionRegistry.getContributions(TARGET_TERMINAL_PROFILES);
+	}
+	resolveDefaultProfileId() {
+		if (this.preferredProfileId) {
+			const preferred = this.getProfiles().find((p) => p.id === this.preferredProfileId);
+			if (preferred) return preferred.id;
+		}
+		const profiles = this.getProfiles().filter((p) => !p.hidden);
+		return (profiles.find((p) => p.isDefault) ?? profiles[0])?.id ?? null;
+	}
+	setInstanceTabsHost(host) {
+		this.instanceTabsHost = host;
+	}
+	getInstanceTabs() {
+		return this.instanceTabsHost;
+	}
+	focusTerminalPanel() {
+		document.querySelector(`docks-tabs#${PANEL_BOTTOM}`)?.activate(VIEW_TERMINAL);
+	}
+	activateTerminal(id) {
+		const tabs = this.getInstanceTabs();
+		if (tabs?.has(id)) tabs.activate(id);
+		this.setActiveTerminal(id);
+	}
+	setActiveTerminal(id) {
+		if (this.activeTerminalId === id) return;
+		this.activeTerminalId = id;
+		publish(TOPIC_TERMINAL_ACTIVE_CHANGED, id ? this.terminals.get(id) : void 0);
+		this.persistState();
+	}
+	async createTerminal(options = {}, forcedId) {
+		const profileId = options.profileId ?? this.resolveDefaultProfileId();
+		if (!profileId) return void 0;
+		const profile = this.getProfiles().find((p) => p.id === profileId);
+		if (!profile) return void 0;
+		const id = forcedId ?? nextTerminalId();
+		if (forcedId) syncTerminalCounterFromId(forcedId);
+		const groupId = options.groupId ?? id;
+		const name = options.name ?? profile.label;
+		let backend;
+		try {
+			backend = await profile.create({
+				...options,
+				profileId,
+				name,
+				groupId
+			});
+		} catch {
+			return;
+		}
+		const terminal = new TerminalInstance(id, name, profileId, {
+			...options,
+			profileId,
+			name,
+			groupId
+		}, groupId);
+		terminal.backend = backend;
+		terminal.hidden = options.hidden ?? false;
+		this.terminals.set(id, terminal);
+		this.openTerminalTab(terminal, profile.icon);
+		if (!options.hidden) {
+			this.focusTerminalPanel();
+			this.activateTerminal(id);
+		}
+		publish(TOPIC_TERMINAL_OPENED, terminal);
+		this.persistState();
+		return terminal;
+	}
+	openTerminalTab(terminal, icon) {
+		const tabs = this.getInstanceTabs();
+		if (!tabs) return;
+		const contribution = {
+			name: terminal.id,
+			label: terminal.name,
+			icon: icon ?? "terminal",
+			closable: true,
+			toolbar: false,
+			beforeClose: async () => confirmKillTerminal(terminal.name),
+			component: (tabId) => html`<docks-terminal-view id="${tabId}" .terminal=${terminal}></docks-terminal-view>`
+		};
+		if (tabs.has(terminal.id)) {
+			tabs.activate(terminal.id);
+			return;
+		}
+		tabs.open(contribution);
+	}
+	async disposeTerminal(id, options) {
+		const terminal = this.terminals.get(id);
+		if (!terminal) return;
+		if (!options?.skipTabRemoval) {
+			const tabs = this.getInstanceTabs();
+			if (tabs?.has(id)) {
+				await tabs.closeTab(new Event("close"), id);
+				return;
+			}
+		}
+		await terminal.backend?.close?.();
+		terminal.backend = null;
+		this.terminals.delete(id);
+		if (this.activeTerminalId === id) {
+			const remaining = [...this.terminals.keys()];
+			this.setActiveTerminal(remaining.length > 0 ? remaining[remaining.length - 1] : null);
+		}
+		publish(TOPIC_TERMINAL_CLOSED, terminal);
+		this.persistState();
+	}
+	async killAll() {
+		const tabs = this.getInstanceTabs();
+		const ids = [...this.terminals.keys()];
+		for (const id of ids) if (tabs?.has(id)) await tabs.closeTab(new Event("close"), id);
+		else await this.disposeTerminal(id, { skipTabRemoval: true });
+	}
+	renameActiveTerminal(name) {
+		const active = this.activeTerminal;
+		if (!active || !(active instanceof TerminalInstance)) return;
+		active.name = name;
+		this.getInstanceTabs()?.updateTabLabel(active.id, name);
+		this.persistState();
+	}
+	setPreferredProfile(profileId) {
+		this.preferredProfileId = profileId;
+		this.persistState();
+	}
+	clearActiveTerminal() {
+		this.activeTerminal?.clear?.();
+	}
+	async runTask(presentation, execute) {
+		let terminal = this.getTerminals().find((t) => t.profileId === presentation.profileId);
+		if (!terminal) terminal = await this.createTerminal({ profileId: presentation.profileId });
+		if (!terminal) return;
+		if (presentation.reveal !== "never") if (presentation.focus !== false) terminal.show();
+		else this.focusTerminalPanel();
+		if (presentation.clear) terminal.clear?.();
+		await execute(terminal);
+	}
+	async persistState() {
+		if (!this.persistCallback) return;
+		const state = {
+			activeTerminalId: this.activeTerminalId,
+			preferredProfileId: this.preferredProfileId,
+			terminals: [...this.terminals.values()].map((t) => ({
+				id: t.id,
+				name: t.name,
+				profileId: t.profileId,
+				groupId: t.groupId,
+				creationOptions: t.creationOptions
+			}))
+		};
+		await this.persistCallback(serializeTerminalState(state));
+	}
+	handleTabActivated(tabName) {
+		if (this.terminals.has(tabName)) this.setActiveTerminal(tabName);
+	}
+	handleTabClosed(tabName) {
+		if (this.terminals.has(tabName)) this.disposeTerminal(tabName, { skipTabRemoval: true });
+	}
+};
+function syncTerminalCounterFromId(id) {
+	const match = /^terminal-(\d+)$/.exec(id);
+	if (!match) return;
+	const n = Number.parseInt(match[1], 10);
+	if (n > terminalCounter) terminalCounter = n;
+}
+var terminalService = new TerminalService();
+rootContext.put("terminalService", terminalService);
+function registerTerminalProfile(contribution) {
+	contributionRegistry.registerContribution(TARGET_TERMINAL_PROFILES, contribution);
+	if (contribution.hidden) return;
+	const profileId = contribution.id;
+	contributionRegistry.registerContribution(TERMINAL_NEW_DROPDOWN, {
+		label: contribution.label,
+		icon: contribution.icon ?? "terminal",
+		component: () => html`
+      <docks-command
+        icon="${contribution.icon ?? "terminal"}"
+        title="${contribution.label}"
+        .action=${() => {
+			terminalService.setPreferredProfile(profileId);
+			terminalService.createTerminal({ profileId });
+		}}
+      >
+        ${contribution.label}
+      </docks-command>
+    `
+	});
+}
+//#endregion
+//#region src/shell-parser.ts
+var NAMED_PARAM_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*=.*$/;
+function tokenize(segment) {
+	const tokens = [];
+	let i = 0;
+	const len = segment.length;
+	while (i < len) {
+		while (i < len && /\s/.test(segment[i])) i++;
+		if (i >= len) break;
+		if (segment[i] === "\"") {
+			let end = i + 1;
+			while (end < len && segment[end] !== "\"") {
+				if (segment[end] === "\\") end++;
+				end++;
+			}
+			tokens.push(segment.slice(i + 1, end).replace(/\\"/g, "\""));
+			i = end + 1;
+		} else {
+			let start = i;
+			while (i < len && !/\s/.test(segment[i]) && segment[i] !== "\"") i++;
+			if (i > start) tokens.push(segment.slice(start, i));
+		}
+	}
+	return tokens;
+}
+function splitChain(line) {
+	const result = [];
+	const regex = /(\s*&&\s*|\s*\|\s*)/g;
+	let lastIndex = 0;
+	let match;
+	while ((match = regex.exec(line)) !== null) {
+		const segment = line.slice(lastIndex, match.index).trim();
+		if (segment) {
+			const op = match[0].includes("|") ? "|" : "&&";
+			result.push({
+				segment,
+				operator: op
+			});
+		}
+		lastIndex = regex.lastIndex;
+	}
+	const tail = line.slice(lastIndex).trim();
+	if (tail) result.push({
+		segment: tail,
+		operator: null
+	});
+	return result;
+}
+function resolveParams(tokens, command) {
+	const params = {};
+	const positionals = [];
+	const paramNames = command?.parameters?.map((p) => p.name) ?? [];
+	for (const token of tokens) if (NAMED_PARAM_REGEX.test(token)) {
+		const eqIdx = token.indexOf("=");
+		const name = token.slice(0, eqIdx);
+		const value = token.slice(eqIdx + 1);
+		params[name] = value === "true" || value === "false" ? value === "true" : value;
+	} else positionals.push(token);
+	paramNames.forEach((name, i) => {
+		if (positionals[i] !== void 0 && !(name in params)) params[name] = positionals[i];
+	});
+	return params;
+}
+function parseShellLine(line, commandRegistry) {
+	return splitChain(line).map(({ segment, operator }) => {
+		const tokens = tokenize(segment);
+		if (tokens.length === 0) return {
+			command: {
+				commandId: "",
+				params: {}
+			},
+			operator
+		};
+		const commandId = tokens[0];
+		const command = commandRegistry.hasCommand(commandId) ? commandRegistry.getCommand(commandId) : void 0;
+		return {
+			command: {
+				commandId,
+				params: resolveParams(tokens.slice(1), command)
+			},
+			operator
+		};
+	});
+}
+//#endregion
+//#region src/line-input.ts
+/** Minimal readline-style editor for xterm-backed REPL backends. */
+var LineInput = class {
+	constructor(write) {
+		this.write = write;
+		this.buffer = "";
+		this.cursor = 0;
+		this.history = [];
+		this.historyDraft = "";
+		this.historyIndex = 0;
+	}
+	reset() {
+		this.buffer = "";
+		this.cursor = 0;
+		this.historyDraft = "";
+		this.historyIndex = this.history.length;
+	}
+	/** Returns the submitted line on Enter, otherwise null. */
+	feed(data) {
+		if (data === "\r") {
+			const line = this.buffer;
+			this.pushHistory(line);
+			this.buffer = "";
+			this.cursor = 0;
+			this.write("\r\n");
+			return line;
+		}
+		if (data === "" || data === "\b") {
+			this.deleteBackward();
+			return null;
+		}
+		if (data === "\x1B[D" || data === "\x1BOD") {
+			this.move(-1);
+			return null;
+		}
+		if (data === "\x1B[C" || data === "\x1BOC") {
+			this.move(1);
+			return null;
+		}
+		if (data === "\x1B[A" || data === "\x1BOA") {
+			this.historyPrev();
+			return null;
+		}
+		if (data === "\x1B[B" || data === "\x1BOB") {
+			this.historyNext();
+			return null;
+		}
+		if (data === "\x1B[3~") {
+			this.deleteForward();
+			return null;
+		}
+		if (data === "\x1B[H" || data === "\x1BOH") {
+			this.cursorHome();
+			return null;
+		}
+		if (data === "\x1B[F" || data === "\x1BOF") {
+			this.cursorEnd();
+			return null;
+		}
+		if (data.startsWith("\x1B")) return null;
+		for (const char of data) {
+			if (char < " ") continue;
+			this.insert(char);
+		}
+		return null;
+	}
+	move(delta) {
+		const next = this.cursor + delta;
+		if (next < 0 || next > this.buffer.length) return;
+		const steps = Math.abs(delta);
+		this.cursor = next;
+		this.write(delta < 0 ? `\x1b[${steps}D` : `\x1b[${steps}C`);
+	}
+	cursorHome() {
+		if (this.cursor === 0) return;
+		this.write(`\x1b[${this.cursor}D`);
+		this.cursor = 0;
+	}
+	cursorEnd() {
+		const steps = this.buffer.length - this.cursor;
+		if (steps <= 0) return;
+		this.write(`\x1b[${steps}C`);
+		this.cursor = this.buffer.length;
+	}
+	insert(char) {
+		if (this.cursor === this.buffer.length) {
+			this.buffer += char;
+			this.cursor++;
+			this.write(char);
+			return;
+		}
+		const tail = this.buffer.slice(this.cursor);
+		this.buffer = this.buffer.slice(0, this.cursor) + char + tail;
+		this.cursor++;
+		this.write(char + tail + `\x1b[${tail.length}D`);
+	}
+	deleteBackward() {
+		if (this.cursor === 0) return;
+		if (this.cursor === this.buffer.length) {
+			this.buffer = this.buffer.slice(0, -1);
+			this.cursor--;
+			this.write("\b \b");
+			return;
+		}
+		const after = this.buffer.slice(this.cursor);
+		this.buffer = this.buffer.slice(0, this.cursor - 1) + after;
+		this.cursor--;
+		this.write(`\b${after} \x1b[${after.length + 1}D`);
+	}
+	deleteForward() {
+		if (this.cursor >= this.buffer.length) return;
+		const after = this.buffer.slice(this.cursor + 1);
+		this.write(`${after} \x1b[${after.length + 1}D`);
+		this.buffer = this.buffer.slice(0, this.cursor) + after;
+	}
+	replaceBuffer(next) {
+		if (this.cursor > 0) this.write(`\x1b[${this.cursor}D`);
+		if (this.buffer.length > 0) this.write("\x1B[K");
+		this.buffer = next;
+		this.cursor = next.length;
+		if (next) this.write(next);
+	}
+	historyPrev() {
+		if (this.history.length === 0) return;
+		if (this.historyIndex === this.history.length) this.historyDraft = this.buffer;
+		if (this.historyIndex === 0) return;
+		this.historyIndex--;
+		this.replaceBuffer(this.history[this.historyIndex]);
+	}
+	historyNext() {
+		if (this.historyIndex >= this.history.length) return;
+		this.historyIndex++;
+		if (this.historyIndex === this.history.length) {
+			this.replaceBuffer(this.historyDraft);
+			this.historyDraft = "";
+			return;
+		}
+		this.replaceBuffer(this.history[this.historyIndex]);
+	}
+	pushHistory(line) {
+		if (line.length > 0 && this.history[this.history.length - 1] !== line) this.history.push(line);
+		this.historyIndex = this.history.length;
+		this.historyDraft = "";
+	}
+};
+//#endregion
+//#region src/commands-backend.ts
+function mapOutputToParams(output, producerCommand) {
+	if (output == null) return {};
+	if (typeof output === "object" && !Array.isArray(output)) return output;
+	const firstOutput = producerCommand?.output?.[0];
+	if (firstOutput) return { [firstOutput.name]: output };
+	return {};
+}
+async function runShellLine(line, registry = commandRegistry) {
+	const segments = parseShellLine(line, registry);
+	const results = [];
+	let pipedOutput = null;
+	let lastProducerCommand;
+	for (let i = 0; i < segments.length; i++) {
+		const { command, operator } = segments[i];
+		if (!command.commandId) continue;
+		const cmd = registry.hasCommand(command.commandId) ? registry.getCommand(command.commandId) : void 0;
+		if (!cmd) return {
+			success: false,
+			results,
+			error: `Command not found: ${command.commandId}`
+		};
+		const mergedParams = {
+			...mapOutputToParams(pipedOutput ?? void 0, lastProducerCommand),
+			...command.params
+		};
+		const context = registry.createExecutionContext(mergedParams);
+		try {
+			const result = registry.execute(command.commandId, context);
+			const resolved = result instanceof Promise ? await result : result;
+			results.push(resolved);
+			if (operator === "|") {
+				pipedOutput = mapOutputToParams(resolved, cmd);
+				lastProducerCommand = cmd;
+			} else {
+				pipedOutput = null;
+				lastProducerCommand = void 0;
+			}
+		} catch (err) {
+			return {
+				success: false,
+				results,
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+	return {
+		success: true,
+		results
+	};
+}
+function formatResult(result) {
+	if (result.error) return `\r\n\x1b[31m${result.error}\x1b[0m\r\n`;
+	if (result.results.length === 0) return "";
+	const last = result.results[result.results.length - 1];
+	if (last == null) return "";
+	if (typeof last === "object") return JSON.stringify(last, null, 2) + "\r\n";
+	return String(last) + "\r\n";
+}
+var CommandsBackend = class {
+	constructor() {
+		this.writeCallbacks = /* @__PURE__ */ new Set();
+		this.prompt = "> ";
+		this.lineInput = new LineInput((data) => this.emit(data));
+	}
+	onDidWrite(callback) {
+		this.writeCallbacks.add(callback);
+		return () => this.writeCallbacks.delete(callback);
+	}
+	emit(data) {
+		for (const cb of this.writeCallbacks) cb(data);
+	}
+	async open() {
+		this.emit("Commands\r\nType commands (supports && and |)\r\n\r\n" + this.prompt);
+	}
+	close() {
+		this.lineInput.reset();
+	}
+	setDimensions(_dimensions) {}
+	handleInput(data) {
+		const line = this.lineInput.feed(data);
+		if (line === null) return;
+		this.runLine(line);
+	}
+	async runLine(line) {
+		const trimmed = line.trim();
+		if (!trimmed) {
+			this.emit(this.prompt);
+			return;
+		}
+		const result = await runShellLine(trimmed);
+		this.emit(formatResult(result));
+		this.emit(this.prompt);
+	}
+};
+//#endregion
+//#region src/js-terminal-backend.ts
+var JS_REPL_PROFILE_ID = "terminal.javascript-repl";
+var PROMPT = "> ";
+function formatJsResult(value) {
+	if (value === void 0) return "";
+	if (value === null) return "null\r\n";
+	if (typeof value === "object") return JSON.stringify(value, null, 2) + "\r\n";
+	return String(value) + "\r\n";
+}
+var JsReplBackend = class {
+	constructor() {
+		this.writeCallbacks = /* @__PURE__ */ new Set();
+		this.runtime = null;
+		this.running = false;
+		this.lineInput = new LineInput((data) => this.emit(data));
+	}
+	onDidWrite(callback) {
+		this.writeCallbacks.add(callback);
+		return () => this.writeCallbacks.delete(callback);
+	}
+	emit(data) {
+		for (const cb of this.writeCallbacks) cb(data);
+	}
+	getRuntime() {
+		if (!this.runtime) this.runtime = createJsRuntime();
+		return this.runtime;
+	}
+	async open() {
+		this.emit("JavaScript REPL\r\n\r\n" + PROMPT);
+	}
+	close() {
+		this.runtime?.close();
+		this.runtime = null;
+		this.lineInput.reset();
+	}
+	setDimensions(_dimensions) {}
+	handleInput(data) {
+		if (this.running) return;
+		const line = this.lineInput.feed(data);
+		if (line === null) return;
+		this.runLine(line);
+	}
+	async runLine(line) {
+		const trimmed = line.trim();
+		if (!trimmed) {
+			this.emit(PROMPT);
+			return;
+		}
+		this.running = true;
+		try {
+			const output = formatJsResult(await this.getRuntime().execute(trimmed));
+			if (output) this.emit(output);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			this.emit(`\x1b[31m${msg}\x1b[0m\r\n`);
+		} finally {
+			this.running = false;
+			this.emit(PROMPT);
+		}
+	}
+};
+//#endregion
+export { VIEW_TERMINAL as _, registerTerminalProfile as a, parseTerminalState as c, TERMINAL_INSTANCES_TABS_ID as d, TERMINAL_NEW_DROPDOWN as f, TOPIC_TERMINAL_OPENED as g, TOPIC_TERMINAL_CLOSED as h, LineInput as i, serializeTerminalState as l, TOPIC_TERMINAL_ACTIVE_CHANGED as m, JsReplBackend as n, terminalService as o, TERMINAL_PANEL_SETTINGS_KEY as p, CommandsBackend as r, emptyTerminalState as s, JS_REPL_PROFILE_ID as t, TARGET_TERMINAL_PROFILES as u };
+
+//# sourceMappingURL=js-terminal-backend-BcQIBeMe.js.map