harunire 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2122 @@
+#!/usr/bin/env node
+import { readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+
+//#region src/ui/ansi.ts
+const ansi = {
+	moveTo: (x, y) => `\x1b[${y + 1};${x + 1}H`,
+	reset: "\x1B[0m",
+	fg: (c) => c === "default" ? "\x1B[39m" : `\x1b[38;2;${c[0]};${c[1]};${c[2]}m`,
+	bg: (c) => c === "default" ? "\x1B[49m" : `\x1b[48;2;${c[0]};${c[1]};${c[2]}m`
+};
+
+//#endregion
+//#region src/ui/ascii.ts
+function ascii(str) {
+	return str;
+}
+
+//#endregion
+//#region src/ui/calc-height.ts
+function calcHeight(widget) {
+	if (widget.type === "text") return 1;
+	if (widget.type === "row") return Math.max(1, ...widget.children.map(calcHeight));
+	if (widget.type === "col") {
+		const gap = widget.gap ?? 0;
+		const childrenHeight = widget.children.reduce((sum, c) => sum + calcHeight(c), 0);
+		const totalGap = gap * Math.max(0, widget.children.length - 1);
+		return widget.height ?? childrenHeight + totalGap;
+	}
+	if (widget.type === "grid") {
+		const numRows = widget.rows.length;
+		const totalGapY = (widget.gapY ?? 0) * Math.max(0, numRows - 1);
+		return numRows * widget.cellHeight + totalGapY;
+	}
+	if (widget.type === "canvas") return widget.height;
+	return 1;
+}
+
+//#endregion
+//#region src/ui/display-width.ts
+/**
+* Calculate display width of a string, handling CJK characters and ANSI escape sequences
+*/
+function isFullWidth$1(char) {
+	const code = char.codePointAt(0);
+	if (code === void 0) return false;
+	if (code >= 19968 && code <= 40959) return true;
+	if (code >= 13312 && code <= 19903) return true;
+	if (code >= 12352 && code <= 12447) return true;
+	if (code >= 12448 && code <= 12543) return true;
+	if (code >= 65280 && code <= 65376) return true;
+	if (code >= 65381 && code <= 65439) return false;
+	if (code >= 12288 && code <= 12351) return true;
+	if (code >= 44032 && code <= 55215) return true;
+	return false;
+}
+function displayWidth$1(str) {
+	const withoutAnsi = str.replace(/\x1b\[[0-9;]*m/g, "");
+	let width = 0;
+	for (const char of withoutAnsi) width += isFullWidth$1(char) ? 2 : 1;
+	return width;
+}
+
+//#endregion
+//#region src/ui/calc-width.ts
+/**
+* Calculate the natural width of a widget
+*/
+function calcWidth(widget) {
+	if (widget.type === "text") {
+		const px = widget.style.px ?? 0;
+		const pl = widget.style.pl ?? px;
+		const pr = widget.style.pr ?? px;
+		return pl + displayWidth$1(widget.content) + pr;
+	}
+	if (widget.type === "row") {
+		const px = widget.px ?? 0;
+		const pl = widget.pl ?? px;
+		const pr = widget.pr ?? px;
+		const gap = widget.gap ?? 0;
+		const childrenWidth = widget.children.reduce((sum, c) => sum + calcWidth(c), 0);
+		const totalGap = gap * Math.max(0, widget.children.length - 1);
+		return widget.width ?? pl + childrenWidth + totalGap + pr;
+	}
+	if (widget.type === "col") {
+		const px = widget.px ?? 0;
+		const pl = widget.pl ?? px;
+		const pr = widget.pr ?? px;
+		const childMaxWidth = Math.max(0, ...widget.children.map(calcWidth));
+		return widget.width ?? pl + childMaxWidth + pr;
+	}
+	if (widget.type === "grid") {
+		const numCols = Math.max(0, ...widget.rows.map((r) => r.length));
+		const totalGapX = (widget.gapX ?? 0) * Math.max(0, numCols - 1);
+		return numCols * widget.cellWidth + totalGapX;
+	}
+	if (widget.type === "canvas") return widget.width;
+	return 0;
+}
+
+//#endregion
+//#region src/ui/errors.ts
+/**
+* Custom error classes for open-tui
+*/
+var HasciiUiError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "HasciiUiError";
+	}
+};
+var HasciiUiInvalidColorError = class extends HasciiUiError {
+	input;
+	constructor(input) {
+		super(`Invalid color: ${JSON.stringify(input)}`);
+		this.name = "HasciiUiInvalidColorError";
+		this.input = input;
+		Object.freeze(this);
+	}
+};
+var HasciiUiOverflowError = class extends HasciiUiError {
+	content;
+	maxWidth;
+	actualWidth;
+	constructor(content, maxWidth, actualWidth) {
+		super(`Content overflow: "${content}" requires ${actualWidth} chars but only ${maxWidth} available`);
+		this.name = "HasciiUiOverflowError";
+		this.content = content;
+		this.maxWidth = maxWidth;
+		this.actualWidth = actualWidth;
+		Object.freeze(this);
+	}
+};
+
+//#endregion
+//#region src/ui/color.ts
+/**
+* Color normalization utilities
+*/
+const NAMED_COLORS = {
+	black: [
+		0,
+		0,
+		0
+	],
+	white: [
+		255,
+		255,
+		255
+	],
+	red: [
+		255,
+		0,
+		0
+	],
+	green: [
+		0,
+		128,
+		0
+	],
+	blue: [
+		0,
+		0,
+		255
+	],
+	yellow: [
+		255,
+		255,
+		0
+	],
+	cyan: [
+		0,
+		255,
+		255
+	],
+	magenta: [
+		255,
+		0,
+		255
+	],
+	gray: [
+		128,
+		128,
+		128
+	],
+	grey: [
+		128,
+		128,
+		128
+	],
+	darkgray: [
+		64,
+		64,
+		64
+	],
+	darkgrey: [
+		64,
+		64,
+		64
+	],
+	lightgray: [
+		192,
+		192,
+		192
+	],
+	lightgrey: [
+		192,
+		192,
+		192
+	],
+	orange: [
+		255,
+		165,
+		0
+	],
+	pink: [
+		255,
+		192,
+		203
+	],
+	purple: [
+		128,
+		0,
+		128
+	],
+	brown: [
+		139,
+		69,
+		19
+	],
+	lime: [
+		0,
+		255,
+		0
+	],
+	navy: [
+		0,
+		0,
+		128
+	],
+	teal: [
+		0,
+		128,
+		128
+	],
+	olive: [
+		128,
+		128,
+		0
+	],
+	maroon: [
+		128,
+		0,
+		0
+	],
+	aqua: [
+		0,
+		255,
+		255
+	],
+	silver: [
+		192,
+		192,
+		192
+	],
+	gold: [
+		255,
+		215,
+		0
+	]
+};
+const HEX_PATTERN = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+function parseHex(hex) {
+	const match = HEX_PATTERN.exec(hex);
+	if (!match || !match[1]) throw new HasciiUiInvalidColorError(hex);
+	let hexValue = match[1];
+	if (hexValue.length === 3) hexValue = hexValue.split("").map((c) => c + c).join("");
+	return [
+		Number.parseInt(hexValue.slice(0, 2), 16),
+		Number.parseInt(hexValue.slice(2, 4), 16),
+		Number.parseInt(hexValue.slice(4, 6), 16)
+	];
+}
+function isRGB(value) {
+	if (!Array.isArray(value) || value.length !== 3) return false;
+	return value.every((n) => typeof n === "number" && n >= 0 && n <= 255 && Number.isInteger(n));
+}
+function normalizeColor(input) {
+	if (input === "default") return "default";
+	if (isRGB(input)) return input;
+	if (typeof input === "string") {
+		if (input.startsWith("#")) return parseHex(input);
+		const named = NAMED_COLORS[input.toLowerCase()];
+		if (named) return named;
+	}
+	throw new HasciiUiInvalidColorError(input);
+}
+
+//#endregion
+//#region src/ui/is-options.ts
+function isOptions(x) {
+	if (typeof x !== "object" || x === null) return false;
+	if ("type" in x) return false;
+	return "justify" in x || "items" in x || "width" in x || "height" in x || "gap" in x || "px" in x || "pl" in x || "pr" in x || "bg" in x;
+}
+
+//#endregion
+//#region src/ui/text.ts
+/**
+* Create a text widget
+*/
+function normalizeStyle(input) {
+	return {
+		px: input.px,
+		pl: input.pl,
+		pr: input.pr,
+		fg: input.fg !== void 0 ? normalizeColor(input.fg) : void 0,
+		bg: input.bg !== void 0 ? normalizeColor(input.bg) : void 0
+	};
+}
+function text(styleOrContent, content) {
+	if (typeof styleOrContent === "string") return {
+		type: "text",
+		content: ascii(styleOrContent),
+		style: {}
+	};
+	return {
+		type: "text",
+		content: ascii(content ?? ""),
+		style: normalizeStyle(styleOrContent)
+	};
+}
+
+//#endregion
+//#region src/ui/col.ts
+/**
+* Create a col widget (vertical layout)
+*/
+function col(optionsOrChild, ...rest) {
+	if (optionsOrChild === void 0) return {
+		type: "col",
+		children: []
+	};
+	if (isOptions(optionsOrChild)) return {
+		type: "col",
+		children: rest.map((c) => typeof c === "string" ? text(c) : c),
+		justify: optionsOrChild.justify,
+		items: optionsOrChild.items,
+		width: optionsOrChild.width,
+		height: optionsOrChild.height,
+		gap: optionsOrChild.gap,
+		px: optionsOrChild.px,
+		pl: optionsOrChild.pl,
+		pr: optionsOrChild.pr,
+		bg: optionsOrChild.bg !== void 0 ? normalizeColor(optionsOrChild.bg) : void 0
+	};
+	return {
+		type: "col",
+		children: [optionsOrChild, ...rest].map((c) => typeof c === "string" ? text(c) : c)
+	};
+}
+
+//#endregion
+//#region src/ui/palette.ts
+const PALETTE = Object.freeze([
+	[
+		0,
+		0,
+		0
+	],
+	[
+		128,
+		0,
+		0
+	],
+	[
+		0,
+		128,
+		0
+	],
+	[
+		128,
+		128,
+		0
+	],
+	[
+		0,
+		0,
+		128
+	],
+	[
+		128,
+		0,
+		128
+	],
+	[
+		0,
+		128,
+		128
+	],
+	[
+		192,
+		192,
+		192
+	],
+	[
+		128,
+		128,
+		128
+	],
+	[
+		255,
+		0,
+		0
+	],
+	[
+		0,
+		255,
+		0
+	],
+	[
+		255,
+		255,
+		0
+	],
+	[
+		0,
+		0,
+		255
+	],
+	[
+		255,
+		0,
+		255
+	],
+	[
+		0,
+		255,
+		255
+	],
+	[
+		255,
+		255,
+		255
+	]
+]);
+function paletteToRgb(index) {
+	return PALETTE[index % PALETTE.length] ?? [
+		0,
+		0,
+		0
+	];
+}
+
+//#endregion
+//#region src/ui/render-widget.ts
+/**
+* Internal recursive widget renderer
+*/
+function renderWidget(widget, x, y, maxWidth, maxHeight, ctx) {
+	if (maxWidth <= 0 || maxHeight <= 0) return ctx;
+	if (widget.type === "text") {
+		const px = widget.style.px ?? 0;
+		const pl = widget.style.pl ?? px;
+		const pr = widget.style.pr ?? px;
+		const availableForPadding = Math.min(pl + pr, maxWidth);
+		const actualPl = Math.min(pl, availableForPadding);
+		const actualPr = Math.min(pr, Math.max(0, availableForPadding - actualPl));
+		const availableForContent = Math.max(0, maxWidth - actualPl - actualPr);
+		const contentLength = displayWidth$1(widget.content);
+		if (contentLength > availableForContent) throw new HasciiUiOverflowError(widget.content, availableForContent, contentLength);
+		if (widget.style.bg) ctx.output += ansi.bg(widget.style.bg);
+		if (widget.style.fg) ctx.output += ansi.fg(widget.style.fg);
+		ctx.output += ansi.moveTo(x, y);
+		ctx.output += " ".repeat(actualPl) + widget.content + " ".repeat(actualPr);
+		return ctx;
+	}
+	if (widget.type === "row") {
+		const rowWidth = Math.min(widget.width ?? calcWidth(widget), maxWidth);
+		const rowHeight = Math.min(calcHeight(widget), maxHeight);
+		if (widget.bg) {
+			ctx.output += ansi.bg(widget.bg);
+			const emptyLine = " ".repeat(rowWidth);
+			for (let row$1 = 0; row$1 < rowHeight; row$1++) ctx.output += ansi.moveTo(x, y + row$1) + emptyLine;
+		}
+		const px = widget.px ?? 0;
+		const pl = widget.pl ?? px;
+		const pr = widget.pr ?? px;
+		const contentWidth = rowWidth - pl - pr;
+		const gap = widget.gap ?? 0;
+		const childrenWidth = widget.children.reduce((sum, c) => sum + calcWidth(c), 0);
+		const totalWidth = childrenWidth + gap * Math.max(0, widget.children.length - 1);
+		let startX = x + pl;
+		let actualGap = gap;
+		if (widget.justify === "center") startX = x + pl + Math.floor((contentWidth - totalWidth) / 2);
+		else if (widget.justify === "end") startX = x + pl + (contentWidth - totalWidth);
+		else if (widget.justify === "space-between" && widget.children.length > 1) {
+			const extraSpace = contentWidth - childrenWidth;
+			actualGap = Math.floor(extraSpace / (widget.children.length - 1));
+		}
+		let cx = startX;
+		let remainingWidth = contentWidth;
+		for (let i = 0; i < widget.children.length; i++) {
+			const child = widget.children[i];
+			if (child) {
+				const childNaturalWidth = calcWidth(child);
+				const childNaturalHeight = calcHeight(child);
+				const childMaxWidth = Math.min(childNaturalWidth, remainingWidth);
+				let cy = y;
+				if (widget.items === "center") cy = y + Math.floor((rowHeight - childNaturalHeight) / 2);
+				else if (widget.items === "end") cy = y + (rowHeight - childNaturalHeight);
+				ctx = renderWidget(child, cx, cy, childMaxWidth, rowHeight, ctx);
+				cx += childMaxWidth;
+				remainingWidth -= childMaxWidth;
+			}
+			if (i < widget.children.length - 1) {
+				cx += actualGap;
+				remainingWidth -= actualGap;
+			}
+			if (remainingWidth <= 0) break;
+		}
+		return ctx;
+	}
+	if (widget.type === "col") {
+		const colWidth = Math.min(widget.width ?? calcWidth(widget), maxWidth);
+		const colHeight = Math.min(widget.height ?? calcHeight(widget), maxHeight);
+		if (widget.bg) {
+			ctx.output += ansi.bg(widget.bg);
+			const emptyLine = " ".repeat(colWidth);
+			for (let row$1 = 0; row$1 < colHeight; row$1++) ctx.output += ansi.moveTo(x, y + row$1) + emptyLine;
+		}
+		const px = widget.px ?? 0;
+		const pl = widget.pl ?? px;
+		const pr = widget.pr ?? px;
+		const contentWidth = colWidth - pl - pr;
+		const gap = widget.gap ?? 0;
+		const childrenHeight = widget.children.reduce((sum, c) => sum + calcHeight(c), 0);
+		const totalHeight = childrenHeight + gap * Math.max(0, widget.children.length - 1);
+		let startY = y;
+		let actualGap = gap;
+		if (widget.justify === "space-between" && widget.children.length > 1) {
+			const extraSpace = colHeight - childrenHeight;
+			actualGap = Math.floor(extraSpace / (widget.children.length - 1));
+		} else if (widget.justify === "center" && totalHeight < colHeight) startY = y + Math.floor((colHeight - totalHeight) / 2);
+		else if (widget.justify === "end" && totalHeight < colHeight) startY = y + (colHeight - totalHeight);
+		let cy = startY;
+		let remainingHeight = colHeight;
+		for (let i = 0; i < widget.children.length; i++) {
+			const child = widget.children[i];
+			if (child) {
+				const childNaturalHeight = calcHeight(child);
+				const childMaxHeight = Math.min(childNaturalHeight, remainingHeight);
+				const childWidth = calcWidth(child);
+				let cx = x + pl;
+				if (widget.items === "center") cx = x + pl + Math.floor((contentWidth - childWidth) / 2);
+				else if (widget.items === "end") cx = x + pl + (contentWidth - childWidth);
+				ctx = renderWidget(child, cx, cy, contentWidth, childMaxHeight, ctx);
+				cy += childMaxHeight;
+				remainingHeight -= childMaxHeight;
+			}
+			if (i < widget.children.length - 1) {
+				cy += actualGap;
+				remainingHeight -= actualGap;
+			}
+			if (remainingHeight <= 0) break;
+		}
+		return ctx;
+	}
+	if (widget.type === "grid") {
+		const gridWidth = calcWidth(widget);
+		const gridHeight = calcHeight(widget);
+		const gapX = widget.gapX ?? 0;
+		const gapY = widget.gapY ?? 0;
+		if (widget.bg) {
+			ctx.output += ansi.bg(widget.bg);
+			const emptyLine = " ".repeat(gridWidth);
+			for (let row$1 = 0; row$1 < gridHeight; row$1++) ctx.output += ansi.moveTo(x, y + row$1) + emptyLine;
+		}
+		for (let rowIdx = 0; rowIdx < widget.rows.length; rowIdx++) {
+			const row$1 = widget.rows[rowIdx];
+			if (!row$1) continue;
+			const cellY = y + rowIdx * (widget.cellHeight + gapY);
+			for (let colIdx = 0; colIdx < row$1.length; colIdx++) {
+				const cell = row$1[colIdx];
+				if (!cell) continue;
+				ctx = renderWidget(cell, x + colIdx * (widget.cellWidth + gapX), cellY, widget.cellWidth, widget.cellHeight, ctx);
+			}
+		}
+		return ctx;
+	}
+	if (widget.type === "canvas") {
+		const canvasWidth = Math.min(widget.width, maxWidth);
+		const canvasHeight = Math.min(widget.height, maxHeight);
+		for (let row$1 = 0; row$1 < canvasHeight; row$1++) {
+			const bufferRow = widget.buffer[row$1];
+			if (!bufferRow) continue;
+			ctx.output += ansi.moveTo(x, y + row$1);
+			for (let col$1 = 0; col$1 < canvasWidth; col$1++) {
+				const cell = bufferRow[col$1];
+				if (!cell) {
+					ctx.output += " ";
+					continue;
+				}
+				const fgRgb = paletteToRgb(cell.fg);
+				ctx.output += ansi.fg(fgRgb);
+				if (cell.bg !== null) {
+					const bgRgb = paletteToRgb(cell.bg);
+					ctx.output += ansi.bg(bgRgb);
+				}
+				ctx.output += cell.char;
+			}
+		}
+		return ctx;
+	}
+	return ctx;
+}
+
+//#endregion
+//#region src/ui/render.ts
+/**
+* Render a widget tree to ANSI string
+*/
+function render(widget, screenX = 0, screenY = 0, maxWidth = 9999, maxHeight = 9999) {
+	return renderWidget(widget, screenX, screenY, maxWidth, maxHeight, { output: "" }).output + ansi.reset;
+}
+
+//#endregion
+//#region src/ui/row.ts
+/**
+* Create a row widget (horizontal layout)
+*/
+function row(optionsOrChild, ...rest) {
+	if (optionsOrChild === void 0) return {
+		type: "row",
+		children: []
+	};
+	if (isOptions(optionsOrChild)) return {
+		type: "row",
+		children: rest.map((c) => typeof c === "string" ? text(c) : c),
+		justify: optionsOrChild.justify,
+		items: optionsOrChild.items,
+		width: optionsOrChild.width,
+		gap: optionsOrChild.gap,
+		px: optionsOrChild.px,
+		pl: optionsOrChild.pl,
+		pr: optionsOrChild.pr,
+		bg: optionsOrChild.bg !== void 0 ? normalizeColor(optionsOrChild.bg) : void 0
+	};
+	return {
+		type: "row",
+		children: [optionsOrChild, ...rest].map((c) => typeof c === "string" ? text(c) : c)
+	};
+}
+
+//#endregion
+//#region src/editor/file-tree.ts
+function buildFileTree(dirPath, depth = 0) {
+	const name = basename(dirPath) || dirPath;
+	const isDirectory = statSync(dirPath).isDirectory();
+	const children = [];
+	if (isDirectory) {
+		const entries = readdirSync(dirPath);
+		for (const entry of entries) {
+			if (entry.startsWith(".")) continue;
+			const childPath = join(dirPath, entry);
+			children.push(buildFileTree(childPath, depth + 1));
+		}
+		children.sort((a, b) => {
+			if (a.isDirectory === b.isDirectory) return a.name.localeCompare(b.name);
+			return a.isDirectory ? -1 : 1;
+		});
+	}
+	return {
+		name,
+		path: dirPath,
+		isDirectory,
+		children,
+		expanded: depth === 0,
+		depth
+	};
+}
+function flattenTree(node, list = [], skipRoot = false) {
+	if (!skipRoot) list.push(node);
+	if (node.isDirectory && node.expanded) for (const child of node.children) flattenTree(child, list);
+	return list;
+}
+function readFile(path) {
+	try {
+		return readFileSync(path, "utf-8").split("\n");
+	} catch {
+		return ["(Cannot read file)"];
+	}
+}
+
+//#endregion
+//#region src/editor/model.ts
+function initModel(targetPath$1, terminalWidth, terminalHeight) {
+	const root = buildFileTree(targetPath$1);
+	return {
+		root,
+		flatList: flattenTree(root, [], true),
+		scrollOffset: 0,
+		selectedIndex: 0,
+		terminalHeight,
+		terminalWidth,
+		openedFile: null,
+		fileContent: [],
+		fileScrollOffset: 0,
+		fileHorizontalOffset: 0,
+		focus: "tree",
+		cursor: {
+			line: 0,
+			col: 0
+		},
+		modified: false,
+		treeVisible: true,
+		mouseEnabled: true
+	};
+}
+
+//#endregion
+//#region src/editor/constants.ts
+const INDENT_SIZE = 2;
+const EDITOR_PADDING = 0;
+const SCROLLBAR_WIDTH = 0;
+
+//#endregion
+//#region src/editor/text-utils.ts
+function isFullWidth(char) {
+	const code = char.codePointAt(0);
+	if (code === void 0) return false;
+	if (code >= 19968 && code <= 40959) return true;
+	if (code >= 13312 && code <= 19903) return true;
+	if (code >= 12352 && code <= 12447) return true;
+	if (code >= 12448 && code <= 12543) return true;
+	if (code >= 65280 && code <= 65376) return true;
+	if (code >= 65381 && code <= 65439) return false;
+	if (code >= 12288 && code <= 12351) return true;
+	return false;
+}
+function isPrintableAscii(char) {
+	const code = char.charCodeAt(0);
+	return code >= 32 && code <= 126;
+}
+function isAllowedChar(char) {
+	return isPrintableAscii(char) || isFullWidth(char);
+}
+function sanitize(str) {
+	let result = "";
+	for (const char of str) if (char.codePointAt(0) === 9) result += "  ";
+	else if (isAllowedChar(char)) result += char;
+	else result += "?";
+	return result;
+}
+function displayWidth(str) {
+	let width = 0;
+	for (const char of str) width += isFullWidth(char) ? 2 : 1;
+	return width;
+}
+function truncateByWidth(str, maxWidth) {
+	let width = 0;
+	let result = "";
+	for (const char of str) {
+		const charWidth = isFullWidth(char) ? 2 : 1;
+		if (width + charWidth > maxWidth) break;
+		result += char;
+		width += charWidth;
+	}
+	return result;
+}
+function sliceByWidth(str, startWidth, maxWidth) {
+	let currentWidth = 0;
+	let result = "";
+	let started = false;
+	for (const char of str) {
+		const charWidth = isFullWidth(char) ? 2 : 1;
+		if (!started) {
+			if (currentWidth + charWidth > startWidth) {
+				started = true;
+				if (currentWidth < startWidth) {
+					result += " ";
+					currentWidth = startWidth + 1;
+				} else {
+					result += char;
+					currentWidth += charWidth;
+				}
+			} else currentWidth += charWidth;
+			continue;
+		}
+		if (displayWidth(result) + charWidth > maxWidth) break;
+		result += char;
+	}
+	return result;
+}
+function padEndByWidth(str, targetWidth) {
+	const currentWidth = displayWidth(str);
+	if (currentWidth >= targetWidth) return str;
+	return str + " ".repeat(targetWidth - currentWidth);
+}
+function charIndexToSanitizedWidth(str, charIndex) {
+	let width = 0;
+	let i = 0;
+	for (const char of str) {
+		if (i >= charIndex) break;
+		if (char.codePointAt(0) === 9) width += 2;
+		else if (isFullWidth(char)) width += 2;
+		else width += 1;
+		i++;
+	}
+	return width;
+}
+function maxDisplayWidth(lines) {
+	let max = 0;
+	for (const line of lines) {
+		const w = displayWidth(line);
+		if (w > max) max = w;
+	}
+	return max;
+}
+function splitAtWidth(str, targetWidth) {
+	let width = 0;
+	let beforeEnd = 0;
+	let charEnd = 0;
+	const chars = [...str];
+	for (let i = 0; i < chars.length; i++) {
+		const char = chars[i];
+		const charWidth = isFullWidth(char) ? 2 : 1;
+		if (width >= targetWidth) {
+			beforeEnd = i;
+			charEnd = i + 1;
+			break;
+		}
+		if (width + charWidth > targetWidth) {
+			beforeEnd = i;
+			charEnd = i + 1;
+			break;
+		}
+		width += charWidth;
+		beforeEnd = i + 1;
+		charEnd = i + 1;
+	}
+	if (beforeEnd >= chars.length) return {
+		before: str,
+		char: " ",
+		after: ""
+	};
+	return {
+		before: chars.slice(0, beforeEnd).join(""),
+		char: chars[beforeEnd] || " ",
+		after: chars.slice(charEnd).join("")
+	};
+}
+
+//#endregion
+//#region src/editor/update.ts
+function update(model$1, msg) {
+	if (msg.type === "NOOP") return model$1;
+	if (msg.type === "RESIZE") return ensureVisible({
+		...model$1,
+		terminalHeight: msg.height,
+		terminalWidth: msg.width
+	});
+	if (msg.type === "MOVE") {
+		const newIndex = Math.max(0, Math.min(model$1.flatList.length - 1, model$1.selectedIndex + msg.delta));
+		return ensureVisible({
+			...model$1,
+			selectedIndex: newIndex
+		});
+	}
+	if (msg.type === "SCROLL") {
+		const contentHeight = model$1.terminalHeight - 2;
+		const maxScroll = Math.max(0, model$1.flatList.length - contentHeight);
+		const newOffset = Math.max(0, Math.min(maxScroll, model$1.scrollOffset + msg.delta));
+		return {
+			...model$1,
+			scrollOffset: newOffset
+		};
+	}
+	if (msg.type === "SCROLL_TO") {
+		const contentHeight = model$1.terminalHeight - 2;
+		const maxScroll = Math.max(0, model$1.flatList.length - contentHeight);
+		const newOffset = Math.max(0, Math.min(maxScroll, msg.position));
+		return {
+			...model$1,
+			scrollOffset: newOffset
+		};
+	}
+	if (msg.type === "SCROLL_FILE") {
+		const contentHeight = model$1.terminalHeight - 2;
+		const maxScroll = Math.max(0, model$1.fileContent.length - contentHeight);
+		const newOffset = Math.max(0, Math.min(maxScroll, model$1.fileScrollOffset + msg.delta));
+		return {
+			...model$1,
+			fileScrollOffset: newOffset
+		};
+	}
+	if (msg.type === "SCROLL_FILE_TO") {
+		const contentHeight = model$1.terminalHeight - 2;
+		const maxScroll = Math.max(0, model$1.fileContent.length - contentHeight);
+		const newOffset = Math.max(0, Math.min(maxScroll, msg.position));
+		return {
+			...model$1,
+			fileScrollOffset: newOffset
+		};
+	}
+	if (msg.type === "SCROLL_FILE_H") {
+		const maxWidth = maxDisplayWidth(model$1.fileContent) + EDITOR_PADDING * 2;
+		const editorWidth = model$1.terminalWidth - SCROLLBAR_WIDTH;
+		const maxScroll = Math.max(0, maxWidth - editorWidth);
+		const newOffset = Math.max(0, Math.min(maxScroll, model$1.fileHorizontalOffset + msg.delta));
+		return {
+			...model$1,
+			fileHorizontalOffset: newOffset
+		};
+	}
+	if (msg.type === "SCROLL_FILE_H_TO") {
+		const maxWidth = maxDisplayWidth(model$1.fileContent) + EDITOR_PADDING * 2;
+		const editorWidth = model$1.terminalWidth - SCROLLBAR_WIDTH;
+		const maxScroll = Math.max(0, maxWidth - editorWidth);
+		const newOffset = Math.max(0, Math.min(maxScroll, msg.position));
+		return {
+			...model$1,
+			fileHorizontalOffset: newOffset
+		};
+	}
+	if (msg.type === "SELECT") {
+		if (msg.index < 0 || msg.index >= model$1.flatList.length) return model$1;
+		return {
+			...model$1,
+			selectedIndex: msg.index
+		};
+	}
+	if (msg.type === "OPEN_FILE") {
+		const content = readFile(msg.path);
+		return {
+			...model$1,
+			openedFile: msg.path,
+			fileContent: content,
+			fileScrollOffset: 0,
+			fileHorizontalOffset: 0,
+			cursor: {
+				line: 0,
+				col: 0
+			},
+			modified: false
+		};
+	}
+	if (msg.type === "TOGGLE") {
+		const node = model$1.flatList[msg.index];
+		if (!node) return model$1;
+		if (!node.isDirectory) {
+			const content = readFile(node.path);
+			return {
+				...model$1,
+				openedFile: node.path,
+				fileContent: content,
+				fileScrollOffset: 0,
+				fileHorizontalOffset: 0,
+				cursor: {
+					line: 0,
+					col: 0
+				},
+				modified: false
+			};
+		}
+		node.expanded = !node.expanded;
+		const newFlatList = flattenTree(model$1.root, [], true);
+		const newSelectedIndex = Math.min(model$1.selectedIndex, newFlatList.length - 1);
+		return {
+			...model$1,
+			flatList: newFlatList,
+			selectedIndex: newSelectedIndex
+		};
+	}
+	if (msg.type === "FOCUS_TOGGLE") {
+		const newFocus = model$1.focus === "tree" ? "editor" : "tree";
+		return {
+			...model$1,
+			focus: newFocus
+		};
+	}
+	if (msg.type === "TOGGLE_TREE") {
+		if (model$1.treeVisible) return {
+			...model$1,
+			treeVisible: false,
+			focus: "editor"
+		};
+		return {
+			...model$1,
+			treeVisible: true,
+			focus: "tree"
+		};
+	}
+	if (msg.type === "CURSOR_MOVE") {
+		if (!model$1.openedFile || model$1.fileContent.length === 0) return model$1;
+		const maxLine = Math.max(0, model$1.fileContent.length - 1);
+		const newLine = Math.max(0, Math.min(maxLine, model$1.cursor.line + msg.deltaLine));
+		const lineContent = model$1.fileContent[newLine] || "";
+		const maxCol = Math.max(0, [...lineContent].length - 1);
+		const newCol = Math.max(0, Math.min(maxCol, model$1.cursor.col + msg.deltaCol));
+		return ensureCursorVisible({
+			...model$1,
+			cursor: {
+				line: newLine,
+				col: newCol
+			}
+		});
+	}
+	if (msg.type === "INSERT_CHAR") {
+		if (!model$1.openedFile) return model$1;
+		const newContent = [...model$1.fileContent];
+		const chars = [...newContent[model$1.cursor.line] || ""];
+		const safeChars = [...msg.char].filter(isAllowedChar);
+		if (safeChars.length === 0) return model$1;
+		chars.splice(model$1.cursor.col, 0, ...safeChars);
+		newContent[model$1.cursor.line] = chars.join("");
+		return ensureCursorVisible({
+			...model$1,
+			fileContent: newContent,
+			cursor: {
+				line: model$1.cursor.line,
+				col: model$1.cursor.col + safeChars.length
+			},
+			modified: true
+		});
+	}
+	if (msg.type === "DELETE_CHAR") {
+		if (!model$1.openedFile) return model$1;
+		const newContent = [...model$1.fileContent];
+		const line = newContent[model$1.cursor.line] || "";
+		const chars = [...line];
+		if (model$1.cursor.col < chars.length) {
+			chars.splice(model$1.cursor.col, 1);
+			newContent[model$1.cursor.line] = chars.join("");
+			return {
+				...model$1,
+				fileContent: newContent,
+				modified: true
+			};
+		}
+		if (model$1.cursor.line < newContent.length - 1) {
+			const nextLine = newContent[model$1.cursor.line + 1] || "";
+			newContent[model$1.cursor.line] = line + nextLine;
+			newContent.splice(model$1.cursor.line + 1, 1);
+			return {
+				...model$1,
+				fileContent: newContent,
+				modified: true
+			};
+		}
+		return model$1;
+	}
+	if (msg.type === "DELETE_CHAR_BEFORE") {
+		if (!model$1.openedFile) return model$1;
+		if (model$1.cursor.col > 0) {
+			const newContent = [...model$1.fileContent];
+			const chars = [...newContent[model$1.cursor.line] || ""];
+			chars.splice(model$1.cursor.col - 1, 1);
+			newContent[model$1.cursor.line] = chars.join("");
+			return ensureCursorVisible({
+				...model$1,
+				fileContent: newContent,
+				cursor: {
+					line: model$1.cursor.line,
+					col: model$1.cursor.col - 1
+				},
+				modified: true
+			});
+		}
+		if (model$1.cursor.line > 0) {
+			const newContent = [...model$1.fileContent];
+			const prevLine = newContent[model$1.cursor.line - 1] || "";
+			const currentLine = newContent[model$1.cursor.line] || "";
+			const newCol = [...prevLine].length;
+			newContent[model$1.cursor.line - 1] = prevLine + currentLine;
+			newContent.splice(model$1.cursor.line, 1);
+			return ensureCursorVisible({
+				...model$1,
+				fileContent: newContent,
+				cursor: {
+					line: model$1.cursor.line - 1,
+					col: newCol
+				},
+				modified: true
+			});
+		}
+		return model$1;
+	}
+	if (msg.type === "INSERT_NEWLINE") {
+		if (!model$1.openedFile) return model$1;
+		const newContent = [...model$1.fileContent];
+		const chars = [...newContent[model$1.cursor.line] || ""];
+		const beforeCursor = chars.slice(0, model$1.cursor.col).join("");
+		const afterCursor = chars.slice(model$1.cursor.col).join("");
+		newContent[model$1.cursor.line] = beforeCursor;
+		newContent.splice(model$1.cursor.line + 1, 0, afterCursor);
+		return ensureCursorVisible({
+			...model$1,
+			fileContent: newContent,
+			cursor: {
+				line: model$1.cursor.line + 1,
+				col: 0
+			},
+			modified: true
+		});
+	}
+	if (msg.type === "SAVE") {
+		if (!model$1.openedFile || !model$1.modified) return model$1;
+		try {
+			writeFileSync(model$1.openedFile, model$1.fileContent.join("\n"));
+			return {
+				...model$1,
+				modified: false
+			};
+		} catch {
+			return model$1;
+		}
+	}
+	if (msg.type === "CLICK") return handleClick(model$1, msg.row, msg.col);
+	if (msg.type === "TOGGLE_MOUSE") return {
+		...model$1,
+		mouseEnabled: !model$1.mouseEnabled
+	};
+	return model$1;
+}
+function ensureVisible(model$1) {
+	const contentHeight = model$1.terminalHeight - 2;
+	let newOffset = model$1.scrollOffset;
+	if (model$1.selectedIndex < model$1.scrollOffset) newOffset = model$1.selectedIndex;
+	if (model$1.selectedIndex >= model$1.scrollOffset + contentHeight) newOffset = model$1.selectedIndex - contentHeight + 1;
+	const maxFileWidth = maxDisplayWidth(model$1.fileContent) + EDITOR_PADDING * 2;
+	const editorWidth = model$1.terminalWidth - SCROLLBAR_WIDTH;
+	const maxHorizontalOffset = Math.max(0, maxFileWidth - editorWidth);
+	const newHorizontalOffset = Math.min(model$1.fileHorizontalOffset, maxHorizontalOffset);
+	const maxFileScrollOffset = Math.max(0, model$1.fileContent.length - contentHeight);
+	const newFileScrollOffset = Math.min(model$1.fileScrollOffset, maxFileScrollOffset);
+	return {
+		...model$1,
+		scrollOffset: newOffset,
+		fileHorizontalOffset: newHorizontalOffset,
+		fileScrollOffset: newFileScrollOffset
+	};
+}
+function ensureCursorVisible(model$1) {
+	const contentHeight = model$1.terminalHeight - 2;
+	const editorContentWidth = model$1.terminalWidth - SCROLLBAR_WIDTH;
+	let newScrollOffset = model$1.fileScrollOffset;
+	let newHorizontalOffset = model$1.fileHorizontalOffset;
+	if (model$1.cursor.line < model$1.fileScrollOffset) newScrollOffset = model$1.cursor.line;
+	if (model$1.cursor.line >= model$1.fileScrollOffset + contentHeight) newScrollOffset = model$1.cursor.line - contentHeight + 1;
+	const cursorWidth = EDITOR_PADDING + charIndexToSanitizedWidth(model$1.fileContent[model$1.cursor.line] || "", model$1.cursor.col);
+	if (cursorWidth < newHorizontalOffset) newHorizontalOffset = Math.max(0, cursorWidth - EDITOR_PADDING);
+	if (cursorWidth >= newHorizontalOffset + editorContentWidth) newHorizontalOffset = cursorWidth - editorContentWidth + 1;
+	return {
+		...model$1,
+		fileScrollOffset: newScrollOffset,
+		fileHorizontalOffset: newHorizontalOffset
+	};
+}
+function handleClick(model$1, row$1, col$1) {
+	const treeWidth = model$1.treeVisible ? Math.floor(model$1.terminalWidth / 2) : 0;
+	const editorWidth = model$1.terminalWidth - treeWidth;
+	const contentHeight = model$1.terminalHeight - 2;
+	if (row$1 === model$1.terminalHeight - 1 && col$1 > treeWidth) {
+		const maxFileWidth = maxDisplayWidth(model$1.fileContent) + EDITOR_PADDING * 2;
+		const editorContentWidth = editorWidth - SCROLLBAR_WIDTH;
+		const scrollbarStart = treeWidth + 1;
+		const scrollbarEnd = scrollbarStart + editorContentWidth;
+		if (maxFileWidth > editorContentWidth && col$1 >= scrollbarStart && col$1 < scrollbarEnd) {
+			const clickPosInScrollbar = col$1 - scrollbarStart;
+			const maxOffset = maxFileWidth - editorContentWidth;
+			const newOffset = Math.floor(clickPosInScrollbar / editorContentWidth * maxOffset);
+			return {
+				...model$1,
+				fileHorizontalOffset: Math.max(0, Math.min(maxOffset, newOffset)),
+				focus: "editor"
+			};
+		}
+		return {
+			...model$1,
+			focus: "editor"
+		};
+	}
+	if (model$1.treeVisible && col$1 <= treeWidth) {
+		if (row$1 < 2 || row$1 > contentHeight + 1) return {
+			...model$1,
+			focus: "tree"
+		};
+		const index = model$1.scrollOffset + row$1 - 2;
+		if (index >= model$1.flatList.length) return {
+			...model$1,
+			focus: "tree"
+		};
+		const node = model$1.flatList[index];
+		if (node && node.isDirectory) {
+			node.expanded = !node.expanded;
+			const newFlatList = flattenTree(model$1.root, [], true);
+			return {
+				...model$1,
+				flatList: newFlatList,
+				selectedIndex: index,
+				focus: "tree"
+			};
+		}
+		if (node && !node.isDirectory) {
+			const content = readFile(node.path);
+			return {
+				...model$1,
+				selectedIndex: index,
+				openedFile: node.path,
+				fileContent: content,
+				fileScrollOffset: 0,
+				fileHorizontalOffset: 0,
+				cursor: {
+					line: 0,
+					col: 0
+				},
+				modified: false,
+				focus: "tree"
+			};
+		}
+		return {
+			...model$1,
+			selectedIndex: index,
+			focus: "tree"
+		};
+	}
+	if (col$1 === model$1.terminalWidth && row$1 >= 2 && row$1 <= contentHeight + 1) {
+		const clickPosInScrollbar = row$1 - 2;
+		const maxScroll = Math.max(0, model$1.fileContent.length - contentHeight);
+		if (maxScroll > 0) {
+			const newOffset = Math.floor(clickPosInScrollbar / contentHeight * model$1.fileContent.length);
+			return {
+				...model$1,
+				fileScrollOffset: Math.max(0, Math.min(maxScroll, newOffset)),
+				focus: "editor"
+			};
+		}
+		return {
+			...model$1,
+			focus: "editor"
+		};
+	}
+	if (row$1 >= 2 && row$1 <= contentHeight + 1) {
+		const clickedLine = model$1.fileScrollOffset + row$1 - 2;
+		if (clickedLine < model$1.fileContent.length) {
+			const clickColInText = col$1 - 1 + model$1.fileHorizontalOffset - EDITOR_PADDING;
+			if (clickColInText < 0) return {
+				...model$1,
+				cursor: {
+					line: clickedLine,
+					col: 0
+				},
+				focus: "editor"
+			};
+			const line = model$1.fileContent[clickedLine] || "";
+			const lineWidth = displayWidth(sanitize(line));
+			const clampedClickCol = Math.min(clickColInText, Math.max(0, lineWidth - 1));
+			let charIndex = 0;
+			let width = 0;
+			for (const char of line) {
+				let charWidth;
+				if (char.codePointAt(0) === 9) charWidth = 2;
+				else if (isFullWidth(char)) charWidth = 2;
+				else charWidth = 1;
+				if (width + charWidth > clampedClickCol) break;
+				width += charWidth;
+				charIndex++;
+			}
+			const maxCharIndex = Math.max(0, [...line].length - 1);
+			charIndex = Math.min(charIndex, maxCharIndex);
+			return {
+				...model$1,
+				cursor: {
+					line: clickedLine,
+					col: charIndex
+				},
+				focus: "editor"
+			};
+		}
+	}
+	return {
+		...model$1,
+		focus: "editor"
+	};
+}
+
+//#endregion
+//#region src/editor/calc-scrollbar.ts
+function calcScrollbar(props) {
+	if (props.totalItems <= props.visibleItems) return {
+		start: 0,
+		end: 0
+	};
+	const thumbSize = Math.max(1, Math.floor(props.visibleItems / props.totalItems * props.height));
+	const maxOffset = props.totalItems - props.visibleItems;
+	const thumbPosition = Math.floor(props.offset / maxOffset * (props.height - thumbSize));
+	return {
+		start: thumbPosition,
+		end: thumbPosition + thumbSize
+	};
+}
+
+//#endregion
+//#region src/editor/calc-horizontal-scrollbar.ts
+function calcHorizontalScrollbar(props) {
+	if (props.maxWidth <= props.visibleWidth) return {
+		start: 0,
+		end: 0
+	};
+	const thumbSize = Math.max(2, Math.floor(props.visibleWidth / props.maxWidth * props.width));
+	const maxOffset = props.maxWidth - props.visibleWidth;
+	const thumbPosition = Math.floor(props.offset / maxOffset * (props.width - thumbSize));
+	return {
+		start: thumbPosition,
+		end: thumbPosition + thumbSize
+	};
+}
+
+//#endregion
+//#region src/editor/view-header.ts
+function viewHeader(props) {
+	const theme$1 = props.theme;
+	const bg = theme$1.headerBgFocus;
+	let content;
+	if (props.focus === "tree") content = ` ${props.rootPath}`;
+	else if (props.openedFile) {
+		const modifiedMark = props.modified ? " [+]" : "";
+		content = ` ${basename(props.openedFile)}${modifiedMark}`;
+	} else content = " (No file)";
+	const headerText = padEndByWidth(truncateByWidth(sanitize(content), props.width), props.width);
+	return text({
+		bg,
+		fg: theme$1.headerFg
+	}, headerText);
+}
+
+//#endregion
+//#region src/editor/view-footer.ts
+function viewFooter(props) {
+	const theme$1 = props.theme;
+	const bg = theme$1.headerBg;
+	let leftContent;
+	if (props.focus === "tree") leftContent = " [Tab] Editor  [Ctrl+C] Quit";
+	else leftContent = ` Ln ${props.cursorLine + 1}, Col ${props.cursorCol + 1}  [Tab] Tree  [Ctrl+S] Save`;
+	const rightContent = `[Esc] ${props.mouseEnabled ? "MOUSE" : "KEY"} `;
+	const leftWidth = displayWidth(sanitize(leftContent));
+	const rightWidth = displayWidth(rightContent);
+	const paddingWidth = Math.max(0, props.width - leftWidth - rightWidth);
+	const padding = " ".repeat(paddingWidth);
+	const footerText = truncateByWidth(sanitize(leftContent) + padding + rightContent, props.width);
+	return text({
+		bg,
+		fg: theme$1.headerFg
+	}, footerText);
+}
+
+//#endregion
+//#region src/editor/theme.ts
+const DIR_INDICATOR = {
+	TRIANGLE_FILLED: {
+		collapsed: "▶",
+		expanded: "▼"
+	},
+	TRIANGLE_OUTLINE: {
+		collapsed: "▷",
+		expanded: "▽"
+	},
+	ARROW: {
+		collapsed: ">",
+		expanded: "v"
+	},
+	PLUS_MINUS: {
+		collapsed: "+",
+		expanded: "-"
+	},
+	CHEVRON: {
+		collapsed: "›",
+		expanded: "⌄"
+	}
+};
+function getDirIndicator(theme$1) {
+	if (typeof theme$1.dirIndicator === "string") return DIR_INDICATOR[theme$1.dirIndicator];
+	return theme$1.dirIndicator;
+}
+const defaultTheme = {
+	dirIndicator: "PLUS_MINUS",
+	treeBg: "default",
+	treeBgIndent: [
+		20,
+		30,
+		50
+	],
+	treeBgPrefix: [
+		30,
+		45,
+		70
+	],
+	treeBgName: [
+		40,
+		55,
+		85
+	],
+	treeBgSelected: [
+		50,
+		70,
+		110
+	],
+	treeFg: [
+		150,
+		170,
+		190
+	],
+	treeFgDir: [
+		120,
+		180,
+		240
+	],
+	treeFgPrefix: [
+		90,
+		150,
+		220
+	],
+	editorBg: "default",
+	editorFg: [
+		180,
+		200,
+		220
+	],
+	editorFgDimmed: [
+		40,
+		50,
+		70
+	],
+	editorBgCurrentLine: "default",
+	editorFgLineNumber: [
+		60,
+		80,
+		120
+	],
+	cursorBg: [
+		100,
+		150,
+		220
+	],
+	cursorFg: [
+		10,
+		15,
+		25
+	],
+	headerBg: [
+		15,
+		20,
+		35
+	],
+	headerBgFocus: [
+		30,
+		50,
+		90
+	],
+	headerFg: [
+		150,
+		180,
+		210
+	],
+	scrollbarTrack: "default",
+	scrollbarThumb: [
+		50,
+		80,
+		130
+	],
+	hScrollbarTrack: "default",
+	hScrollbarThumb: [
+		50,
+		80,
+		130
+	]
+};
+
+//#endregion
+//#region src/editor/view-tree-line.ts
+function viewTreeLine(props) {
+	const theme$1 = props.theme;
+	if (!props.node) return {
+		widget: text({}, ""),
+		width: 0
+	};
+	const indentWidth = (props.node.depth - 1) * INDENT_SIZE;
+	const indent = " ".repeat(indentWidth);
+	const dirIndicator = getDirIndicator(theme$1);
+	let prefix;
+	if (props.node.isDirectory) prefix = props.node.expanded ? dirIndicator.expanded : dirIndicator.collapsed;
+	else prefix = "-";
+	const prefixWithSpace = " " + prefix + " ";
+	const prefixWidth = displayWidth(prefixWithSpace);
+	const truncatedName = truncateByWidth(sanitize(props.node.name) + " ", props.maxWidth - indentWidth - prefixWidth);
+	const nameWidth = displayWidth(truncatedName);
+	const indentBg = props.isSelected ? theme$1.treeBgSelected : theme$1.treeBgIndent;
+	const prefixBg = props.isSelected ? theme$1.treeBgSelected : theme$1.treeBgPrefix;
+	const nameBg = props.isSelected ? theme$1.treeBgSelected : theme$1.treeBgName;
+	const prefixFg = theme$1.treeFgPrefix;
+	const nameFg = props.node.isDirectory ? theme$1.treeFgDir : theme$1.treeFg;
+	const totalWidth = indentWidth + prefixWidth + nameWidth;
+	if (indentWidth === 0) return {
+		widget: row(text({
+			bg: prefixBg,
+			fg: prefixFg
+		}, prefixWithSpace), text({
+			bg: nameBg,
+			fg: nameFg
+		}, truncatedName)),
+		width: totalWidth
+	};
+	return {
+		widget: row(text({ bg: indentBg }, indent), text({
+			bg: prefixBg,
+			fg: prefixFg
+		}, prefixWithSpace), text({
+			bg: nameBg,
+			fg: nameFg
+		}, truncatedName)),
+		width: totalWidth
+	};
+}
+
+//#endregion
+//#region src/editor/view-editor-line.ts
+function viewEditorLine(props) {
+	const theme$1 = props.theme;
+	const contentPadding = " ".repeat(EDITOR_PADDING);
+	const lineBg = props.isCurrentLine ? theme$1.editorBgCurrentLine : theme$1.editorBg;
+	const lineFg = props.dimmed ? theme$1.editorFgDimmed : theme$1.editorFg;
+	const showVScrollbar = !props.dimmed && props.isScrollbarThumb;
+	const vScrollbarBg = showVScrollbar ? theme$1.scrollbarThumb : lineBg;
+	const hScrollbar = props.hScrollbar;
+	const isHScrollbarLine = hScrollbar !== void 0 && !props.dimmed;
+	if (props.line === void 0) {
+		const paddedVisible = padEndByWidth(sliceByWidth(" ".repeat(props.contentWidth), props.visibleStart, props.visibleWidth), props.visibleWidth);
+		if (isHScrollbarLine) return renderHScrollbarLine(paddedVisible, hScrollbar, props.visibleWidth, lineFg, showVScrollbar, theme$1, -1);
+		const splitLast = splitAtWidth(paddedVisible, props.visibleWidth - 1);
+		return row(text({
+			bg: lineBg,
+			fg: lineFg
+		}, splitLast.before), text({
+			bg: vScrollbarBg,
+			fg: lineFg
+		}, splitLast.char + splitLast.after));
+	}
+	const paddedVisibleText = padEndByWidth(sliceByWidth(padEndByWidth(sliceByWidth(contentPadding + padEndByWidth(sanitize(props.line), props.maxLineWidth) + contentPadding, props.horizontalOffset, props.contentWidth), props.contentWidth), props.visibleStart, props.visibleWidth), props.visibleWidth);
+	if (isHScrollbarLine) {
+		let cursorPosInVisible = -1;
+		if (props.showCursor && props.isCurrentLine) cursorPosInVisible = EDITOR_PADDING + charIndexToSanitizedWidth(props.line, props.cursor.col) - props.horizontalOffset - props.visibleStart;
+		return renderHScrollbarLine(paddedVisibleText, hScrollbar, props.visibleWidth, lineFg, showVScrollbar, theme$1, cursorPosInVisible);
+	}
+	const scrollbarPos = props.visibleWidth - 1;
+	const splitScrollbar = splitAtWidth(paddedVisibleText, scrollbarPos);
+	if (props.showCursor && props.isCurrentLine) {
+		const cursorPosInVisible = EDITOR_PADDING + charIndexToSanitizedWidth(props.line, props.cursor.col) - props.horizontalOffset - props.visibleStart;
+		if (cursorPosInVisible >= 0 && cursorPosInVisible < props.visibleWidth) {
+			if (cursorPosInVisible === scrollbarPos) return row(text({
+				bg: lineBg,
+				fg: lineFg
+			}, splitScrollbar.before), text({
+				bg: theme$1.cursorBg,
+				fg: theme$1.cursorFg
+			}, splitScrollbar.char + splitScrollbar.after));
+			const splitCursor = splitAtWidth(splitScrollbar.before, cursorPosInVisible);
+			return row(text({
+				bg: lineBg,
+				fg: lineFg
+			}, splitCursor.before), text({
+				bg: theme$1.cursorBg,
+				fg: theme$1.cursorFg
+			}, splitCursor.char), text({
+				bg: lineBg,
+				fg: lineFg
+			}, splitCursor.after), text({
+				bg: vScrollbarBg,
+				fg: lineFg
+			}, splitScrollbar.char + splitScrollbar.after));
+		}
+	}
+	return row(text({
+		bg: lineBg,
+		fg: lineFg
+	}, splitScrollbar.before), text({
+		bg: vScrollbarBg,
+		fg: lineFg
+	}, splitScrollbar.char + splitScrollbar.after));
+}
+function renderHScrollbarLine(content, hScrollbar, visibleWidth, fg, showVScrollbar, theme$1, cursorPos) {
+	const vScrollbarPos = visibleWidth - 1;
+	const splitVScrollbar = splitAtWidth(content, vScrollbarPos);
+	const mainContent = splitVScrollbar.before;
+	const vScrollbarChar = splitVScrollbar.char + splitVScrollbar.after;
+	const thumbStart = Math.max(hScrollbar.start, 0);
+	const thumbEnd = Math.min(hScrollbar.end, vScrollbarPos);
+	const vScrollbarBg = showVScrollbar ? theme$1.scrollbarThumb : theme$1.hScrollbarTrack;
+	const cursorOnVScrollbar = cursorPos === vScrollbarPos;
+	const cursorInMain = cursorPos >= 0 && cursorPos < visibleWidth && cursorPos < vScrollbarPos;
+	if (thumbEnd <= thumbStart) {
+		if (cursorOnVScrollbar) return row(text({
+			bg: theme$1.hScrollbarTrack,
+			fg
+		}, mainContent), text({
+			bg: theme$1.cursorBg,
+			fg: theme$1.cursorFg
+		}, vScrollbarChar));
+		if (cursorInMain) {
+			const splitCursor = splitAtWidth(mainContent, cursorPos);
+			return row(text({
+				bg: theme$1.hScrollbarTrack,
+				fg
+			}, splitCursor.before), text({
+				bg: theme$1.cursorBg,
+				fg: theme$1.cursorFg
+			}, splitCursor.char), text({
+				bg: theme$1.hScrollbarTrack,
+				fg
+			}, splitCursor.after), text({
+				bg: vScrollbarBg,
+				fg
+			}, vScrollbarChar));
+		}
+		return row(text({
+			bg: theme$1.hScrollbarTrack,
+			fg
+		}, mainContent), text({
+			bg: vScrollbarBg,
+			fg
+		}, vScrollbarChar));
+	}
+	const segments = [];
+	if (cursorInMain) {
+		const splitCursor = splitAtWidth(mainContent, cursorPos);
+		if (cursorPos > 0) if (cursorPos <= thumbStart) segments.push(text({
+			bg: theme$1.hScrollbarTrack,
+			fg
+		}, splitCursor.before));
+		else if (cursorPos >= thumbEnd) if (thumbStart > 0) {
+			const splitThumbStart = splitAtWidth(splitCursor.before, thumbStart);
+			segments.push(text({
+				bg: theme$1.hScrollbarTrack,
+				fg
+			}, splitThumbStart.before));
+			const thumbPart = splitThumbStart.char + splitThumbStart.after;
+			if (thumbEnd < cursorPos) {
+				const splitThumbEnd = splitAtWidth(thumbPart, thumbEnd - thumbStart);
+				segments.push(text({
+					bg: theme$1.hScrollbarThumb,
+					fg
+				}, splitThumbEnd.before + splitThumbEnd.char));
+				segments.push(text({
+					bg: theme$1.hScrollbarTrack,
+					fg
+				}, splitThumbEnd.after));
+			} else segments.push(text({
+				bg: theme$1.hScrollbarThumb,
+				fg
+			}, thumbPart));
+		} else {
+			const splitThumbEnd = splitAtWidth(splitCursor.before, thumbEnd);
+			segments.push(text({
+				bg: theme$1.hScrollbarThumb,
+				fg
+			}, splitThumbEnd.before + splitThumbEnd.char));
+			segments.push(text({
+				bg: theme$1.hScrollbarTrack,
+				fg
+			}, splitThumbEnd.after));
+		}
+		else if (thumbStart > 0) {
+			const splitThumbStart = splitAtWidth(splitCursor.before, thumbStart);
+			segments.push(text({
+				bg: theme$1.hScrollbarTrack,
+				fg
+			}, splitThumbStart.before));
+			segments.push(text({
+				bg: theme$1.hScrollbarThumb,
+				fg
+			}, splitThumbStart.char + splitThumbStart.after));
+		} else segments.push(text({
+			bg: theme$1.hScrollbarThumb,
+			fg
+		}, splitCursor.before));
+		segments.push(text({
+			bg: theme$1.cursorBg,
+			fg: theme$1.cursorFg
+		}, splitCursor.char));
+		const afterCursorPos = cursorPos + 1;
+		if (afterCursorPos < vScrollbarPos) {
+			const afterContent = splitCursor.after;
+			if (afterCursorPos >= thumbEnd) segments.push(text({
+				bg: theme$1.hScrollbarTrack,
+				fg
+			}, afterContent));
+			else if (afterCursorPos < thumbStart) {
+				const splitToThumb = splitAtWidth(afterContent, thumbStart - afterCursorPos);
+				segments.push(text({
+					bg: theme$1.hScrollbarTrack,
+					fg
+				}, splitToThumb.before + splitToThumb.char));
+				const afterThumbStart = splitToThumb.after;
+				const thumbLen = thumbEnd - thumbStart - 1;
+				if (thumbLen > 0) {
+					const splitThumbEnd = splitAtWidth(afterThumbStart, thumbLen);
+					segments.push(text({
+						bg: theme$1.hScrollbarThumb,
+						fg
+					}, splitThumbEnd.before + splitThumbEnd.char));
+					segments.push(text({
+						bg: theme$1.hScrollbarTrack,
+						fg
+					}, splitThumbEnd.after));
+				} else segments.push(text({
+					bg: theme$1.hScrollbarTrack,
+					fg
+				}, afterThumbStart));
+			} else {
+				const remainingThumb = thumbEnd - afterCursorPos;
+				if (remainingThumb > 0) {
+					const splitThumbEnd = splitAtWidth(afterContent, remainingThumb);
+					segments.push(text({
+						bg: theme$1.hScrollbarThumb,
+						fg
+					}, splitThumbEnd.before + splitThumbEnd.char));
+					segments.push(text({
+						bg: theme$1.hScrollbarTrack,
+						fg
+					}, splitThumbEnd.after));
+				} else segments.push(text({
+					bg: theme$1.hScrollbarTrack,
+					fg
+				}, afterContent));
+			}
+		}
+	} else {
+		const splitBeforeThumb = splitAtWidth(mainContent, thumbStart);
+		const beforeThumbContent = splitBeforeThumb.before;
+		const afterBeforeThumb = splitBeforeThumb.char + splitBeforeThumb.after;
+		const thumbLength = thumbEnd - thumbStart;
+		const splitThumb = splitAtWidth(afterBeforeThumb, thumbLength);
+		const thumbContent = splitThumb.before + (thumbLength > splitThumb.before.length ? splitThumb.char : "");
+		const afterThumbContent = thumbLength > splitThumb.before.length ? splitThumb.after : splitThumb.char + splitThumb.after;
+		segments.push(text({
+			bg: theme$1.hScrollbarTrack,
+			fg
+		}, beforeThumbContent));
+		segments.push(text({
+			bg: theme$1.hScrollbarThumb,
+			fg
+		}, thumbContent));
+		segments.push(text({
+			bg: theme$1.hScrollbarTrack,
+			fg
+		}, afterThumbContent));
+	}
+	if (cursorOnVScrollbar) segments.push(text({
+		bg: theme$1.cursorBg,
+		fg: theme$1.cursorFg
+	}, vScrollbarChar));
+	else segments.push(text({
+		bg: vScrollbarBg,
+		fg
+	}, vScrollbarChar));
+	return row(...segments);
+}
+
+//#endregion
+//#region src/editor/view.ts
+function view(props) {
+	const model$1 = props.model;
+	const theme$1 = props.theme;
+	const totalWidth = Math.max(10, model$1.terminalWidth);
+	const height = Math.max(5, model$1.terminalHeight);
+	const contentHeight = Math.max(1, height - 2);
+	const maxTreeWidth = model$1.treeVisible ? Math.floor(totalWidth / 2) : 0;
+	const editorContentWidth = Math.max(1, totalWidth - SCROLLBAR_WIDTH);
+	const visibleItems = model$1.flatList.slice(model$1.scrollOffset, model$1.scrollOffset + contentHeight);
+	const visibleLines = model$1.fileContent.slice(model$1.fileScrollOffset, model$1.fileScrollOffset + contentHeight);
+	const fileScrollbar = calcScrollbar({
+		totalItems: model$1.fileContent.length,
+		visibleItems: contentHeight,
+		offset: model$1.fileScrollOffset,
+		height: contentHeight
+	});
+	const maxLineWidth = maxDisplayWidth(model$1.fileContent);
+	const hScrollbar = calcHorizontalScrollbar({
+		maxWidth: maxLineWidth + EDITOR_PADDING * 2,
+		visibleWidth: totalWidth - maxTreeWidth,
+		offset: model$1.fileHorizontalOffset,
+		width: totalWidth - maxTreeWidth
+	});
+	const contentRows = [];
+	for (let i = 0; i < contentHeight; i++) {
+		const node = visibleItems[i];
+		const line = visibleLines[i];
+		const lineIndex = model$1.fileScrollOffset + i;
+		const isLastLine = i === contentHeight - 1;
+		if (model$1.treeVisible) {
+			const treeResult = viewTreeLine({
+				node,
+				isSelected: model$1.scrollOffset + i === model$1.selectedIndex,
+				maxWidth: maxTreeWidth,
+				theme: theme$1
+			});
+			const editorVisibleStart = treeResult.width;
+			const editorVisibleWidth = totalWidth - treeResult.width - SCROLLBAR_WIDTH;
+			const editorLine = viewEditorLine({
+				line,
+				lineIndex,
+				contentWidth: editorContentWidth,
+				horizontalOffset: model$1.fileHorizontalOffset,
+				maxLineWidth,
+				isScrollbarThumb: i >= fileScrollbar.start && i < fileScrollbar.end,
+				cursor: model$1.cursor,
+				showCursor: model$1.focus === "editor" && model$1.openedFile !== null,
+				isCurrentLine: lineIndex === model$1.cursor.line,
+				theme: theme$1,
+				visibleStart: editorVisibleStart,
+				visibleWidth: editorVisibleWidth,
+				dimmed: model$1.focus === "tree",
+				hScrollbar: isLastLine ? hScrollbar : void 0
+			});
+			contentRows.push(row(treeResult.widget, editorLine));
+		} else {
+			const editorLine = viewEditorLine({
+				line,
+				lineIndex,
+				contentWidth: editorContentWidth,
+				horizontalOffset: model$1.fileHorizontalOffset,
+				maxLineWidth,
+				isScrollbarThumb: i >= fileScrollbar.start && i < fileScrollbar.end,
+				cursor: model$1.cursor,
+				showCursor: model$1.focus === "editor" && model$1.openedFile !== null,
+				isCurrentLine: lineIndex === model$1.cursor.line,
+				theme: theme$1,
+				visibleStart: 0,
+				visibleWidth: totalWidth - SCROLLBAR_WIDTH,
+				dimmed: model$1.focus === "tree",
+				hScrollbar: isLastLine ? hScrollbar : void 0
+			});
+			contentRows.push(editorLine);
+		}
+	}
+	const header = viewHeader({
+		rootPath: model$1.root.path,
+		openedFile: model$1.openedFile,
+		width: totalWidth,
+		focus: model$1.focus,
+		modified: model$1.modified,
+		theme: theme$1
+	});
+	const footer = viewFooter({
+		width: totalWidth,
+		focus: model$1.focus,
+		cursorLine: model$1.cursor.line,
+		cursorCol: model$1.cursor.col,
+		mouseEnabled: model$1.mouseEnabled,
+		theme: theme$1
+	});
+	return col(header, ...contentRows, footer);
+}
+
+//#endregion
+//#region src/editor/parse-input.ts
+function parseTreeInput(str, model$1) {
+	if (str === "\x1B[A" || str === "k") return {
+		type: "MOVE",
+		delta: -1
+	};
+	if (str === "\x1B[B" || str === "j") return {
+		type: "MOVE",
+		delta: 1
+	};
+	if (str === "\x1B[C" || str === "l" || str === "\r" || str === "\n") return {
+		type: "TOGGLE",
+		index: model$1.selectedIndex
+	};
+	if (str === "\x1B[D" || str === "h") {
+		const node = model$1.flatList[model$1.selectedIndex];
+		if (node && node.isDirectory && node.expanded) return {
+			type: "TOGGLE",
+			index: model$1.selectedIndex
+		};
+		return { type: "NOOP" };
+	}
+	if (str === "\x1B[5~") return {
+		type: "MOVE",
+		delta: -20
+	};
+	if (str === "\x1B[6~") return {
+		type: "MOVE",
+		delta: 20
+	};
+	return { type: "NOOP" };
+}
+function parseEditorInput(str) {
+	if (str === "\x1B[A") return {
+		type: "CURSOR_MOVE",
+		deltaLine: -1,
+		deltaCol: 0
+	};
+	if (str === "\x1B[B") return {
+		type: "CURSOR_MOVE",
+		deltaLine: 1,
+		deltaCol: 0
+	};
+	if (str === "\x1B[C") return {
+		type: "CURSOR_MOVE",
+		deltaLine: 0,
+		deltaCol: 1
+	};
+	if (str === "\x1B[D") return {
+		type: "CURSOR_MOVE",
+		deltaLine: 0,
+		deltaCol: -1
+	};
+	if (str === "\x1B[5~") return {
+		type: "SCROLL_FILE",
+		delta: -20
+	};
+	if (str === "\x1B[6~") return {
+		type: "SCROLL_FILE",
+		delta: 20
+	};
+	if (str === "" || str === "\b") return { type: "DELETE_CHAR_BEFORE" };
+	if (str === "\x1B[3~") return { type: "DELETE_CHAR" };
+	if (str === "\r" || str === "\n") return { type: "INSERT_NEWLINE" };
+	if (str === "") return { type: "SAVE" };
+	if (str.length > 0 && !str.startsWith("\x1B")) return {
+		type: "INSERT_CHAR",
+		char: str
+	};
+	return { type: "NOOP" };
+}
+function parseMouseInput(str, model$1) {
+	const mouseMatch = str.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
+	if (!mouseMatch || !mouseMatch[1] || !mouseMatch[2] || !mouseMatch[3] || !mouseMatch[4]) return { type: "NOOP" };
+	const button = parseInt(mouseMatch[1], 10);
+	const mouseCol = parseInt(mouseMatch[2], 10);
+	const mouseRow = parseInt(mouseMatch[3], 10);
+	const isPress = mouseMatch[4] === "M";
+	const treeWidth = model$1.treeVisible ? Math.floor(model$1.terminalWidth / 2) : 0;
+	if (button === 0 && isPress) return {
+		type: "CLICK",
+		row: mouseRow,
+		col: mouseCol
+	};
+	if (button === 64) {
+		if (model$1.treeVisible && mouseCol <= treeWidth) return {
+			type: "SCROLL",
+			delta: -3
+		};
+		return {
+			type: "SCROLL_FILE",
+			delta: -3
+		};
+	}
+	if (button === 65) {
+		if (model$1.treeVisible && mouseCol <= treeWidth) return {
+			type: "SCROLL",
+			delta: 3
+		};
+		return {
+			type: "SCROLL_FILE",
+			delta: 3
+		};
+	}
+	if (button === 68) return {
+		type: "SCROLL_FILE_H",
+		delta: -8
+	};
+	if (button === 69) return {
+		type: "SCROLL_FILE_H",
+		delta: 8
+	};
+	return { type: "NOOP" };
+}
+function parseInput(data, model$1) {
+	const str = data.toString();
+	if (str === "q" || str === "") return { type: "NOOP" };
+	if (str === "	") return { type: "TOGGLE_TREE" };
+	if (str === "\x1B") return { type: "TOGGLE_MOUSE" };
+	if (model$1.focus === "tree") {
+		const msg = parseTreeInput(str, model$1);
+		if (msg.type !== "NOOP") return msg;
+	}
+	if (model$1.focus === "editor" && model$1.openedFile) {
+		const msg = parseEditorInput(str);
+		if (msg.type !== "NOOP") return msg;
+	}
+	const mouseMsg = parseMouseInput(str, model$1);
+	if (mouseMsg.type !== "NOOP") return mouseMsg;
+	return { type: "NOOP" };
+}
+function shouldQuit(data) {
+	const str = data.toString();
+	return str === "q" || str === "";
+}
+
+//#endregion
+//#region src/editor/terminal.ts
+function enterAltScreen() {
+	return "\x1B[?1049h";
+}
+function exitAltScreen() {
+	return "\x1B[?1049l";
+}
+function hideCursor() {
+	return "\x1B[?25l";
+}
+function showCursor() {
+	return "\x1B[?25h";
+}
+function enableMouse() {
+	return "\x1B[?1000h\x1B[?1006h";
+}
+function disableMouse() {
+	return "\x1B[?1000l\x1B[?1006l";
+}
+function clearScreen() {
+	return "\x1B[2J\x1B[H";
+}
+function moveCursor(x, y) {
+	return `\x1b[${y};${x}H`;
+}
+
+//#endregion
+//#region src/index.ts
+function cleanup() {
+	process.stdout.write(showCursor() + disableMouse() + exitAltScreen());
+	process.stdin.setRawMode(false);
+}
+function getCursorScreenPosition(model$1) {
+	const contentHeight = model$1.terminalHeight - 2;
+	if (model$1.focus === "tree" && model$1.treeVisible) {
+		if (model$1.selectedIndex < model$1.scrollOffset || model$1.selectedIndex >= model$1.scrollOffset + contentHeight) return null;
+		return {
+			x: 1,
+			y: 2 + (model$1.selectedIndex - model$1.scrollOffset)
+		};
+	}
+	if (model$1.focus === "editor" && model$1.openedFile) {
+		if (model$1.cursor.line < model$1.fileScrollOffset || model$1.cursor.line >= model$1.fileScrollOffset + contentHeight) return null;
+		const screenRow = 2 + (model$1.cursor.line - model$1.fileScrollOffset);
+		const cursorPosInView = EDITOR_PADDING + charIndexToSanitizedWidth(model$1.fileContent[model$1.cursor.line] || "", model$1.cursor.col) - model$1.fileHorizontalOffset;
+		const editorWidth = model$1.terminalWidth;
+		if (cursorPosInView < 0 || cursorPosInView >= editorWidth) return null;
+		return {
+			x: 1 + cursorPosInView,
+			y: screenRow
+		};
+	}
+	return null;
+}
+function handleError(err) {
+	writeFileSync("/tmp/editor-error.log", err instanceof Error ? `${err.message}\n${err.stack}` : String(err));
+	cleanup();
+	console.error("Error logged to /tmp/editor-error.log");
+	process.exit(1);
+}
+const targetPath = process.argv[2] || process.cwd();
+if (!process.stdin.isTTY || !process.stdout.isTTY) {
+	console.error("This program requires an interactive terminal.");
+	process.exit(1);
+}
+process.on("uncaughtException", handleError);
+let model = initModel(targetPath, process.stdout.columns || 80, process.stdout.rows || 24);
+const theme = defaultTheme;
+process.stdout.write(enterAltScreen() + enableMouse());
+function renderWithCursor() {
+	let output = render(view({
+		model,
+		theme
+	}), 0, 0, model.terminalWidth, model.terminalHeight);
+	const cursorPos = getCursorScreenPosition(model);
+	if (cursorPos) output += showCursor() + moveCursor(cursorPos.x, cursorPos.y);
+	else output += hideCursor();
+	return output;
+}
+process.stdout.write(renderWithCursor());
+process.stdout.on("resize", () => {
+	try {
+		const msg = {
+			type: "RESIZE",
+			height: process.stdout.rows || 24,
+			width: process.stdout.columns || 80
+		};
+		model = update(model, msg);
+		process.stdout.write(clearScreen() + renderWithCursor());
+	} catch (err) {
+		handleError(err);
+	}
+});
+process.stdin.setRawMode(true);
+process.stdin.resume();
+process.stdin.on("data", (data) => {
+	try {
+		if (shouldQuit(data)) {
+			cleanup();
+			process.exit(0);
+		}
+		const prevMouseEnabled = model.mouseEnabled;
+		const msg = parseInput(data, model);
+		model = update(model, msg);
+		let output = "";
+		if (model.mouseEnabled !== prevMouseEnabled) output += model.mouseEnabled ? enableMouse() : disableMouse();
+		output += renderWithCursor();
+		process.stdout.write(output);
+	} catch (err) {
+		handleError(err);
+	}
+});
+process.on("exit", cleanup);
+process.on("SIGINT", () => {
+	cleanup();
+	process.exit(0);
+});
+
+//#endregion
+export {  };