@jano-editor/editor 1.0.0-alpha.1

package/dist/src-wMDtJsWF.js

@@ -0,0 +1,2979 @@
+import { i as loadConfig, n as getPluginsDir, r as isPluginEnabled, t as getPaths } from "./cli.js";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, extname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region packages/ui/src/screen.ts
+var ESC$1 = "\x1B";
+function createScreen(stream = process.stdout) {
+	const write = (data) => stream.write(data);
+	return {
+		get width() {
+			return stream.columns;
+		},
+		get height() {
+			return stream.rows;
+		},
+		enter() {
+			write(`${ESC$1}[?1049h`);
+			write(`${ESC$1}[?25l`);
+		},
+		leave() {
+			write(`${ESC$1}[?25h`);
+			write(`${ESC$1}[?1049l`);
+		},
+		clear() {
+			write(`${ESC$1}[2J`);
+		},
+		moveTo(x, y) {
+			write(`${ESC$1}[${y + 1};${x + 1}H`);
+		},
+		showCursor() {
+			write(`${ESC$1}[?25h`);
+		},
+		hideCursor() {
+			write(`${ESC$1}[?25l`);
+		},
+		write(data) {
+			write(data);
+		}
+	};
+}
+//#endregion
+//#region packages/ui/src/color.ts
+var ESC = "\x1B";
+function fg(r, g, b) {
+	return `${ESC}[38;2;${r};${g};${b}m`;
+}
+function bg(r, g, b) {
+	return `${ESC}[48;2;${r};${g};${b}m`;
+}
+var reset = `${ESC}[0m`;
+`${ESC}`;
+`${ESC}`;
+`${ESC}`;
+`${ESC}`;
+//#endregion
+//#region packages/ui/src/draw.ts
+var borders = {
+	single: {
+		tl: "┌",
+		tr: "┐",
+		bl: "└",
+		br: "┘",
+		h: "─",
+		v: "│"
+	},
+	double: {
+		tl: "╔",
+		tr: "╗",
+		bl: "╚",
+		br: "╝",
+		h: "═",
+		v: "║"
+	},
+	round: {
+		tl: "╭",
+		tr: "╮",
+		bl: "╰",
+		br: "╯",
+		h: "─",
+		v: "│"
+	}
+};
+function createDraw(screen) {
+	let buffer = [];
+	let bufW = 0;
+	let bufH = 0;
+	function ensureBuffer() {
+		const w = screen.width;
+		const h = screen.height;
+		if (w !== bufW || h !== bufH) {
+			bufW = w;
+			bufH = h;
+			buffer = [];
+			for (let y = 0; y < h; y++) {
+				buffer[y] = [];
+				for (let x = 0; x < w; x++) buffer[y][x] = {
+					char: " ",
+					style: ""
+				};
+			}
+		}
+	}
+	function set(x, y, char, style = "") {
+		if (x < 0 || y < 0 || x >= bufW || y >= bufH) return;
+		buffer[y][x] = {
+			char,
+			style
+		};
+	}
+	function buildStyle(opts) {
+		let s = "";
+		if (opts.fg) s += fg(opts.fg[0], opts.fg[1], opts.fg[2]);
+		if (opts.bg) s += bg(opts.bg[0], opts.bg[1], opts.bg[2]);
+		return s;
+	}
+	return {
+		clear() {
+			ensureBuffer();
+			for (let y = 0; y < bufH; y++) for (let x = 0; x < bufW; x++) buffer[y][x] = {
+				char: " ",
+				style: ""
+			};
+		},
+		char(x, y, char, opts = {}) {
+			ensureBuffer();
+			set(x, y, char, buildStyle(opts));
+		},
+		text(x, y, text, opts = {}) {
+			ensureBuffer();
+			const style = buildStyle(opts);
+			for (let i = 0; i < text.length; i++) set(x + i, y, text[i], style);
+		},
+		line(x1, y1, x2, y2, opts = {}) {
+			ensureBuffer();
+			const style = buildStyle(opts);
+			const char = opts.char || (y1 === y2 ? "─" : "│");
+			if (y1 === y2) {
+				const start = Math.min(x1, x2);
+				const end = Math.max(x1, x2);
+				for (let x = start; x <= end; x++) set(x, y1, char, style);
+			} else if (x1 === x2) {
+				const start = Math.min(y1, y2);
+				const end = Math.max(y1, y2);
+				for (let y = start; y <= end; y++) set(x1, y, char, style);
+			}
+		},
+		rect(x, y, w, h, opts = {}) {
+			ensureBuffer();
+			const style = buildStyle(opts);
+			const b = borders[opts.border || "single"];
+			set(x, y, b.tl, style);
+			set(x + w - 1, y, b.tr, style);
+			set(x, y + h - 1, b.bl, style);
+			set(x + w - 1, y + h - 1, b.br, style);
+			for (let i = 1; i < w - 1; i++) {
+				set(x + i, y, b.h, style);
+				set(x + i, y + h - 1, b.h, style);
+			}
+			for (let i = 1; i < h - 1; i++) {
+				set(x, y + i, b.v, style);
+				set(x + w - 1, y + i, b.v, style);
+			}
+			if (opts.fill) {
+				const fillStyle = buildStyle({ bg: opts.fill });
+				for (let iy = 1; iy < h - 1; iy++) for (let ix = 1; ix < w - 1; ix++) set(x + ix, y + iy, " ", fillStyle);
+			}
+		},
+		flush() {
+			ensureBuffer();
+			let out = "";
+			for (let y = 0; y < bufH; y++) {
+				out += `\x1b[${y + 1};1H`;
+				let lastStyle = "";
+				for (let x = 0; x < bufW; x++) {
+					const cell = buffer[y][x];
+					if (cell.style !== lastStyle) {
+						out += reset + cell.style;
+						lastStyle = cell.style;
+					}
+					out += cell.char;
+				}
+			}
+			out += reset;
+			screen.write(out);
+		}
+	};
+}
+//#endregion
+//#region packages/ui/src/dialog.ts
+var theme$1 = {
+	border: [
+		120,
+		120,
+		120
+	],
+	title: [
+		255,
+		255,
+		100
+	],
+	message: [
+		200,
+		200,
+		200
+	],
+	buttonFg: [
+		0,
+		0,
+		0
+	],
+	buttonBg: [
+		180,
+		180,
+		180
+	],
+	buttonActiveFg: [
+		0,
+		0,
+		0
+	],
+	buttonActiveBg: [
+		100,
+		200,
+		255
+	],
+	inputFg: [
+		255,
+		255,
+		255
+	],
+	inputBg: [
+		50,
+		50,
+		50
+	],
+	fill: [
+		30,
+		30,
+		30
+	]
+};
+function showDialog(screen, draw, opts, renderBackground) {
+	return new Promise((resolve) => {
+		const buttons = opts.buttons ?? [];
+		const hasInput = opts.input ?? false;
+		let selectedButton = 0;
+		let inputText = opts.inputValue ?? "";
+		let inputCursorX = inputText.length;
+		let buttonsActive = !hasInput;
+		const dialogW = opts.width ?? Math.min(50, screen.width - 4);
+		const messageLines = wrapText(opts.message, dialogW - 4);
+		function calcHeight() {
+			let h = 2;
+			h += messageLines.length;
+			if (hasInput) h += 2;
+			if (buttons.length > 0) h += 2;
+			return h;
+		}
+		let backgroundDrawn = false;
+		function renderDialog() {
+			if (!backgroundDrawn) {
+				renderBackground();
+				backgroundDrawn = true;
+			}
+			const w = dialogW;
+			const h = calcHeight();
+			const x = Math.floor((screen.width - w) / 2);
+			const y = Math.floor((screen.height - h) / 2);
+			draw.rect(x, y, w, h, {
+				fg: theme$1.border,
+				border: opts.border ?? "round",
+				fill: theme$1.fill
+			});
+			if (opts.title) {
+				const titleText = ` ${opts.title} `;
+				const titleX = x + Math.floor((w - titleText.length) / 2);
+				draw.text(titleX, y, titleText, { fg: theme$1.title });
+			}
+			let row = y + 1;
+			for (const line of messageLines) {
+				draw.text(x + 2, row, line, {
+					fg: theme$1.message,
+					bg: theme$1.fill
+				});
+				row++;
+			}
+			if (hasInput) {
+				row++;
+				const inputW = w - 4;
+				for (let i = 0; i < inputW; i++) draw.char(x + 2 + i, row, " ", { bg: theme$1.inputBg });
+				const visibleText = inputText.substring(0, inputW);
+				draw.text(x + 2, row, visibleText, {
+					fg: theme$1.inputFg,
+					bg: theme$1.inputBg
+				});
+				if (inputText.length === 0 && opts.inputPlaceholder) draw.text(x + 2, row, opts.inputPlaceholder.substring(0, inputW), {
+					fg: [
+						100,
+						100,
+						100
+					],
+					bg: theme$1.inputBg
+				});
+				row++;
+			}
+			if (buttons.length > 0) {
+				row++;
+				const btnWidths = buttons.map((b) => b.label.length + 2);
+				const totalLen = btnWidths.reduce((a, b) => a + b, 0) + (buttons.length - 1) * 2;
+				let btnX = x + Math.floor((w - totalLen) / 2);
+				for (let i = 0; i < buttons.length; i++) {
+					const label = ` ${buttons[i].label} `;
+					const isActive = buttonsActive && i === selectedButton;
+					draw.text(btnX, row, label, {
+						fg: isActive ? theme$1.buttonActiveFg : theme$1.buttonFg,
+						bg: isActive ? theme$1.buttonActiveBg : theme$1.buttonBg
+					});
+					btnX += btnWidths[i] + 2;
+				}
+			}
+			draw.flush();
+			if (hasInput && !buttonsActive) {
+				const inputY = y + 1 + messageLines.length + 1;
+				screen.moveTo(x + 2 + inputCursorX, inputY);
+				screen.showCursor();
+			} else screen.hideCursor();
+		}
+		function onData(data) {
+			if (data[0] === 27 && data.length === 1) {
+				cleanup();
+				resolve({ type: "cancel" });
+				return;
+			}
+			if (data[0] === 13) {
+				if (hasInput && !buttonsActive && buttons.length > 0) {
+					buttonsActive = true;
+					renderDialog();
+					return;
+				}
+				cleanup();
+				if (hasInput && !buttonsActive && buttons.length === 0) resolve({
+					type: "input",
+					value: inputText
+				});
+				else if (buttons.length > 0) resolve({
+					type: "button",
+					value: buttons[selectedButton].value,
+					inputValue: inputText
+				});
+				return;
+			}
+			if (data[0] === 9 && hasInput && buttons.length > 0) {
+				buttonsActive = !buttonsActive;
+				renderDialog();
+				return;
+			}
+			if (data[0] === 27 && data[1] === 91) {
+				const seq = data.toString("utf8", 2);
+				if (buttonsActive) {
+					if (seq === "C" || seq === "D") {
+						if (seq === "C") selectedButton = Math.min(selectedButton + 1, buttons.length - 1);
+						if (seq === "D") selectedButton = Math.max(selectedButton - 1, 0);
+						renderDialog();
+					}
+				} else if (hasInput) {
+					if (seq === "C") inputCursorX = Math.min(inputCursorX + 1, inputText.length);
+					if (seq === "D") inputCursorX = Math.max(inputCursorX - 1, 0);
+					if (seq === "H") inputCursorX = 0;
+					if (seq === "F") inputCursorX = inputText.length;
+					renderDialog();
+				}
+				return;
+			}
+			if (data[0] === 127 && hasInput && !buttonsActive) {
+				if (inputCursorX > 0) {
+					inputText = inputText.substring(0, inputCursorX - 1) + inputText.substring(inputCursorX);
+					inputCursorX--;
+					renderDialog();
+				}
+				return;
+			}
+			if (hasInput && !buttonsActive) {
+				const ch = data.toString("utf8");
+				if ((ch.codePointAt(0) ?? 0) >= 32) {
+					inputText = inputText.substring(0, inputCursorX) + ch + inputText.substring(inputCursorX);
+					inputCursorX += ch.length;
+					renderDialog();
+				}
+			}
+		}
+		function cleanup() {
+			process.stdin.removeListener("data", onData);
+		}
+		process.stdin.on("data", onData);
+		renderDialog();
+	});
+}
+function wrapText(text, maxWidth) {
+	const result = [];
+	for (const line of text.split("\n")) if (line.length <= maxWidth) result.push(line);
+	else {
+		let remaining = line;
+		while (remaining.length > maxWidth) {
+			let breakAt = remaining.lastIndexOf(" ", maxWidth);
+			if (breakAt <= 0) breakAt = maxWidth;
+			result.push(remaining.substring(0, breakAt));
+			remaining = remaining.substring(breakAt).trimStart();
+		}
+		if (remaining.length > 0) result.push(remaining);
+	}
+	return result;
+}
+//#endregion
+//#region packages/ui/src/list.ts
+function drawList(draw, opts) {
+	const { x, y, width, height, items, selectedIndex, scrollOffset, fg = [
+		171,
+		178,
+		191
+	], bg = [
+		30,
+		30,
+		30
+	], selectedFg = [
+		255,
+		255,
+		255
+	], selectedBg = [
+		60,
+		100,
+		180
+	], descriptionFg = [
+		100,
+		105,
+		115
+	] } = opts;
+	for (let i = 0; i < height; i++) {
+		const itemIdx = i + scrollOffset;
+		const screenY = y + i;
+		if (itemIdx >= items.length) {
+			for (let col = 0; col < width; col++) draw.char(x + col, screenY, " ", { bg });
+			continue;
+		}
+		const item = items[itemIdx];
+		const isSelected = itemIdx === selectedIndex;
+		const rowFg = isSelected ? selectedFg : fg;
+		const rowBg = isSelected ? selectedBg : bg;
+		for (let col = 0; col < width; col++) draw.char(x + col, screenY, " ", { bg: rowBg });
+		const label = item.label.substring(0, width);
+		draw.text(x, screenY, label, {
+			fg: rowFg,
+			bg: rowBg
+		});
+		if (item.description) {
+			const descMaxW = width - label.length - 2;
+			if (descMaxW > 3) {
+				const desc = item.description.substring(0, descMaxW);
+				draw.text(x + width - desc.length, screenY, desc, {
+					fg: isSelected ? selectedFg : descriptionFg,
+					bg: rowBg
+				});
+			}
+		}
+	}
+	if (items.length > height) {
+		const thumbSize = Math.max(1, Math.round(height * (height / items.length)));
+		const scrollRatio = scrollOffset / Math.max(1, items.length - height);
+		const thumbPos = Math.round(scrollRatio * (height - thumbSize));
+		for (let i = 0; i < height; i++) if (i >= thumbPos && i < thumbPos + thumbSize) draw.char(x + width - 1, y + i, "┃", { fg: [
+			100,
+			100,
+			100
+		] });
+	}
+}
+function listMoveUp(state, _itemCount) {
+	const selectedIndex = Math.max(0, state.selectedIndex - 1);
+	let scrollOffset = state.scrollOffset;
+	if (selectedIndex < scrollOffset) scrollOffset = selectedIndex;
+	return {
+		selectedIndex,
+		scrollOffset
+	};
+}
+function listMoveDown(state, itemCount, visibleHeight) {
+	const selectedIndex = Math.min(itemCount - 1, state.selectedIndex + 1);
+	let scrollOffset = state.scrollOffset;
+	if (selectedIndex >= scrollOffset + visibleHeight) scrollOffset = selectedIndex - visibleHeight + 1;
+	return {
+		selectedIndex,
+		scrollOffset
+	};
+}
+//#endregion
+//#region packages/ui/src/search.ts
+var theme = {
+	border: [
+		80,
+		90,
+		105
+	],
+	fill: [
+		30,
+		33,
+		40
+	],
+	title: [
+		230,
+		200,
+		100
+	],
+	inputFg: [
+		255,
+		255,
+		255
+	],
+	inputBg: [
+		45,
+		48,
+		55
+	],
+	inputActiveBorder: [
+		100,
+		200,
+		255
+	],
+	placeholder: [
+		80,
+		85,
+		95
+	],
+	matchCount: [
+		100,
+		200,
+		255
+	],
+	labelFg: [
+		130,
+		135,
+		145
+	],
+	replaceFg: [
+		152,
+		195,
+		121
+	]
+};
+function findMatches(lines, query, maxResults) {
+	if (!query) return [];
+	const matches = [];
+	const lowerQuery = query.toLowerCase();
+	for (let i = 0; i < lines.length && matches.length < maxResults; i++) {
+		const line = lines[i];
+		const lowerLine = line.toLowerCase();
+		let searchFrom = 0;
+		while (searchFrom < lowerLine.length && matches.length < maxResults) {
+			const col = lowerLine.indexOf(lowerQuery, searchFrom);
+			if (col === -1) break;
+			const contextStart = Math.max(0, col - 15);
+			const contextEnd = Math.min(line.length, col + query.length + 30);
+			const prefix = contextStart > 0 ? "…" : "";
+			const suffix = contextEnd < line.length ? "…" : "";
+			const context = prefix + line.substring(contextStart, contextEnd) + suffix;
+			matches.push({
+				line: i,
+				col,
+				length: query.length,
+				context
+			});
+			searchFrom = col + 1;
+		}
+	}
+	return matches;
+}
+function showSearch(screen, draw, lines, opts, renderBackground) {
+	return new Promise((resolve) => {
+		let query = opts.initialQuery ?? "";
+		let replace = opts.initialReplace ?? "";
+		let queryCursorX = query.length;
+		let replaceCursorX = replace.length;
+		let activeField = 0;
+		let matches = [];
+		let listState = {
+			selectedIndex: 0,
+			scrollOffset: 0
+		};
+		const searchW = opts.width ?? Math.min(60, screen.width - 4);
+		const listH = Math.min(15, screen.height - 10);
+		updateMatches();
+		if (opts.lastSelectedIndex != null && opts.lastSelectedIndex < matches.length) listState = {
+			selectedIndex: opts.lastSelectedIndex,
+			scrollOffset: Math.max(0, opts.lastSelectedIndex - Math.floor(listH / 2))
+		};
+		let backgroundDrawn = false;
+		function renderSearch() {
+			if (!backgroundDrawn) {
+				renderBackground();
+				backgroundDrawn = true;
+			}
+			const totalH = 5 + listH + 1;
+			const x = Math.floor((screen.width - searchW) / 2);
+			const y = 1;
+			const inputW = searchW - 7;
+			draw.rect(x, y, searchW, totalH, {
+				fg: theme.border,
+				border: opts.border ?? "round",
+				fill: theme.fill
+			});
+			draw.text(x + Math.floor((searchW - 18) / 2), y, " Search & Replace ", { fg: theme.title });
+			if (query.length > 0) {
+				const countText = ` ${matches.length} `;
+				draw.text(x + searchW - countText.length - 1, y, countText, { fg: theme.matchCount });
+			}
+			const searchY = y + 1;
+			draw.text(x + 1, searchY, "  ⌕", {
+				fg: theme.labelFg,
+				bg: theme.fill
+			});
+			for (let i = 0; i < inputW; i++) draw.char(x + 5 + i, searchY, " ", { bg: theme.inputBg });
+			if (query.length > 0) draw.text(x + 5, searchY, query.substring(0, inputW), {
+				fg: theme.inputFg,
+				bg: theme.inputBg
+			});
+			else draw.text(x + 5, searchY, "Search...", {
+				fg: theme.placeholder,
+				bg: theme.inputBg
+			});
+			if (activeField === 0) draw.char(x + 4, searchY, "▎", { fg: theme.inputActiveBorder });
+			const replaceY = y + 2;
+			draw.text(x + 1, replaceY, "  →", {
+				fg: theme.labelFg,
+				bg: theme.fill
+			});
+			for (let i = 0; i < inputW; i++) draw.char(x + 5 + i, replaceY, " ", { bg: theme.inputBg });
+			if (replace.length > 0) draw.text(x + 5, replaceY, replace.substring(0, inputW), {
+				fg: theme.replaceFg,
+				bg: theme.inputBg
+			});
+			else draw.text(x + 5, replaceY, "Replace...", {
+				fg: theme.placeholder,
+				bg: theme.inputBg
+			});
+			if (activeField === 1) draw.char(x + 4, replaceY, "▎", { fg: theme.inputActiveBorder });
+			const hintY = y + 3;
+			const hint = replace.length > 0 ? " Enter=Replace  ^A=All  ↑↓=Nav  Esc=Close" : " Enter=Jump  ↑↓=Navigate  Tab=Replace  Esc=Close";
+			draw.text(x + 1, hintY, hint.substring(0, searchW - 2), {
+				fg: [
+					70,
+					75,
+					85
+				],
+				bg: theme.fill
+			});
+			const sepY = y + 4;
+			for (let i = 1; i < searchW - 1; i++) draw.char(x + i, sepY, "─", { fg: theme.border });
+			const listItems = matches.map((m) => ({
+				label: ` ${String(m.line + 1).padStart(4)} │ ${m.context}`,
+				value: `${m.line}:${m.col}`
+			}));
+			drawList(draw, {
+				x: x + 1,
+				y: sepY + 1,
+				width: searchW - 2,
+				height: listH,
+				items: listItems,
+				selectedIndex: listState.selectedIndex,
+				scrollOffset: listState.scrollOffset,
+				bg: theme.fill
+			});
+			screen.hideCursor();
+			draw.flush();
+			if (activeField === 0) screen.moveTo(x + 5 + queryCursorX, searchY);
+			else screen.moveTo(x + 5 + replaceCursorX, replaceY);
+			screen.showCursor();
+		}
+		function updateMatches(preserveSelection = false) {
+			matches = findMatches(lines, query, opts.maxResults ?? 500);
+			if (preserveSelection && listState.selectedIndex < matches.length) return;
+			const cl = opts.cursorLine ?? 0;
+			const cc = opts.cursorCol ?? 0;
+			let best = 0;
+			for (let i = 0; i < matches.length; i++) {
+				const m = matches[i];
+				if (m.line > cl || m.line === cl && m.col >= cc) {
+					best = i;
+					break;
+				}
+				best = i;
+			}
+			listState = {
+				selectedIndex: best,
+				scrollOffset: Math.max(0, best - Math.floor(listH / 2))
+			};
+		}
+		function getActiveText() {
+			return activeField === 0 ? query : replace;
+		}
+		function getActiveCursorX() {
+			return activeField === 0 ? queryCursorX : replaceCursorX;
+		}
+		function setActiveText(text) {
+			if (activeField === 0) {
+				query = text;
+				updateMatches();
+			} else replace = text;
+		}
+		function setActiveCursorX(x) {
+			if (activeField === 0) queryCursorX = x;
+			else replaceCursorX = x;
+		}
+		function onData(data) {
+			if (data[0] === 27 && data.length === 1) {
+				cleanup();
+				resolve({
+					type: "cancel",
+					query,
+					replacement: replace,
+					selectedIndex: listState.selectedIndex
+				});
+				return;
+			}
+			if (data[0] === 9) {
+				activeField = activeField === 0 ? 1 : 0;
+				renderSearch();
+				return;
+			}
+			if (data[0] === 13) {
+				if (matches.length === 0) return;
+				cleanup();
+				if (replace.length > 0) resolve({
+					type: "replace",
+					match: matches[listState.selectedIndex],
+					query,
+					replacement: replace,
+					selectedIndex: listState.selectedIndex
+				});
+				else resolve({
+					type: "jump",
+					match: matches[listState.selectedIndex],
+					query,
+					selectedIndex: listState.selectedIndex
+				});
+				return;
+			}
+			if (data.length === 1 && data[0] === 1 && replace.length > 0 && matches.length > 0) {
+				cleanup();
+				resolve({
+					type: "replaceAll",
+					matches: [...matches],
+					query,
+					replacement: replace,
+					selectedIndex: listState.selectedIndex
+				});
+				return;
+			}
+			if (data[0] === 27 && data[1] === 91) {
+				const seq = data.toString("utf8", 2);
+				if (seq === "Z") {
+					activeField = activeField === 0 ? 1 : 0;
+					renderSearch();
+					return;
+				}
+				if (seq === "A" && matches.length > 0) {
+					listState = listMoveUp(listState, matches.length);
+					renderSearch();
+					return;
+				}
+				if (seq === "B" && matches.length > 0) {
+					listState = listMoveDown(listState, matches.length, listH);
+					renderSearch();
+					return;
+				}
+				if (seq === "C") {
+					setActiveCursorX(Math.min(getActiveCursorX() + 1, getActiveText().length));
+					renderSearch();
+					return;
+				}
+				if (seq === "D") {
+					setActiveCursorX(Math.max(getActiveCursorX() - 1, 0));
+					renderSearch();
+					return;
+				}
+				if (seq === "H") {
+					setActiveCursorX(0);
+					renderSearch();
+					return;
+				}
+				if (seq === "F") {
+					setActiveCursorX(getActiveText().length);
+					renderSearch();
+					return;
+				}
+				return;
+			}
+			if (data[0] === 127) {
+				const cx = getActiveCursorX();
+				if (cx > 0) {
+					const text = getActiveText();
+					setActiveText(text.substring(0, cx - 1) + text.substring(cx));
+					setActiveCursorX(cx - 1);
+					renderSearch();
+				}
+				return;
+			}
+			if (data[0] === 8) {
+				const text = getActiveText();
+				const cx = getActiveCursorX();
+				setActiveText(text.substring(cx));
+				setActiveCursorX(0);
+				renderSearch();
+				return;
+			}
+			const ch = data.toString("utf8");
+			if ((ch.codePointAt(0) ?? 0) >= 32) {
+				const text = getActiveText();
+				const cx = getActiveCursorX();
+				setActiveText(text.substring(0, cx) + ch + text.substring(cx));
+				setActiveCursorX(cx + ch.length);
+				renderSearch();
+			}
+		}
+		function cleanup() {
+			process.stdin.removeListener("data", onData);
+		}
+		process.stdin.on("data", onData);
+		renderSearch();
+	});
+}
+//#endregion
+//#region packages/editor/src/editor.ts
+function createEditor(filePath) {
+	if (!filePath) return {
+		lines: [""],
+		filePath: "",
+		dirty: false,
+		clipboardParts: [],
+		isNewFile: true
+	};
+	if (!existsSync(filePath)) return {
+		lines: [""],
+		filePath,
+		dirty: false,
+		clipboardParts: [],
+		isNewFile: true
+	};
+	return {
+		lines: readFileSync(filePath, "utf8").split("\n"),
+		filePath,
+		dirty: false,
+		clipboardParts: [],
+		isNewFile: false
+	};
+}
+function saveAs(state, filePath) {
+	state.filePath = filePath;
+	writeFileSync(filePath, state.lines.join("\n"), "utf8");
+	state.dirty = false;
+	state.isNewFile = false;
+}
+function insertChar(state, x, y, ch) {
+	const line = state.lines[y];
+	state.lines[y] = line.substring(0, x) + ch + line.substring(x);
+	state.dirty = true;
+	return x + ch.length;
+}
+function insertNewline(state, x, y) {
+	const before = state.lines[y].substring(0, x);
+	const after = state.lines[y].substring(x);
+	state.lines[y] = before;
+	state.lines.splice(y + 1, 0, after);
+	state.dirty = true;
+	return {
+		x: 0,
+		y: y + 1
+	};
+}
+function deleteCharBack(state, x, y) {
+	if (x > 0) {
+		const line = state.lines[y];
+		state.lines[y] = line.substring(0, x - 1) + line.substring(x);
+		state.dirty = true;
+		return {
+			x: x - 1,
+			y
+		};
+	}
+	if (y > 0) {
+		const newX = state.lines[y - 1].length;
+		state.lines[y - 1] += state.lines[y];
+		state.lines.splice(y, 1);
+		state.dirty = true;
+		return {
+			x: newX,
+			y: y - 1
+		};
+	}
+	return {
+		x,
+		y
+	};
+}
+function deleteWordBack(state, x, y, boundaryX) {
+	if (x > 0) {
+		const line = state.lines[y];
+		state.lines[y] = line.substring(0, boundaryX) + line.substring(x);
+		state.dirty = true;
+		return {
+			x: boundaryX,
+			y
+		};
+	}
+	if (y > 0) {
+		const newX = state.lines[y - 1].length;
+		state.lines[y - 1] += state.lines[y];
+		state.lines.splice(y, 1);
+		state.dirty = true;
+		return {
+			x: newX,
+			y: y - 1
+		};
+	}
+	return {
+		x,
+		y
+	};
+}
+function deleteWordForward(state, x, y, boundaryX) {
+	if (x < state.lines[y].length) {
+		const line = state.lines[y];
+		state.lines[y] = line.substring(0, x) + line.substring(boundaryX);
+	} else if (y < state.lines.length - 1) {
+		state.lines[y] += state.lines[y + 1];
+		state.lines.splice(y + 1, 1);
+	}
+	state.dirty = true;
+}
+function deleteCharForward(state, x, y) {
+	if (x < state.lines[y].length) {
+		const line = state.lines[y];
+		state.lines[y] = line.substring(0, x) + line.substring(x + 1);
+	} else if (y < state.lines.length - 1) {
+		state.lines[y] += state.lines[y + 1];
+		state.lines.splice(y + 1, 1);
+	}
+	state.dirty = true;
+}
+function insertTab(state, x, y) {
+	const line = state.lines[y];
+	state.lines[y] = line.substring(0, x) + "  " + line.substring(x);
+	state.dirty = true;
+	return x + 2;
+}
+function moveLinesUp(state, startLine, endLine) {
+	if (startLine <= 0) return false;
+	const moved = state.lines.splice(startLine, endLine - startLine + 1);
+	state.lines.splice(startLine - 1, 0, ...moved);
+	state.dirty = true;
+	return true;
+}
+function moveLinesDown(state, startLine, endLine) {
+	if (endLine >= state.lines.length - 1) return false;
+	const moved = state.lines.splice(startLine, endLine - startLine + 1);
+	state.lines.splice(startLine + 1, 0, ...moved);
+	state.dirty = true;
+	return true;
+}
+function pasteText(state, x, y, text) {
+	const pasteLines = text.split("\n");
+	if (pasteLines.length === 1) {
+		const line = state.lines[y];
+		state.lines[y] = line.substring(0, x) + pasteLines[0] + line.substring(x);
+		state.dirty = true;
+		return {
+			x: x + pasteLines[0].length,
+			y
+		};
+	}
+	const before = state.lines[y].substring(0, x);
+	const after = state.lines[y].substring(x);
+	state.lines[y] = before + pasteLines[0];
+	for (let i = 1; i < pasteLines.length - 1; i++) state.lines.splice(y + i, 0, pasteLines[i]);
+	const lastLine = pasteLines[pasteLines.length - 1];
+	state.lines.splice(y + pasteLines.length - 1, 0, lastLine + after);
+	state.dirty = true;
+	return {
+		x: lastLine.length,
+		y: y + pasteLines.length - 1
+	};
+}
+//#endregion
+//#region packages/editor/src/cursor-manager.ts
+function wordBoundaryLeft(line, col) {
+	if (col <= 0) return 0;
+	let i = col - 1;
+	while (i > 0 && /\s/.test(line[i])) i--;
+	if (i >= 0 && /[^\w\s]/.test(line[i])) {
+		while (i > 0 && /[^\w\s]/.test(line[i - 1])) i--;
+		return i;
+	}
+	while (i > 0 && /\w/.test(line[i - 1])) i--;
+	return i;
+}
+function wordBoundaryRight(line, col) {
+	const len = line.length;
+	if (col >= len) return len;
+	let i = col;
+	if (/\w/.test(line[i])) while (i < len && /\w/.test(line[i])) i++;
+	else if (/[^\w\s]/.test(line[i])) while (i < len && /[^\w\s]/.test(line[i])) i++;
+	while (i < len && /\s/.test(line[i])) i++;
+	return i;
+}
+function getSelRange(c) {
+	if (!c.anchor) return null;
+	const a = c.anchor;
+	const b = {
+		x: c.x,
+		y: c.y
+	};
+	if (a.y < b.y || a.y === b.y && a.x <= b.x) return {
+		start: a,
+		end: b
+	};
+	return {
+		start: b,
+		end: a
+	};
+}
+function isInRange(range, lineIdx, colIdx) {
+	if (!range) return false;
+	if (lineIdx < range.start.y || lineIdx > range.end.y) return false;
+	if (lineIdx === range.start.y && colIdx < range.start.x) return false;
+	if (lineIdx === range.end.y && colIdx >= range.end.x) return false;
+	return true;
+}
+function clampCursor(c, lines) {
+	if (c.y < 0) c.y = 0;
+	if (c.y >= lines.length) c.y = lines.length - 1;
+	const lineLen = lines[c.y].length;
+	if (c.x < 0) c.x = 0;
+	if (c.x > lineLen) c.x = lineLen;
+}
+function moveLeftOne(c, lines) {
+	if (c.x > 0) c.x--;
+	else if (c.y > 0) {
+		c.y--;
+		c.x = lines[c.y].length;
+	}
+}
+function moveRightOne(c, lines) {
+	if (c.x < lines[c.y].length) c.x++;
+	else if (c.y < lines.length - 1) {
+		c.y++;
+		c.x = 0;
+	}
+}
+function createCursorManager() {
+	const cursors = [{
+		x: 0,
+		y: 0,
+		anchor: null
+	}];
+	let scrollX = 0;
+	let scrollY = 0;
+	return {
+		get primary() {
+			return cursors[0];
+		},
+		get all() {
+			return cursors;
+		},
+		get count() {
+			return cursors.length;
+		},
+		get isMulti() {
+			return cursors.length > 1;
+		},
+		get scrollX() {
+			return scrollX;
+		},
+		set scrollX(v) {
+			scrollX = v;
+		},
+		get scrollY() {
+			return scrollY;
+		},
+		set scrollY(v) {
+			scrollY = v;
+		},
+		saveState() {
+			return {
+				cursors: cursors.map((c) => ({
+					x: c.x,
+					y: c.y,
+					anchor: c.anchor ? { ...c.anchor } : null
+				})),
+				scrollX,
+				scrollY
+			};
+		},
+		restoreState(snapshot) {
+			cursors.length = 0;
+			for (const c of snapshot.cursors) cursors.push({
+				x: c.x,
+				y: c.y,
+				anchor: c.anchor ? { ...c.anchor } : null
+			});
+			scrollX = snapshot.scrollX;
+			scrollY = snapshot.scrollY;
+		},
+		addAbove(x, y) {
+			cursors.push({
+				x,
+				y,
+				anchor: null
+			});
+		},
+		addBelow() {
+			const allY = cursors.map((c) => c.y);
+			const newY = Math.max(...allY) + 1;
+			const newX = cursors[0].x;
+			cursors.push({
+				x: newX,
+				y: newY,
+				anchor: null
+			});
+		},
+		clearExtras() {
+			cursors.splice(1);
+		},
+		getSelection(c) {
+			return getSelRange(c);
+		},
+		getSelectedText(c, lines) {
+			const range = getSelRange(c);
+			if (!range) return "";
+			if (range.start.y === range.end.y) return lines[range.start.y].substring(range.start.x, range.end.x);
+			const parts = [];
+			parts.push(lines[range.start.y].substring(range.start.x));
+			for (let y = range.start.y + 1; y < range.end.y; y++) parts.push(lines[y]);
+			parts.push(lines[range.end.y].substring(0, range.end.x));
+			return parts.join("\n");
+		},
+		isCellSelected(lineIdx, colIdx) {
+			return cursors.some((c) => isInRange(getSelRange(c), lineIdx, colIdx));
+		},
+		isCellExtraCursor(lineIdx, colIdx) {
+			return cursors.slice(1).some((c) => c.y === lineIdx && c.x === colIdx);
+		},
+		startSelectionAll() {
+			for (const c of cursors) if (!c.anchor) c.anchor = {
+				x: c.x,
+				y: c.y
+			};
+		},
+		clearSelectionAll() {
+			for (const c of cursors) c.anchor = null;
+		},
+		collapseEmptySelections() {
+			for (const c of cursors) if (c.anchor && c.x === c.anchor.x && c.y === c.anchor.y) c.anchor = null;
+		},
+		forEachBottomUp(fn) {
+			const indexed = cursors.map((c, i) => ({
+				c,
+				i
+			}));
+			indexed.sort((a, b) => b.c.y - a.c.y || b.c.x - a.c.x);
+			for (const { c, i } of indexed) fn(c, i === 0);
+		},
+		forEachAll(fn) {
+			cursors.forEach((c, i) => fn(c, i === 0));
+		},
+		moveAll(direction, lines, pageSize) {
+			for (const c of cursors) switch (direction) {
+				case "up":
+					c.y--;
+					break;
+				case "down":
+					c.y++;
+					break;
+				case "left":
+					moveLeftOne(c, lines);
+					break;
+				case "right":
+					moveRightOne(c, lines);
+					break;
+				case "home":
+					c.x = 0;
+					break;
+				case "end":
+					c.x = lines[c.y]?.length ?? 0;
+					break;
+				case "pageup":
+					c.y -= pageSize;
+					break;
+				case "pagedown":
+					c.y += pageSize;
+					break;
+			}
+		},
+		moveWordAll(direction, lines) {
+			for (const c of cursors) if (direction === "left") {
+				if (c.x > 0) c.x = wordBoundaryLeft(lines[c.y], c.x);
+				else if (c.y > 0) {
+					c.y--;
+					c.x = lines[c.y].length;
+				}
+			} else if (c.x < lines[c.y].length) c.x = wordBoundaryRight(lines[c.y], c.x);
+			else if (c.y < lines.length - 1) {
+				c.y++;
+				c.x = 0;
+			}
+		},
+		mergeIntoSelection(direction) {
+			if (cursors.length <= 1) return;
+			const all = [];
+			for (const c of cursors) {
+				all.push({
+					x: c.x,
+					y: c.y
+				});
+				if (c.anchor) all.push(c.anchor);
+			}
+			let min = all[0], max = all[0];
+			for (const p of all) {
+				if (p.y < min.y || p.y === min.y && p.x < min.x) min = p;
+				if (p.y > max.y || p.y === max.y && p.x > max.x) max = p;
+			}
+			cursors.splice(1);
+			if (direction === "down") {
+				cursors[0].anchor = { ...min };
+				cursors[0].x = max.x;
+				cursors[0].y = max.y;
+			} else {
+				cursors[0].anchor = { ...max };
+				cursors[0].x = min.x;
+				cursors[0].y = min.y;
+			}
+		},
+		clampAll(lines) {
+			for (const c of cursors) clampCursor(c, lines);
+		},
+		dedup() {
+			const seen = /* @__PURE__ */ new Set();
+			seen.add(`${cursors[0].x},${cursors[0].y}`);
+			for (let i = cursors.length - 1; i >= 1; i--) {
+				const key = `${cursors[i].x},${cursors[i].y}`;
+				if (seen.has(key)) cursors.splice(i, 1);
+				else seen.add(key);
+			}
+		},
+		ensureVisible(viewW, viewH) {
+			const p = cursors[0];
+			if (p.y < scrollY) scrollY = p.y;
+			if (p.y >= scrollY + viewH) scrollY = p.y - viewH + 1;
+			if (p.x < scrollX) scrollX = p.x;
+			if (p.x >= scrollX + viewW) scrollX = p.x - viewW + 1;
+		},
+		deleteSelection(c, lines) {
+			const range = getSelRange(c);
+			if (!range) return;
+			if (range.start.y === range.end.y) {
+				const line = lines[range.start.y];
+				lines[range.start.y] = line.substring(0, range.start.x) + line.substring(range.end.x);
+			} else {
+				const before = lines[range.start.y].substring(0, range.start.x);
+				const after = lines[range.end.y].substring(range.end.x);
+				lines[range.start.y] = before + after;
+				lines.splice(range.start.y + 1, range.end.y - range.start.y);
+			}
+			c.x = range.start.x;
+			c.y = range.start.y;
+			c.anchor = null;
+		}
+	};
+}
+//#endregion
+//#region packages/editor/src/undo.ts
+var GROUP_THRESHOLD = 800;
+function truncate(s, max) {
+	return s.length > max ? s.substring(0, max - 1) + "…" : s;
+}
+function createUndoManager() {
+	const undoStack = [];
+	const redoStack = [];
+	let pendingLabel = "";
+	let pendingCursorBefore = {
+		x: 0,
+		y: 0
+	};
+	let pendingLinesBefore = [];
+	let pendingCursorState = null;
+	let hasPending = false;
+	function buildEntry(label, cursorBefore, cursorAfter, linesBefore, linesAfter) {
+		const diffs = [];
+		const removed = [];
+		const inserted = [];
+		const minLen = Math.min(linesBefore.length, linesAfter.length);
+		for (let i = 0; i < minLen; i++) if (linesBefore[i] !== linesAfter[i]) diffs.push({
+			index: i,
+			old: linesBefore[i],
+			new: linesAfter[i]
+		});
+		for (let i = minLen; i < linesBefore.length; i++) removed.push({
+			index: i,
+			content: linesBefore[i]
+		});
+		for (let i = minLen; i < linesAfter.length; i++) inserted.push({
+			index: i,
+			content: linesAfter[i]
+		});
+		return {
+			label,
+			timestamp: Date.now(),
+			cursorBefore,
+			cursorAfter,
+			cursorStateBefore: null,
+			cursorStateAfter: null,
+			diffs,
+			removed,
+			inserted
+		};
+	}
+	function applyUndo(entry, lines, cursor) {
+		const result = [...lines];
+		for (let i = entry.inserted.length - 1; i >= 0; i--) {
+			const ins = entry.inserted[i];
+			if (ins.index < result.length) result.splice(ins.index, 1);
+		}
+		for (const rem of entry.removed) result.splice(rem.index, 0, rem.content);
+		for (const diff of entry.diffs) if (diff.index < result.length) result[diff.index] = diff.old;
+		cursor.x = entry.cursorBefore.x;
+		cursor.y = entry.cursorBefore.y;
+		return result;
+	}
+	function applyRedo(entry, lines, cursor) {
+		const result = [...lines];
+		for (const diff of entry.diffs) if (diff.index < result.length) result[diff.index] = diff.new;
+		for (let i = entry.removed.length - 1; i >= 0; i--) {
+			const rem = entry.removed[i];
+			if (rem.index < result.length) result.splice(rem.index, 1);
+		}
+		for (const ins of entry.inserted) result.splice(ins.index, 0, ins.content);
+		cursor.x = entry.cursorAfter.x;
+		cursor.y = entry.cursorAfter.y;
+		return result;
+	}
+	function canGroup(label) {
+		if (undoStack.length === 0) return false;
+		const last = undoStack[undoStack.length - 1];
+		if (last.label !== label) return false;
+		if (Date.now() - last.timestamp > GROUP_THRESHOLD) return false;
+		if (label !== "type") return false;
+		return true;
+	}
+	return {
+		snapshot(label, cursorBefore, linesBefore, cursorState) {
+			pendingLabel = label;
+			pendingCursorBefore = { ...cursorBefore };
+			pendingLinesBefore = [...linesBefore];
+			pendingCursorState = cursorState ?? null;
+			hasPending = true;
+		},
+		commit(cursorAfter, linesAfter, cursorState) {
+			if (!hasPending) return;
+			hasPending = false;
+			if (pendingLinesBefore.length === linesAfter.length && pendingLinesBefore.every((l, i) => l === linesAfter[i])) return;
+			if (canGroup(pendingLabel)) {
+				const last = undoStack[undoStack.length - 1];
+				const merged = buildEntry(pendingLabel, last.cursorBefore, { ...cursorAfter }, applyUndo(last, linesAfter, { ...cursorAfter }), [...linesAfter]);
+				merged.cursorBefore = last.cursorBefore;
+				merged.cursorStateBefore = last.cursorStateBefore;
+				merged.cursorStateAfter = cursorState ?? null;
+				undoStack[undoStack.length - 1] = merged;
+			} else {
+				const entry = buildEntry(pendingLabel, pendingCursorBefore, { ...cursorAfter }, pendingLinesBefore, [...linesAfter]);
+				entry.cursorStateBefore = pendingCursorState;
+				entry.cursorStateAfter = cursorState ?? null;
+				undoStack.push(entry);
+			}
+			redoStack.length = 0;
+		},
+		undo(lines, cursor) {
+			const entry = undoStack.pop();
+			if (!entry) return null;
+			redoStack.push(entry);
+			return {
+				lines: applyUndo(entry, lines, cursor),
+				cursorState: entry.cursorStateBefore
+			};
+		},
+		redo(lines, cursor) {
+			const entry = redoStack.pop();
+			if (!entry) return null;
+			undoStack.push(entry);
+			return {
+				lines: applyRedo(entry, lines, cursor),
+				cursorState: entry.cursorStateAfter
+			};
+		},
+		getHistory() {
+			return undoStack;
+		},
+		describeEntry(entry) {
+			const line = entry.cursorAfter.y + 1;
+			if (entry.diffs.length > 0) {
+				const diff = entry.diffs[0];
+				const added = diff.new.length > diff.old.length ? diff.new.substring(diff.old.length === 0 ? 0 : diff.old.length) : "";
+				const removed = diff.old.length > diff.new.length ? diff.old.substring(diff.new.length === 0 ? 0 : diff.new.length) : "";
+				if (entry.label === "type" && added) return `Ln ${line}: +"${truncate(added, 25)}"`;
+				if (entry.label === "backspace" && removed) return `Ln ${line}: -"${truncate(removed, 25)}"`;
+				if (entry.label === "delete" && removed) return `Ln ${line}: -"${truncate(removed, 25)}"`;
+				if (added && removed) return `Ln ${line}: "${truncate(removed, 12)}" → "${truncate(added, 12)}"`;
+				if (added) return `Ln ${line}: +"${truncate(added, 25)}"`;
+				if (removed) return `Ln ${line}: -"${truncate(removed, 25)}"`;
+			}
+			if (entry.inserted.length > 0) {
+				const text = entry.inserted[0].content;
+				return `Ln ${line}: +line "${truncate(text || "(empty)", 20)}"`;
+			}
+			if (entry.removed.length > 0) {
+				const text = entry.removed[0].content;
+				return `Ln ${line}: -line "${truncate(text || "(empty)", 20)}"`;
+			}
+			if (entry.label === "enter") return `Ln ${line}: new line`;
+			if (entry.label === "tab") return `Ln ${line}: indent`;
+			if (entry.label === "cut") return `Ln ${line}: cut`;
+			if (entry.label === "paste") return `Ln ${line}: paste`;
+			return `Ln ${line}: ${entry.label}`;
+		},
+		jumpTo(index, lines, cursor) {
+			let current = lines;
+			while (undoStack.length > index + 1) {
+				const entry = undoStack.pop();
+				redoStack.push(entry);
+				current = applyUndo(entry, current, cursor);
+			}
+			while (undoStack.length < index + 1 && redoStack.length > 0) {
+				const entry = redoStack.pop();
+				undoStack.push(entry);
+				current = applyRedo(entry, current, cursor);
+			}
+			return current;
+		}
+	};
+}
+//#endregion
+//#region packages/editor/src/keypress.ts
+function parseKey(data) {
+	const key = {
+		name: "",
+		ctrl: false,
+		shift: false,
+		alt: false,
+		raw: data
+	};
+	if (data.length === 1 && data[0] === 13) {
+		key.name = "enter";
+		return key;
+	}
+	if (data.length === 1 && data[0] === 9) {
+		key.name = "tab";
+		return key;
+	}
+	if (data.length === 1 && data[0] === 8) {
+		key.name = "backspace";
+		key.ctrl = true;
+		return key;
+	}
+	if (data.length === 1 && data[0] < 27) {
+		key.ctrl = true;
+		key.name = String.fromCharCode(data[0] + 96);
+		return key;
+	}
+	if (data.length === 2 && data[0] === 27 && data[1] >= 32) {
+		key.alt = true;
+		key.name = String.fromCharCode(data[1]);
+		return key;
+	}
+	if (data[0] === 27 && data[1] === 79) {
+		switch (data[2]) {
+			case 80:
+				key.name = "f1";
+				break;
+			case 81:
+				key.name = "f2";
+				break;
+			case 82:
+				key.name = "f3";
+				break;
+			case 83:
+				key.name = "f4";
+				break;
+			default:
+				key.name = "unknown";
+				break;
+		}
+		return key;
+	}
+	if (data[0] === 27 && data[1] === 91) {
+		switch (data.toString("utf8", 2)) {
+			case "A":
+				key.name = "up";
+				break;
+			case "B":
+				key.name = "down";
+				break;
+			case "C":
+				key.name = "right";
+				break;
+			case "D":
+				key.name = "left";
+				break;
+			case "H":
+				key.name = "home";
+				break;
+			case "F":
+				key.name = "end";
+				break;
+			case "5~":
+				key.name = "pageup";
+				break;
+			case "6~":
+				key.name = "pagedown";
+				break;
+			case "3~":
+				key.name = "delete";
+				break;
+			case "3;5~":
+				key.name = "delete";
+				key.ctrl = true;
+				break;
+			case "1;2A":
+				key.name = "up";
+				key.shift = true;
+				break;
+			case "1;2B":
+				key.name = "down";
+				key.shift = true;
+				break;
+			case "1;2C":
+				key.name = "right";
+				key.shift = true;
+				break;
+			case "1;2D":
+				key.name = "left";
+				key.shift = true;
+				break;
+			case "1;2H":
+				key.name = "home";
+				key.shift = true;
+				break;
+			case "1;2F":
+				key.name = "end";
+				key.shift = true;
+				break;
+			case "1;3A":
+				key.name = "up";
+				key.alt = true;
+				break;
+			case "1;3B":
+				key.name = "down";
+				key.alt = true;
+				break;
+			case "1;5A":
+				key.name = "up";
+				key.ctrl = true;
+				break;
+			case "1;5B":
+				key.name = "down";
+				key.ctrl = true;
+				break;
+			case "1;5C":
+				key.name = "right";
+				key.ctrl = true;
+				break;
+			case "1;5D":
+				key.name = "left";
+				key.ctrl = true;
+				break;
+			case "1;6A":
+				key.name = "up";
+				key.ctrl = true;
+				key.shift = true;
+				break;
+			case "1;6B":
+				key.name = "down";
+				key.ctrl = true;
+				key.shift = true;
+				break;
+			case "1;6C":
+				key.name = "right";
+				key.ctrl = true;
+				key.shift = true;
+				break;
+			case "1;6D":
+				key.name = "left";
+				key.ctrl = true;
+				key.shift = true;
+				break;
+			case "1;7A":
+				key.name = "up";
+				key.ctrl = true;
+				key.alt = true;
+				break;
+			case "1;7B":
+				key.name = "down";
+				key.ctrl = true;
+				key.alt = true;
+				break;
+			case "1;7C":
+				key.name = "right";
+				key.ctrl = true;
+				key.alt = true;
+				break;
+			case "1;7D":
+				key.name = "left";
+				key.ctrl = true;
+				key.alt = true;
+				break;
+			default:
+				key.name = "unknown";
+				break;
+		}
+		return key;
+	}
+	if (data[0] === 127) {
+		key.name = "backspace";
+		return key;
+	}
+	key.name = data.toString("utf8");
+	return key;
+}
+//#endregion
+//#region packages/editor/src/plugins/context.ts
+function buildContext(editor, cm, viewport, action) {
+	const allCursors = cm.all.map((c) => ({
+		position: {
+			line: c.y,
+			col: c.x
+		},
+		anchor: c.anchor ? {
+			line: c.anchor.y,
+			col: c.anchor.x
+		} : null
+	}));
+	return {
+		filePath: editor.filePath,
+		fileName: basename(editor.filePath),
+		extension: extname(editor.filePath),
+		lines: editor.lines,
+		lineCount: editor.lines.length,
+		cursors: allCursors,
+		action,
+		viewport: {
+			firstVisibleLine: viewport.firstLine,
+			lastVisibleLine: viewport.lastLine,
+			width: viewport.width,
+			height: viewport.height
+		},
+		dirty: editor.dirty,
+		language: ""
+	};
+}
+function buildAction(type, c, previousPosition, extra) {
+	return {
+		type,
+		cursor: {
+			position: {
+				line: c.y,
+				col: c.x
+			},
+			anchor: c.anchor ? {
+				line: c.anchor.y,
+				col: c.anchor.x
+			} : null
+		},
+		previousPosition,
+		char: extra?.char,
+		pastedText: extra?.pastedText
+	};
+}
+//#endregion
+//#region packages/editor/src/plugins/apply.ts
+function applyEditResult(result, editor, cm, targetCursor) {
+	if (result.replaceAll) {
+		if (result.replaceAll.length !== editor.lines.length || result.replaceAll.some((l, i) => l !== editor.lines[i])) {
+			editor.lines = result.replaceAll;
+			editor.dirty = true;
+		}
+	}
+	if (result.edits) {
+		const sorted = [...result.edits].sort((a, b) => {
+			if (a.range.start.line !== b.range.start.line) return b.range.start.line - a.range.start.line;
+			return b.range.start.col - a.range.start.col;
+		});
+		for (const edit of sorted) {
+			const { start, end } = edit.range;
+			if (start.line === end.line) {
+				const line = editor.lines[start.line];
+				editor.lines[start.line] = line.substring(0, start.col) + edit.text + line.substring(end.col);
+			} else {
+				const firstPart = editor.lines[start.line].substring(0, start.col);
+				const lastPart = editor.lines[end.line].substring(end.col);
+				const newLines = edit.text.split("\n");
+				newLines[0] = firstPart + newLines[0];
+				newLines[newLines.length - 1] = newLines[newLines.length - 1] + lastPart;
+				editor.lines.splice(start.line, end.line - start.line + 1, ...newLines);
+			}
+			editor.dirty = true;
+		}
+	}
+	if (result.cursors && result.cursors.length > 0) {
+		const resultCursor = result.cursors[0];
+		const target = targetCursor ?? cm.primary;
+		target.x = resultCursor.position.col;
+		target.y = resultCursor.position.line;
+		target.anchor = resultCursor.anchor ? {
+			x: resultCursor.anchor.col,
+			y: resultCursor.anchor.line
+		} : null;
+	}
+}
+//#endregion
+//#region packages/editor/src/input.ts
+function notifyPlugin(plugin, actionType, c, prevPos, editor, cm, screen, extra) {
+	if (!plugin?.onCursorAction) return;
+	const action = buildAction(actionType, c, {
+		line: prevPos.y,
+		col: prevPos.x
+	}, extra);
+	const ctx = buildContext(editor, cm, getViewport(cm, screen), action);
+	const result = plugin.onCursorAction(ctx);
+	if (result) applyEditResult(result, editor, cm, c);
+}
+function snap(undo, label, cm, editor) {
+	undo.snapshot(label, {
+		x: cm.primary.x,
+		y: cm.primary.y
+	}, editor.lines, cm.saveState());
+}
+function commit(undo, cm, editor) {
+	undo.commit({
+		x: cm.primary.x,
+		y: cm.primary.y
+	}, editor.lines, cm.saveState());
+}
+function getViewport(cm, screen) {
+	return {
+		firstLine: cm.scrollY,
+		lastLine: cm.scrollY + screen.height - 5,
+		width: screen.width,
+		height: screen.height
+	};
+}
+function handleKey(key, editor, cm, screen, undo, plugin) {
+	const isWindows = process.platform === "win32" || !!process.env["WSL_DISTRO_NAME"];
+	if ((key.name === "up" || key.name === "down") && key.ctrl && (isWindows ? key.alt : key.shift)) {
+		const allCursors = cm.all;
+		if (key.name === "up") {
+			const newY = Math.min(...allCursors.map((c) => c.y)) - 1;
+			if (newY >= 0) {
+				const newX = Math.min(cm.primary.x, editor.lines[newY].length);
+				cm.addAbove(newX, newY);
+				cm.dedup();
+			}
+		} else {
+			const newY = Math.max(...allCursors.map((c) => c.y)) + 1;
+			if (newY < editor.lines.length) {
+				const newX = Math.min(cm.primary.x, editor.lines[newY].length);
+				cm.addBelow();
+				const last = cm.all[cm.all.length - 1];
+				last.x = newX;
+				last.y = newY;
+				cm.dedup();
+			}
+		}
+		return "continue";
+	}
+	if (key.shift && key.ctrl && (key.name === "left" || key.name === "right")) {
+		cm.startSelectionAll();
+		cm.moveWordAll(key.name, editor.lines);
+		cm.clampAll(editor.lines);
+		cm.collapseEmptySelections();
+		return "continue";
+	}
+	if (key.shift && [
+		"up",
+		"down",
+		"left",
+		"right",
+		"home",
+		"end"
+	].includes(key.name)) {
+		cm.startSelectionAll();
+		cm.moveAll(key.name, editor.lines, screen.height - 2);
+		cm.clampAll(editor.lines);
+		if (cm.isMulti && (key.name === "up" || key.name === "down")) {
+			cm.mergeIntoSelection(key.name);
+			return "continue";
+		}
+		cm.collapseEmptySelections();
+		return "continue";
+	}
+	if (key.raw.length === 1 && key.raw[0] === 27) {
+		if (cm.isMulti) {
+			cm.clearExtras();
+			return "continue";
+		}
+	}
+	if (key.alt && (key.name === "up" || key.name === "down")) {
+		const p = cm.primary;
+		const range = cm.getSelection(p);
+		const startLine = range ? range.start.y : p.y;
+		const endLine = range ? range.end.y : p.y;
+		snap(undo, "move-line", cm, editor);
+		if (key.name === "up") {
+			if (moveLinesUp(editor, startLine, endLine)) {
+				p.y--;
+				if (p.anchor) p.anchor = {
+					x: p.anchor.x,
+					y: p.anchor.y - 1
+				};
+			}
+		} else if (moveLinesDown(editor, startLine, endLine)) {
+			p.y++;
+			if (p.anchor) p.anchor = {
+				x: p.anchor.x,
+				y: p.anchor.y + 1
+			};
+		}
+		commit(undo, cm, editor);
+		cm.clampAll(editor.lines);
+		return "continue";
+	}
+	if (key.name === "f1" || key.name === "f2" || key.name === "f3" || key.name === "f4") {
+		if (key.name === "f2") return "history";
+		if (key.name === "f3" && plugin?.onFormat) {
+			const linesBefore = [...editor.lines];
+			snap(undo, "format", cm, editor);
+			const ctx = buildContext(editor, cm, getViewport(cm, screen));
+			const result = plugin.onFormat(ctx);
+			if (result) applyEditResult(result, editor, cm);
+			if (editor.lines.length !== linesBefore.length || editor.lines.some((l, i) => l !== linesBefore[i])) commit(undo, cm, editor);
+			cm.clampAll(editor.lines);
+		}
+		return "continue";
+	}
+	if (key.ctrl) {
+		const p = cm.primary;
+		switch (key.name) {
+			case "q": return "exit";
+			case "s": return "save";
+			case "f": return "search";
+			case "g": return "goto";
+			case "left":
+				cm.moveWordAll("left", editor.lines);
+				break;
+			case "right":
+				cm.moveWordAll("right", editor.lines);
+				break;
+			case "backspace":
+				snap(undo, "delete-word", cm, editor);
+				cm.forEachBottomUp((c) => {
+					if (c.anchor) {
+						cm.deleteSelection(c, editor.lines);
+						editor.dirty = true;
+					} else {
+						const b = wordBoundaryLeft(editor.lines[c.y], c.x);
+						const pos = deleteWordBack(editor, c.x, c.y, b);
+						c.x = pos.x;
+						c.y = pos.y;
+					}
+				});
+				commit(undo, cm, editor);
+				break;
+			case "delete":
+				snap(undo, "delete-word", cm, editor);
+				cm.forEachBottomUp((c) => {
+					if (c.anchor) {
+						cm.deleteSelection(c, editor.lines);
+						editor.dirty = true;
+					} else {
+						const b = wordBoundaryRight(editor.lines[c.y], c.x);
+						deleteWordForward(editor, c.x, c.y, b);
+					}
+				});
+				commit(undo, cm, editor);
+				break;
+			case "z": {
+				const result = undo.undo(editor.lines, p);
+				if (result) {
+					editor.lines = result.lines;
+					editor.dirty = true;
+					if (result.cursorState) cm.restoreState(result.cursorState);
+				}
+				break;
+			}
+			case "y": {
+				const result = undo.redo(editor.lines, p);
+				if (result) {
+					editor.lines = result.lines;
+					editor.dirty = true;
+					if (result.cursorState) cm.restoreState(result.cursorState);
+				}
+				break;
+			}
+			case "c": {
+				const parts = [];
+				cm.forEachAll((c) => {
+					const text = cm.getSelectedText(c, editor.lines);
+					if (text) parts.push(text);
+				});
+				if (parts.length > 0) {
+					editor.clipboardParts = parts;
+					cm.clearSelectionAll();
+				}
+				break;
+			}
+			case "x": {
+				snap(undo, "cut", cm, editor);
+				const parts = [];
+				cm.forEachBottomUp((c) => {
+					if (c.anchor) {
+						parts.unshift(cm.getSelectedText(c, editor.lines));
+						cm.deleteSelection(c, editor.lines);
+						editor.dirty = true;
+					} else {
+						parts.unshift(editor.lines[c.y]);
+						editor.lines.splice(c.y, 1);
+						if (editor.lines.length === 0) editor.lines = [""];
+						if (c.y >= editor.lines.length) c.y = editor.lines.length - 1;
+						c.x = Math.min(c.x, editor.lines[c.y].length);
+						editor.dirty = true;
+					}
+				});
+				editor.clipboardParts = parts;
+				commit(undo, cm, editor);
+				break;
+			}
+			case "v": {
+				if (editor.clipboardParts.length === 0) break;
+				snap(undo, "paste", cm, editor);
+				const parts = editor.clipboardParts;
+				const cursorCount = cm.count;
+				if (parts.length === cursorCount) cm.forEachBottomUp((c) => {
+					const partIdx = cm.all.indexOf(c);
+					if (c.anchor) {
+						cm.deleteSelection(c, editor.lines);
+						editor.dirty = true;
+					}
+					const pos = pasteText(editor, c.x, c.y, parts[partIdx]);
+					c.x = pos.x;
+					c.y = pos.y;
+				});
+				else if (cursorCount === 1) {
+					const c = cm.primary;
+					if (c.anchor) {
+						cm.deleteSelection(c, editor.lines);
+						editor.dirty = true;
+					}
+					for (let i = 0; i < parts.length - 1; i++) editor.lines.splice(c.y + i, 0, parts[i]);
+					c.y += parts.length - 1;
+					const lastPart = parts[parts.length - 1];
+					const line = editor.lines[c.y];
+					editor.lines[c.y] = line.substring(0, c.x) + lastPart + line.substring(c.x);
+					c.x += lastPart.length;
+					editor.dirty = true;
+				} else {
+					const joined = parts.join("\n");
+					cm.forEachBottomUp((c) => {
+						if (c.anchor) {
+							cm.deleteSelection(c, editor.lines);
+							editor.dirty = true;
+						}
+						const pos = pasteText(editor, c.x, c.y, joined);
+						c.x = pos.x;
+						c.y = pos.y;
+					});
+				}
+				commit(undo, cm, editor);
+				break;
+			}
+		}
+		cm.clampAll(editor.lines);
+		return "continue";
+	}
+	switch (key.name) {
+		case "up":
+		case "down":
+		case "left":
+		case "right":
+		case "home":
+		case "end":
+			cm.clearSelectionAll();
+			cm.moveAll(key.name, editor.lines, 0);
+			break;
+		case "pageup":
+		case "pagedown":
+			cm.clearSelectionAll();
+			cm.moveAll(key.name, editor.lines, screen.height - 2);
+			break;
+		case "enter": {
+			snap(undo, "enter", cm, editor);
+			const sorted = [...cm.all].sort((a, b) => a.y - b.y || a.x - b.x);
+			let lineShift = 0;
+			for (const c of sorted) {
+				c.y += lineShift;
+				const prev = {
+					x: c.x,
+					y: c.y
+				};
+				if (c.anchor) {
+					cm.deleteSelection(c, editor.lines);
+					editor.dirty = true;
+				}
+				const pos = insertNewline(editor, c.x, c.y);
+				c.x = pos.x;
+				c.y = pos.y;
+				notifyPlugin(plugin, "newline", c, prev, editor, cm, screen);
+				lineShift++;
+			}
+			commit(undo, cm, editor);
+			break;
+		}
+		case "backspace":
+			snap(undo, "backspace", cm, editor);
+			cm.forEachBottomUp((c) => {
+				const prev = {
+					x: c.x,
+					y: c.y
+				};
+				if (c.anchor) {
+					cm.deleteSelection(c, editor.lines);
+					editor.dirty = true;
+				} else {
+					const pos = deleteCharBack(editor, c.x, c.y);
+					c.x = pos.x;
+					c.y = pos.y;
+				}
+				notifyPlugin(plugin, "backspace", c, prev, editor, cm, screen);
+			});
+			commit(undo, cm, editor);
+			break;
+		case "delete":
+			snap(undo, "delete", cm, editor);
+			cm.forEachBottomUp((c) => {
+				const prev = {
+					x: c.x,
+					y: c.y
+				};
+				if (c.anchor) {
+					cm.deleteSelection(c, editor.lines);
+					editor.dirty = true;
+				} else deleteCharForward(editor, c.x, c.y);
+				notifyPlugin(plugin, "delete", c, prev, editor, cm, screen);
+			});
+			commit(undo, cm, editor);
+			break;
+		case "tab":
+			snap(undo, "tab", cm, editor);
+			cm.forEachBottomUp((c) => {
+				const prev = {
+					x: c.x,
+					y: c.y
+				};
+				c.x = insertTab(editor, c.x, c.y);
+				notifyPlugin(plugin, "tab", c, prev, editor, cm, screen);
+			});
+			commit(undo, cm, editor);
+			break;
+		default: {
+			const ch = key.name;
+			if (ch === "unknown") break;
+			if ((ch.codePointAt(0) ?? 0) >= 32) {
+				snap(undo, "type", cm, editor);
+				cm.forEachBottomUp((c) => {
+					const prev = {
+						x: c.x,
+						y: c.y
+					};
+					if (c.anchor) {
+						cm.deleteSelection(c, editor.lines);
+						editor.dirty = true;
+					}
+					c.x = insertChar(editor, c.x, c.y, ch);
+					notifyPlugin(plugin, "char", c, prev, editor, cm, screen, { char: ch });
+				});
+				commit(undo, cm, editor);
+			}
+			break;
+		}
+	}
+	cm.clampAll(editor.lines);
+	cm.dedup();
+	return "continue";
+}
+//#endregion
+//#region packages/editor/src/highlight.ts
+function tokenizeLine(line, plugin) {
+	if (!plugin?.highlight) return [];
+	const tokens = [];
+	const { keywords, patterns } = plugin.highlight;
+	const claimed = /* @__PURE__ */ new Set();
+	function addToken(start, end, type) {
+		for (let i = start; i < end; i++) if (claimed.has(i)) return;
+		tokens.push({
+			start,
+			end,
+			type
+		});
+		for (let i = start; i < end; i++) claimed.add(i);
+	}
+	const order = [
+		"comment",
+		"string",
+		"number",
+		"keyword",
+		"type",
+		"function",
+		"operator",
+		"variable",
+		"property",
+		"tag",
+		"attribute",
+		"constant",
+		"builtin",
+		"punctuation"
+	];
+	if (patterns) for (const type of order) {
+		const pattern = patterns[type];
+		if (!pattern) continue;
+		const re = new RegExp(pattern.source, pattern.flags.replace("g", "") + "g");
+		let match;
+		while ((match = re.exec(line)) !== null) {
+			addToken(match.index, match.index + match[0].length, type);
+			if (match[0].length === 0) re.lastIndex++;
+		}
+	}
+	if (keywords && keywords.length > 0) {
+		const kwPattern = new RegExp(`\\b(${keywords.join("|")})\\b`, "g");
+		let match;
+		while ((match = kwPattern.exec(line)) !== null) addToken(match.index, match.index + match[0].length, "keyword");
+	}
+	return tokens.sort((a, b) => a.start - b.start);
+}
+//#endregion
+//#region packages/editor/src/plugins/types.ts
+var tokenColors = {
+	keyword: [
+		198,
+		120,
+		221
+	],
+	string: [
+		152,
+		195,
+		121
+	],
+	comment: [
+		92,
+		99,
+		112
+	],
+	number: [
+		209,
+		154,
+		102
+	],
+	type: [
+		229,
+		192,
+		123
+	],
+	function: [
+		97,
+		175,
+		239
+	],
+	operator: [
+		86,
+		182,
+		194
+	],
+	variable: [
+		224,
+		108,
+		117
+	],
+	property: [
+		224,
+		108,
+		117
+	],
+	tag: [
+		224,
+		108,
+		117
+	],
+	attribute: [
+		209,
+		154,
+		102
+	],
+	constant: [
+		209,
+		154,
+		102
+	],
+	builtin: [
+		198,
+		120,
+		221
+	],
+	punctuation: [
+		171,
+		178,
+		191
+	]
+};
+//#endregion
+//#region packages/editor/src/render.ts
+function getShortcuts(plugin) {
+	const list = [
+		["^Q", "Exit"],
+		["^S", "Save"],
+		["^Z", "Undo"],
+		["^Y", "Redo"],
+		["^X", "Cut"],
+		["^V", "Paste"]
+	];
+	list.push(["^F", "Search"]);
+	list.push(["^G", "Go to"]);
+	const isWindows = process.platform === "win32" || !!process.env["WSL_DISTRO_NAME"];
+	list.push([isWindows ? "^⌥↕" : "^⇧↕", "Multi"]);
+	if (plugin?.onFormat) list.push(["F3", "Format"]);
+	return list;
+}
+function gutterWidth(lineCount) {
+	return String(lineCount).length + 1;
+}
+function getViewDimensions(screen, lineCount) {
+	const gw = gutterWidth(lineCount);
+	const contentTop = 1;
+	return {
+		gw,
+		contentTop,
+		viewH: screen.height - 4 - contentTop + 1,
+		viewW: screen.width - 2 - gw
+	};
+}
+function render(screen, draw, editor, cm, plugin, pluginVersion) {
+	draw.clear();
+	const w = screen.width;
+	const h = screen.height;
+	const { gw, contentTop, viewH, viewW } = getViewDimensions(screen, editor.lines.length);
+	draw.rect(0, 0, w, h - 1, {
+		fg: [
+			55,
+			60,
+			70
+		],
+		border: "round"
+	});
+	for (let x = 1; x < w - 1; x++) draw.char(x, 0, "─", { fg: [
+		55,
+		60,
+		70
+	] });
+	const langName = plugin ? ` [${plugin.name}]` : "";
+	const title = ` jano — ${editor.filePath || "untitled"}${langName} `;
+	const titleX = Math.floor((w - title.length) / 2);
+	draw.text(titleX, 0, title, { fg: [
+		230,
+		200,
+		100
+	] });
+	if (plugin && pluginVersion) {
+		const vText = ` v${pluginVersion} `;
+		draw.text(w - vText.length - 1, 0, vText, { fg: [
+			80,
+			85,
+			95
+		] });
+	}
+	for (let y = 0; y < viewH; y++) {
+		const lineIdx = y + cm.scrollY;
+		if (lineIdx >= editor.lines.length) break;
+		const lineNum = String(lineIdx + 1).padStart(gw - 1, " ") + " ";
+		const isCurrentLine = lineIdx === cm.primary.y;
+		draw.text(1, contentTop + y, lineNum, { fg: isCurrentLine ? [
+			180,
+			185,
+			195
+		] : [
+			70,
+			75,
+			85
+		] });
+		const line = editor.lines[lineIdx];
+		const tokens = tokenizeLine(line, plugin);
+		const colorMap = Array.from({ length: line.length }).fill(null);
+		for (const token of tokens) {
+			const color = tokenColors[token.type];
+			if (color) for (let i = token.start; i < token.end && i < line.length; i++) colorMap[i] = color;
+		}
+		for (let col = 0; col < viewW; col++) {
+			const charIdx = col + cm.scrollX;
+			const screenX = 1 + gw + col;
+			const screenY = contentTop + y;
+			const ch = charIdx < line.length ? line[charIdx] : " ";
+			if (cm.isCellSelected(lineIdx, charIdx)) draw.char(screenX, screenY, ch, {
+				fg: [
+					255,
+					255,
+					255
+				],
+				bg: [
+					60,
+					100,
+					180
+				]
+			});
+			else if (cm.isCellExtraCursor(lineIdx, charIdx)) draw.char(screenX, screenY, ch, {
+				fg: [
+					0,
+					0,
+					0
+				],
+				bg: [
+					200,
+					200,
+					200
+				]
+			});
+			else if (charIdx < line.length) {
+				const fg = colorMap[charIdx] ?? [
+					171,
+					178,
+					191
+				];
+				draw.char(screenX, screenY, ch, { fg });
+			}
+		}
+	}
+	if (editor.lines.length > viewH) {
+		const scrollRatio = cm.scrollY / (editor.lines.length - viewH);
+		const thumbSize = Math.max(1, Math.round(viewH * (viewH / editor.lines.length)));
+		const thumbPos = Math.round(scrollRatio * (viewH - thumbSize));
+		for (let y = 0; y < viewH; y++) {
+			const screenY = contentTop + y;
+			if (y >= thumbPos && y < thumbPos + thumbSize) draw.char(w - 1, screenY, "┃", { fg: [
+				140,
+				140,
+				140
+			] });
+		}
+	}
+	const maxLineLen = Math.max(...editor.lines.slice(cm.scrollY, cm.scrollY + viewH).map((l) => l.length), 0);
+	if (maxLineLen > viewW) {
+		const scrollRatio = cm.scrollX / (maxLineLen - viewW);
+		const thumbSize = Math.max(2, Math.round(viewW * (viewW / maxLineLen)));
+		const thumbPos = Math.round(scrollRatio * (viewW - thumbSize));
+		const barY = h - 2;
+		for (let x = 0; x < viewW; x++) if (x >= thumbPos && x < thumbPos + thumbSize) draw.char(1 + gw + x, barY, "━", { fg: [
+			140,
+			140,
+			140
+		] });
+	}
+	const p = cm.primary;
+	const statusY = h - 3;
+	for (let x = 1; x < w - 1; x++) draw.char(x, statusY, " ", { bg: [
+		45,
+		50,
+		60
+	] });
+	const posInfo = ` Ln ${p.y + 1}, Col ${p.x + 1}`;
+	draw.text(2, statusY, posInfo, {
+		fg: [
+			180,
+			185,
+			195
+		],
+		bg: [
+			45,
+			50,
+			60
+		]
+	});
+	const modified = editor.dirty ? " ●" : "";
+	const fileInfo = `${editor.lines.length} lines${modified}`;
+	const fileInfoX = Math.floor((w - fileInfo.length) / 2);
+	draw.text(fileInfoX, statusY, fileInfo, {
+		fg: editor.dirty ? [
+			229,
+			192,
+			123
+		] : [
+			130,
+			135,
+			145
+		],
+		bg: [
+			45,
+			50,
+			60
+		]
+	});
+	if (cm.isMulti) {
+		const multiInfo = `${cm.count} cursors `;
+		draw.text(w - multiInfo.length - 1, statusY, multiInfo, {
+			fg: [
+				100,
+				200,
+				255
+			],
+			bg: [
+				45,
+				50,
+				60
+			]
+		});
+	}
+	const helpY = h - 1;
+	const sc = getShortcuts(plugin);
+	for (let x = 0; x < w; x++) draw.char(x, helpY, " ", { bg: [
+		35,
+		38,
+		45
+	] });
+	let helpX = 1;
+	for (let i = 0; i < sc.length; i++) {
+		const [key, label] = sc[i];
+		draw.text(helpX, helpY, key, {
+			fg: [
+				220,
+				220,
+				220
+			],
+			bg: [
+				60,
+				65,
+				75
+			]
+		});
+		draw.text(helpX + key.length, helpY, ` ${label}`, {
+			fg: [
+				120,
+				125,
+				135
+			],
+			bg: [
+				35,
+				38,
+				45
+			]
+		});
+		helpX += key.length + label.length + 3;
+		if (i < sc.length - 1) draw.text(helpX - 1, helpY, "│", {
+			fg: [
+				55,
+				58,
+				65
+			],
+			bg: [
+				35,
+				38,
+				45
+			]
+		});
+	}
+	screen.hideCursor();
+	draw.flush();
+	const screenCursorX = 1 + gw + (p.x - cm.scrollX);
+	const screenCursorY = contentTop + (p.y - cm.scrollY);
+	screen.moveTo(screenCursorX, screenCursorY);
+	screen.showCursor();
+}
+//#endregion
+//#region packages/editor/src/plugins/manifest.ts
+function validateManifest(data) {
+	if (!data || typeof data !== "object") return null;
+	const obj = data;
+	if (typeof obj.name !== "string" || !obj.name) return null;
+	if (typeof obj.version !== "string" || !obj.version) return null;
+	if (typeof obj.description !== "string") return null;
+	if (!Array.isArray(obj.extensions) || obj.extensions.length === 0) return null;
+	if (!obj.extensions.every((e) => typeof e === "string")) return null;
+	if (typeof obj.entry !== "string" || !obj.entry) return null;
+	const api = typeof obj.api === "number" ? obj.api : 1;
+	return {
+		name: obj.name,
+		version: obj.version,
+		api,
+		description: obj.description,
+		extensions: obj.extensions,
+		entry: obj.entry,
+		author: typeof obj.author === "string" ? obj.author : void 0,
+		homepage: typeof obj.homepage === "string" ? obj.homepage : void 0,
+		license: typeof obj.license === "string" ? obj.license : void 0
+	};
+}
+//#endregion
+//#region packages/editor/src/plugins/loader.ts
+async function loadPlugins() {
+	const pluginsDir = getPluginsDir();
+	const config = loadConfig();
+	const result = {
+		plugins: [],
+		errors: [],
+		conflicts: []
+	};
+	if (!existsSync(pluginsDir)) return result;
+	let dirs;
+	try {
+		dirs = readdirSync(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+	} catch {
+		return result;
+	}
+	const extensionMap = /* @__PURE__ */ new Map();
+	for (const dirName of dirs) {
+		const dir = join(pluginsDir, dirName);
+		const manifestPath = join(dir, "plugin.json");
+		if (!existsSync(manifestPath)) {
+			result.errors.push({
+				dir,
+				error: "Missing plugin.json"
+			});
+			continue;
+		}
+		let manifest;
+		try {
+			const raw = readFileSync(manifestPath, "utf8");
+			manifest = validateManifest(JSON.parse(raw));
+		} catch (err) {
+			result.errors.push({
+				dir,
+				error: `Invalid plugin.json: ${String(err)}`
+			});
+			continue;
+		}
+		if (!manifest) {
+			result.errors.push({
+				dir,
+				error: "plugin.json missing required fields"
+			});
+			continue;
+		}
+		if (manifest.api > 1) {
+			result.errors.push({
+				dir,
+				error: `"${manifest.name}" requires API v${manifest.api}, but jano supports v1. Update jano to use this plugin.`
+			});
+			continue;
+		}
+		if (!isPluginEnabled(config, manifest.name)) continue;
+		let hasConflict = false;
+		for (const ext of manifest.extensions) {
+			const existing = extensionMap.get(ext);
+			if (existing) {
+				result.conflicts.push(`Extension "${ext}" claimed by both "${existing}" and "${manifest.name}". Skipping "${manifest.name}".`);
+				hasConflict = true;
+				break;
+			}
+		}
+		if (hasConflict) continue;
+		const entryPath = join(dir, manifest.entry);
+		if (!existsSync(entryPath)) {
+			result.errors.push({
+				dir,
+				error: `Entry file not found: ${manifest.entry}`
+			});
+			continue;
+		}
+		try {
+			const mod = await import(pathToFileURL(entryPath).href);
+			const plugin = mod.default?.default ?? mod.default ?? mod.plugin ?? mod;
+			if (!plugin.name || !plugin.extensions) {
+				result.errors.push({
+					dir,
+					error: "Plugin does not export a valid LanguagePlugin"
+				});
+				continue;
+			}
+			for (const ext of manifest.extensions) extensionMap.set(ext, manifest.name);
+			result.plugins.push({
+				manifest,
+				plugin,
+				dir
+			});
+		} catch (err) {
+			result.errors.push({
+				dir,
+				error: `Failed to load: ${String(err)}`
+			});
+		}
+	}
+	return result;
+}
+//#endregion
+//#region packages/editor/src/plugins/index.ts
+var loadedPlugins = [];
+async function initPlugins() {
+	const result = await loadPlugins();
+	loadedPlugins = result.plugins;
+	return result;
+}
+function getLoadedPlugins() {
+	return loadedPlugins;
+}
+function detectLanguage(filePath) {
+	const ext = extname(filePath);
+	const base = basename(filePath);
+	for (const { plugin } of loadedPlugins) for (const pattern of plugin.extensions) if (pattern === ext || pattern === base) return plugin;
+	return null;
+}
+//#endregion
+//#region packages/editor/src/index.ts
+var filePath = process.argv[2] || void 0;
+var screen = createScreen();
+var draw = createDraw(screen);
+var editor = createEditor(filePath);
+var cm = createCursorManager();
+var undo = createUndoManager();
+var plugin = null;
+var pluginVersion;
+var dialogOpen = false;
+function update() {
+	const { viewW, viewH } = getViewDimensions(screen, editor.lines.length);
+	cm.ensureVisible(viewW, viewH);
+	render(screen, draw, editor, cm, plugin, pluginVersion);
+}
+function reloadPlugin() {
+	plugin = detectLanguage(editor.filePath);
+	if (plugin) pluginVersion = getLoadedPlugins().find((p) => p.plugin === plugin)?.manifest.version;
+	else pluginVersion = void 0;
+}
+async function trySave(filePath) {
+	const { existsSync } = await import("node:fs");
+	if (existsSync(filePath) && filePath !== editor.filePath) {
+		dialogOpen = true;
+		const confirm = await showDialog(screen, draw, {
+			title: "Overwrite?",
+			message: `"${filePath}" already exists. Overwrite?`,
+			buttons: [{
+				label: "Overwrite",
+				value: "yes"
+			}, {
+				label: "Cancel",
+				value: "no"
+			}],
+			border: "round"
+		}, update);
+		dialogOpen = false;
+		if (confirm.type !== "button" || confirm.value !== "yes") return false;
+	}
+	try {
+		saveAs(editor, filePath);
+		reloadPlugin();
+		return true;
+	} catch (err) {
+		dialogOpen = true;
+		await showDialog(screen, draw, {
+			title: "Error",
+			message: `Could not save: ${err instanceof Error ? err.message : String(err)}`,
+			buttons: [{
+				label: "OK",
+				value: "ok"
+			}],
+			border: "round"
+		}, update);
+		dialogOpen = false;
+		return false;
+	}
+}
+async function saveWithDialog() {
+	dialogOpen = true;
+	const result = await showDialog(screen, draw, {
+		title: "Save As",
+		message: "Enter file name:",
+		input: true,
+		inputPlaceholder: "filename.ext",
+		buttons: [{
+			label: "Save",
+			value: "save"
+		}, {
+			label: "Cancel",
+			value: "cancel"
+		}],
+		border: "round",
+		width: 50
+	}, update);
+	dialogOpen = false;
+	let targetPath = "";
+	if (result.type === "button" && result.value === "save" && result.inputValue) targetPath = result.inputValue;
+	else if (result.type === "input" && result.value) targetPath = result.value;
+	if (targetPath) await trySave(targetPath);
+	update();
+}
+async function confirmExit() {
+	if (!editor.dirty) {
+		screen.leave();
+		process.exit(0);
+	}
+	dialogOpen = true;
+	const result = await showDialog(screen, draw, {
+		title: "Unsaved Changes",
+		message: `Save changes to "${editor.filePath || "untitled"}" before closing?`,
+		buttons: [
+			{
+				label: "Save",
+				value: "save"
+			},
+			{
+				label: "Discard",
+				value: "discard"
+			},
+			{
+				label: "Cancel",
+				value: "cancel"
+			}
+		],
+		border: "round"
+	}, update);
+	dialogOpen = false;
+	if (result.type === "button") {
+		if (result.value === "save") {
+			if (!editor.filePath) {
+				await saveWithDialog();
+				if (!editor.filePath) {
+					update();
+					return;
+				}
+			} else if (!await trySave(editor.filePath)) {
+				update();
+				return;
+			}
+			screen.leave();
+			process.exit(0);
+		}
+		if (result.value === "discard") {
+			screen.leave();
+			process.exit(0);
+		}
+	}
+	update();
+}
+async function showHistory() {
+	const history = undo.getHistory();
+	if (history.length === 0) {
+		dialogOpen = true;
+		await showDialog(screen, draw, {
+			title: "History",
+			message: "No changes recorded yet.",
+			buttons: [{
+				label: "OK",
+				value: "ok"
+			}],
+			border: "round"
+		}, update);
+		dialogOpen = false;
+		update();
+		return;
+	}
+	dialogOpen = true;
+	const items = ["  0. Original file"];
+	for (let i = 0; i < history.length; i++) {
+		const entry = history[i];
+		const time = new Date(entry.timestamp).toLocaleTimeString();
+		const desc = undo.describeEntry(entry);
+		const marker = i === history.length - 1 ? "▸" : " ";
+		items.push(`${marker} ${i + 1}. [${time}] ${desc}`);
+	}
+	const result = await showDialog(screen, draw, {
+		title: `History (${history.length} changes)`,
+		message: items.slice(-15).join("\n"),
+		input: true,
+		inputPlaceholder: "Number (0 = original)...",
+		buttons: [{
+			label: "Jump",
+			value: "jump"
+		}, {
+			label: "Cancel",
+			value: "cancel"
+		}],
+		border: "round",
+		width: 60
+	}, update);
+	dialogOpen = false;
+	if (result.type === "input" || result.type === "button" && result.value === "jump") {
+		const inputVal = result.type === "input" ? result.value : result.inputValue ?? "";
+		const idx = parseInt(inputVal, 10);
+		if (idx === 0) {
+			while (true) {
+				const undone = undo.undo(editor.lines, cm.primary);
+				if (!undone) break;
+				editor.lines = undone.lines;
+				if (undone.cursorState) cm.restoreState(undone.cursorState);
+			}
+			editor.dirty = false;
+		} else if (idx >= 1 && idx <= history.length) {
+			editor.lines = undo.jumpTo(idx - 1, editor.lines, cm.primary);
+			editor.dirty = true;
+		}
+	}
+	update();
+}
+var lastSearchQuery = "";
+var lastReplaceText = "";
+var lastSelectedIndex;
+async function openSearch() {
+	dialogOpen = true;
+	const result = await showSearch(screen, draw, editor.lines, {
+		initialQuery: lastSearchQuery,
+		initialReplace: lastReplaceText,
+		cursorLine: cm.primary.y,
+		cursorCol: cm.primary.x,
+		lastSelectedIndex,
+		border: "round"
+	}, update);
+	dialogOpen = false;
+	lastSearchQuery = result.query;
+	lastSelectedIndex = result.selectedIndex;
+	if (result.type === "replace" || result.type === "replaceAll") lastReplaceText = result.replacement;
+	else lastReplaceText = "";
+	const p = cm.primary;
+	cm.clearExtras();
+	if (result.type === "jump") {
+		p.y = result.match.line;
+		p.x = result.match.col;
+		p.anchor = null;
+	}
+	if (result.type === "replace") {
+		undo.snapshot("replace", {
+			x: p.x,
+			y: p.y
+		}, editor.lines, cm.saveState());
+		const m = result.match;
+		const line = editor.lines[m.line];
+		editor.lines[m.line] = line.substring(0, m.col) + result.replacement + line.substring(m.col + m.length);
+		editor.dirty = true;
+		p.y = m.line;
+		p.x = m.col + result.replacement.length;
+		p.anchor = null;
+		undo.commit({
+			x: p.x,
+			y: p.y
+		}, editor.lines, cm.saveState());
+		update();
+		openSearch();
+		return;
+	}
+	if (result.type === "replaceAll") {
+		undo.snapshot("replace-all", {
+			x: p.x,
+			y: p.y
+		}, editor.lines, cm.saveState());
+		const sorted = [...result.matches].sort((a, b) => b.line - a.line || b.col - a.col);
+		for (const m of sorted) {
+			const line = editor.lines[m.line];
+			editor.lines[m.line] = line.substring(0, m.col) + result.replacement + line.substring(m.col + m.length);
+		}
+		editor.dirty = true;
+		undo.commit({
+			x: p.x,
+			y: p.y
+		}, editor.lines, cm.saveState());
+	}
+	update();
+}
+async function openGoto() {
+	dialogOpen = true;
+	const total = editor.lines.length;
+	const current = cm.primary.y + 1;
+	const result = await showDialog(screen, draw, {
+		title: `Go to Line (1-${total})`,
+		message: `Current: line ${current}`,
+		input: true,
+		inputPlaceholder: "Line number, 'start' or 'end'...",
+		buttons: [
+			{
+				label: "Start",
+				value: "start"
+			},
+			{
+				label: "Go",
+				value: "go"
+			},
+			{
+				label: "End",
+				value: "end"
+			}
+		],
+		border: "round",
+		width: 45
+	}, update);
+	dialogOpen = false;
+	const p = cm.primary;
+	cm.clearExtras();
+	p.anchor = null;
+	if (result.type === "button") {
+		if (result.value === "start") {
+			p.y = 0;
+			p.x = 0;
+		} else if (result.value === "end") {
+			p.y = editor.lines.length - 1;
+			p.x = 0;
+		} else if (result.value === "go") {
+			const inputVal = result.inputValue ?? "";
+			const line = parseInt(inputVal, 10);
+			if (line >= 1 && line <= editor.lines.length) {
+				p.y = line - 1;
+				p.x = 0;
+			}
+		}
+	} else if (result.type === "input") {
+		const val = result.value.trim().toLowerCase();
+		if (val === "start" || val === "s") {
+			p.y = 0;
+			p.x = 0;
+		} else if (val === "end" || val === "e") {
+			p.y = editor.lines.length - 1;
+			p.x = 0;
+		} else {
+			const line = parseInt(val, 10);
+			if (line >= 1 && line <= editor.lines.length) {
+				p.y = line - 1;
+				p.x = 0;
+			}
+		}
+	}
+	update();
+}
+async function start() {
+	const paths = getPaths();
+	console.log(`[jano] config: ${paths.config}`);
+	console.log(`[jano] plugins: ${paths.plugins}`);
+	const loadResult = await initPlugins();
+	console.log(`[jano] loaded ${loadResult.plugins.length} plugin(s)`);
+	for (const p of loadResult.plugins) console.log(`[jano]   ✓ ${p.manifest.name} v${p.manifest.version} (${p.manifest.extensions.join(", ")})`);
+	for (const err of loadResult.errors) console.log(`[jano]   ✗ ${err.dir}: ${err.error}`);
+	for (const conflict of loadResult.conflicts) console.log(`[jano]   ⚠ ${conflict}`);
+	if (filePath) {
+		plugin = detectLanguage(filePath);
+		if (plugin) {
+			pluginVersion = getLoadedPlugins().find((p) => p.plugin === plugin)?.manifest.version;
+			console.log(`[jano] language: ${plugin.name}`);
+		}
+	}
+	screen.enter();
+	process.stdin.setRawMode(true);
+	update();
+}
+start();
+process.stdin.on("data", (data) => {
+	if (dialogOpen) return;
+	switch (handleKey(parseKey(data), editor, cm, screen, undo, plugin)) {
+		case "exit":
+			confirmExit();
+			return;
+		case "history":
+			showHistory();
+			return;
+		case "search":
+			openSearch();
+			return;
+		case "goto":
+			openGoto();
+			return;
+		case "save":
+			if (editor.filePath) trySave(editor.filePath).then(() => update());
+			else saveWithDialog();
+			return;
+	}
+	update();
+});
+process.stdout.on("resize", update);
+//#endregion
+export {};